diff --git a/SPTPersistentCache.xcodeproj/project.pbxproj b/SPTPersistentCache.xcodeproj/project.pbxproj
index b04d4c1..4a02c9c 100644
--- a/SPTPersistentCache.xcodeproj/project.pbxproj
+++ b/SPTPersistentCache.xcodeproj/project.pbxproj
@@ -378,7 +378,7 @@
 			isa = PBXProject;
 			attributes = {
 				CLASSPREFIX = SPTPersistentCache;
-				LastUpgradeCheck = 0910;
+				LastUpgradeCheck = 0900;
 				ORGANIZATIONNAME = Spotify;
 				TargetAttributes = {
 					0510FF121BA2FF7A00ED0766 = {
@@ -492,7 +492,14 @@
 			isa = XCBuildConfiguration;
 			baseConfigurationReference = 9C882A801C65422700D463BB /* project.xcconfig */;
 			buildSettings = {
+				CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES;
+				CLANG_WARN_COMMA = YES;
+				CLANG_WARN_INFINITE_RECURSION = YES;
+				CLANG_WARN_RANGE_LOOP_ANALYSIS = YES;
+				CLANG_WARN_STRICT_PROTOTYPES = YES;
+				CLANG_WARN_SUSPICIOUS_MOVE = YES;
 				ENABLE_STRICT_OBJC_MSGSEND = YES;
+				ENABLE_TESTABILITY = YES;
 				GCC_DYNAMIC_NO_PIC = NO;
 				GCC_SYMBOLS_PRIVATE_EXTERN = NO;
 				HEADER_SEARCH_PATHS = (
@@ -501,6 +508,7 @@
 				);
 				MTL_ENABLE_DEBUG_INFO = YES;
 				ONLY_ACTIVE_ARCH = YES;
+				VALID_ARCHS = "armv7 arm64 armv7k";
 			};
 			name = Debug;
 		};
@@ -508,6 +516,12 @@
 			isa = XCBuildConfiguration;
 			baseConfigurationReference = 9C882A801C65422700D463BB /* project.xcconfig */;
 			buildSettings = {
+				CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES;
+				CLANG_WARN_COMMA = YES;
+				CLANG_WARN_INFINITE_RECURSION = YES;
+				CLANG_WARN_RANGE_LOOP_ANALYSIS = YES;
+				CLANG_WARN_STRICT_PROTOTYPES = YES;
+				CLANG_WARN_SUSPICIOUS_MOVE = YES;
 				ENABLE_STRICT_OBJC_MSGSEND = YES;
 				HEADER_SEARCH_PATHS = (
 					include,
@@ -515,6 +529,7 @@
 				);
 				MTL_ENABLE_DEBUG_INFO = NO;
 				VALIDATE_PRODUCT = YES;
+				VALID_ARCHS = "armv7 arm64 armv7k";
 			};
 			name = Release;
 		};
@@ -522,6 +537,7 @@
 			isa = XCBuildConfiguration;
 			buildSettings = {
 				COMBINE_HIDPI_IMAGES = YES;
+				ONLY_ACTIVE_ARCH = NO;
 				OTHER_LDFLAGS = "-ObjC";
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				SKIP_INSTALL = YES;
diff --git a/SPTPersistentCache.xcodeproj/xcshareddata/xcschemes/SPTPersistentCache.xcscheme b/SPTPersistentCache.xcodeproj/xcshareddata/xcschemes/SPTPersistentCache.xcscheme
index faab200..d1363c1 100644
--- a/SPTPersistentCache.xcodeproj/xcshareddata/xcschemes/SPTPersistentCache.xcscheme
+++ b/SPTPersistentCache.xcodeproj/xcshareddata/xcschemes/SPTPersistentCache.xcscheme
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <Scheme
-   LastUpgradeVersion = "0910"
+   LastUpgradeVersion = "0900"
    version = "1.3">
    <BuildAction
       parallelizeBuildables = "YES"
diff --git a/Sources/SPTPersistentCache.m b/Sources/SPTPersistentCache.m
index ef455aa..f7e4b43 100644
--- a/Sources/SPTPersistentCache.m
+++ b/Sources/SPTPersistentCache.m
@@ -390,6 +390,11 @@ - (void)unscheduleGarbageCollector
     [self.garbageCollector unschedule];
 }
 
+- (void)enqueueGarbageCollector
+{
+    [self.garbageCollector enqueueGarbageCollection];
+}
+
 - (void)pruneWithCallback:(SPTPersistentCacheResponseCallback _Nullable)callback
                   onQueue:(dispatch_queue_t _Nullable)queue
 {
diff --git a/Sources/SPTPersistentCacheFileManager.m b/Sources/SPTPersistentCacheFileManager.m
index d82d2fb..4fe5d9e 100644
--- a/Sources/SPTPersistentCacheFileManager.m
+++ b/Sources/SPTPersistentCacheFileManager.m
@@ -22,8 +22,6 @@
 #import "SPTPersistentCacheDebugUtilities.h"
 #import "SPTPersistentCacheOptions.h"
 
-static const double SPTPersistentCacheFileManagerMinFreeDiskSpace = 0.1;
-
 const NSUInteger SPTPersistentCacheFileManagerSubDirNameLength = 2;
 
 @implementation SPTPersistentCacheFileManager
@@ -179,7 +177,7 @@ - (SPTPersistentCacheDiskSize)optimizedDiskSizeForCacheSize:(SPTPersistentCacheD
         SPTPersistentCacheDiskSize totalSpace = fileSystemSize.longLongValue;
         SPTPersistentCacheDiskSize freeSpace = fileSystemFreeSpace.longLongValue + currentCacheSize;
         SPTPersistentCacheDiskSize proposedCacheSize = freeSpace - llrint(totalSpace *
-                                                                              SPTPersistentCacheFileManagerMinFreeDiskSpace);
+                                                                              self.options.minimumFreeDiskSpaceFraction);
         
         tempCacheSize = MAX(0, proposedCacheSize);
         
diff --git a/Sources/SPTPersistentCacheGarbageCollector.h b/Sources/SPTPersistentCacheGarbageCollector.h
index f1c149d..5d2f9d8 100644
--- a/Sources/SPTPersistentCacheGarbageCollector.h
+++ b/Sources/SPTPersistentCacheGarbageCollector.h
@@ -68,4 +68,9 @@
  */
 - (void)unschedule;
 
+/**
+ *  Enqueues the garbage collector. Called automatically if scheduled by the above functions.
+ */
+- (void)enqueueGarbageCollection;
+
 @end
diff --git a/Sources/SPTPersistentCacheGarbageCollector.m b/Sources/SPTPersistentCacheGarbageCollector.m
index 3bc352c..eb42a7d 100644
--- a/Sources/SPTPersistentCacheGarbageCollector.m
+++ b/Sources/SPTPersistentCacheGarbageCollector.m
@@ -61,7 +61,7 @@ - (void)dealloc
 
 #pragma mark -
 
-- (void)enqueueGarbageCollection:(NSTimer *)timer
+- (void)enqueueGarbageCollection
 {
     __weak __typeof(self) const weakSelf = self;
     NSBlockOperation *operation = [NSBlockOperation blockOperationWithBlock:^{
@@ -81,6 +81,11 @@ - (void)enqueueGarbageCollection:(NSTimer *)timer
     [self.queue addOperation:operation];
 }
 
+- (void)garbageCollectionTimerFired:(NSTimer *)timer
+{
+    [self enqueueGarbageCollection];
+}
+
 - (void)schedule
 {
     if (!SPTPersistentCacheGarbageCollectorSchedulerIsInMainQueue()) {
@@ -100,7 +105,7 @@ - (void)schedule
 
     self.timer = [NSTimer timerWithTimeInterval:self.options.garbageCollectionInterval
                                          target:self
-                                       selector:@selector(enqueueGarbageCollection:)
+                                       selector:@selector(garbageCollectionTimerFired:)
                                        userInfo:nil
                                         repeats:YES];
     
diff --git a/Sources/SPTPersistentCacheOptions.m b/Sources/SPTPersistentCacheOptions.m
index af68f2a..8c0a6c4 100644
--- a/Sources/SPTPersistentCacheOptions.m
+++ b/Sources/SPTPersistentCacheOptions.m
@@ -27,6 +27,7 @@
 const NSUInteger SPTPersistentCacheDefaultExpirationTimeSec = 10 * 60;
 const NSUInteger SPTPersistentCacheDefaultGCIntervalSec = 6 * 60 + 3;
 static const NSUInteger SPTPersistentCacheDefaultCacheSizeInBytes = 0; // unbounded
+const double SPTPersistentCacheDefaultMinFreeDiskSpaceFraction = 0.1; // 10% of total disk size
 
 const NSUInteger SPTPersistentCacheMinimumGCIntervalLimit = 60;
 const NSUInteger SPTPersistentCacheMinimumExpirationLimit = 60;
@@ -55,6 +56,7 @@ - (instancetype)init
         _garbageCollectionInterval = SPTPersistentCacheDefaultGCIntervalSec;
         _defaultExpirationPeriod = SPTPersistentCacheDefaultExpirationTimeSec;
         _sizeConstraintBytes = SPTPersistentCacheDefaultCacheSizeInBytes;
+        _minimumFreeDiskSpaceFraction = SPTPersistentCacheDefaultMinFreeDiskSpaceFraction;
         _maxConcurrentOperations = NSOperationQueueDefaultMaxConcurrentOperationCount;
         _writePriority = NSOperationQueuePriorityNormal;
         _writeQualityOfService = NSQualityOfServiceDefault;
@@ -117,6 +119,7 @@ - (id)copyWithZone:(NSZone *)zone
     copy.garbageCollectionInterval = self.garbageCollectionInterval;
     copy.defaultExpirationPeriod = self.defaultExpirationPeriod;
     copy.sizeConstraintBytes = self.sizeConstraintBytes;
+    copy.minimumFreeDiskSpaceFraction = self.minimumFreeDiskSpaceFraction;
 
     copy.debugOutput = self.debugOutput;
     copy.timingCallback = self.timingCallback;
diff --git a/Tests/SPTPersistentCacheFileManagerTests.m b/Tests/SPTPersistentCacheFileManagerTests.m
index ec9b423..5752962 100644
--- a/Tests/SPTPersistentCacheFileManagerTests.m
+++ b/Tests/SPTPersistentCacheFileManagerTests.m
@@ -69,6 +69,7 @@ - (void)setUp
     SPTPersistentCacheOptions *options = [SPTPersistentCacheOptions new];
     options.cachePath = SPTPersistentCacheFileManagerTestsCachePath;
     options.cacheIdentifier = @"test";
+    options.sizeConstraintBytes = (SPTPersistentCacheDiskSize)1024 * 1024 * 1024 * 3; // 3 GiB
     self.options = options;
     
     self.cacheFileManager = [[SPTPersistentCacheFileManagerForTests alloc] initWithOptions:self.options];
@@ -168,6 +169,33 @@ - (void)testOptimizedDiskSizeForCacheSizeSmall
     XCTAssertEqual(optimizedSize, (SPTPersistentCacheDiskSize)0);
 }
 
+- (void)testMinimumFreeDiskSpaceFraction
+{
+    const SPTPersistentCacheDiskSize diskSize = (SPTPersistentCacheDiskSize)1024 * 1024 * 1024 * 16; // 16GiB
+    const SPTPersistentCacheDiskSize freeSpace = (SPTPersistentCacheDiskSize)1024 * 1024 * 1024 * 8; // 8GiB
+    NSFileManagerMock *fileManager = [NSFileManagerMock new];
+    fileManager.mock_attributesOfFileSystemForPaths = @{SPTPersistentCacheFileManagerTestsCachePath: @{NSFileSystemSize: @(diskSize),
+                                                                                                       NSFileSystemFreeSize: @(freeSpace)}};
+    self.cacheFileManager.test_fileManager = fileManager;
+
+    self.cacheFileManager.options.minimumFreeDiskSpaceFraction = 1.0;
+    SPTPersistentCacheDiskSize optimizedSize = [self.cacheFileManager optimizedDiskSizeForCacheSize:0];
+    XCTAssertEqual(optimizedSize, (SPTPersistentCacheDiskSize)0);
+
+    self.cacheFileManager.options.minimumFreeDiskSpaceFraction = 0.0;
+    optimizedSize = [self.cacheFileManager optimizedDiskSizeForCacheSize:0];
+    XCTAssertEqual(optimizedSize, (SPTPersistentCacheDiskSize)self.options.sizeConstraintBytes);
+
+    self.cacheFileManager.options.minimumFreeDiskSpaceFraction = 0.5;
+    optimizedSize = [self.cacheFileManager optimizedDiskSizeForCacheSize:0];
+    XCTAssertEqual(optimizedSize, (SPTPersistentCacheDiskSize)0);
+
+    const SPTPersistentCacheDiskSize twoGiB = (SPTPersistentCacheDiskSize)1024 * 1024 * 1024 * 2;
+    self.cacheFileManager.options.minimumFreeDiskSpaceFraction = (freeSpace - twoGiB) / (double)diskSize;
+    optimizedSize = [self.cacheFileManager optimizedDiskSizeForCacheSize:0];
+    XCTAssertEqual(optimizedSize, twoGiB);
+}
+
 - (void)testRemoveAllDataButKeysWithoutKeys
 {
     NSString *keyOne = @"AA";
diff --git a/Tests/SPTPersistentCacheGarbageCollectorTests.m b/Tests/SPTPersistentCacheGarbageCollectorTests.m
index 951c593..ad4c680 100644
--- a/Tests/SPTPersistentCacheGarbageCollectorTests.m
+++ b/Tests/SPTPersistentCacheGarbageCollectorTests.m
@@ -25,7 +25,7 @@
 
 @interface SPTPersistentCacheGarbageCollector ()
 @property (nonatomic, strong) NSTimer *timer;
-- (void)enqueueGarbageCollection:(NSTimer *)timer;
+- (void)garbageCollectionTimerFired:(NSTimer *)timer;
 @end
     
 
@@ -97,7 +97,7 @@ - (void)testGarbageCollectorEnqueue
     dataCacheForUnitTests.queue = self.garbageCollector.queue;
 
     dataCacheForUnitTests.testExpectation = expectation;
-    [self.garbageCollector enqueueGarbageCollection:nil];
+    [self.garbageCollector enqueueGarbageCollection];
     
     [self waitForExpectationsWithTimeout:1.0 handler:^(NSError * _Nullable error) {
         XCTAssertTrue(dataCacheForUnitTests.wasRunRegularGCCalled);
@@ -106,6 +106,23 @@ - (void)testGarbageCollectorEnqueue
     }];
 }
 
+- (void)testGarbageCollectorTimerFired
+{
+    __weak XCTestExpectation *expectation = [self expectationWithDescription:@"testGarbageCollectorEnqueue"];
+
+    SPTPersistentCacheForTimerProxyUnitTests *dataCacheForUnitTests = (SPTPersistentCacheForTimerProxyUnitTests *)self.garbageCollector.cache;
+    dataCacheForUnitTests.queue = self.garbageCollector.queue;
+
+    dataCacheForUnitTests.testExpectation = expectation;
+    [self.garbageCollector garbageCollectionTimerFired:nil];
+
+    [self waitForExpectationsWithTimeout:1.0 handler:^(NSError * _Nullable error) {
+        XCTAssertTrue(dataCacheForUnitTests.wasRunRegularGCCalled);
+        XCTAssertTrue(dataCacheForUnitTests.wasPruneBySizeCalled);
+        XCTAssertFalse(dataCacheForUnitTests.wasCalledFromIncorrectQueue);
+    }];
+}
+
 - (void)testIsGarbageCollectionScheduled
 {
     XCTAssertFalse(self.garbageCollector.isGarbageCollectionScheduled);
diff --git a/Tests/SPTPersistentCacheTests.m b/Tests/SPTPersistentCacheTests.m
index 599e889..f539aa1 100644
--- a/Tests/SPTPersistentCacheTests.m
+++ b/Tests/SPTPersistentCacheTests.m
@@ -870,6 +870,18 @@ - (void)testUnscheduleGarbageCollection
     XCTAssertFalse(cache.garbageCollector.isGarbageCollectionScheduled);
 }
 
+- (void)testEnqueueGargabeCollection
+{
+    SPTPersistentCache *cache = [self createCacheWithTimeCallback:^NSTimeInterval{
+        // Exceed expiration interval by 1 sec
+        return kTestEpochTime + SPTPersistentCacheDefaultExpirationTimeSec + 1;
+    }
+                                                   expirationTime:SPTPersistentCacheDefaultExpirationTimeSec];
+
+    [cache.garbageCollector enqueueGarbageCollection];
+    XCTAssertFalse(cache.garbageCollector.isGarbageCollectionScheduled);
+}
+
 /**
  * This test also checks Req.#1.2 of cache API.
  */
diff --git a/include/SPTPersistentCache/SPTPersistentCache.h b/include/SPTPersistentCache/SPTPersistentCache.h
index a768725..2aa22ea 100644
--- a/include/SPTPersistentCache/SPTPersistentCache.h
+++ b/include/SPTPersistentCache/SPTPersistentCache.h
@@ -229,6 +229,11 @@ typedef NSString * _Nonnull(^SPTPersistentCacheChooseKeyCallback)(NSArray<NSStri
  * Stop garbage collection. If already stopped this method does nothing.
  */
 - (void)unscheduleGarbageCollector;
+/**
+ * Run the garbage collector right now. Use this if scheduling isn't appropriate,
+ * for example in applicationWillResignActive:
+ */
+- (void)enqueueGarbageCollector;
 /**
  * Delete all files files in managed folder unconditionaly.
  * @param callback May be nil if not interested in result.
diff --git a/include/SPTPersistentCache/SPTPersistentCacheOptions.h b/include/SPTPersistentCache/SPTPersistentCacheOptions.h
index eb138b6..cff9161 100644
--- a/include/SPTPersistentCache/SPTPersistentCacheOptions.h
+++ b/include/SPTPersistentCache/SPTPersistentCacheOptions.h
@@ -176,6 +176,13 @@ FOUNDATION_EXPORT const NSUInteger SPTPersistentCacheMinimumExpirationLimit;
  *  @note Defaults to `0` (unbounded).
  */
 @property (nonatomic, assign) NSUInteger sizeConstraintBytes;
+/**
+ *  The minimum fraction of free disk space required for caching. If there is less disk space
+ *  available than this, the cache will be purged during garbage collection until the treshold
+ *  is met. This could mean that the whole cache is evicted if the device is low on space.
+ *  @note Defaults to `0.1`, 10% of the total disk size.
+ */
+@property (nonatomic, assign) double minimumFreeDiskSpaceFraction;
 /**
  * The queue priority for garbage collection. Defaults to NSOperationQueuePriorityLow.
  */