diskstore removed

redis.conf

@@ -312,32 +312,6 @@ no-appendfsync-on-rewrite no
 auto-aof-rewrite-percentage 100
 auto-aof-rewrite-min-size 64mb
 
-#################################### DISK STORE ###############################
-
-# When disk store is active Redis works as an on-disk database, where memory
-# is only used as a object cache.
-#
-# This mode is good for datasets that are bigger than memory, and in general
-# when you want to trade speed for:
-#
-# - less memory used
-# - immediate server restart
-# - per key durability, without need for backgrond savig
-#
-# On the other hand, with disk store enabled MULTI/EXEC are no longer
-# transactional from the point of view of the persistence on disk, that is,
-# Redis transactions will still guarantee that commands are either processed
-# all or nothing, but there is no guarantee that all the keys are flushed
-# on disk in an atomic way.
-#
-# Of course with disk store enabled Redis is not as fast as it is when
-# working with just the memory back end.
-
-diskstore-enabled no
-diskstore-path redis.ds
-cache-max-memory 0
-cache-flush-delay 0
-
 ############################### ADVANCED CONFIG ###############################
 
 # Hashes are encoded in a special way (much more memory efficient) when they

src/Makefile

@@ -61,7 +61,7 @@ QUIET_CC = @printf ' %b %b\n' $(CCCOLOR)CC$(ENDCOLOR) $(SRCCOLOR)$@$(ENDCOLOR
 QUIET_LINK = @printf ' %b %b\n' $(LINKCOLOR)LINK$(ENDCOLOR) $(BINCOLOR)$@$(ENDCOLOR);
 endif
 
-OBJ = adlist.o ae.o anet.o dict.o redis.o sds.o zmalloc.o lzf_c.o lzf_d.o pqsort.o zipmap.o sha1.o ziplist.o release.o networking.o util.o object.o db.o replication.o rdb.o t_string.o t_list.o t_set.o t_zset.o t_hash.o config.o aof.o dscache.o pubsub.o multi.o debug.o sort.o intset.o syncio.o diskstore.o cluster.o crc16.o endian.o
+OBJ = adlist.o ae.o anet.o dict.o redis.o sds.o zmalloc.o lzf_c.o lzf_d.o pqsort.o zipmap.o sha1.o ziplist.o release.o networking.o util.o object.o db.o replication.o rdb.o t_string.o t_list.o t_set.o t_zset.o t_hash.o config.o aof.o pubsub.o multi.o debug.o sort.o intset.o syncio.o cluster.o crc16.o endian.o
 BENCHOBJ = ae.o anet.o redis-benchmark.o sds.o adlist.o zmalloc.o
 CLIOBJ = anet.o sds.o adlist.o redis-cli.o zmalloc.o release.o
 CHECKDUMPOBJ = redis-check-dump.o lzf_c.o lzf_d.o

src/aof.c

@@ -574,10 +574,6 @@ int rewriteAppendOnlyFileBackground(void) {
  long long start;
 
  if (server.bgrewritechildpid != -1) return REDIS_ERR;
- if (server.ds_enabled != 0) {
- redisLog(REDIS_WARNING,"BGREWRITEAOF called with diskstore enabled: AOF is not supported when diskstore is enabled. Operation not performed.");
- return REDIS_ERR;
- }
  start = ustime();
  if ((childpid = fork()) == 0) {
  char tmpfile[256];

src/config.c

@@ -251,18 +251,6 @@ void loadServerConfig(char *filename) {
  } else if (!strcasecmp(argv[0],"dbfilename") && argc == 2) {
  zfree(server.dbfilename);
  server.dbfilename = zstrdup(argv[1]);
- } else if (!strcasecmp(argv[0],"diskstore-enabled") && argc == 2) {
- if ((server.ds_enabled = yesnotoi(argv[1])) == -1) {
- err = "argument must be 'yes' or 'no'"; goto loaderr;
- }
- } else if (!strcasecmp(argv[0],"diskstore-path") && argc == 2) {
- sdsfree(server.ds_path);
- server.ds_path = sdsnew(argv[1]);
- } else if (!strcasecmp(argv[0],"cache-max-memory") && argc == 2) {
- server.cache_max_memory = memtoll(argv[1],NULL);
- } else if (!strcasecmp(argv[0],"cache-flush-delay") && argc == 2) {
- server.cache_flush_delay = atoi(argv[1]);
- if (server.cache_flush_delay < 0) server.cache_flush_delay = 0;
  } else if (!strcasecmp(argv[0],"hash-max-zipmap-entries") && argc == 2) {
  server.hash_max_zipmap_entries = memtoll(argv[1], NULL);
  } else if (!strcasecmp(argv[0],"hash-max-zipmap-value") && argc == 2) {

src/db.c

@@ -31,13 +31,6 @@ void SlotToKeyDel(robj *key);
  * the disk object. If it is in this state, we wait.
  */
 
-void lookupWaitBusyKey(redisDb *db, robj *key) {
- /* FIXME: wait just for this key, not everything */
- waitEmptyIOJobsQueue();
- processAllPendingIOJobs();
- redisAssert((cacheScheduleIOGetFlags(db,key) & REDIS_IO_SAVEINPROG) == 0);
-}
-
 robj *lookupKey(redisDb *db, robj *key) {
  dictEntry *de = dictFind(db->dict,key->ptr);
  if (de) {
@@ -48,52 +41,9 @@ robj *lookupKey(redisDb *db, robj *key) {
  * a copy on write madness. */
  if (server.bgsavechildpid == -1 && server.bgrewritechildpid == -1)
  val->lru = server.lruclock;
-
- if (server.ds_enabled &&
- cacheScheduleIOGetFlags(db,key) & REDIS_IO_SAVEINPROG)
- {
- /* Need to wait for the key to get unbusy */
- redisLog(REDIS_DEBUG,"Lookup found a key in SAVEINPROG state. Waiting. (Key was in the cache)");
- lookupWaitBusyKey(db,key);
- }
  server.stat_keyspace_hits++;
  return val;
  } else {
- time_t expire;
- robj *val;
-
- /* Key not found in the in memory hash table, but if disk store is
- * enabled we may have this key on disk. If so load it in memory
- * in a blocking way. */
- if (server.ds_enabled && cacheKeyMayExist(db,key)) {
- long flags = cacheScheduleIOGetFlags(db,key);
-
- /* They key is not in cache, but it has a SAVE op in queue?
- * The only possibility is that the key was deleted, since
- * dirty keys are not evicted. */
- if (flags & REDIS_IO_SAVE) {
- server.stat_keyspace_misses++;
- return NULL;
- }
-
- /* At this point we need to blocking load the key in memory.
- * The first thing we do is waiting here if the key is busy. */
- if (flags & REDIS_IO_SAVEINPROG) {
- redisLog(REDIS_DEBUG,"Lookup found a key in SAVEINPROG state. Waiting (while force loading).");
- lookupWaitBusyKey(db,key);
- }
-
- redisLog(REDIS_DEBUG,"Force loading key %s via lookup", key->ptr);
- val = dsGet(db,key,&expire);
- if (val) {
- dbAdd(db,key,val);
- if (expire != -1) setExpire(db,key,expire);
- server.stat_keyspace_hits++;
- return val;
- } else {
- cacheSetKeyDoesNotExist(db,key);
- }
- }
  server.stat_keyspace_misses++;
  return NULL;
  }
@@ -130,7 +80,6 @@ void dbAdd(redisDb *db, robj *key, robj *val) {
  int retval = dictAdd(db->dict, copy, val);
 
  redisAssert(retval == REDIS_OK);
- if (server.ds_enabled) cacheSetKeyMayExist(db,key);
  if (server.cluster_enabled) SlotToKeyAdd(key);
  }
 
@@ -144,7 +93,6 @@ void dbOverwrite(redisDb *db, robj *key, robj *val) {
 
  redisAssert(de != NULL);
  dictReplace(db->dict, key->ptr, val);
- if (server.ds_enabled) cacheSetKeyMayExist(db,key);
 }
 
 /* High level Set operation. This function can be used in order to set
@@ -196,14 +144,6 @@ robj *dbRandomKey(redisDb *db) {
 
 /* Delete a key, value, and associated expiration entry if any, from the DB */
 int dbDelete(redisDb *db, robj *key) {
- /* If diskstore is enabled make sure to awake waiting clients for this key
- * as it is not really useful to wait for a key already deleted to be
- * loaded from disk. */
- if (server.ds_enabled) {
- handleClientsBlockedOnSwappedKey(db,key);
- cacheSetKeyDoesNotExist(db,key);
- }
-
  /* Deleting an entry from the expires dict will not free the sds of
  * the key, because it is shared with the main dictionary. */
  if (dictSize(db->expires) > 0) dictDelete(db->expires,key->ptr);
@@ -225,7 +165,6 @@ long long emptyDb() {
  removed += dictSize(server.db[j].dict);
  dictEmpty(server.db[j].dict);
  dictEmpty(server.db[j].expires);
- if (server.ds_enabled) dictEmpty(server.db[j].io_negcache);
  }
  return removed;
 }
@@ -248,8 +187,6 @@ int selectDb(redisClient *c, int id) {
 
 void signalModifiedKey(redisDb *db, robj *key) {
  touchWatchedKey(db,key);
- if (server.ds_enabled)
- cacheScheduleIO(db,key,REDIS_IO_SAVE);
 }
 
 void signalFlushedDb(int dbid) {
@@ -265,7 +202,6 @@ void flushdbCommand(redisClient *c) {
  signalFlushedDb(c->db->id);
  dictEmpty(c->db->dict);
  dictEmpty(c->db->expires);
- if (server.ds_enabled) dsFlushDb(c->db->id);
  addReply(c,shared.ok);
 }
 
@@ -277,33 +213,18 @@ void flushallCommand(redisClient *c) {
  kill(server.bgsavechildpid,SIGKILL);
  rdbRemoveTempFile(server.bgsavechildpid);
  }
- if (server.ds_enabled)
- dsFlushDb(-1);
- else
- rdbSave(server.dbfilename);
+ rdbSave(server.dbfilename);
  server.dirty++;
 }
 
 void delCommand(redisClient *c) {
  int deleted = 0, j;
 
  for (j = 1; j < c->argc; j++) {
- if (server.ds_enabled) {
- lookupKeyRead(c->db,c->argv[j]);
- /* FIXME: this can be optimized a lot, no real need to load
- * a possibly huge value. */
- }
  if (dbDelete(c->db,c->argv[j])) {
  signalModifiedKey(c->db,c->argv[j]);
  server.dirty++;
  deleted++;
- } else if (server.ds_enabled) {
- if (cacheKeyMayExist(c->db,c->argv[j]) &&
- dsExists(c->db,c->argv[j]))
- {
- cacheScheduleIO(c->db,c->argv[j],REDIS_IO_SAVE);
- deleted = 1;
- }
  }
  }
  addReplyLongLong(c,deleted);
@@ -618,7 +539,6 @@ void expireatCommand(redisClient *c) {
 void ttlCommand(redisClient *c) {
  time_t expire, ttl = -1;
 
- if (server.ds_enabled) lookupKeyRead(c->db,c->argv[1]);
  expire = getExpire(c->db,c->argv[1]);
  if (expire != -1) {
  ttl = (expire-time(NULL));

src/debug.c

@@ -212,26 +212,7 @@ void computeDatasetDigest(unsigned char *final) {
 void debugCommand(redisClient *c) {
  if (!strcasecmp(c->argv[1]->ptr,"segfault")) {
  *((char*)-1) = 'x';
- } else if (!strcasecmp(c->argv[1]->ptr,"flushcache")) {
- if (!server.ds_enabled) {
- addReplyError(c, "DEBUG FLUSHCACHE called with diskstore off.");
- return;
- } else if (server.bgsavethread != (pthread_t) -1) {
- addReplyError(c, "Can't flush cache while BGSAVE is in progress.");
- return;
- } else {
- /* To flush the whole cache we need to wait for everything to
- * be flushed on disk... */
- cacheForcePointInTime();
- emptyDb();
- addReply(c,shared.ok);
- return;
- }
  } else if (!strcasecmp(c->argv[1]->ptr,"reload")) {
- if (server.ds_enabled) {
- addReply(c,shared.ok);
- return;
- }
  if (rdbSave(server.dbfilename) != REDIS_OK) {
  addReply(c,shared.err);
  return;
@@ -256,7 +237,6 @@ void debugCommand(redisClient *c) {
  robj *val;
  char *strenc;
 
- if (server.ds_enabled) lookupKeyRead(c->db,c->argv[2]);
  if ((de = dictFind(c->db->dict,c->argv[2]->ptr)) == NULL) {
  addReply(c,shared.nokeyerr);
  return;