ox-bundlecachetest 2.14.23

data/ext/ox/cache.c

@@ -0,0 +1,351 @@
+// Copyright (c) 2011, 2021 Peter Ohler. All rights reserved.
+// Licensed under the MIT License. See LICENSE file in the project root for license details.
+
+#if HAVE_PTHREAD_MUTEX_INIT
+#include <pthread.h>
+#endif
+#include <stdlib.h>
+
+#include "cache.h"
+
+// The stdlib calloc, realloc, and free are used instead of the Ruby ALLOC,
+// ALLOC_N, REALLOC, and xfree since the later could trigger a GC which will
+// either corrupt memory or if the mark function locks will deadlock.
+
+#define REHASH_LIMIT 4
+#define MIN_SHIFT 8
+#define REUSE_MAX 8192
+
+#if HAVE_PTHREAD_MUTEX_INIT
+#define CACHE_LOCK(c) pthread_mutex_lock(&((c)->mutex))
+#define CACHE_UNLOCK(c) pthread_mutex_unlock(&((c)->mutex))
+#else
+#define CACHE_LOCK(c) rb_mutex_lock((c)->mutex)
+#define CACHE_UNLOCK(c) rb_mutex_unlock((c)->mutex)
+#endif
+
+// almost the Murmur hash algorithm
+#define M 0x5bd1e995
+
+typedef struct _slot {
+    struct _slot     *next;
+    VALUE             val;
+    uint64_t          hash;
+    volatile uint32_t use_cnt;
+    uint8_t           klen;
+    char              key[CACHE_MAX_KEY];
+} *Slot;
+
+typedef struct _cache {
+    volatile Slot  *slots;
+    volatile size_t cnt;
+    VALUE (*form)(const char *str, size_t len);
+    uint64_t size;
+    uint64_t mask;
+    VALUE (*intern)(struct _cache *c, const char *key, size_t len, const char **keyp);
+    volatile Slot reuse;
+    size_t        rcnt;
+#if HAVE_PTHREAD_MUTEX_INIT
+    pthread_mutex_t mutex;
+#else
+    VALUE mutex;
+#endif
+    uint8_t xrate;
+    bool    mark;
+} *Cache;
+
+const rb_data_type_t ox_cache_type = {
+    "Ox/Cache",
+    {
+        ox_cache_mark,
+        ox_cache_free,
+        NULL,
+    },
+    0,
+    0,
+};
+
+static uint64_t hash_calc(const uint8_t *key, size_t len) {
+    const uint8_t *end     = key + len;
+    const uint8_t *endless = key + (len & 0xFFFFFFFC);
+    uint64_t       h       = (uint64_t)len;
+    uint64_t       k;
+
+    while (key < endless) {
+        k = (uint64_t)*key++;
+        k |= (uint64_t)*key++ << 8;
+        k |= (uint64_t)*key++ << 16;
+        k |= (uint64_t)*key++ << 24;
+
+        k *= M;
+        k ^= k >> 24;
+        h *= M;
+        h ^= k * M;
+    }
+    if (1 < end - key) {
+        uint16_t k16 = (uint16_t)*key++;
+
+        k16 |= (uint16_t)*key++ << 8;
+        h ^= k16 << 8;
+    }
+    if (key < end) {
+        h ^= *key;
+    }
+    h *= M;
+    h ^= h >> 13;
+    h *= M;
+    h ^= h >> 15;
+
+    return h;
+}
+
+static void rehash(Cache c) {
+    uint64_t osize;
+    Slot    *end;
+    Slot    *sp;
+
+    osize    = c->size;
+    c->size  = osize * 4;
+    c->mask  = c->size - 1;
+    c->slots = realloc((void *)c->slots, sizeof(Slot) * c->size);
+    memset((Slot *)c->slots + osize, 0, sizeof(Slot) * osize * 3);
+    end = (Slot *)c->slots + osize;
+    for (sp = (Slot *)c->slots; sp < end; sp++) {
+        Slot s    = *sp;
+        Slot next = NULL;
+
+        *sp = NULL;
+        for (; NULL != s; s = next) {
+            uint64_t h      = s->hash & c->mask;
+            Slot    *bucket = (Slot *)c->slots + h;
+
+            next    = s->next;
+            s->next = *bucket;
+            *bucket = s;
+        }
+    }
+}
+
+static VALUE ox_lockless_intern(Cache c, const char *key, size_t len, const char **keyp) {
+    uint64_t       h      = hash_calc((const uint8_t *)key, len);
+    Slot          *bucket = (Slot *)c->slots + (h & c->mask);
+    Slot           b;
+    volatile VALUE rkey;
+
+    while (REUSE_MAX < c->rcnt) {
+        if (NULL != (b = c->reuse)) {
+            c->reuse = b->next;
+            free(b);
+            c->rcnt--;
+        } else {
+            // An accounting error occured somewhere so correct it.
+            c->rcnt = 0;
+        }
+    }
+    for (b = *bucket; NULL != b; b = b->next) {
+        if ((uint8_t)len == b->klen && 0 == strncmp(b->key, key, len)) {
+            b->use_cnt += 16;
+            if (NULL != keyp) {
+                *keyp = b->key;
+            }
+            return b->val;
+        }
+    }
+    rkey = c->form(key, len);
+    if (NULL == (b = c->reuse)) {
+        b = calloc(1, sizeof(struct _slot));
+    } else {
+        c->reuse = b->next;
+        c->rcnt--;
+    }
+    b->hash = h;
+    memcpy(b->key, key, len);
+    b->klen     = (uint8_t)len;
+    b->key[len] = '\0';
+    b->val      = rkey;
+    b->use_cnt  = 4;
+    b->next     = *bucket;
+    *bucket     = b;
+    c->cnt++;  // Don't worry about wrapping. Worse case is the entry is removed and recreated.
+    if (NULL != keyp) {
+        *keyp = b->key;
+    }
+    if (REHASH_LIMIT < c->cnt / c->size) {
+        rehash(c);
+    }
+    return rkey;
+}
+
+static VALUE ox_locking_intern(Cache c, const char *key, size_t len, const char **keyp) {
+    uint64_t       h;
+    Slot          *bucket;
+    Slot           b;
+    uint64_t       old_size;
+    volatile VALUE rkey;
+
+    CACHE_LOCK(c);
+    while (REUSE_MAX < c->rcnt) {
+        if (NULL != (b = c->reuse)) {
+            c->reuse = b->next;
+            free(b);
+            c->rcnt--;
+        } else {
+            // An accounting error occured somewhere so correct it.
+            c->rcnt = 0;
+        }
+    }
+    h      = hash_calc((const uint8_t *)key, len);
+    bucket = (Slot *)c->slots + (h & c->mask);
+    for (b = *bucket; NULL != b; b = b->next) {
+        if ((uint8_t)len == b->klen && 0 == strncmp(b->key, key, len)) {
+            b->use_cnt += 4;
+            if (NULL != keyp) {
+                *keyp = b->key;
+            }
+            CACHE_UNLOCK(c);
+
+            return b->val;
+        }
+    }
+    old_size = c->size;
+    // The creation of a new value may trigger a GC which be a problem if the
+    // cache is locked so make sure it is unlocked for the key value creation.
+    if (NULL != (b = c->reuse)) {
+        c->reuse = b->next;
+        c->rcnt--;
+    }
+    CACHE_UNLOCK(c);
+    if (NULL == b) {
+        b = calloc(1, sizeof(struct _slot));
+    }
+    rkey    = c->form(key, len);
+    b->hash = h;
+    memcpy(b->key, key, len);
+    b->klen     = (uint8_t)len;
+    b->key[len] = '\0';
+    b->val      = rkey;
+    b->use_cnt  = 16;
+
+    // Lock again to add the new entry.
+    CACHE_LOCK(c);
+    if (old_size != c->size) {
+        h      = hash_calc((const uint8_t *)key, len);
+        bucket = (Slot *)c->slots + (h & c->mask);
+    }
+    b->next = *bucket;
+    *bucket = b;
+    c->cnt++;  // Don't worry about wrapping. Worse case is the entry is removed and recreated.
+    if (NULL != keyp) {
+        *keyp = b->key;
+    }
+    if (REHASH_LIMIT < c->cnt / c->size) {
+        rehash(c);
+    }
+    CACHE_UNLOCK(c);
+
+    return rkey;
+}
+
+Cache ox_cache_create(size_t size, VALUE (*form)(const char *str, size_t len), bool mark, bool locking) {
+    Cache c     = calloc(1, sizeof(struct _cache));
+    int   shift = 0;
+
+    for (; REHASH_LIMIT < size; size /= 2, shift++) {
+    }
+    if (shift < MIN_SHIFT) {
+        shift = MIN_SHIFT;
+    }
+#if HAVE_PTHREAD_MUTEX_INIT
+    pthread_mutex_init(&c->mutex, NULL);
+#else
+    c->mutex = rb_mutex_new();
+#endif
+    c->size  = 1 << shift;
+    c->mask  = c->size - 1;
+    c->slots = calloc(c->size, sizeof(Slot));
+    c->form  = form;
+    c->xrate = 1;  // low
+    c->mark  = mark;
+    if (locking) {
+        c->intern = ox_locking_intern;
+    } else {
+        c->intern = ox_lockless_intern;
+    }
+    return c;
+}
+
+void ox_cache_free(void *ptr) {
+    Cache    c = (Cache)ptr;
+    uint64_t i;
+
+    for (i = 0; i < c->size; i++) {
+        Slot next;
+        Slot s;
+
+        for (s = c->slots[i]; NULL != s; s = next) {
+            next = s->next;
+            free(s);
+        }
+    }
+    free((void *)c->slots);
+    free(c);
+}
+
+void ox_cache_mark(void *ptr) {
+    Cache    c = (Cache)ptr;
+    uint64_t i;
+
+#if !HAVE_PTHREAD_MUTEX_INIT
+    rb_gc_mark(c->mutex);
+#endif
+    if (0 == c->cnt) {
+        return;
+    }
+    for (i = 0; i < c->size; i++) {
+        Slot s;
+        Slot prev = NULL;
+        Slot next;
+
+        for (s = c->slots[i]; NULL != s; s = next) {
+            next = s->next;
+            if (0 == s->use_cnt) {
+                if (NULL == prev) {
+                    c->slots[i] = next;
+                } else {
+                    prev->next = next;
+                }
+                c->cnt--;
+                s->next  = c->reuse;
+                c->reuse = s;
+                c->rcnt++;
+                continue;
+            }
+            switch (c->xrate) {
+            case 0: break;
+            case 2: s->use_cnt -= 2; break;
+            case 3: s->use_cnt /= 2; break;
+            default: s->use_cnt--; break;
+            }
+            if (c->mark) {
+                rb_gc_mark(s->val);
+            }
+            prev = s;
+        }
+    }
+}
+
+VALUE
+ox_cache_intern(Cache c, const char *key, size_t len, const char **keyp) {
+    if (CACHE_MAX_KEY <= len) {
+        if (NULL != keyp) {
+            volatile VALUE rkey = c->form(key, len);
+
+            if (SYMBOL_P(rkey)) {
+                *keyp = rb_id2name(rb_sym2id(rkey));
+            }
+            return rkey;
+        }
+        return c->form(key, len);
+    }
+    return c->intern(c, key, len, keyp);
+}

data/ext/ox/cache.h

@@ -0,0 +1,21 @@
+// Copyright (c) 2021 Peter Ohler. All rights reserved.
+// Licensed under the MIT License. See LICENSE file in the project root for license details.
+
+#ifndef OX_CACHE_H
+#define OX_CACHE_H
+
+#include <ruby.h>
+#include <stdbool.h>
+
+#define CACHE_MAX_KEY 35
+
+struct _cache;
+
+extern const rb_data_type_t ox_cache_type;
+
+extern struct _cache *ox_cache_create(size_t size, VALUE (*form)(const char *str, size_t len), bool mark, bool locking);
+extern void           ox_cache_free(void *ptr);
+extern void           ox_cache_mark(void *ptr);
+extern VALUE          ox_cache_intern(struct _cache *c, const char *key, size_t len, const char **keyp);
+
+#endif /* OX_CACHE_H */

data/ext/ox/cache8.c

@@ -0,0 +1,106 @@
+/* cache8.h
+ * Copyright (c) 2011, Peter Ohler
+ * All rights reserved.
+ */
+
+#include "cache8.h"
+
+#include <errno.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "ruby.h"
+
+#define BITS 4
+#define MASK 0x000000000000000FULL
+#define SLOT_CNT 16
+#define DEPTH 16
+
+typedef union {
+    struct _cache8 *child;
+    slot_t          value;
+} Bucket;
+
+struct _cache8 {
+    Bucket buckets[SLOT_CNT];
+};
+
+static void cache8_delete(Cache8 cache, int depth);
+// static void	slot_print(Cache8 cache, sid_t key, unsigned int depth);
+
+void ox_cache8_new(Cache8 *cache) {
+    Bucket *b;
+    int     i;
+
+    *cache = ALLOC(struct _cache8);
+    for (i = SLOT_CNT, b = (*cache)->buckets; 0 < i; i--, b++) {
+        b->value = 0;
+    }
+}
+
+void ox_cache8_delete(Cache8 cache) {
+    cache8_delete(cache, 0);
+}
+
+static void cache8_delete(Cache8 cache, int depth) {
+    Bucket      *b;
+    unsigned int i;
+
+    for (i = 0, b = cache->buckets; i < SLOT_CNT; i++, b++) {
+        if (0 != b->child) {
+            if (DEPTH - 1 != depth) {
+                cache8_delete(b->child, depth + 1);
+            }
+        }
+    }
+    xfree(cache);
+}
+
+slot_t ox_cache8_get(Cache8 cache, sid_t key, slot_t **slot) {
+    Bucket *b;
+    int     i;
+    sid_t   k8 = (sid_t)key;
+    sid_t   k;
+
+    for (i = 64 - BITS; 0 < i; i -= BITS) {
+        k = (k8 >> i) & MASK;
+        b = cache->buckets + k;
+        if (0 == b->child) {
+            ox_cache8_new(&b->child);
+        }
+        cache = b->child;
+    }
+    *slot = &(cache->buckets + (k8 & MASK))->value;
+
+    return **slot;
+}
+
+#if 0
+void
+ox_cache8_print(Cache8 cache) {
+    //printf("-------------------------------------------\n");
+    slot_print(cache, 0, 0);
+}
+
+static void
+slot_print(Cache8 c, sid_t key, unsigned int depth) {
+    Bucket		*b;
+    unsigned int	i;
+    sid_t		k8 = (sid_t)key;
+    sid_t		k;
+
+    for (i = 0, b = c->buckets; i < SLOT_CNT; i++, b++) {
+	if (0 != b->child) {
+	    k = (k8 << BITS) | i;
+	    //printf("*** key: 0x%016llx  depth: %u  i: %u\n", k, depth, i);
+	    if (DEPTH - 1 == depth) {
+		printf("0x%016llx: %4llu\n", (unsigned long long)k, (unsigned long long)b->value);
+	    } else {
+		slot_print(b->child, k, depth + 1);
+	    }
+	}
+    }
+}
+#endif

data/ext/ox/cache8.h

@@ -0,0 +1,23 @@
+/* cache8.h
+ * Copyright (c) 2011, Peter Ohler
+ * All rights reserved.
+ */
+
+#ifndef OX_CACHE8_H
+#define OX_CACHE8_H
+
+#include "ruby.h"
+#include "stdint.h"
+
+typedef struct _cache8 *Cache8;
+typedef uint64_t        slot_t;
+typedef uint64_t        sid_t;
+
+extern void ox_cache8_new(Cache8 *cache);
+extern void ox_cache8_delete(Cache8 cache);
+
+extern slot_t ox_cache8_get(Cache8 cache, sid_t key, slot_t **slot);
+
+// extern void	ox_cache8_print(Cache8 cache);
+
+#endif /* OX_CACHE8_H */