ffi-hydrogen 0.1.0

data/vendor/stringencoders/test/speedtest_ascii.c

@@ -0,0 +1,345 @@
+#include "modp_ascii.h"
+#include "modp_ascii_data.h"
+#include <ctype.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <time.h>
+
+//extern const char gsToUpperMap[256];
+/**
+ * This is standard clib implementation of uppercasing a string.
+ * It has an unfair advantage since it's inside the test file
+ * so the optimizer can inline it.
+ */
+static void toupper_copy1(char* dest, const char* str, size_t len)
+{
+    size_t i;
+    for (i = 0; i < len; ++i) {
+        // toupper is defined in <ctype.h>
+        *dest++ = (char)toupper((int)str[i]);
+    }
+    *dest = 0;
+}
+
+/**
+ * Skipping ctype, and doing the compare directly
+ *
+ */
+static void toupper_copy2(char* dest, const char* str, size_t len)
+{
+    size_t i;
+    char c;
+    for (i = 0; i < len; ++i) {
+        c = str[i];
+        *dest++ = (char)((c >= 'a' && c <= 'z') ? c : (c - 32));
+    }
+    *dest = 0;
+}
+
+/** 
+ * Sequential table lookup
+ */
+static void toupper_copy3(char* dest, const char* str, size_t len)
+{
+    size_t i;
+    unsigned char c;
+    for (i = 0; i < len; ++i) {
+        c = (unsigned char)str[i];
+        *dest++ = (char)gsToUpperMap[c];
+    }
+    *dest = 0;
+}
+
+/** \brief toupper Version 4 -- parallel table lookup
+ *
+ *
+ */
+static void toupper_copy4(char* dest, const char* str, size_t len)
+{
+    /*
+     *  size_t i;
+     *  for (i = 0; i < len; ++i) {
+     *      char c = str[i];
+     *      *dest++ = (c >= 'a' && c <= 'z') ? c - 32 : c;
+     *  }
+     */
+
+    size_t i;
+    uint8_t c1, c2, c3, c4;
+
+    const size_t leftover = len % 4;
+    const size_t imax = len - leftover;
+    const uint8_t* s = (const uint8_t*)str;
+    for (i = 0; i != imax; i += 4) {
+        /*
+         *  it's important to make these variables
+         *  it helps the optimizer to figure out what to do
+         */
+        c1 = s[i], c2 = s[i + 1], c3 = s[i + 2], c4 = s[i + 3];
+        dest[0] = (char)gsToUpperMap[c1];
+        dest[1] = (char)gsToUpperMap[c2];
+        dest[2] = (char)gsToUpperMap[c3];
+        dest[3] = (char)gsToUpperMap[c4];
+        dest += 4;
+    }
+
+    switch (leftover) {
+    case 3:
+        *dest++ = (char)gsToUpperMap[s[i++]];
+    case 2:
+        *dest++ = (char)gsToUpperMap[s[i++]];
+    case 1:
+        *dest++ = (char)gsToUpperMap[s[i]];
+    case 0:
+        *dest = '\0';
+    }
+}
+
+/** \brief toupper Versions 5 -- hsieh alternate
+ * Based code from Paul Hsieh
+ * http://www.azillionmonkeys.com/qed/asmexample.html
+ *
+ * This was his "improved" version, but it appears to either run just
+ * as fast, or a bit slower than his original version
+ */
+static void toupper_copy5(char* dest, const char* str, size_t len)
+{
+    size_t i;
+    uint32_t eax, ebx, ecx, edx;
+    const uint8_t* ustr = (const uint8_t*)str;
+    const int leftover = len % 4;
+    const size_t imax = len / 4;
+    const uint32_t* s = (const uint32_t*)str;
+    uint32_t* d = (uint32_t*)dest;
+    for (i = 0; i != imax; ++i) {
+        eax = s[i];
+        ebx = 0x80808080u | eax;
+        ecx = ebx - 0x61616161u;
+        edx = ~(ebx - 0x7b7b7b7bu);
+        ebx = (ecx & edx) & (~eax & 0x80808080u);
+        *d++ = eax - (ebx >> 2);
+    }
+
+    i = imax * 4;
+    dest = (char*)d;
+    switch (leftover) {
+    case 3:
+        *dest++ = (char)gsToUpperMap[ustr[i++]];
+    case 2:
+        *dest++ = (char)gsToUpperMap[ustr[i++]];
+    case 1:
+        *dest++ = (char)gsToUpperMap[ustr[i]];
+    case 0:
+        *dest = '\0';
+    }
+}
+
+/** \brief ToUpper Version 6 -- Hsieh original, ASM style
+ * Based code from Paul Hsieh
+ * http://www.azillionmonkeys.com/qed/asmexample.html
+ *
+ * This is almost a direct port of the original ASM code, on some
+ * platforms/compilers it does run faster then the "de-asm'ed" version
+ * used in the modp library.
+ *
+ */
+static void toupper_copy6(char* dest, const char* str, size_t len)
+{
+    size_t i = 0;
+    uint32_t eax, ebx, ecx, edx;
+    const uint8_t* ustr = (const uint8_t*)str;
+    const int leftover = len % 4;
+    const size_t imax = len / 4;
+    const uint32_t* s = (const uint32_t*)str;
+    uint32_t* d = (uint32_t*)dest;
+    for (i = 0; i != imax; ++i) {
+#if 1
+        /*
+         * as close to original asm code as possible
+         */
+        eax = s[i];
+        ebx = 0x7f7f7f7f;
+        edx = 0x7f7f7f7f;
+        ebx = ebx & eax;
+        ebx = ebx + 0x05050505;
+        ecx = eax;
+        ecx = ~ecx;
+        ebx = ebx & edx;
+        ebx = ebx + 0x1a1a1a1a;
+        ebx = ebx & ecx;
+        ebx = ebx >> 2;
+        ebx = ebx & 0x20202020;
+        eax = eax - ebx;
+        *d++ = eax;
+#else
+        /*
+         * "de-asm'ed" version, this is what is used in the modp library
+         */
+        eax = s[i];
+        ebx = (0x7f7f7f7ful & eax) + 0x05050505ul;
+        ebx = (0x7f7f7f7ful & ebx) + 0x1a1a1a1aul;
+        ebx = ((ebx & ~eax) >> 2) & 0x20202020ul;
+        *d++ = eax - ebx;
+#endif
+    }
+
+    i = imax * 4;
+    dest = (char*)d;
+    switch (leftover) {
+    case 3:
+        *dest++ = (char)gsToUpperMap[ustr[i++]];
+    case 2:
+        *dest++ = (char)gsToUpperMap[ustr[i++]];
+    case 1:
+        *dest++ = (char)gsToUpperMap[ustr[i]];
+    case 0:
+        *dest = '\0';
+    }
+}
+
+static void modp_toupper_copy_a2(char* dest, const char* str, size_t len)
+{
+    size_t i = 0;
+    uint32_t eax, ebx;
+    const uint8_t* ustr = (const uint8_t*)str;
+    const size_t leftover = len % 4;
+    const size_t imax = len / 4;
+    const uint32_t* s = (const uint32_t*)str;
+    uint32_t* d = (uint32_t*)dest;
+    for (i = 0; i != imax; ++i) {
+        eax = s[i];
+
+        ebx = (0x7f7f7f7fu & eax) + 0x05050505u;
+        ebx = (0x7f7f7f7fu & ebx) + 0x1a1a1a1au;
+        ebx = ((ebx & ~eax) >> 2) & 0x20202020u;
+        *d++ = eax - ebx;
+    }
+
+    i = imax * 4;
+    dest = (char*)d;
+    switch (leftover) {
+    case 3:
+        *dest++ = (char)gsToUpperMap[ustr[i++]];
+    case 2:
+        *dest++ = (char)gsToUpperMap[ustr[i++]];
+    case 1:
+        *dest++ = (char)gsToUpperMap[ustr[i]];
+    case 0:
+        *dest = '\0';
+    }
+}
+
+int main(void)
+{
+    double last = 0.0;
+    size_t i = 0;
+    char buf[256];
+    char obuf[300];
+
+    for (i = 0; i < 256; ++i) {
+        buf[i] = (char)i;
+    }
+
+    uint32_t max = 1000000;
+    clock_t t0, t1;
+    printf("%s", "type\tclib\tdirect\tmap\tpara\thsieh1\thsieh2\tAlt\tFinal\timprovement\n");
+
+    printf("toupper\t");
+    fflush(stdout);
+
+    /**
+     ** V1
+     **/
+    t0 = clock();
+    for (i = 0; i < max; ++i) {
+        toupper_copy1(obuf, buf, sizeof(buf));
+    }
+    t1 = clock();
+    last = (double)(t1 - t0);
+    printf("%lu\t", (t1 - t0));
+    fflush(stdout);
+
+    /**
+     ** V2
+     **/
+    t0 = clock();
+    for (i = 0; i < max; ++i) {
+        toupper_copy2(obuf, buf, sizeof(buf));
+    }
+    t1 = clock();
+    printf("%lu\t", (t1 - t0));
+    fflush(stdout);
+
+    /**
+     ** V3
+     **/
+    t0 = clock();
+    for (i = 0; i < max; ++i) {
+        toupper_copy3(obuf, buf, sizeof(buf));
+    }
+    t1 = clock();
+    printf("%lu\t", (t1 - t0));
+    fflush(stdout);
+
+    /**
+     ** V4 -- Parallel Table Lookup
+     **/
+    t0 = clock();
+    for (i = 0; i < max; ++i) {
+        toupper_copy4(obuf, buf, sizeof(buf));
+    }
+    t1 = clock();
+    printf("%lu\t", (t1 - t0));
+    fflush(stdout);
+
+    /**
+     ** V5 -- Hsieh Alternate
+     **/
+    t0 = clock();
+    for (i = 0; i < max; ++i) {
+        toupper_copy5(obuf, buf, sizeof(buf));
+    }
+    t1 = clock();
+    printf("%lu\t", (t1 - t0));
+    fflush(stdout);
+
+    /**
+     ** HSEIH -- asm style
+     **/
+    t0 = clock();
+    for (i = 0; i < max; ++i) {
+        toupper_copy6(obuf, buf, sizeof(buf));
+    }
+    t1 = clock();
+    printf("%lu\t", (t1 - t0));
+    fflush(stdout);
+
+    /**
+     ** MODP ALT
+     **/
+    t0 = clock();
+    for (i = 0; i < max; ++i) {
+        modp_toupper_copy_a2(obuf, buf, sizeof(buf));
+    }
+    t1 = clock();
+
+    printf("%lu\t", (t1 - t0));
+    fflush(stdout);
+
+    /**
+     ** MODP FINAL
+     **/
+    t0 = clock();
+    for (i = 0; i < max; ++i) {
+        modp_toupper_copy(obuf, buf, sizeof(buf));
+    }
+    t1 = clock();
+
+    printf("%lu\t", (t1 - t0));
+    fflush(stdout);
+
+    printf("%.1fx\n", last / ((double)(t1 - t0)));
+    fflush(stdout);
+
+    return 0;
+}

data/vendor/stringencoders/test/speedtest_msg.c

@@ -0,0 +1,78 @@
+#include "modp_json.h"
+
+#include <time.h>
+#ifndef CLOCKS_PER_SEC
+#ifdef CLK_TCK
+#define CLOCKS_PER_SEC (CLK_TCK)
+#endif
+#endif
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+size_t test_json_encode(char* dest)
+{
+    modp_json_ctx ctx;
+    modp_json_init(&ctx, dest);
+    modp_json_map_open(&ctx);
+
+    modp_json_add_cstring(&ctx, "start_ms");
+    modp_json_add_uint32(&ctx, 123456789);
+
+    modp_json_add_cstring(&ctx, "remote_ip");
+    modp_json_add_cstring(&ctx, "123.123.123.13");
+
+    modp_json_add_cstring(&ctx, "request");
+    modp_json_add_cstring(&ctx, "GET /foobar HTTP/1.1");
+
+    modp_json_add_cstring(&ctx, "headers_in");
+    modp_json_ary_open(&ctx);
+
+    modp_json_ary_open(&ctx);
+    modp_json_add_cstring(&ctx, "Accept");
+    modp_json_add_cstring(&ctx, "*/*");
+    modp_json_ary_close(&ctx);
+
+    modp_json_ary_open(&ctx);
+    modp_json_add_cstring(&ctx, "Content-type");
+    modp_json_add_cstring(&ctx, "text/plain");
+    modp_json_ary_close(&ctx);
+
+    modp_json_ary_open(&ctx);
+    modp_json_add_cstring(&ctx, "Connection");
+    modp_json_add_cstring(&ctx, "close");
+    modp_json_ary_close(&ctx);
+
+    modp_json_ary_open(&ctx);
+    modp_json_add_cstring(&ctx, "User-agent");
+    modp_json_add_cstring(&ctx, "Mozilla/5.0 (iPad; U; CPU OS 3_2_1 like Mac OS X; en-us) AppleWebKit/531.21.10 (KHTML, like Gecko) Mobile/7B405");
+    modp_json_ary_close(&ctx);
+
+    modp_json_ary_close(&ctx);
+    modp_json_map_close(&ctx);
+    return modp_json_end(&ctx);
+}
+
+int main(void)
+{
+
+    const int imax = 1000000;
+    clock_t t0, t1;
+    int i;
+    double s1;
+    size_t len;
+    char buf2[512];
+
+    printf("ALG\tEncodes/Sec\tBYTES\n");
+    fflush(stdout);
+    t0 = clock();
+    for (i = 0; i < imax; ++i) {
+        len = test_json_encode(NULL);
+        len = test_json_encode(buf2);
+    }
+    t1 = clock();
+    s1 = (double)(t1 - t0) * (1.0 / (double)CLOCKS_PER_SEC);
+    printf("%s\t%8.0f\t%u\n", "JSON", imax / s1, (unsigned)len);
+    fflush(stdout);
+    return 0;
+}

data/vendor/stringencoders/test/speedtest_numtoa.c

@@ -0,0 +1,276 @@
+/* needed since we compile as C90
+ * trick gcc to accepting snprintf which is a C99-ism
+ */
+#define _ISOC99_SOURCE
+#define _DEFAULT_SOURCE
+#define _XOPEN_SOURCE 500
+#define _POSIX_C_SOURCE 200112L
+#include <stdint.h>
+#include <stdio.h>
+#include <time.h>
+
+#include "modp_numtoa.h"
+
+int main(void)
+{
+    char buf[100];
+    uint32_t max = 1000000;
+    clock_t t0, t1;
+    double d, last;
+    uint32_t i;
+    uint8_t ju8;
+    uint16_t ju16;
+    int8_t j8;
+    int16_t j16;
+    printf("%s", "    type   \tsprintf\tsnprf\tnumtoa\timprovement\n");
+
+    printf("unsigned 8\t");
+    t0 = clock();
+    for (i = 0; i < max; ++i) {
+        ju8 = (uint8_t)i;
+        sprintf(buf, "%hhu", ju8);
+    }
+    t1 = clock();
+    printf("%lu\t", (t1 - t0));
+    fflush(stdout);
+
+    t0 = clock();
+    for (i = 0; i < max; ++i) {
+        ju8 = (uint8_t)i;
+        snprintf(buf, sizeof(buf), "%hhu", ju8);
+    }
+    t1 = clock();
+    last = ((double)(t1 - t0));
+    printf("%lu\t", (t1 - t0));
+    fflush(stdout);
+
+    t0 = clock();
+    for (i = 0; i < max; ++i) {
+        ju8 = (uint8_t)i;
+        modp_uitoa10(ju8, buf);
+    }
+    t1 = clock();
+    printf("%lu\t", (t1 - t0));
+    printf("%.1fx\n", last / ((double)(t1 - t0)));
+    fflush(stdout);
+
+    printf("unsigned 16\t");
+    t0 = clock();
+    for (i = 0; i < max; ++i) {
+        ju16 = (uint16_t)i;
+        sprintf(buf, "%hu", ju16);
+    }
+    t1 = clock();
+    printf("%lu\t", (t1 - t0));
+    fflush(stdout);
+
+    t0 = clock();
+    for (i = 0; i < max; ++i) {
+        ju16 = (uint16_t)i;
+        snprintf(buf, sizeof(buf), "%hu", ju16);
+    }
+    t1 = clock();
+    last = ((double)(t1 - t0));
+    printf("%lu\t", (t1 - t0));
+    fflush(stdout);
+
+    t0 = clock();
+    for (i = 0; i < max; ++i) {
+        ju16 = (uint16_t)i;
+        modp_uitoa10(ju16, buf);
+    }
+    t1 = clock();
+    printf("%lu\t", ((t1 - t0)));
+    printf("%.1fx\n", last / ((double)(t1 - t0)));
+    fflush(stdout);
+
+    printf("unsigned 32\t");
+    t0 = clock();
+    for (i = 0; i < max; ++i) {
+        sprintf(buf, "%u", i);
+    }
+    t1 = clock();
+    printf("%lu\t", ((t1 - t0)));
+    fflush(stdout);
+
+    t0 = clock();
+    for (i = 0; i < max; ++i) {
+        snprintf(buf, sizeof(buf), "%u", i);
+    }
+    t1 = clock();
+    last = ((double)(t1 - t0));
+    printf("%lu\t", ((t1 - t0)));
+    fflush(stdout);
+
+    t0 = clock();
+    for (i = 0; i < max; ++i) {
+        modp_uitoa10(i, buf);
+    }
+    t1 = clock();
+    printf("%lu\t", ((t1 - t0)));
+    printf("%.1fx\n", last / ((double)(t1 - t0)));
+    fflush(stdout);
+
+    printf("signed 8\t");
+    t0 = clock();
+    for (i = 0; i < max; ++i) {
+        j8 = (int8_t)i;
+        sprintf(buf, "%hhd", j8);
+    }
+    t1 = clock();
+    printf("%lu\t", ((t1 - t0)));
+    fflush(stdout);
+
+    t0 = clock();
+    for (i = 0; i < max; ++i) {
+        j8 = (int8_t)i;
+        snprintf(buf, sizeof(buf), "%hhd", j8);
+    }
+    t1 = clock();
+    last = ((double)(t1 - t0));
+    printf("%lu\t", ((t1 - t0)));
+    fflush(stdout);
+
+    t0 = clock();
+    for (i = 0; i < max; ++i) {
+        j8 = (int8_t)i;
+        modp_itoa10(j8, buf);
+    }
+    t1 = clock();
+    printf("%lu\t", ((t1 - t0)));
+    printf("%.1fx\n", last / ((double)(t1 - t0)));
+    fflush(stdout);
+
+    printf("signed 16\t");
+    t0 = clock();
+    for (i = 0; i < max; ++i) {
+        j16 = (int16_t)i;
+        sprintf(buf, "%hd", j16);
+    }
+    t1 = clock();
+    printf("%lu\t", ((t1 - t0)));
+    fflush(stdout);
+
+    t0 = clock();
+    for (i = 0; i < max; ++i) {
+        j16 = (int16_t)i;
+        snprintf(buf, sizeof(buf), "%hd", j16);
+    }
+    t1 = clock();
+    last = ((double)(t1 - t0));
+    printf("%lu\t", ((t1 - t0)));
+    fflush(stdout);
+
+    t0 = clock();
+    for (i = 0; i < max; ++i) {
+        j16 = (int16_t)i;
+        modp_itoa10(j16, buf);
+    }
+    t1 = clock();
+    printf("%lu\t", ((t1 - t0)));
+    printf("%.1fx\n", last / ((double)(t1 - t0)));
+    fflush(stdout);
+
+    printf("%s", "signed 32\t");
+    fflush(stdout);
+
+    t0 = clock();
+    for (i = 0; i < max; ++i) {
+        sprintf(buf, "%d", i);
+    }
+    t1 = clock();
+    printf("%lu\t", ((t1 - t0)));
+    fflush(stdout);
+
+    t0 = clock();
+    for (i = 0; i < max; ++i) {
+        snprintf(buf, sizeof(buf), "%d", i);
+    }
+    t1 = clock();
+    last = ((double)(t1 - t0));
+    printf("%lu\t", ((t1 - t0)));
+    fflush(stdout);
+
+    t0 = clock();
+    for (i = 0; i < max; ++i) {
+        modp_itoa10((int32_t)i, buf);
+    }
+    t1 = clock();
+    printf("%lu\t", ((t1 - t0)));
+    printf("%.1fx\n", last / ((double)(t1 - t0)));
+    fflush(stdout);
+
+    /* UITOA16 */
+
+    printf("%s", "unsigned 32 hex\t");
+    fflush(stdout);
+
+    t0 = clock();
+    for (i = 0; i < max; ++i) {
+        sprintf(buf, "%X", i);
+    }
+    t1 = clock();
+    printf("%lu\t", ((t1 - t0)));
+    fflush(stdout);
+
+    t0 = clock();
+    for (i = 0; i < max; ++i) {
+        snprintf(buf, sizeof(buf), "%08X", i);
+    }
+    t1 = clock();
+    last = ((double)(t1 - t0));
+    printf("%lu\t", ((t1 - t0)));
+    fflush(stdout);
+
+    t0 = clock();
+    for (i = 0; i < max; ++i) {
+        modp_uitoa16(i, buf, 1);
+    }
+    t1 = clock();
+    printf("%lu\t", ((t1 - t0)));
+    printf("%.1fx\n", last / ((double)(t1 - t0)));
+    fflush(stdout);
+
+    /** FLOATING POINT **/
+
+    printf("%s", "\n    type   \t%e\t%f\t%g\tdtoa\timprovement\n");
+    printf("%s", "double\t\t");
+    t0 = clock();
+    for (i = 0; i < max; ++i) {
+        sprintf(buf, "%e", (double)(i));
+    }
+    t1 = clock();
+    printf("%lu\t", ((t1 - t0)));
+    fflush(stdout);
+
+    t0 = clock();
+    for (i = 0; i < max; ++i) {
+        d = (double)i + 0.1;
+        snprintf(buf, sizeof(buf), "%f", d);
+    }
+    t1 = clock();
+    printf("%lu\t", ((t1 - t0)));
+    fflush(stdout);
+
+    t0 = clock();
+    for (i = 0; i < max; ++i) {
+        d = (double)i + 0.123456;
+        snprintf(buf, sizeof(buf), "%g", d);
+    }
+    t1 = clock();
+    last = ((double)(t1 - t0));
+    printf("%lu\t", ((t1 - t0)));
+    fflush(stdout);
+
+    t0 = clock();
+    for (i = 0; i < max; ++i) {
+        d = (double)i + 0.123456;
+        modp_dtoa(d, buf, 6);
+    }
+    t1 = clock();
+    printf("%lu\t", ((t1 - t0)));
+    printf("%.1fx\n", last / ((double)(t1 - t0)));
+    fflush(stdout);
+
+    return 0;
+}