ulid_fast 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 675e2d1ea39c7608d9bb84a96efeab8acdf7eef82c1dd294c300577db946f72e
+  data.tar.gz: a58b60f8ff7177465adb801d194d80e456cbcaa4f7b90ea9efdb7cda2d0666bb
+SHA512:
+  metadata.gz: 2aa59ba886b3f1d00ade9e4f3aa5595d41ebf15ccc2ad0a841d4d88dc1e58b5c8954032a3a3403e3dba9f691e8bbdf2b79a130d3b454aec5f1ec34ec9154027e
+  data.tar.gz: 6805293e8c88cf1464cdebb3f157c5fc97749b85e53068bf29f4b22b3a370fc4f1bd1ebc92a08e7454f3e771b62acda7bed04b36d0d62ee6c37e96fffd46202c

data/ext/ulid_fast/extconf.rb

@@ -0,0 +1,3 @@
+require 'mkmf'
+
+create_makefile('ulid_fast')

data/ext/ulid_fast/ulid-fast.c

@@ -0,0 +1,88 @@
+#include <stdlib.h>
+#include <ruby.h>
+#include <ruby/encoding.h>
+#include "ulid.h"
+
+
+static VALUE m_ULID;
+
+
+void
+rb_ulid_generator_mark (void *_self)
+{
+  /*
+   * This function is not needed becaue there is no malloc() or
+   * pointers to other VALUE objects.
+   * However, to help others understand how Ruby C extensions
+   * work I've left it here.
+   *
+    struct ulid_generator *ug;
+
+    TypedData_Get_Struct(self, struct ulid_generator, &UlidGeneratorType, ug);
+
+    rb_gc_mark(ug->thing);
+    rb_gc_mark(ug->other_thing);
+  */
+}
+
+void
+rb_ulid_generator_free (void *_self)
+{
+  // Not needed. We do not malloc() here or in the ulid lib
+  // free(_self);
+}
+
+static const rb_data_type_t UlidGeneratorType = {
+    "UlidGenerator",
+    { rb_ulid_generator_mark, rb_ulid_generator_free, NULL }
+};
+
+static VALUE
+rb_ulid_generate(VALUE self)
+{
+  struct ulid_generator *ug;
+
+  TypedData_Get_Struct(self, struct ulid_generator, &UlidGeneratorType, ug);
+  char ulid[27];
+
+  ulid_generate(ug, ulid);
+
+  return rb_utf8_str_new(ulid, 26);
+}
+
+static VALUE
+rb_ulid_alloc(VALUE self)
+{
+  struct ulid_generator *ug;
+  VALUE obj;
+  obj = TypedData_Make_Struct(self, struct ulid_generator, &UlidGeneratorType, ug);
+
+  int ret = ulid_generator_init(ug, ULID_SECURE);
+
+  if (ret != 0)
+    rb_raise(rb_eRuntimeError, "ulid_generator_init failure");
+
+  return obj;
+}
+
+// TODO ..
+/*
+static VALUE
+rb_ulid_each(int argc, VALUE* argv, VALUE self)
+{
+  // return rb_funcall(self, rb_intern("to_enum"), 2, rb_intern("generate"), self,);
+
+  return Qnil;
+}
+*/
+
+void
+Init_ulid_fast() {
+  m_ULID = rb_define_module("ULID");
+    
+  VALUE cls = rb_define_class_under(m_ULID, "Generator", rb_cObject);
+  // rb_include_module(m_ULID, rb_mEnumerable);
+  rb_define_alloc_func(cls, rb_ulid_alloc);
+  rb_define_method(cls, "generate", rb_ulid_generate, 0);
+  //rb_define_method(cls, "each", rb_ulid_each, -1);
+}

data/ext/ulid_fast/ulid.c

@@ -0,0 +1,294 @@
+/* ULID generation and parsing library (implementation)
+ *
+ * This is free and unencumbered software released into the public domain.
+ */
+#ifdef _WIN32
+#  define WIN32_LEAN_AND_MEAN
+#  include <windows.h>
+#  pragma comment(lib, "advapi32.lib")
+#elif __linux__
+#  define _GNU_SOURCE
+#  include <unistd.h>
+#  include <sys/time.h>
+#  include <sys/syscall.h>
+#else
+#  define _POSIX_C_SOURCE 200112L
+#  include <sys/time.h>
+#endif
+#include <time.h>
+#include <stdio.h>
+#include <string.h>
+#include "ulid.h"
+
+/* Returns unix epoch microseconds.
+ */
+static unsigned long long
+platform_utime(int coarse)
+{
+#ifdef _WIN32
+    FILETIME ft;
+    (void)coarse;
+    GetSystemTimeAsFileTime(&ft);
+    return ((unsigned long long)ft.dwHighDateTime << 32 |
+            (unsigned long long)ft.dwLowDateTime  <<  0)
+        / 10 - 11644473600000000ULL;
+#elif __linux__
+    /* CLOCK_REALTIME_COARSE has a resolution of 1ms, which is
+     * sufficient for this purpose. It's also _much_ faster.
+     */
+    struct timespec tv[1];
+    clock_gettime(coarse ? CLOCK_REALTIME_COARSE : CLOCK_REALTIME, tv);
+    return tv->tv_sec * 1000000ULL + tv->tv_nsec / 1000ULL;
+#else
+    struct timespec tv[1];
+    (void)coarse;
+    clock_gettime(CLOCK_REALTIME, tv);
+    return tv->tv_sec * 1000000ULL + tv->tv_nsec / 1000ULL;
+#endif
+}
+
+/* Gather entropy from the operating system.
+ * Returns 0 on success.
+ */
+static int
+platform_entropy(void *buf, int len)
+{
+#if _WIN32
+    BOOLEAN NTAPI SystemFunction036(PVOID, ULONG);
+    return !SystemFunction036(buf, len);
+#elif __linux__
+    return syscall(SYS_getrandom, buf, len, 0) != len;
+#else
+    int r = 0;
+    FILE *f = fopen("/dev/urandom", "rb");
+    if (f) {
+        r = fread(buf, len, 1, f);
+        fclose(f);
+    }
+    return !r;
+#endif
+}
+
+int
+ulid_generator_init(struct ulid_generator *g, int flags)
+{
+    g->last_ts = 0;
+    g->flags = flags;
+    g->i = g->j = 0;
+    for (int i = 0; i < 256; i++)
+        g->s[i] = i;
+
+    /* RC4 is used to fill the random segment of ULIDs. It's tiny,
+     * simple, perfectly sufficient for the task (assuming it's seeded
+     * properly), and doesn't require fixed-width integers. It's not the
+     * fastest option, but it's plenty fast for the task.
+     *
+     * Besides, when we're in a serious hurry in normal operation (not
+     * in "relaxed" mode), we're incrementing the random field much more
+     * often than generating fresh random bytes.
+     */
+
+    int initstyle = 1;
+    unsigned char key[256] = {0};
+    if (!platform_entropy(key, 256)) {
+        /* Mix entropy into the RC4 state. */
+        for (int i = 0, j = 0; i < 256; i++) {
+            j = (j + g->s[i] + key[i]) & 0xff;
+            int tmp = g->s[i];
+            g->s[i] = g->s[j];
+            g->s[j] = tmp;
+        }
+        initstyle = 0;
+    } else if (!(flags & ULID_SECURE)) {
+        /* Failed to read entropy from OS, so generate some. */
+        unsigned long n = 0;
+        unsigned long long now;
+        unsigned long long start = platform_utime(0);
+        do {
+            struct {
+                clock_t clk;
+                unsigned long long ts;
+                long n;
+                void *stackgap;
+            } noise;
+            noise.ts = now = platform_utime(0);
+            noise.clk = clock();
+            noise.stackgap = &noise;
+            noise.n = n;
+            unsigned char *k = (unsigned char *)&noise;
+            for (int i = 0, j = 0; i < 256; i++) {
+                j = (j + g->s[i] + k[i % sizeof(noise)]) & 0xff;
+                int tmp = g->s[i];
+                g->s[i] = g->s[j];
+                g->s[j] = tmp;
+            }
+        } while (n++ < 1UL << 16 || now - start < 500000ULL);
+    }
+    return initstyle;
+}
+
+void
+ulid_encode(char str[27], const unsigned char ulid[16])
+{
+    static const char set[256] = {
+        0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
+        0x38, 0x39, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46,
+        0x47, 0x48, 0x4a, 0x4b, 0x4d, 0x4e, 0x50, 0x51,
+        0x52, 0x53, 0x54, 0x56, 0x57, 0x58, 0x59, 0x5a,
+        0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
+        0x38, 0x39, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46,
+        0x47, 0x48, 0x4a, 0x4b, 0x4d, 0x4e, 0x50, 0x51,
+        0x52, 0x53, 0x54, 0x56, 0x57, 0x58, 0x59, 0x5a,
+        0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
+        0x38, 0x39, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46,
+        0x47, 0x48, 0x4a, 0x4b, 0x4d, 0x4e, 0x50, 0x51,
+        0x52, 0x53, 0x54, 0x56, 0x57, 0x58, 0x59, 0x5a,
+        0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
+        0x38, 0x39, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46,
+        0x47, 0x48, 0x4a, 0x4b, 0x4d, 0x4e, 0x50, 0x51,
+        0x52, 0x53, 0x54, 0x56, 0x57, 0x58, 0x59, 0x5a,
+        0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
+        0x38, 0x39, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46,
+        0x47, 0x48, 0x4a, 0x4b, 0x4d, 0x4e, 0x50, 0x51,
+        0x52, 0x53, 0x54, 0x56, 0x57, 0x58, 0x59, 0x5a,
+        0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
+        0x38, 0x39, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46,
+        0x47, 0x48, 0x4a, 0x4b, 0x4d, 0x4e, 0x50, 0x51,
+        0x52, 0x53, 0x54, 0x56, 0x57, 0x58, 0x59, 0x5a,
+        0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
+        0x38, 0x39, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46,
+        0x47, 0x48, 0x4a, 0x4b, 0x4d, 0x4e, 0x50, 0x51,
+        0x52, 0x53, 0x54, 0x56, 0x57, 0x58, 0x59, 0x5a,
+        0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
+        0x38, 0x39, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46,
+        0x47, 0x48, 0x4a, 0x4b, 0x4d, 0x4e, 0x50, 0x51,
+        0x52, 0x53, 0x54, 0x56, 0x57, 0x58, 0x59, 0x5a
+    };
+    str[ 0] = set[ ulid[ 0] >> 5];
+    str[ 1] = set[ ulid[ 0] >> 0];
+    str[ 2] = set[ ulid[ 1] >> 3];
+    str[ 3] = set[(ulid[ 1] << 2 | ulid[ 2] >> 6) & 0x1f];
+    str[ 4] = set[ ulid[ 2] >> 1];
+    str[ 5] = set[(ulid[ 2] << 4 | ulid[ 3] >> 4) & 0x1f];
+    str[ 6] = set[(ulid[ 3] << 1 | ulid[ 4] >> 7) & 0x1f];
+    str[ 7] = set[ ulid[ 4] >> 2];
+    str[ 8] = set[(ulid[ 4] << 3 | ulid[ 5] >> 5) & 0x1f];
+    str[ 9] = set[ ulid[ 5] >> 0];
+    str[10] = set[ ulid[ 6] >> 3];
+    str[11] = set[(ulid[ 6] << 2 | ulid[ 7] >> 6) & 0x1f];
+    str[12] = set[ ulid[ 7] >> 1];
+    str[13] = set[(ulid[ 7] << 4 | ulid[ 8] >> 4) & 0x1f];
+    str[14] = set[(ulid[ 8] << 1 | ulid[ 9] >> 7) & 0x1f];
+    str[15] = set[ ulid[ 9] >> 2];
+    str[16] = set[(ulid[ 9] << 3 | ulid[10] >> 5) & 0x1f];
+    str[17] = set[ ulid[10] >> 0];
+    str[18] = set[ ulid[11] >> 3];
+    str[19] = set[(ulid[11] << 2 | ulid[12] >> 6) & 0x1f];
+    str[20] = set[ ulid[12] >> 1];
+    str[21] = set[(ulid[12] << 4 | ulid[13] >> 4) & 0x1f];
+    str[22] = set[(ulid[13] << 1 | ulid[14] >> 7) & 0x1f];
+    str[23] = set[ ulid[14] >> 2];
+    str[24] = set[(ulid[14] << 3 | ulid[15] >> 5) & 0x1f];
+    str[25] = set[ ulid[15] >> 0];
+    str[26] = 0;
+}
+
+int
+ulid_decode(unsigned char ulid[16], const char *s)
+{
+    static const signed char v[] = {
+          -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+          -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+          -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+          -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+          -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+          -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+        0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+        0x08, 0x09,   -1,   -1,   -1,   -1,   -1,   -1,
+          -1, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
+        0x11, 0x01, 0x12, 0x13, 0x01, 0x14, 0x15, 0x00,
+        0x16, 0x17, 0x18, 0x19, 0x1a,   -1, 0x1b, 0x1c,
+        0x1d, 0x1e, 0x1f,   -1,   -1,   -1,   -1,   -1,
+          -1, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
+        0x11, 0x01, 0x12, 0x13, 0x01, 0x14, 0x15, 0x00,
+        0x16, 0x17, 0x18, 0x19, 0x1a,   -1, 0x1b, 0x1c,
+        0x1d, 0x1e, 0x1f,   -1,   -1,   -1,   -1,   -1,
+          -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+          -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+          -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+          -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+          -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+          -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+          -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+          -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+          -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+          -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+          -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+          -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+          -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+          -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+          -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+          -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1
+    };
+    if (v[(int)s[0]] > 7)
+        return 1;
+    for (int i = 0; i < 26; i++)
+        if (v[(int)s[i]] == -1)
+            return 2;
+    ulid[ 0] = v[(int)s[ 0]] << 5 | v[(int)s[ 1]] >> 0;
+    ulid[ 1] = v[(int)s[ 2]] << 3 | v[(int)s[ 3]] >> 2;
+    ulid[ 2] = v[(int)s[ 3]] << 6 | v[(int)s[ 4]] << 1 | v[(int)s[ 5]] >> 4;
+    ulid[ 3] = v[(int)s[ 5]] << 4 | v[(int)s[ 6]] >> 1;
+    ulid[ 4] = v[(int)s[ 6]] << 7 | v[(int)s[ 7]] << 2 | v[(int)s[ 8]] >> 3;
+    ulid[ 5] = v[(int)s[ 8]] << 5 | v[(int)s[ 9]] >> 0;
+    ulid[ 6] = v[(int)s[10]] << 3 | v[(int)s[11]] >> 2;
+    ulid[ 7] = v[(int)s[11]] << 6 | v[(int)s[12]] << 1 | v[(int)s[13]] >> 4;
+    ulid[ 8] = v[(int)s[13]] << 4 | v[(int)s[14]] >> 1;
+    ulid[ 9] = v[(int)s[14]] << 7 | v[(int)s[15]] << 2 | v[(int)s[16]] >> 3;
+    ulid[10] = v[(int)s[16]] << 5 | v[(int)s[17]] >> 0;
+    ulid[11] = v[(int)s[18]] << 3 | v[(int)s[19]] >> 2;
+    ulid[12] = v[(int)s[19]] << 6 | v[(int)s[20]] << 1 | v[(int)s[21]] >> 4;
+    ulid[13] = v[(int)s[21]] << 4 | v[(int)s[22]] >> 1;
+    ulid[14] = v[(int)s[22]] << 7 | v[(int)s[23]] << 2 | v[(int)s[24]] >> 3;
+    ulid[15] = v[(int)s[24]] << 5 | v[(int)s[25]] >> 0;
+    return 0;
+}
+
+void
+ulid_generate(struct ulid_generator *g, char str[27])
+{
+    unsigned long long ts = platform_utime(1) / 1000;
+
+    if (!(g->flags & ULID_RELAXED) && g->last_ts == ts) {
+        /* Chance of 80-bit overflow is so small that it's not considered. */
+        for (int i = 15; i > 5; i--)
+            if (++g->last[i])
+                break;
+        ulid_encode(str, g->last);
+        return;
+    }
+
+    /* Fill out timestamp */
+    g->last_ts = ts;
+    g->last[0] = ts >> 40;
+    g->last[1] = ts >> 32;
+    g->last[2] = ts >> 24;
+    g->last[3] = ts >> 16;
+    g->last[4] = ts >>  8;
+    g->last[5] = ts >>  0;
+
+    /* Fill out random section */
+    for (int k = 0; k < 10; k++) {
+        g->i = (g->i + 1) & 0xff;
+        g->j = (g->j + g->s[g->i]) & 0xff;
+        int tmp = g->s[g->i];
+        g->s[g->i] = g->s[g->j];
+        g->s[g->j] = tmp;
+        g->last[6 + k] = g->s[(g->s[g->i] + g->s[g->j]) & 0xff];
+    }
+    if (g->flags & ULID_PARANOID)
+        g->last[6] &= 0x7f;
+
+    ulid_encode(str, g->last);
+}
+

data/ext/ulid_fast/ulid.h

@@ -0,0 +1,59 @@
+/* ULID generation and parsing library (API)
+ *
+ * This is free and unencumbered software released into the public domain.
+ */
+#ifndef ULID_H
+#define ULID_H
+
+/* Generator configuration flags */
+#define ULID_RELAXED   (1 << 0)
+#define ULID_PARANOID  (1 << 1)
+#define ULID_SECURE    (1 << 2)
+
+struct ulid_generator {
+    unsigned char last[16];
+    unsigned long long last_ts;
+    int flags;
+    unsigned char i, j;
+    unsigned char s[256];
+};
+
+/* Initialize a new ULID generator instance.
+ *
+ * The ULID_RELAXED flag allows ULIDs generated within the same
+ * millisecond to be non-monotonic, e.g. the random section is generated
+ * fresh each time.
+ *
+ * The ULID_PARANOID flag causes the generator to clear the highest bit
+ * of the random field, which guarantees that overflow cannot occur.
+ * Normally the chance of overflow is non-zero, but negligible. This
+ * makes it zero. It doesn't make sense to use this flag in conjunction
+ * with ULID_RELAX.
+ *
+ * The ULID_SECURE flag doesn't fall back on userspace initialization if
+ * system entropy could not be gathered. You _must_ check the return
+ * value if you use this flag, since it now indicates a hard error.
+ *
+ * Returns 0 if the generator was successfully initialized from secure
+ * system entropy. Returns 1 if this failed and instead derived entropy
+ * in userspace (or is uninitialized in the case of ULID_SECURE).
+ */
+int  ulid_generator_init(struct ulid_generator *, int flags);
+
+/* Generate a new ULID.
+ * A zero terminating byte is written to the output buffer.
+ */
+void ulid_generate(struct ulid_generator *, char [27]);
+
+/* Encode a 128-bit binary ULID to its text format.
+ * A zero terminating byte is written to the output buffer.
+ */
+void ulid_encode(char [27], const unsigned char [16]);
+
+/* Decode a text ULID to a 128-bit binary ULID.
+ * Returns non-zero if input was invalid.
+ */
+int  ulid_decode(unsigned char [16], const char *);
+
+#endif
+

data/lib/ulid_fast/version.rb

@@ -0,0 +1,3 @@
+module ULID
+  VERSION = '0.1.0'
+end

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification
+name: ulid_fast
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- James Cook
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-02-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5'
+description: 
+email: 
+executables: []
+extensions:
+- ext/ulid_fast/extconf.rb
+extra_rdoc_files: []
+files:
+- ext/ulid_fast/extconf.rb
+- ext/ulid_fast/ulid-fast.c
+- ext/ulid_fast/ulid.c
+- ext/ulid_fast/ulid.h
+- lib/ulid_fast/version.rb
+homepage: https://github.com/jamescook/ulid_fast
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: '2.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: ULID Ruby C Extension
+test_files: []