add missing files

Signed-off-by: Ran Shidlansik <[email protected]>

Author: ranshid

src/entry.c

@@ -0,0 +1,347 @@
+#include <stdbool.h>
+#include "sds.h"
+#include "server.h"
+#include "serverassert.h"
+#include "entry.h"
+
+#include <stdbool.h>
+
+/*-----------------------------------------------------------------------------
+ * Hash Entry API
+ *----------------------------------------------------------------------------*/
+
+/* The entry pointer is the field sds. We encode the entry layout type
+ * in the field SDS header. Field type SDS_TYPE_5 doesn't have any spare bits to
+ * encode this so we use it only for the first layout type.
+ *
+ * Entry with embedded value, used for small sizes. The value is stored as
+ * SDS_TYPE_8. The field can use any SDS type.
+ *
+ *     +--------------+---------------+
+ *     | field        | value         |
+ *     | hdr "foo" \0 | hdr8 "bar" \0 |
+ *     +------^-------+---------------+
+ *            |
+ *            |
+ *          entry pointer = field sds
+ *
+ * Entry with value pointer, used for larger fields and values. The field is SDS
+ * type 8 or higher.
+ *
+ *     +-------+--------------+
+ *     | value | field        |
+ *     | ptr   | hdr "foo" \0 |
+ *     +-------+------^-------+
+ *                    |
+ *                    |
+ *                 entry pointer = field sds
+ */
+
+/* The maximum allocation size we want to use for entries with embedded
+ * values. */
+#define EMBED_VALUE_MAX_ALLOC_SIZE 128
+
+/* SDS aux flag. If set, it indicates that the entry has TTL metadata set. */
+#define FIELD_SDS_AUX_BIT_ENTRY_HAS_TTL 0
+
+/* SDS aux flag. If set, it indicates that the entry has an embedded value
+ * pointer located in memory before the embedded field. If unset, the entry
+ * instead has an embedded value located after the embedded field. */
+#define FIELD_SDS_AUX_BIT_ENTRY_HAS_VALUE_PTR 2
+
+bool entryHasValuePtr(const entry *entry) {
+    return sdsGetAuxBit(entry, FIELD_SDS_AUX_BIT_ENTRY_HAS_VALUE_PTR);
+}
+
+bool entryHasExpiry(const entry *entry) {
+    return sdsGetAuxBit(entry, FIELD_SDS_AUX_BIT_ENTRY_HAS_TTL);
+}
+
+/* Returns the location of a pointer to a separately allocated value. Only for
+ * an entry without an embedded value. */
+sds *entryGetValueRef(const entry *entry) {
+    serverAssert(entryHasValuePtr(entry));
+    char *field_data = sdsAllocPtr(entry);
+    field_data -= sizeof(sds *);
+    return (sds *)field_data;
+}
+
+/* The entry pointer is the field sds, but that's an implementation detail. */
+sds entryGetField(const entry *entry) {
+    return (sds)entry;
+}
+
+sds entryGetValue(const entry *entry) {
+    if (entryHasValuePtr(entry)) {
+        return *entryGetValueRef(entry);
+    } else {
+        /* Skip field content, field null terminator and value sds8 hdr. */
+        size_t offset = sdslen(entry) + 1 + sdsHdrSize(SDS_TYPE_8);
+        serverAssert((char *)entry + offset);
+
+        return (char *)entry + offset;
+    }
+}
+
+entry *entrySetValue(entry *e, sds value) {
+    if (entryHasValuePtr(e)) {
+        sds *value_ref = entryGetValueRef(e);
+        sdsfree(*value_ref);
+        *value_ref = value;
+        return e;
+    } else {
+        entry *new_entry = entryUpdate(e, value, entryGetExpiry(e));
+        return new_entry;
+    }
+}
+
+/* Returns the address of the entry allocation. */
+void *entryAllocPtr(const entry *entry) {
+    char *buf = sdsAllocPtr(entry);
+    if (entryHasValuePtr(entry)) buf -= sizeof(sds *);
+    if (entryHasExpiry(entry)) buf -= sizeof(long long);
+    return buf;
+}
+
+/**************************************** Entry Expiry API *****************************************/
+long long entryGetExpiry(const entry *entry) {
+    long long expiry = EXPIRY_NONE;
+    if (entryHasExpiry(entry)) {
+        char *buf = sdsAllocPtr(entry);
+        if (entryHasValuePtr(entry)) buf -= sizeof(sds *);
+        buf -= sizeof(expiry);
+        memcpy(&expiry, buf, sizeof(expiry));
+    }
+    return expiry;
+}
+
+entry *entrySetExpiry(entry *e, long long expiry) {
+    if (entryHasExpiry(e)) {
+        char *buf = sdsAllocPtr(e);
+        if (entryHasValuePtr(e)) buf -= sizeof(sds *);
+        buf -= sizeof(expiry);
+        memcpy(buf, &expiry, sizeof(expiry));
+        return e;
+    }
+    entry *new_entry = entryUpdate(e, NULL, expiry);
+    return new_entry;
+}
+
+int entryIsExpired(entry *entry) {
+    /* Don't expire anything while loading. It will be done later. */
+    if (server.loading) return 0;
+    if (!timestampIsExpired(entryGetExpiry(entry))) return 0;
+    if (server.primary_host == NULL && server.import_mode) {
+        if (server.current_client && server.current_client->flag.import_source) return 0;
+    }
+    return 1;
+}
+/**************************************** Entry Expiry API - End *****************************************/
+
+void freeentry(entry *entry) {
+    if (entryHasValuePtr(entry)) {
+        sdsfree(*entryGetValueRef(entry));
+    }
+    zfree(entryAllocPtr(entry));
+}
+
+/* takes ownership of value, does not take ownership of field */
+entry *entryCreate(sds field, sds value, long long expiry) {
+    /* In case simple sds just return the same field we got. */
+    if (!value && expiry == EXPIRY_NONE)
+        return field;
+    sds embedded_field_sds;
+    size_t expiry_size = (expiry == EXPIRY_NONE) ? 0 : sizeof(long long);
+    size_t field_len = sdslen(field);
+    int field_sds_type = sdsReqType(field_len);
+    if (field_sds_type == SDS_TYPE_5 && (expiry_size > 0)) {
+        field_sds_type = SDS_TYPE_8;
+    }
+    size_t field_size = sdsReqSize(field_len, field_sds_type);
+    size_t value_len = value ? sdslen(value) : 0;
+    size_t value_size = value ? sdsReqSize(value_len, SDS_TYPE_8) : 0;
+    size_t alloc_size = field_size + expiry_size;
+    bool embed_value = false;
+    if (value) {
+        if (alloc_size + value_size <= EMBED_VALUE_MAX_ALLOC_SIZE) {
+            /* Embed field and value. Value is fixed to SDS_TYPE_8. Unused
+             * allocation space is recorded in the embedded value's SDS header.
+             *
+             *     +------+--------------+---------------+
+             *     | TTL  | field        | value         |
+             *     |      | hdr "foo" \0 | hdr8 "bar" \0 |
+             *     +------+--------------+---------------+
+             */
+            embed_value = true;
+            alloc_size += value_size;
+        } else {
+            /* Embed field, but not value. Field must be >= SDS_TYPE_8 to encode to
+             * indicate this type of entry.
+             *
+             *     +------+-------+---------------+
+             *     | TTL  | value | field         |
+             *     |      | ptr   | hdr8 "foo" \0 |
+             *     +------+-------+---------------+
+             */
+            embed_value = false;
+            alloc_size += sizeof(sds *);
+            if (field_sds_type == SDS_TYPE_5) {
+                field_sds_type = SDS_TYPE_8;
+                alloc_size -= field_size;
+                field_size = sdsReqSize(field_len, field_sds_type);
+                alloc_size += field_size;
+            }
+        }
+    }
+    /* allocate the buffer */
+    size_t buf_size;
+    char *buf = zmalloc_usable(alloc_size, &buf_size);
+
+    /* Set The expiry if exists */
+    if (expiry_size) {
+        memcpy(buf, &expiry, expiry_size);
+        buf += expiry_size;
+        buf_size -= expiry_size;
+    }
+    if (value) {
+        if (!embed_value) {
+            *(sds *)buf = value;
+            buf += sizeof(sds *);
+            buf_size -= sizeof(sds *);
+        } else {
+            sdswrite(buf + field_size, buf_size - field_size, SDS_TYPE_8, value, value_len);
+            sdsfree(value);
+            buf_size -= value_size;
+        }
+    }
+    /* Set the field data */
+    embedded_field_sds = sdswrite(buf, field_size, field_sds_type, field, field_len);
+
+    /* Field sds aux bits are zero, which we use for this entry encoding. */
+    sdsSetAuxBit(embedded_field_sds, FIELD_SDS_AUX_BIT_ENTRY_HAS_VALUE_PTR, embed_value ? 0 : 1);
+    sdsSetAuxBit(embedded_field_sds, FIELD_SDS_AUX_BIT_ENTRY_HAS_TTL, expiry_size > 0 ? 1 : 0);
+    return (void *)embedded_field_sds;
+}
+
+/* Frees previous value, takes ownership of new value, returns entry (may be
+ * reallocated). */
+entry *entryUpdate(entry *e, sds value, long long expiry) {
+    sds field = (sds)e;
+
+    bool update_value = value ? true : false;
+    long long ttl = entryGetExpiry(e);
+    bool update_expiry = (expiry != ttl) ? true : false;
+    if (!update_value && !update_expiry)
+        return e;
+    if (update_expiry) ttl = expiry;
+    value = update_value ? value : entryGetValue(e);
+    size_t expiry_size = ttl != EXPIRY_NONE ? sizeof(ttl) : 0;
+    int field_sds_type = sdsReqType(sdslen(field));
+    if (field_sds_type == SDS_TYPE_5 && (expiry_size > 0)) {
+        field_sds_type = SDS_TYPE_8;
+    }
+    size_t field_size = sdsHdrSize(field_sds_type) + sdsalloc(field) + 1;
+    size_t value_len = value ? sdslen(value) : 0;
+    size_t value_size = value ? sdsReqSize(value_len, SDS_TYPE_8) : 0;
+
+    size_t required_size = field_size + value_size + expiry_size;
+    size_t current_allocation_size = entryMemUsage(e);
+    bool create_new_entry = (update_expiry && (entryGetExpiry(e) == EXPIRY_NONE || ttl == EXPIRY_NONE)) ||
+                            !(update_value && !entryHasValuePtr(e) &&
+                              required_size <= EMBED_VALUE_MAX_ALLOC_SIZE &&
+                              required_size <= current_allocation_size &&
+                              required_size >= current_allocation_size * 3 / 4);
+
+    if (!create_new_entry) {
+        /* In this case we are sure we do not have to allocate new entry, so expiry must already be set. */
+        if (update_expiry) {
+            serverAssert(entryHasExpiry(e));
+            char *buf = sdsAllocPtr(e);
+            if (entryHasValuePtr(e)) buf -= sizeof(sds *);
+            buf -= sizeof(expiry);
+            memcpy(buf, &expiry, sizeof(expiry));
+        }
+        /* In this case we are sure we do not have to allocate new entry, so value must already be set or we have enough room to embed it. */
+        if (update_value) {
+            if (entryHasValuePtr(e)) {
+                sds *value_ref = entryGetValueRef(e);
+                sdsfree(*value_ref);
+                *value_ref = value;
+            } else {
+                /* Skip field content, field null terminator and value sds8 hdr. */
+                sds old_value = entryGetValue(e);
+                sdswrite(sdsAllocPtr(old_value), sdsAllocSize(old_value), SDS_TYPE_8, value, sdslen(value));
+                sdsfree(value);
+            }
+        }
+        return e;
+
+    } else {
+        /* Check if the value can be reused. */
+        int value_was_embedded = !entryHasValuePtr(e);
+        /* In case the original entry value is embedded and we know the destination entry will be able to embed the value
+         * We should duplicate the value.
+         * TODO: We could basically optimize this case better by signaling entryCreate to take the value and avoid freeing it. */
+        if (value_was_embedded && required_size <= EMBED_VALUE_MAX_ALLOC_SIZE)
+            value = sdsdup(value);
+        /* if not we have to duplicate it, remove it from the original entry since we are going to delete it.*/
+        else if (!value_was_embedded) {
+            sds *value_ref = entryGetValueRef(e);
+            *value_ref = NULL;
+        }
+    }
+
+    entry *new_entry = entryCreate(entryGetField(e), value, ttl);
+    if (new_entry != e)
+        freeentry(e);
+    return new_entry;
+}
+
+/* Returns memory usage of a entry, including all allocations owned by
+ * the entry. */
+size_t entryMemUsage(entry *entry) {
+    size_t mem = 0;
+
+    if (entryHasValuePtr(entry)) {
+        /* In case the value is not embedded we might not be able to sum all the allocation sizes since the field
+         * header could be too small for holding the real allocation size. */
+        mem += zmalloc_usable_size(entryAllocPtr(entry));
+    } else {
+        mem += sdsReqSize(sdslen(entry), sdsType(entry));
+        if (entryHasExpiry(entry)) mem += sizeof(long long);
+    }
+    mem += sdsAllocSize(entryGetValue(entry));
+    return mem;
+}
+
+/* Defragments a hashtable entry (field-value pair) if needed, using the
+ * provided defrag functions. The defrag functions return NULL if the allocation
+ * was not moved, otherwise they return a pointer to the new memory location.
+ * A separate sds defrag function is needed because of the unique memory layout
+ * of sds strings.
+ * If the location of the entry changed we return the new location,
+ * otherwise we return NULL. */
+entry *entryDefrag(entry *entry, void *(*defragfn)(void *), sds (*sdsdefragfn)(sds)) {
+    if (entryHasValuePtr(entry)) {
+        sds *value_ref = entryGetValueRef(entry);
+        sds new_value = sdsdefragfn(*value_ref);
+        if (new_value) *value_ref = new_value;
+    }
+    char *allocation = entryAllocPtr(entry);
+    char *new_allocation = defragfn(allocation);
+    if (new_allocation != NULL) {
+        /* Return the same offset into the new allocation as the entry's offset
+         * in the old allocation. */
+        return new_allocation + ((char *)entry - allocation);
+    }
+    return NULL;
+}
+
+/* Used for releasing memory to OS to avoid unnecessary CoW. Called when we've
+ * forked and memory won't be used again. See zmadvise_dontneed() */
+void dismissEntry(entry *entry) {
+    /* Only dismiss values memory since the field size usually is small. */
+    if (entryHasValuePtr(entry)) {
+        dismissSds(*entryGetValueRef(entry));
+    }
+}

src/entry.h

@@ -0,0 +1,25 @@
+#ifndef _VFIELD_H_
+#define _VFIELD_H_
+
+#include "sds.h"
+#include <stdbool.h>
+
+typedef void entry;
+
+sds *entryGetValueRef(const entry *entry);
+sds entryGetField(const entry *entry);
+sds entryGetValue(const entry *entry);
+entry *entrySetValue(entry *entry, sds value);
+long long entryGetExpiry(const entry *entry);
+bool entryHasExpiry(const entry *entry);
+entry *entrySetExpiry(entry *entry, long long expiry);
+int entryIsExpired(entry *entry);
+
+void entryFree(entry *entry);
+entry *entryCreate(sds field, sds value, long long expiry);
+entry *entryUpdate(entry *entry, sds value, long long expiry);
+size_t entryMemUsage(entry *entry);
+entry *entryDefrag(entry *entry, void *(*defragfn)(void *), sds (*sdsdefragfn)(sds));
+void dismissEntry(entry *entry);
+
+#endif