X-Git-Url: http://git.vrable.net/?a=blobdiff_plain;f=bluesky%2Fcache.c;h=cdd5c65e30f65975b6bfe3c1991b19ae1952b98e;hb=7f01069131555a0e9ab332e578a9eb2815e1e12d;hp=d8ef5faba32cd9f2a8f41c5c486e1de339f09ee0;hpb=0ca475013b6d6da3fa520001f6f6a50cab482299;p=bluesky.git diff --git a/bluesky/cache.c b/bluesky/cache.c index d8ef5fa..cdd5c65 100644 --- a/bluesky/cache.c +++ b/bluesky/cache.c @@ -235,8 +235,11 @@ static void drop_caches(BlueSkyInode *inode) * memory-mapped from log file or similar, so the kernel can drop this clean * data from memory for us and hence memory management isn't too important. * Mainly, we'll want to drop references to data that hasn't been accessed in a - * while so that it is possible to reclaim log segments on disk. */ -static void flushd_clean(BlueSkyFS *fs) + * while so that it is possible to reclaim log segments on disk. + * + * If aggressive is set, try much harder to drop data from the caches to free + * up space. */ +static void flushd_clean(BlueSkyFS *fs, int aggressive) { g_mutex_lock(fs->lock); @@ -251,7 +254,7 @@ static void flushd_clean(BlueSkyFS *fs) inode = fs->accessed_list.prev->data; uint64_t elapsed = bluesky_get_current_time() - inode->access_time; - if (elapsed < CACHE_DROP_DELAY) + if (elapsed < CACHE_DROP_DELAY && !aggressive) break; if (bluesky_verbose) { @@ -325,12 +328,14 @@ void bluesky_cachefile_gc(BlueSkyFS *fs) * then we'll just skip the file on this pass. */ if (g_mutex_trylock(cachefile->lock)) { int64_t age = bluesky_get_current_time() - cachefile->atime; - g_print("%s addr=%p mapcount=%d refcount=%d atime_age=%f", - cachefile->filename, cachefile->addr, cachefile->mapcount, - cachefile->refcount, age / 1e6); - if (cachefile->fetching) - g_print(" (fetching)"); - g_print("\n"); + if (bluesky_verbose) { + g_print("%s addr=%p mapcount=%d refcount=%d size=%d atime_age=%f", + cachefile->filename, cachefile->addr, cachefile->mapcount, + cachefile->refcount, cachefile->disk_used, age / 1e6); + if (cachefile->fetching) + g_print(" (fetching)"); + g_print("\n"); + } gboolean deletion_candidate = FALSE; if (g_atomic_int_get(&fs->log->disk_used) @@ -350,14 +355,19 @@ void bluesky_cachefile_gc(BlueSkyFS *fs) } if (deletion_candidate) { - g_print(" ...deleting\n"); + if (bluesky_verbose) { + g_print(" ...deleting\n"); + } if (unlinkat(fs->log->dirfd, cachefile->filename, 0) < 0) { fprintf(stderr, "Unable to unlink journal %s: %m\n", cachefile->filename); } - g_atomic_int_add(&fs->log->disk_used, -(cachefile->len / 1024)); + g_atomic_int_add(&fs->log->disk_used, -cachefile->disk_used); g_hash_table_remove(fs->log->mmap_cache, cachefile->filename); + bluesky_rangeset_free(cachefile->items); + if (cachefile->prefetches != NULL) + bluesky_rangeset_free(cachefile->prefetches); g_mutex_unlock(cachefile->lock); g_mutex_free(cachefile->lock); g_cond_free(cachefile->cond); @@ -370,6 +380,7 @@ void bluesky_cachefile_gc(BlueSkyFS *fs) files = g_list_delete_link(files, files); } g_list_free(files); + g_print("\nEnding cache size: %d kB\n", fs->log->disk_used); g_mutex_unlock(fs->log->mmap_lock); } @@ -389,8 +400,17 @@ static gpointer flushd_task(BlueSkyFS *fs) flushd_dirty(fs); flushd_cloud(fs); - flushd_clean(fs); + flushd_clean(fs, 0); bluesky_cachefile_gc(fs); + + /* If running out of disk cache space, make another more aggressive pass to + * free up space. */ + if (g_atomic_int_get(&fs->log->disk_used) > bluesky_options.cache_size) { + g_print("Still short on disk space, trying again to free space...\n"); + flushd_clean(fs, 1); + bluesky_cachefile_gc(fs); + } + g_mutex_unlock(fs->flushd_lock); return NULL; @@ -401,9 +421,68 @@ void bluesky_flushd_invoke(BlueSkyFS *fs) g_thread_create((GThreadFunc)flushd_task, fs, FALSE, NULL); } +/* How urgent is flushing out data? Returns one of several values: + * 0 - memory state is fine + * 1 - should launch flushd if not already running + * 2 - should delay writers while memory frees up + * 3 - should block writers until memory frees up + */ +static int compute_pressure(BlueSkyFS *fs) +{ + /* LEVEL 3 */ + /* Too much dirty data in memory? */ + if (g_atomic_int_get(&fs->cache_dirty) + + g_atomic_int_get(&fs->cache_log_dirty) + > bluesky_watermark_high_dirty) + { + g_print("pressure: too much dirty data (3)\n"); + return 3; + } + + /* Too much uncommitted data in the journal on disk, not yet flushed to the + * cloud? */ + /*printf("Dirty journals: %d to %d\n", + fs->log->journal_watermark, fs->log->seq_num);*/ + int dirty_limit; + dirty_limit = bluesky_options.cache_size / (LOG_SEGMENT_SIZE / 1024) / 2; + int dirty_journals = fs->log->seq_num - fs->log->journal_watermark + 1; + if (dirty_journals > 1 && dirty_journals >= dirty_limit) { + printf("pressure: too many dirty journals (%d >= %d) (3)\n", + dirty_journals, dirty_limit); + return 3; + } + + /* LEVEL 2 */ + if (g_atomic_int_get(&fs->cache_dirty) > bluesky_watermark_med2_dirty) { + g_print("pressure: too much dirty data (2)\n"); + return 2; + } + + if (dirty_journals > 1 && dirty_journals > dirty_limit * 3 / 4) { + printf("pressure: many dirty journals (%d), should start writeback (2)\n", + dirty_journals); + return 2; + } + + /* LEVEL 1 */ + if (g_atomic_int_get(&fs->cache_dirty) > bluesky_watermark_medium_dirty) { + g_print("pressure: too much dirty data (1)\n"); + return 1; + } + + if (dirty_journals > 1 && dirty_journals > dirty_limit / 2) { + printf("pressure: many dirty journals (%d), should start writeback (1)\n", + dirty_journals); + return 1; + } + + return 0; +} + void bluesky_flushd_invoke_conditional(BlueSkyFS *fs) { - if (g_atomic_int_get(&fs->cache_dirty) < bluesky_watermark_medium_dirty) + int pressure = compute_pressure(fs); + if (pressure == 0) return; if (bluesky_verbose) { @@ -416,16 +495,26 @@ void bluesky_flushd_invoke_conditional(BlueSkyFS *fs) /* If the system is under heavy memory pressure, actually delay execution * so the flush daemon can catch up. */ - while (g_atomic_int_get(&fs->cache_dirty) - + g_atomic_int_get(&fs->cache_log_dirty) - > bluesky_watermark_high_dirty) { + while (pressure > 1) { g_log("bluesky/flushd", G_LOG_LEVEL_DEBUG, "Waiting due to memory pressure, dirty=%d + %d", g_atomic_int_get(&fs->cache_dirty), g_atomic_int_get(&fs->cache_log_dirty)); g_mutex_lock(fs->lock); - g_cond_wait(fs->flushd_cond, fs->lock); + pressure = compute_pressure(fs); + if (pressure > 2) { + g_cond_wait(fs->flushd_cond, fs->lock); + } else if (pressure > 1) { + /* Wait for up to 10 seconds. */ + GTimeVal timeout; + g_get_current_time(&timeout); + g_time_val_add(&timeout, 10 * 1000 * 1000); + g_cond_timed_wait(fs->flushd_cond, fs->lock, &timeout); + } g_mutex_unlock(fs->lock); + pressure = compute_pressure(fs); + if (pressure == 1) + break; /* Do not loop indefinitely for a pressure of 1 */ } }