correctly set AOF base size field in server structure

[redis.git] / src / dscache.c

diff --git a/src/dscache.c b/src/dscache.c
index 92f529418359fe767eb9639872c30d4b155c24d6..46300e63700e8c7c7bc2958e5a0656db701d5b80 100644 (file)
--- a/src/dscache.c
+++ b/src/dscache.c
@@ -107,6 +107,8 @@
  */
 
 void spawnIOThread(void);
  */
 
 void spawnIOThread(void);

+int cacheScheduleIOPushJobs(int flags);
+int processActiveIOJobs(int max);

 
 /* =================== Virtual Memory - Blocking Side  ====================== */
 
 
 /* =================== Virtual Memory - Blocking Side  ====================== */
 


@@ -130,6 +132,7 @@ void dsInit(void) {
     server.io_ready_clients = listCreate();
     pthread_mutex_init(&server.io_mutex,NULL);
     pthread_cond_init(&server.io_condvar,NULL);
     server.io_ready_clients = listCreate();
     pthread_mutex_init(&server.io_mutex,NULL);
     pthread_cond_init(&server.io_condvar,NULL);

+    pthread_mutex_init(&server.bgsavethread_mutex,NULL);

     server.io_active_threads = 0;
     if (pipe(pipefds) == -1) {
         redisLog(REDIS_WARNING,"Unable to intialized DS: pipe(2): %s. Exiting."
     server.io_active_threads = 0;
     if (pipe(pipefds) == -1) {
         redisLog(REDIS_WARNING,"Unable to intialized DS: pipe(2): %s. Exiting."


@@ -182,8 +185,7 @@ int cacheFreeOneEntry(void) {
          * are swappable objects */
         int maxtries = 100;
 
          * are swappable objects */
         int maxtries = 100;
 

-        if (dictSize(db->dict) == 0) continue;
-        for (i = 0; i < 5; i++) {
+        for (i = 0; i < 5 && dictSize(db->dict); i++) {

             dictEntry *de;
             double swappability;
             robj keyobj;
             dictEntry *de;
             double swappability;
             robj keyobj;


@@ -210,10 +212,17 @@ int cacheFreeOneEntry(void) {
         }
     }
     if (best == NULL) {
         }
     }
     if (best == NULL) {

-        /* FIXME: If there are objects that are in the write queue
-         * so we can't delete them we should block here, at the cost of
-         * slowness as the object cache memory limit is considered 
-         * n hard limit. */
+        /* Not able to free a single object? we should check if our
+         * IO queues have stuff in queue, and try to consume the queue
+         * otherwise we'll use an infinite amount of memory if changes to
+         * the dataset are faster than I/O */
+        if (listLength(server.cache_io_queue) > 0) {
+            redisLog(REDIS_DEBUG,"--- Busy waiting IO to reclaim memory");
+            cacheScheduleIOPushJobs(REDIS_IO_ASAP);
+            processActiveIOJobs(1);
+            return REDIS_OK;
+        }
+        /* Nothing to free at all... */

         return REDIS_ERR;
     }
     key = dictGetEntryKey(best);
         return REDIS_ERR;
     }
     key = dictGetEntryKey(best);


@@ -231,13 +240,6 @@ int cacheFreeOneEntry(void) {
     return REDIS_OK;
 }
 
     return REDIS_OK;
 }
 

-/* Return true if it's safe to swap out objects in a given moment.
- * Basically we don't want to swap objects out while there is a BGSAVE
- * or a BGAEOREWRITE running in backgroud. */
-int dsCanTouchDiskStore(void) {
-    return (server.bgsavechildpid == -1 && server.bgrewritechildpid == -1);
-}
-

 /* ==================== Disk store negative caching  ========================
  *
  * When disk store is enabled, we need negative caching, that is, to remember
 /* ==================== Disk store negative caching  ========================
  *
  * When disk store is enabled, we need negative caching, that is, to remember


@@ -314,7 +316,14 @@ void freeIOJob(iojob *j) {
 
 /* Every time a thread finished a Job, it writes a byte into the write side
  * of an unix pipe in order to "awake" the main thread, and this function
 
 /* Every time a thread finished a Job, it writes a byte into the write side
  * of an unix pipe in order to "awake" the main thread, and this function

- * is called. */
+ * is called.
+ *
+ * If privdata == NULL the function will try to put more jobs in the queue
+ * of IO jobs to process as more room is made. privdata is equal to NULL
+ * when the function is called from the event loop, so we want to push
+ * more IO jobs in the queue. Instead when the function is called by
+ * other functions that want to create a write-barrier to avoid race 
+ * conditions we don't push new jobs in the queue. */

 void vmThreadedIOCompletedJob(aeEventLoop *el, int fd, void *privdata,
             int mask)
 {
 void vmThreadedIOCompletedJob(aeEventLoop *el, int fd, void *privdata,
             int mask)
 {


@@ -322,7 +331,6 @@ void vmThreadedIOCompletedJob(aeEventLoop *el, int fd, void *privdata,
     int retval, processed = 0, toprocess = -1;
     REDIS_NOTUSED(el);
     REDIS_NOTUSED(mask);
     int retval, processed = 0, toprocess = -1;
     REDIS_NOTUSED(el);
     REDIS_NOTUSED(mask);

-    REDIS_NOTUSED(privdata);

 
     /* For every byte we read in the read side of the pipe, there is one
      * I/O job completed to process. */
 
     /* For every byte we read in the read side of the pipe, there is one
      * I/O job completed to process. */


@@ -375,12 +383,12 @@ void vmThreadedIOCompletedJob(aeEventLoop *el, int fd, void *privdata,
             }
             cacheScheduleIODelFlag(j->db,j->key,REDIS_IO_LOADINPROG);
             handleClientsBlockedOnSwappedKey(j->db,j->key);
             }
             cacheScheduleIODelFlag(j->db,j->key,REDIS_IO_LOADINPROG);
             handleClientsBlockedOnSwappedKey(j->db,j->key);

-            freeIOJob(j);

         } else if (j->type == REDIS_IOJOB_SAVE) {
             cacheScheduleIODelFlag(j->db,j->key,REDIS_IO_SAVEINPROG);
         } else if (j->type == REDIS_IOJOB_SAVE) {
             cacheScheduleIODelFlag(j->db,j->key,REDIS_IO_SAVEINPROG);

-            freeIOJob(j);

         }
         }

+        freeIOJob(j);

         processed++;
         processed++;

+        if (privdata == NULL) cacheScheduleIOPushJobs(0);

         if (processed == toprocess) return;
     }
     if (retval < 0 && errno != EAGAIN) {
         if (processed == toprocess) return;
     }
     if (retval < 0 && errno != EAGAIN) {


@@ -402,6 +410,7 @@ void *IOThreadEntryPoint(void *arg) {
     iojob *j;
     listNode *ln;
     REDIS_NOTUSED(arg);
     iojob *j;
     listNode *ln;
     REDIS_NOTUSED(arg);

+    long long start;

 
     pthread_detach(pthread_self());
     lockThreadedIO();
 
     pthread_detach(pthread_self());
     lockThreadedIO();


@@ -409,10 +418,13 @@ void *IOThreadEntryPoint(void *arg) {
         /* Get a new job to process */
         if (listLength(server.io_newjobs) == 0) {
             /* Wait for more work to do */
         /* Get a new job to process */
         if (listLength(server.io_newjobs) == 0) {
             /* Wait for more work to do */

+            redisLog(REDIS_DEBUG,"[T] wait for signal");

             pthread_cond_wait(&server.io_condvar,&server.io_mutex);
             pthread_cond_wait(&server.io_condvar,&server.io_mutex);

+            redisLog(REDIS_DEBUG,"[T] signal received");

             continue;
         }
             continue;
         }

-        redisLog(REDIS_DEBUG,"%ld IO jobs to process",
+        start = ustime();
+        redisLog(REDIS_DEBUG,"[T] %ld IO jobs to process",

             listLength(server.io_newjobs));
         ln = listFirst(server.io_newjobs);
         j = ln->value;
             listLength(server.io_newjobs));
         ln = listFirst(server.io_newjobs);
         j = ln->value;


@@ -422,7 +434,7 @@ void *IOThreadEntryPoint(void *arg) {
         ln = listLast(server.io_processing); /* We use ln later to remove it */
         unlockThreadedIO();
 
         ln = listLast(server.io_processing); /* We use ln later to remove it */
         unlockThreadedIO();
 

-        redisLog(REDIS_DEBUG,"Thread %ld: new job type %s: %p about key '%s'",
+        redisLog(REDIS_DEBUG,"[T] %ld: new job type %s: %p about key '%s'",

             (long) pthread_self(),
             (j->type == REDIS_IOJOB_LOAD) ? "load" : "save",
             (void*)j, (char*)j->key->ptr);
             (long) pthread_self(),
             (j->type == REDIS_IOJOB_LOAD) ? "load" : "save",
             (void*)j, (char*)j->key->ptr);


@@ -435,22 +447,25 @@ void *IOThreadEntryPoint(void *arg) {
             if (j->val) j->expire = expire;
         } else if (j->type == REDIS_IOJOB_SAVE) {
             if (j->val) {
             if (j->val) j->expire = expire;
         } else if (j->type == REDIS_IOJOB_SAVE) {
             if (j->val) {

-                dsSet(j->db,j->key,j->val);
+                dsSet(j->db,j->key,j->val,j->expire);

             } else {
                 dsDel(j->db,j->key);
             }
         }
 
         /* Done: insert the job into the processed queue */
             } else {
                 dsDel(j->db,j->key);
             }
         }
 
         /* Done: insert the job into the processed queue */

-        redisLog(REDIS_DEBUG,"Thread %ld completed the job: %p (key %s)",
+        redisLog(REDIS_DEBUG,"[T] %ld completed the job: %p (key %s)",

             (long) pthread_self(), (void*)j, (char*)j->key->ptr);
 
             (long) pthread_self(), (void*)j, (char*)j->key->ptr);
 

+        redisLog(REDIS_DEBUG,"[T] lock IO");

         lockThreadedIO();
         lockThreadedIO();

+        redisLog(REDIS_DEBUG,"[T] IO locked");

         listDelNode(server.io_processing,ln);
         listAddNodeTail(server.io_processed,j);
 
         /* Signal the main thread there is new stuff to process */
         redisAssert(write(server.io_ready_pipe_write,"x",1) == 1);
         listDelNode(server.io_processing,ln);
         listAddNodeTail(server.io_processed,j);
 
         /* Signal the main thread there is new stuff to process */
         redisAssert(write(server.io_ready_pipe_write,"x",1) == 1);

+        redisLog(REDIS_DEBUG,"TIME (%c): %lld\n", j->type == REDIS_IOJOB_LOAD ? 'L' : 'S', ustime()-start);

     }
     /* never reached, but that's the full pattern... */
     unlockThreadedIO();
     }
     /* never reached, but that's the full pattern... */
     unlockThreadedIO();


@@ -476,62 +491,95 @@ void spawnIOThread(void) {
     server.io_active_threads++;
 }
 
     server.io_active_threads++;
 }
 

-/* Wait that all the pending IO Jobs are processed */
-void waitEmptyIOJobsQueue(void) {
-    while(1) {
+/* Wait that up to 'max' pending IO Jobs are processed by the I/O thread.
+ * From our point of view an IO job processed means that the count of
+ * server.io_processed must increase by one.
+ *
+ * If max is -1, all the pending IO jobs will be processed.
+ *
+ * Returns the number of IO jobs processed.
+ *
+ * NOTE: while this may appear like a busy loop, we are actually blocked
+ * by IO since we continuously acquire/release the IO lock. */
+int processActiveIOJobs(int max) {
+    int processed = 0;
+
+    while(max == -1 || max > 0) {

         int io_processed_len;
 
         int io_processed_len;
 

+        redisLog(REDIS_DEBUG,"[P] lock IO");

         lockThreadedIO();
         lockThreadedIO();

+        redisLog(REDIS_DEBUG,"Waiting IO jobs processing: new:%d proessing:%d processed:%d",listLength(server.io_newjobs),listLength(server.io_processing),listLength(server.io_processed));
+

         if (listLength(server.io_newjobs) == 0 &&
             listLength(server.io_processing) == 0)
         {
         if (listLength(server.io_newjobs) == 0 &&
             listLength(server.io_processing) == 0)
         {

+            /* There is nothing more to process */
+            redisLog(REDIS_DEBUG,"[P] Nothing to process, unlock IO, return");

             unlockThreadedIO();
             unlockThreadedIO();

-            return;
+            break;

         }
         }

+
+#if 1

         /* If there are new jobs we need to signal the thread to
         /* If there are new jobs we need to signal the thread to

-         * process the next one. */
-        redisLog(REDIS_DEBUG,"waitEmptyIOJobsQueue: new %d, processing %d",
+         * process the next one. FIXME: drop this if useless. */
+        redisLog(REDIS_DEBUG,"[P] waitEmptyIOJobsQueue: new %d, processing %d, processed %d",

             listLength(server.io_newjobs),
             listLength(server.io_newjobs),

-            listLength(server.io_processing));
+            listLength(server.io_processing),
+            listLength(server.io_processed));

 
 

-        /* FIXME: signal or not?

         if (listLength(server.io_newjobs)) {
         if (listLength(server.io_newjobs)) {

+            redisLog(REDIS_DEBUG,"[P] There are new jobs, signal");

             pthread_cond_signal(&server.io_condvar);
         }
             pthread_cond_signal(&server.io_condvar);
         }

-        */
-        /* While waiting for empty jobs queue condition we post-process some
-         * finshed job, as I/O threads may be hanging trying to write against
-         * the io_ready_pipe_write FD but there are so much pending jobs that
-         * it's blocking. */
+#endif
+
+        /* Check if we can process some finished job */

         io_processed_len = listLength(server.io_processed);
         io_processed_len = listLength(server.io_processed);

+        redisLog(REDIS_DEBUG,"[P] Unblock IO");

         unlockThreadedIO();
         unlockThreadedIO();

+        redisLog(REDIS_DEBUG,"[P] Wait");
+        usleep(10000);

         if (io_processed_len) {
             vmThreadedIOCompletedJob(NULL,server.io_ready_pipe_read,
                                                         (void*)0xdeadbeef,0);
         if (io_processed_len) {
             vmThreadedIOCompletedJob(NULL,server.io_ready_pipe_read,
                                                         (void*)0xdeadbeef,0);

-            /* FIXME: probably wiser to drop this sleeps. Anyway 
-             * the contention on the IO thread will avoid we to loop
-             * too fast here. */
-            usleep(1000); /* 1 millisecond */
-        } else {
-            /* FIXME: same as fixme above. */
-            usleep(10000); /* 10 milliseconds */
+            processed++;
+            if (max != -1) max--;

         }
     }
         }
     }

+    return processed;

 }
 
 }
 

-/* Process all the IO Jobs already completed by threads but still waiting
- * processing from the main thread. */
-void processAllPendingIOJobs(void) {
-    while(1) {
+void waitEmptyIOJobsQueue(void) {
+    processActiveIOJobs(-1);
+}
+
+/* Process up to 'max' IO Jobs already completed by threads but still waiting
+ * processing from the main thread.
+ *
+ * If max == -1 all the pending jobs are processed.
+ *
+ * The number of processed jobs is returned. */
+int processPendingIOJobs(int max) {
+    int processed = 0;
+
+    while(max == -1 || max > 0) {

         int io_processed_len;
 
         lockThreadedIO();
         io_processed_len = listLength(server.io_processed);
         unlockThreadedIO();
         int io_processed_len;
 
         lockThreadedIO();
         io_processed_len = listLength(server.io_processed);
         unlockThreadedIO();

-        if (io_processed_len == 0) return;
+        if (io_processed_len == 0) break;

         vmThreadedIOCompletedJob(NULL,server.io_ready_pipe_read,
                                                     (void*)0xdeadbeef,0);
         vmThreadedIOCompletedJob(NULL,server.io_ready_pipe_read,
                                                     (void*)0xdeadbeef,0);

+        if (max != -1) max--;
+        processed++;

     }
     }

+    return processed;
+}
+
+void processAllPendingIOJobs(void) {
+    processPendingIOJobs(-1);

 }
 
 /* This function must be called while with threaded IO locked */
 }
 
 /* This function must be called while with threaded IO locked */


@@ -539,11 +587,23 @@ void queueIOJob(iojob *j) {
     redisLog(REDIS_DEBUG,"Queued IO Job %p type %d about key '%s'\n",
         (void*)j, j->type, (char*)j->key->ptr);
     listAddNodeTail(server.io_newjobs,j);
     redisLog(REDIS_DEBUG,"Queued IO Job %p type %d about key '%s'\n",
         (void*)j, j->type, (char*)j->key->ptr);
     listAddNodeTail(server.io_newjobs,j);

-    if (server.io_active_threads < server.vm_max_threads)
-        spawnIOThread();

 }
 
 }
 

-void dsCreateIOJob(int type, redisDb *db, robj *key, robj *val) {
+/* Consume all the IO scheduled operations, and all the thread IO jobs
+ * so that eventually the state of diskstore is a point-in-time snapshot.
+ *
+ * This is useful when we need to BGSAVE with diskstore enabled. */
+void cacheForcePointInTime(void) {
+    redisLog(REDIS_NOTICE,"Diskstore: synching on disk to reach point-in-time state.");
+    while (listLength(server.cache_io_queue) != 0) {
+        cacheScheduleIOPushJobs(REDIS_IO_ASAP);
+        processActiveIOJobs(1);
+    }
+    waitEmptyIOJobsQueue();
+    processAllPendingIOJobs();
+}
+
+void cacheCreateIOJob(int type, redisDb *db, robj *key, robj *val, time_t expire) {

     iojob *j;
 
     j = zmalloc(sizeof(*j));
     iojob *j;
 
     j = zmalloc(sizeof(*j));


@@ -553,6 +613,7 @@ void dsCreateIOJob(int type, redisDb *db, robj *key, robj *val) {
     incrRefCount(key);
     j->val = val;
     if (val) incrRefCount(val);
     incrRefCount(key);
     j->val = val;
     if (val) incrRefCount(val);

+    j->expire = expire;

 
     lockThreadedIO();
     queueIOJob(j);
 
     lockThreadedIO();
     queueIOJob(j);


@@ -597,8 +658,6 @@ void dsCreateIOJob(int type, redisDb *db, robj *key, robj *val) {
 #define REDIS_IO_LOADINPROG 4
 #define REDIS_IO_SAVEINPROG 8
 
 #define REDIS_IO_LOADINPROG 4
 #define REDIS_IO_SAVEINPROG 8
 

-void cacheScheduleIOPushJobs(int onlyloads);
-

 void cacheScheduleIOAddFlag(redisDb *db, robj *key, long flag) {
     struct dictEntry *de = dictFind(db->io_queued,key);
 
 void cacheScheduleIOAddFlag(redisDb *db, robj *key, long flag) {
     struct dictEntry *de = dictFind(db->io_queued,key);
 


@@ -659,7 +718,7 @@ void cacheScheduleIO(redisDb *db, robj *key, int type) {
      * in queue for the same key. */
     if (type == REDIS_IO_LOAD && !(flags & REDIS_IO_SAVE)) {
         listAddNodeHead(server.cache_io_queue, op);
      * in queue for the same key. */
     if (type == REDIS_IO_LOAD && !(flags & REDIS_IO_SAVE)) {
         listAddNodeHead(server.cache_io_queue, op);

-        cacheScheduleIOPushJobs(1);
+        cacheScheduleIOPushJobs(REDIS_IO_ONLYLOADS);

     } else {
         /* FIXME: probably when this happens we want to at least move
          * the write job about this queue on top, and set the creation time
     } else {
         /* FIXME: probably when this happens we want to at least move
          * the write job about this queue on top, and set the creation time


@@ -669,16 +728,25 @@ void cacheScheduleIO(redisDb *db, robj *key, int type) {
 }
 
 /* Push scheduled IO operations into IO Jobs that the IO thread can process.
 }
 
 /* Push scheduled IO operations into IO Jobs that the IO thread can process.

- * If 'onlyloads' is true only IO_LOAD jobs are processed: this is useful
- * since it's save to push LOAD IO jobs from any place of the code, while
+ *
+ * If flags include REDIS_IO_ONLYLOADS only load jobs are processed:this is
+ * useful since it's safe to push LOAD IO jobs from any place of the code, while

  * SAVE io jobs should never be pushed while we are processing a command
  * (not protected by lookupKey() that will block on keys in IO_SAVEINPROG
  * SAVE io jobs should never be pushed while we are processing a command
  * (not protected by lookupKey() that will block on keys in IO_SAVEINPROG

- * state. */
-#define MAX_IO_JOBS_QUEUE 100
-void cacheScheduleIOPushJobs(int onlyloads) {
+ * state.
+ *
+ * The REDIS_IO_ASAP flag tells the function to don't wait for the IO job
+ * scheduled completion time, but just do the operation ASAP. This is useful
+ * when we need to reclaim memory from the IO queue.
+ */
+#define MAX_IO_JOBS_QUEUE 10
+int cacheScheduleIOPushJobs(int flags) {

     time_t now = time(NULL);
     listNode *ln;
     time_t now = time(NULL);
     listNode *ln;

-    int jobs, topush = 0;
+    int jobs, topush = 0, pushed = 0;
+
+    /* Don't push new jobs if there is a threaded BGSAVE in progress. */
+    if (server.bgsavethread != (pthread_t) -1) return 0;

 
     /* Sync stuff on disk, but only if we have less
      * than MAX_IO_JOBS_QUEUE IO jobs. */
 
     /* Sync stuff on disk, but only if we have less
      * than MAX_IO_JOBS_QUEUE IO jobs. */


@@ -693,66 +761,70 @@ void cacheScheduleIOPushJobs(int onlyloads) {
 
     while((ln = listFirst(server.cache_io_queue)) != NULL) {
         ioop *op = ln->value;
 
     while((ln = listFirst(server.cache_io_queue)) != NULL) {
         ioop *op = ln->value;

+        struct dictEntry *de;
+        robj *val;

 
         if (!topush) break;
         topush--;
 
 
         if (!topush) break;
         topush--;
 

-        if (op->type == REDIS_IO_LOAD ||
-            (!onlyloads && (now - op->ctime) >= server.cache_flush_delay))
+        if (op->type != REDIS_IO_LOAD && flags & REDIS_IO_ONLYLOADS) break;
+
+        /* Don't execute SAVE before the scheduled time for completion */
+        if (op->type == REDIS_IO_SAVE && !(flags & REDIS_IO_ASAP) &&
+              (now - op->ctime) < server.cache_flush_delay) break;
+
+        /* Don't add a SAVE job in the IO thread queue if there is already
+         * a save in progress for the same key. */
+        if (op->type == REDIS_IO_SAVE && 
+            cacheScheduleIOGetFlags(op->db,op->key) & REDIS_IO_SAVEINPROG)

         {
         {

-            struct dictEntry *de;
-            robj *val;
-
-            /* Don't add a SAVE job in queue if there is already
-             * a save in progress for the same key. */
-            if (op->type == REDIS_IO_SAVE && 
-                cacheScheduleIOGetFlags(op->db,op->key) & REDIS_IO_SAVEINPROG)
-            {
-                /* Move the operation at the end of the list of there
-                 * are other operations. Otherwise break, nothing to do
-                 * here. */
-                if (listLength(server.cache_io_queue) > 1) {
-                    listDelNode(server.cache_io_queue,ln);
-                    listAddNodeTail(server.cache_io_queue,op);
-                    continue;
-                } else {
-                    break;
-                }
+            /* Move the operation at the end of the list if there
+             * are other operations, so we can try to process the next one.
+             * Otherwise break, nothing to do here. */
+            if (listLength(server.cache_io_queue) > 1) {
+                listDelNode(server.cache_io_queue,ln);
+                listAddNodeTail(server.cache_io_queue,op);
+                continue;
+            } else {
+                break;

             }
             }

+        }

 
 

-            redisLog(REDIS_DEBUG,"Creating IO %s Job for key %s",
-                op->type == REDIS_IO_LOAD ? "load" : "save", op->key->ptr);
+        redisLog(REDIS_DEBUG,"Creating IO %s Job for key %s",
+            op->type == REDIS_IO_LOAD ? "load" : "save", op->key->ptr);

 
 

-            if (op->type == REDIS_IO_LOAD) {
-                dsCreateIOJob(REDIS_IOJOB_LOAD,op->db,op->key,NULL);
+        if (op->type == REDIS_IO_LOAD) {
+            cacheCreateIOJob(REDIS_IOJOB_LOAD,op->db,op->key,NULL,0);
+        } else {
+            time_t expire = -1;
+
+            /* Lookup the key, in order to put the current value in the IO
+             * Job. Otherwise if the key does not exists we schedule a disk
+             * store delete operation, setting the value to NULL. */
+            de = dictFind(op->db->dict,op->key->ptr);
+            if (de) {
+                val = dictGetEntryVal(de);
+                expire = getExpire(op->db,op->key);

             } else {
             } else {

-                /* Lookup the key, in order to put the current value in the IO
-                 * Job. Otherwise if the key does not exists we schedule a disk
-                 * store delete operation, setting the value to NULL. */
-                de = dictFind(op->db->dict,op->key->ptr);
-                if (de) {
-                    val = dictGetEntryVal(de);
-                } else {
-                    /* Setting the value to NULL tells the IO thread to delete
-                     * the key on disk. */
-                    val = NULL;
-                }
-                dsCreateIOJob(REDIS_IOJOB_SAVE,op->db,op->key,val);
+                /* Setting the value to NULL tells the IO thread to delete
+                 * the key on disk. */
+                val = NULL;

             }
             }

-            /* Mark the operation as in progress. */
-            cacheScheduleIODelFlag(op->db,op->key,op->type);
-            cacheScheduleIOAddFlag(op->db,op->key,
-                (op->type == REDIS_IO_LOAD) ? REDIS_IO_LOADINPROG :
-                                              REDIS_IO_SAVEINPROG);
-            /* Finally remove the operation from the queue.
-             * But we'll have trace of it in the hash table. */
-            listDelNode(server.cache_io_queue,ln);
-            decrRefCount(op->key);
-            zfree(op);
-        } else {
-            break; /* too early */
+            cacheCreateIOJob(REDIS_IOJOB_SAVE,op->db,op->key,val,expire);

         }
         }

+        /* Mark the operation as in progress. */
+        cacheScheduleIODelFlag(op->db,op->key,op->type);
+        cacheScheduleIOAddFlag(op->db,op->key,
+            (op->type == REDIS_IO_LOAD) ? REDIS_IO_LOADINPROG :
+                                          REDIS_IO_SAVEINPROG);
+        /* Finally remove the operation from the queue.
+         * But we'll have trace of it in the hash table. */
+        listDelNode(server.cache_io_queue,ln);
+        decrRefCount(op->key);
+        zfree(op);
+        pushed++;

     }
     }

+    return pushed;

 }
 
 void cacheCron(void) {
 }
 
 void cacheCron(void) {


@@ -818,62 +890,17 @@ int waitForSwappedKey(redisClient *c, robj *key) {
     listAddNodeTail(l,c);
 
     /* Are we already loading the key from disk? If not create a job */
     listAddNodeTail(l,c);
 
     /* Are we already loading the key from disk? If not create a job */

-    if (de == NULL)
-        cacheScheduleIO(c->db,key,REDIS_IO_LOAD);
-    return 1;
-}
-
-/* Preload keys for any command with first, last and step values for
- * the command keys prototype, as defined in the command table. */
-void waitForMultipleSwappedKeys(redisClient *c, struct redisCommand *cmd, int argc, robj **argv) {
-    int j, last;
-    if (cmd->vm_firstkey == 0) return;
-    last = cmd->vm_lastkey;
-    if (last < 0) last = argc+last;
-    for (j = cmd->vm_firstkey; j <= last; j += cmd->vm_keystep) {
-        redisAssert(j < argc);
-        waitForSwappedKey(c,argv[j]);
-    }
-}
-
-/* Preload keys needed for the ZUNIONSTORE and ZINTERSTORE commands.
- * Note that the number of keys to preload is user-defined, so we need to
- * apply a sanity check against argc. */
-void zunionInterBlockClientOnSwappedKeys(redisClient *c, struct redisCommand *cmd, int argc, robj **argv) {
-    int i, num;
-    REDIS_NOTUSED(cmd);
-
-    num = atoi(argv[2]->ptr);
-    if (num > (argc-3)) return;
-    for (i = 0; i < num; i++) {
-        waitForSwappedKey(c,argv[3+i]);
-    }
-}
-
-/* Preload keys needed to execute the entire MULTI/EXEC block.
- *
- * This function is called by blockClientOnSwappedKeys when EXEC is issued,
- * and will block the client when any command requires a swapped out value. */
-void execBlockClientOnSwappedKeys(redisClient *c, struct redisCommand *cmd, int argc, robj **argv) {
-    int i, margc;
-    struct redisCommand *mcmd;
-    robj **margv;
-    REDIS_NOTUSED(cmd);
-    REDIS_NOTUSED(argc);
-    REDIS_NOTUSED(argv);
-
-    if (!(c->flags & REDIS_MULTI)) return;
-    for (i = 0; i < c->mstate.count; i++) {
-        mcmd = c->mstate.commands[i].cmd;
-        margc = c->mstate.commands[i].argc;
-        margv = c->mstate.commands[i].argv;
-
-        if (mcmd->vm_preload_proc != NULL) {
-            mcmd->vm_preload_proc(c,mcmd,margc,margv);
-        } else {
-            waitForMultipleSwappedKeys(c,mcmd,margc,margv);
-        }
+    if (de == NULL) {
+        int flags = cacheScheduleIOGetFlags(c->db,key);
+
+        /* It is possible that even if there are no clients waiting for
+         * a load operation, still we have a load operation in progress.
+         * For instance think to a client performing a GET and then
+         * closing the connection */
+        if ((flags & (REDIS_IO_LOAD|REDIS_IO_LOADINPROG)) == 0)
+            cacheScheduleIO(c->db,key,REDIS_IO_LOAD);

     }
     }

+    return 1;

 }
 
 /* Is this client attempting to run a command against swapped keys?
 }
 
 /* Is this client attempting to run a command against swapped keys?


@@ -887,10 +914,39 @@ void execBlockClientOnSwappedKeys(redisClient *c, struct redisCommand *cmd, int
  * Return 1 if the client is marked as blocked, 0 if the client can
  * continue as the keys it is going to access appear to be in memory. */
 int blockClientOnSwappedKeys(redisClient *c, struct redisCommand *cmd) {
  * Return 1 if the client is marked as blocked, 0 if the client can
  * continue as the keys it is going to access appear to be in memory. */
 int blockClientOnSwappedKeys(redisClient *c, struct redisCommand *cmd) {

-    if (cmd->vm_preload_proc != NULL) {
-        cmd->vm_preload_proc(c,cmd,c->argc,c->argv);
+    int *keyindex, numkeys, j, i;
+
+    /* EXEC is a special case, we need to preload all the commands
+     * queued into the transaction */
+    if (cmd->proc == execCommand) {
+        struct redisCommand *mcmd;
+        robj **margv;
+        int margc;
+
+        if (!(c->flags & REDIS_MULTI)) return 0;
+        for (i = 0; i < c->mstate.count; i++) {
+            mcmd = c->mstate.commands[i].cmd;
+            margc = c->mstate.commands[i].argc;
+            margv = c->mstate.commands[i].argv;
+
+            keyindex = getKeysFromCommand(mcmd,margv,margc,&numkeys,
+                                          REDIS_GETKEYS_PRELOAD);
+            for (j = 0; j < numkeys; j++) {
+                redisLog(REDIS_DEBUG,"Preloading %s",
+                    (char*)margv[keyindex[j]]->ptr);
+                waitForSwappedKey(c,margv[keyindex[j]]);
+            }
+            getKeysFreeResult(keyindex);
+        }

     } else {
     } else {

-        waitForMultipleSwappedKeys(c,cmd,c->argc,c->argv);
+        keyindex = getKeysFromCommand(cmd,c->argv,c->argc,&numkeys,
+                                      REDIS_GETKEYS_PRELOAD);
+        for (j = 0; j < numkeys; j++) {
+            redisLog(REDIS_DEBUG,"Preloading %s",
+                (char*)c->argv[keyindex[j]]->ptr);
+            waitForSwappedKey(c,c->argv[keyindex[j]]);
+        }
+        getKeysFreeResult(keyindex);

     }
 
     /* If the client was blocked for at least one key, mark it as blocked. */
     }
 
     /* If the client was blocked for at least one key, mark it as blocked. */