Issue 69 fixed. Object integer encoding now works with replication and MONITORing...

diff --git a/Changelog b/Changelog
index 1ce4d1184bcccab08c7a279fc79b18bf77c627cc..fa9174cd504d8a750d7383099e7ca1a1fc0e3172 100644 (file)
--- a/Changelog
+++ b/Changelog
@@ -1,3 +1,8 @@
+2009-09-18 LREM fixed, used to crash since the new object integer encoding is on the stage
+2009-09-17 maxmemory didn't worked in 64 systems for values > 4GB since it used to be an unsigned int. Fixed
+2009-09-10 incremented version number to 1.001, AKA Redis edge is no longer stable...
+2009-09-10 in-memory specialized object encoding (for now 32 signed integers only)
+2009-09-03 Latest doc changes for 1.0

 2009-09-03 Redis 1.0.0 release
 2009-09-02 Redis version pushed to 1.0
 2009-09-02 Ruby client lib updated to the latest git version
 2009-09-03 Redis 1.0.0 release
 2009-09-02 Redis version pushed to 1.0
 2009-09-02 Ruby client lib updated to the latest git version

diff --git a/redis.c b/redis.c
index 78b53a9da17eea1dd3ea5969b879c28307d28208..2edc186f438e2ae36a299a4870887b563bed0b34 100644 (file)
--- a/redis.c
+++ b/redis.c
@@ -342,6 +342,7 @@ static void freeMemoryIfNeeded(void);
 static int processCommand(redisClient *c);
 static void setupSigSegvAction(void);
 static void rdbRemoveTempFile(pid_t childpid);
 static int processCommand(redisClient *c);
 static void setupSigSegvAction(void);
 static void rdbRemoveTempFile(pid_t childpid);

+static size_t stringObjectLen(robj *o);

 
 static void authCommand(redisClient *c);
 static void pingCommand(redisClient *c);
 
 static void authCommand(redisClient *c);
 static void pingCommand(redisClient *c);


@@ -1412,7 +1413,8 @@ static void replicationFeedSlaves(list *slaves, struct redisCommand *cmd, int di
             robj *lenobj;
 
             lenobj = createObject(REDIS_STRING,
             robj *lenobj;
 
             lenobj = createObject(REDIS_STRING,

-                sdscatprintf(sdsempty(),"%d\r\n",sdslen(argv[j]->ptr)));
+                sdscatprintf(sdsempty(),"%d\r\n",
+                    stringObjectLen(argv[j])));

             lenobj->refcount = 0;
             outv[outc++] = lenobj;
         }
             lenobj->refcount = 0;
             outv[outc++] = lenobj;
         }


@@ -1919,6 +1921,17 @@ static int compareStringObjects(robj *a, robj *b) {
     }
 }
 
     }
 }
 

+static size_t stringObjectLen(robj *o) {
+    assert(o->type == REDIS_STRING);
+    if (o->encoding == REDIS_ENCODING_RAW) {
+        return sdslen(o->ptr);
+    } else {
+        char buf[32];
+
+        return snprintf(buf,32,"%ld",(long)o->ptr);
+    }
+}
+

 /*============================ DB saving/loading ============================ */
 
 static int rdbSaveType(FILE *fp, unsigned char type) {
 /*============================ DB saving/loading ============================ */
 
 static int rdbSaveType(FILE *fp, unsigned char type) {


@@ -3533,8 +3546,9 @@ static robj *lookupKeyByPattern(redisDb *db, robj *pattern, robj *subst) {
     int prefixlen, sublen, postfixlen;
     /* Expoit the internal sds representation to create a sds string allocated on the stack in order to make this function faster */
     struct {
     int prefixlen, sublen, postfixlen;
     /* Expoit the internal sds representation to create a sds string allocated on the stack in order to make this function faster */
     struct {

-        long len;
-        long free;
+        int len;
+        unsigned short free;
+        unsigned short _len; /* not used here */

         char buf[REDIS_SORTKEY_MAX+1];
     } keyname;
 
         char buf[REDIS_SORTKEY_MAX+1];
     } keyname;
 


@@ -3558,6 +3572,7 @@ static robj *lookupKeyByPattern(redisDb *db, robj *pattern, robj *subst) {
     memcpy(keyname.buf+prefixlen+sublen,p+1,postfixlen);
     keyname.buf[prefixlen+sublen+postfixlen] = '\0';
     keyname.len = prefixlen+sublen+postfixlen;
     memcpy(keyname.buf+prefixlen+sublen,p+1,postfixlen);
     keyname.buf[prefixlen+sublen+postfixlen] = '\0';
     keyname.len = prefixlen+sublen+postfixlen;

+    keyname._len = USHRT_MAX;

 
     keyobj.refcount = 1;
     keyobj.type = REDIS_STRING;
 
     keyobj.refcount = 1;
     keyobj.type = REDIS_STRING;

diff --git a/sds.c b/sds.c
index 8e9fd96d9befd2a4b4b7eb7ca9317001df24f8b8..b63a4a766173fbaed81daac13a9c272729654414 100644 (file)
--- a/sds.c
+++ b/sds.c
@@ -28,6 +28,8 @@
  * POSSIBILITY OF SUCH DAMAGE.
  */
 
  * POSSIBILITY OF SUCH DAMAGE.
  */
 

+ /* TODO: check if it can happen that _len+free > USHRT_MAX */
+

 #define SDS_ABORT_ON_OOM
 
 #include "sds.h"
 #define SDS_ABORT_ON_OOM
 
 #include "sds.h"


@@ -46,13 +48,25 @@ static void sdsOomAbort(void) {
 sds sdsnewlen(const void *init, size_t initlen) {
     struct sdshdr *sh;
 
 sds sdsnewlen(const void *init, size_t initlen) {
     struct sdshdr *sh;
 

-    sh = zmalloc(sizeof(struct sdshdr)+initlen+1);
-#ifdef SDS_ABORT_ON_OOM
-    if (sh == NULL) sdsOomAbort();
-#else
-    if (sh == NULL) return NULL;
-#endif
-    sh->len = initlen;
+    if (initlen >= USHRT_MAX) {
+        sh = zmalloc(sizeof(struct sdshdr)+initlen+1);
+        sh->len = initlen;
+        sh->_len = USHRT_MAX;
+        #ifdef SDS_ABORT_ON_OOM
+            if (sh == NULL) sdsOomAbort();
+        #else
+            if (sh == NULL) return NULL;
+        #endif
+    } else {
+        sh = zmalloc(sizeof(int)+initlen+1);
+        sh = (struct sdshdr*) (((char*)sh)-sizeof(int));
+        #ifdef SDS_ABORT_ON_OOM
+            if (sh == NULL) sdsOomAbort();
+        #else
+            if (sh == NULL) return NULL;
+        #endif
+        sh->_len = initlen;
+    }

     sh->free = 0;
     if (initlen) {
         if (init) memcpy(sh->buf, init, initlen);
     sh->free = 0;
     if (initlen) {
         if (init) memcpy(sh->buf, init, initlen);


@@ -73,7 +87,10 @@ sds sdsnew(const char *init) {
 
 size_t sdslen(const sds s) {
     struct sdshdr *sh = (void*) (s-(sizeof(struct sdshdr)));
 
 size_t sdslen(const sds s) {
     struct sdshdr *sh = (void*) (s-(sizeof(struct sdshdr)));

-    return sh->len;
+    if (sh->_len == USHRT_MAX)
+        return sh->len;
+    else
+        return sh->_len;

 }
 
 sds sdsdup(const sds s) {
 }
 
 sds sdsdup(const sds s) {


@@ -81,8 +98,14 @@ sds sdsdup(const sds s) {
 }
 
 void sdsfree(sds s) {
 }
 
 void sdsfree(sds s) {

+    struct sdshdr *sh;
+

     if (s == NULL) return;
     if (s == NULL) return;

-    zfree(s-sizeof(struct sdshdr));
+    sh = (void*) (s-(sizeof(struct sdshdr)));
+    if (sh->_len == USHRT_MAX)
+        zfree(s-sizeof(struct sdshdr));
+    else
+        zfree(s-sizeof(struct sdshdr)+sizeof(int));

 }
 
 size_t sdsavail(sds s) {
 }
 
 size_t sdsavail(sds s) {


@@ -93,40 +116,73 @@ size_t sdsavail(sds s) {
 void sdsupdatelen(sds s) {
     struct sdshdr *sh = (void*) (s-(sizeof(struct sdshdr)));
     int reallen = strlen(s);
 void sdsupdatelen(sds s) {
     struct sdshdr *sh = (void*) (s-(sizeof(struct sdshdr)));
     int reallen = strlen(s);

-    sh->free += (sh->len-reallen);
-    sh->len = reallen;
+
+    if (sh->_len == USHRT_MAX) {
+        sh->free += (sh->len-reallen);
+        sh->len = reallen;
+    } else {
+        sh->free += (sh->_len-reallen);
+        sh->_len = reallen;
+    }

 }
 
 static sds sdsMakeRoomFor(sds s, size_t addlen) {
     struct sdshdr *sh, *newsh;
     size_t free = sdsavail(s);
 }
 
 static sds sdsMakeRoomFor(sds s, size_t addlen) {
     struct sdshdr *sh, *newsh;
     size_t free = sdsavail(s);

-    size_t len, newlen;
+    size_t len, newlen, newfree;

 
 

-    if (free >= addlen) return s;
+    if (free >= addlen) {
+        sh = (void*) (s-(sizeof(struct sdshdr)));
+        if (sh->_len == USHRT_MAX) {
+            sh->len += addlen;
+        } else {
+            sh->_len += addlen;
+        }
+        sh->free -= addlen;
+        return s;
+    }

     len = sdslen(s);
     sh = (void*) (s-(sizeof(struct sdshdr)));
     len = sdslen(s);
     sh = (void*) (s-(sizeof(struct sdshdr)));

-    newlen = (len+addlen)*2;
-    newsh = zrealloc(sh, sizeof(struct sdshdr)+newlen+1);
+    newlen = (len+addlen);
+    newfree = ((addlen*2) > USHRT_MAX) ? USHRT_MAX : (addlen*2);
+    if (newlen+newfree >= USHRT_MAX || sh->_len == USHRT_MAX) {
+        if (sh->_len == USHRT_MAX) {
+            newsh = zrealloc(sh, sizeof(struct sdshdr)+newlen+1+newfree);
+        } else {
+            newsh = zmalloc(sizeof(struct sdshdr)+newlen+1+newfree);
+            if (!newsh) return NULL;
+            memcpy(newsh->buf,sh->buf,len);
+            newsh->buf[len] = '\0';
+            zfree(((char*)sh)+sizeof(int));
+        }

 #ifdef SDS_ABORT_ON_OOM
 #ifdef SDS_ABORT_ON_OOM

-    if (newsh == NULL) sdsOomAbort();
+        if (newsh == NULL) sdsOomAbort();

 #else
 #else

-    if (newsh == NULL) return NULL;
+        if (newsh == NULL) return NULL;

 #endif
 #endif

-
-    newsh->free = newlen - len;
+        newsh->_len = USHRT_MAX;
+        newsh->free = newfree;
+        newsh->len = newlen;
+    } else {
+        newsh = zrealloc(((char*)sh)+sizeof(int), sizeof(int)+newlen+1+newfree);
+        newsh = (struct sdshdr*) (((char*)newsh)-sizeof(int));
+#ifdef SDS_ABORT_ON_OOM
+        if (newsh == NULL) sdsOomAbort();
+#else
+        if (newsh == NULL) return NULL;
+#endif
+        newsh->_len = newlen;
+        newsh->free = newfree;
+    }

     return newsh->buf;
 }
 
 sds sdscatlen(sds s, void *t, size_t len) {
     return newsh->buf;
 }
 
 sds sdscatlen(sds s, void *t, size_t len) {

-    struct sdshdr *sh;

     size_t curlen = sdslen(s);
 
     s = sdsMakeRoomFor(s,len);
     if (s == NULL) return NULL;
     size_t curlen = sdslen(s);
 
     s = sdsMakeRoomFor(s,len);
     if (s == NULL) return NULL;

-    sh = (void*) (s-(sizeof(struct sdshdr)));

     memcpy(s+curlen, t, len);
     memcpy(s+curlen, t, len);

-    sh->len = curlen+len;
-    sh->free = sh->free-len;

     s[curlen+len] = '\0';
     return s;
 }
     s[curlen+len] = '\0';
     return s;
 }


@@ -137,18 +193,20 @@ sds sdscat(sds s, char *t) {
 
 sds sdscpylen(sds s, char *t, size_t len) {
     struct sdshdr *sh = (void*) (s-(sizeof(struct sdshdr)));
 
 sds sdscpylen(sds s, char *t, size_t len) {
     struct sdshdr *sh = (void*) (s-(sizeof(struct sdshdr)));

-    size_t totlen = sh->free+sh->len;
+    size_t totlen;
+    
+    if (sh->_len == USHRT_MAX) {
+        totlen = sh->free+sh->len;
+    } else {
+        totlen = sh->free+sh->_len;
+    }

 
     if (totlen < len) {
         s = sdsMakeRoomFor(s,len-totlen);
         if (s == NULL) return NULL;
 
     if (totlen < len) {
         s = sdsMakeRoomFor(s,len-totlen);
         if (s == NULL) return NULL;

-        sh = (void*) (s-(sizeof(struct sdshdr)));
-        totlen = sh->free+sh->len;

     }
     memcpy(s, t, len);
     s[len] = '\0';
     }
     memcpy(s, t, len);
     s[len] = '\0';

-    sh->len = len;
-    sh->free = totlen-len;

     return s;
 }
 
     return s;
 }
 


@@ -196,8 +254,13 @@ sds sdstrim(sds s, const char *cset) {
     len = (sp > ep) ? 0 : ((ep-sp)+1);
     if (sh->buf != sp) memmove(sh->buf, sp, len);
     sh->buf[len] = '\0';
     len = (sp > ep) ? 0 : ((ep-sp)+1);
     if (sh->buf != sp) memmove(sh->buf, sp, len);
     sh->buf[len] = '\0';

-    sh->free = sh->free+(sh->len-len);
-    sh->len = len;
+    if (sh->_len == USHRT_MAX) {
+        sh->free = sh->free+(sh->len-len);
+        sh->len = len;
+    } else {
+        sh->free = sh->free+(sh->_len-len);
+        sh->_len = len;
+    }

     return s;
 }
 
     return s;
 }
 


@@ -224,8 +287,13 @@ sds sdsrange(sds s, long start, long end) {
     }
     if (start != 0) memmove(sh->buf, sh->buf+start, newlen);
     sh->buf[newlen] = 0;
     }
     if (start != 0) memmove(sh->buf, sh->buf+start, newlen);
     sh->buf[newlen] = 0;

-    sh->free = sh->free+(sh->len-newlen);
-    sh->len = newlen;
+    if (sh->_len == USHRT_MAX) {
+        sh->free = sh->free+(sh->len-newlen);
+        sh->len = newlen;
+    } else {
+        sh->free = sh->free+(sh->_len-newlen);
+        sh->_len = newlen;
+    }

     return s;
 }
 
     return s;
 }
 

diff --git a/sds.h b/sds.h
index 0fc2c9281ba9e9153395cc0c33169fc5deb86833..582cb2f34773988d0793089687c3b4dd11537555 100644 (file)
--- a/sds.h
+++ b/sds.h
@@ -32,12 +32,14 @@
 #define __SDS_H
 
 #include <sys/types.h>
 #define __SDS_H
 
 #include <sys/types.h>

+#include <limits.h>

 
 typedef char *sds;
 
 struct sdshdr {
 
 typedef char *sds;
 
 struct sdshdr {

-    long len;
-    long free;
+    int len;
+    unsigned short free;
+    unsigned short _len; /* USHRT_MAX if it is a "long" sds string */

     char buf[];
 };
 
     char buf[];
 };