Move dictEntry to PM

dictEntry instances will be allocated to PM. Involves only main dictionary entries.

Author: pkarp

src/db.c

@@ -177,12 +177,16 @@ robj *lookupKeyWriteOrReply(client *c, robj *key, robj *reply) {
  *
  * The program is aborted if the key already exists. */
 void dbAdd(redisDb *db, robj *key, robj *val) {
-    sds copy;
+    sds copy = NULL;
     if (server.keys_on_pmem)
         copy = sdsdupPM(key->ptr);
     else
         copy = sdsdup(key->ptr);
-    int retval = dictAdd(db->dict, copy, val);
+    int retval = 0;
+    if (server.dictionary_entries_on_pmem)
+        retval = dictAddPM(db->dict, copy, val);
+    else
+        retval = dictAdd(db->dict, copy, val);
 
     serverAssertWithInfo(NULL,key,retval == DICT_OK);
     if (val->type == OBJ_LIST ||
@@ -1167,7 +1171,7 @@ void setExpire(client *c, redisDb *db, robj *key, long long when) {
     /* Reuse the sds from the main dict in the expire dict */
     kde = dictFind(db->dict,key->ptr);
     serverAssertWithInfo(NULL,key,kde != NULL);
-    de = dictAddOrFind(db->expires,dictGetKey(kde));
+    de = dictAddOrFind(db->expires,dictGetKey(kde),server.dictionary_entries_on_pmem);
     dictSetSignedIntegerVal(de,when);
 
     int writable_slave = server.masterhost && server.repl_slave_ro == 0;

src/dict.c

@@ -264,7 +264,7 @@ static void _dictRehashStep(dict *d) {
 /* Add an element to the target hash table */
 int dictAdd(dict *d, void *key, void *val)
 {
-    dictEntry *entry = dictAddRaw(d,key,NULL);
+    dictEntry *entry = dictAddRaw(d,key,NULL,0);
 
     if (!entry) return DICT_ERR;
     dictSetVal(d, entry, val);
@@ -289,7 +289,7 @@ int dictAdd(dict *d, void *key, void *val)
  *
  * If key was added, the hash entry is returned to be manipulated by the caller.
  */
-dictEntry *dictAddRaw(dict *d, void *key, dictEntry **existing)
+dictEntry *dictAddRaw(dict *d, void *key, dictEntry **existing, int dictionaryEntriesOnPmem)
 {
     long index;
     dictEntry *entry;
@@ -307,7 +307,10 @@ dictEntry *dictAddRaw(dict *d, void *key, dictEntry **existing)
      * system it is more likely that recently added entries are accessed
      * more frequently. */
     ht = dictIsRehashing(d) ? &d->ht[1] : &d->ht[0];
-    entry = zmalloc(sizeof(*entry));
+    if (dictionaryEntriesOnPmem)
+        entry = zmalloc_pmem(sizeof(*entry));
+    else
+        entry = zmalloc(sizeof(*entry));
     entry->next = ht->table[index];
     ht->table[index] = entry;
     ht->used++;
@@ -317,6 +320,29 @@ dictEntry *dictAddRaw(dict *d, void *key, dictEntry **existing)
     return entry;
 }
 
+#ifdef USE_MEMKIND
+int dictAddPM(dict *d, void *key, void *val)
+{
+    dictEntry *entry = dictAddRaw(d,key,NULL,1);
+
+    if (!entry) return DICT_ERR;
+    dictSetVal(d, entry, val);
+    return DICT_OK;
+}
+
+#else
+int dictAddPM(dict *d, void *key, void *val)
+{
+    (void)(d);
+    (void)(key);
+    (void)(val);
+    printf("ERROR: dictAddPM is supported only by memkind\n");
+    exit(1);
+     /* unreachable */
+    return NULL;
+}
+#endif
+
 /* Add or Overwrite:
  * Add an element, discarding the old value if the key already exists.
  * Return 1 if the key was added from scratch, 0 if there was already an
@@ -328,7 +354,7 @@ int dictReplace(dict *d, void *key, void *val)
 
     /* Try to add the element. If the key
      * does not exists dictAdd will succeed. */
-    entry = dictAddRaw(d,key,&existing);
+    entry = dictAddRaw(d,key,&existing,0);
     if (entry) {
         dictSetVal(d, entry, val);
         return 1;
@@ -352,9 +378,9 @@ int dictReplace(dict *d, void *key, void *val)
  * existing key is returned.)
  *
  * See dictAddRaw() for more information. */
-dictEntry *dictAddOrFind(dict *d, void *key) {
+dictEntry *dictAddOrFind(dict *d, void *key, int dictionaryEntriesOnPmem) {
     dictEntry *entry, *existing;
-    entry = dictAddRaw(d,key,&existing);
+    entry = dictAddRaw(d,key,&existing,dictionaryEntriesOnPmem);
     return entry ? entry : existing;
 }
 

src/dict.h

@@ -151,8 +151,9 @@ typedef void (dictScanBucketFunction)(void *privdata, dictEntry **bucketref);
 dict *dictCreate(dictType *type, void *privDataPtr);
 int dictExpand(dict *d, unsigned long size);
 int dictAdd(dict *d, void *key, void *val);
-dictEntry *dictAddRaw(dict *d, void *key, dictEntry **existing);
-dictEntry *dictAddOrFind(dict *d, void *key);
+int dictAddPM(dict *d, void *key, void *val);
+dictEntry *dictAddRaw(dict *d, void *key, dictEntry **existing, int dictionaryEntriesOnPmem);
+dictEntry *dictAddOrFind(dict *d, void *key, int dictionaryEntriesOnPmem);
 int dictReplace(dict *d, void *key, void *val);
 int dictDelete(dict *d, const void *key);
 dictEntry *dictUnlink(dict *ht, const void *key);

src/expire.c

@@ -439,7 +439,7 @@ void rememberSlaveKeyWithExpire(redisDb *db, robj *key) {
     }
     if (db->id > 63) return;
 
-    dictEntry *de = dictAddOrFind(slaveKeysWithExpire,key->ptr);
+    dictEntry *de = dictAddOrFind(slaveKeysWithExpire,key->ptr,server.dictionary_entries_on_pmem);
     /* If the entry was just created, set it to a copy of the SDS string
      * representing the key: we don't want to need to take those keys
      * in sync with the main DB. The keys will be removed by expireSlaveKeys()

src/sentinel.c

@@ -3853,7 +3853,7 @@ int sentinelLeaderIncr(dict *counters, char *runid) {
     dictEntry *existing, *de;
     uint64_t oldval;
 
-    de = dictAddRaw(counters,runid,&existing);
+    de = dictAddRaw(counters,runid,&existing,0);
     if (existing) {
         oldval = dictGetUnsignedIntegerVal(existing);
         dictSetUnsignedIntegerVal(existing,oldval+1);

src/t_set.c

@@ -53,7 +53,7 @@ int setTypeAdd(robj *subject, sds value) {
     long long llval;
     if (subject->encoding == OBJ_ENCODING_HT) {
         dict *ht = subject->ptr;
-        dictEntry *de = dictAddRaw(ht,value,NULL);
+        dictEntry *de = dictAddRaw(ht,value,NULL,0);
         if (de) {
             dictSetKey(ht,de,sdsdup(value));
             dictSetVal(ht,de,NULL);

src/t_zset.c

@@ -2332,7 +2332,7 @@ void zunionInterGenericCommand(client *c, robj *dstkey, int op) {
                 if (isnan(score)) score = 0;
 
                 /* Search for this element in the accumulating dictionary. */
-                de = dictAddRaw(accumulator,zuiSdsFromValue(&zval),&existing);
+                de = dictAddRaw(accumulator,zuiSdsFromValue(&zval),&existing,0);
                 /* If we don't have it, we need to create a new entry. */
                 if (!existing) {
                     tmp = zuiNewSdsFromValue(&zval);