gumath 0.2.0dev5

data/ext/ruby_gumath/gumath/libgumath/tbl.c

@@ -0,0 +1,223 @@
+/*
+ * BSD 3-Clause License
+ *
+ * Copyright (c) 2017-2018, plures
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its
+ *    contributors may be used to endorse or promote products derived from
+ *    this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+
+#include <stdio.h>
+#include <limits.h>
+#include <stddef.h>
+#include "gumath.h"
+
+
+/*****************************************************************************/
+/*                                 Charmap                                   */
+/*****************************************************************************/
+
+#define ALPHABET_LEN 64
+
+static int code[UCHAR_MAX+1];
+static unsigned char alpha[ALPHABET_LEN+1] =
+    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_.";
+
+static void
+init_charmap(void)
+{
+    int i;
+
+    for (i = 0; i < UCHAR_MAX+1; i++) {
+        code[i] = UCHAR_MAX;
+    }
+
+    for (i = 0; i < ALPHABET_LEN; i++) {
+        code[alpha[i]] = i;
+    }
+}
+
+
+/*****************************************************************************/
+/*                              Function tables                              */
+/*****************************************************************************/
+
+/* Function table */
+struct _gm_tbl {
+    gm_func_t *value;
+    gm_tbl_t *next[];
+};
+
+gm_tbl_t *
+gm_tbl_new(ndt_context_t *ctx)
+{
+    gm_tbl_t *t;
+    int i;
+
+    t = ndt_alloc_size(offsetof(gm_tbl_t, next) + ALPHABET_LEN * (sizeof t));
+    if (t == NULL) {
+        return ndt_memory_error(ctx);
+    }
+
+    t->value = NULL;
+
+    for (i = 0; i < ALPHABET_LEN; i++) {
+        t->next[i] = NULL;
+    }
+
+    return t;
+}
+
+void
+gm_tbl_del(gm_tbl_t *t)
+{
+    int i;
+
+    if (t == NULL) {
+        return;
+    }
+
+    gm_func_del(t->value);
+
+    for (i = 0; i < ALPHABET_LEN; i++) {
+        gm_tbl_del(t->next[i]);
+    }
+
+    ndt_free(t);
+}
+
+int
+gm_tbl_add(gm_tbl_t *tbl, const char *key, gm_func_t *value, ndt_context_t *ctx)
+{
+    gm_tbl_t *t = tbl;
+    const unsigned char *cp;
+    int i;
+
+    for (cp = (const unsigned char *)key; *cp != '\0'; cp++) {
+        i = code[*cp];
+        if (i == UCHAR_MAX) {
+            ndt_err_format(ctx, NDT_ValueError,
+                           "invalid character in function name: '%c'", *cp);
+            gm_func_del(value);
+            return -1;
+        }
+
+        if (t->next[i] == NULL) {
+            gm_tbl_t *u = gm_tbl_new(ctx);
+            if (u == NULL) {
+                gm_func_del(value);
+                return -1;
+            }
+            t->next[i] = u;
+            t = u;
+        }
+        else {
+            t = t->next[i];
+        }
+    }
+
+    if (t->value) {
+        ndt_err_format(ctx, NDT_ValueError, "duplicate function name '%s'", key);
+        gm_func_del(value);
+        return -1;
+    }
+
+    t->value = value;
+    return 0;
+}
+
+gm_func_t *
+gm_tbl_find(const gm_tbl_t *tbl, const char *key, ndt_context_t *ctx)
+{
+    const gm_tbl_t *t = tbl;
+    const unsigned char *cp;
+    int i;
+
+    for (cp = (const unsigned char *)key; *cp != '\0'; cp++) {
+        i = code[*cp];
+        if (i == UCHAR_MAX) {
+            ndt_err_format(ctx, NDT_ValueError,
+                           "invalid character in function name: '%c'", *cp);
+            return NULL;
+        }
+
+        if (t->next[i] == NULL) {
+            ndt_err_format(ctx, NDT_ValueError,
+                           "cannot find function '%s'", key);
+            return NULL;
+        }
+        t = t->next[i];
+    }
+
+    if (t->value == NULL) {
+        ndt_err_format(ctx, NDT_RuntimeError,
+                       "cannot find function '%s'", key);
+        return NULL;
+    }
+
+    return t->value;
+}
+
+int
+gm_tbl_map(const gm_tbl_t *tbl, int (*f)(const gm_func_t *, void *), void *state)
+{
+    const gm_tbl_t *t = tbl;
+    int i;
+
+    if (t->value) {
+        if (f(t->value, state) < 0) {
+            return -1;
+        }
+    }
+
+    for (i = 0; i < ALPHABET_LEN; i++) {
+        if (t->next[i] && gm_tbl_map(t->next[i], f, state) < 0) {
+            return -1;
+        }
+    }
+
+    return 0;
+}
+
+
+/*****************************************************************************/
+/*                           Initialize global values                        */
+/*****************************************************************************/
+
+void
+gm_init(void)
+{
+    static bool initialized = false;
+
+    if (!initialized) {
+        init_charmap();
+    }
+    else {
+        fprintf(stderr, "gm_init: warning: ignoring attempt to initialize "
+                        "libgumath a second time\n");
+    }
+}

data/ext/ruby_gumath/gumath/libgumath/thread.c

@@ -0,0 +1,175 @@
+/*
+* BSD 3-Clause License
+*
+* Copyright (c) 2017-2018, plures
+* All rights reserved.
+*
+* Redistribution and use in source and binary forms, with or without
+* modification, are permitted provided that the following conditions are met:
+*
+* 1. Redistributions of source code must retain the above copyright notice,
+*    this list of conditions and the following disclaimer.
+*
+* 2. Redistributions in binary form must reproduce the above copyright notice,
+*    this list of conditions and the following disclaimer in the documentation
+*    and/or other materials provided with the distribution.
+*
+* 3. Neither the name of the copyright holder nor the names of its
+*    contributors may be used to endorse or promote products derived from
+*    this software without specific prior written permission.
+*
+* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include <inttypes.h>
+#include "ndtypes.h"
+#include "xnd.h"
+#include "gumath.h"
+#include "config.h"
+
+
+#ifdef HAVE_PTHREAD_H
+#include <pthread.h>
+
+struct thread_info {
+    pthread_t tid;
+    int tnum;
+    int nrows;
+    int ncols;
+    const gm_kernel_t *kernel;
+    xnd_t **slices;
+    int outer_dims;
+    ndt_context_t ctx;
+};
+
+static void
+init_static_context(ndt_context_t *ctx)
+{
+    static const ndt_context_t c = {
+      .flags=0,
+      .err=NDT_Success,
+      .msg=ConstMsg,
+      .ConstMsg="Success" };
+
+    *ctx = c;
+}
+
+static void
+clear_all_slices(xnd_t *slices[], int *nslices, int stop)
+{
+    for (int i = 0; i < stop; i++) {
+        for (int k = 0; k < nslices[i]; k++) {
+            ndt_del((ndt_t *)slices[i][k].type);
+        }
+        ndt_free(slices[i]);
+    }
+}
+
+static void *
+apply_thread(void *arg)
+{
+    struct thread_info *tinfo = arg;
+    ALLOCA(xnd_t, stack, tinfo->nrows);
+
+    for (int i = 0; i < tinfo->nrows; i++) {
+        stack[i] = tinfo->slices[i][tinfo->tnum];
+    }
+
+    gm_apply(tinfo->kernel, stack, tinfo->outer_dims, &tinfo->ctx);
+    return NULL;
+}
+
+int
+gm_apply_thread(const gm_kernel_t *kernel, xnd_t stack[], int outer_dims,
+                uint32_t flags, const int64_t nthreads, ndt_context_t *ctx)
+{
+    const int nrows = (int)kernel->set->sig->Function.nargs;
+    ALLOCA(xnd_t *, slices, nrows);
+    ALLOCA(int, nslices, nrows);
+    struct thread_info *tinfo;
+    int ncols, tnum;
+
+    if (nthreads <= 1 || nrows == 0 || outer_dims == 0 ||
+        !(flags & NDT_STRIDED)) {
+        return gm_apply(kernel, stack, outer_dims, ctx);
+    }
+
+    for (int i = 0; i < nrows; i++) {
+        int64_t ncols = nthreads;
+        slices[i] = xnd_split(&stack[i], &ncols, outer_dims, ctx);
+        if (ndt_err_occurred(ctx)) {
+            clear_all_slices(slices, nslices, i);
+            return -1;
+        }
+        nslices[i] = ncols;
+    }
+
+    ncols = nslices[0];
+    for (int i = 1; i < nrows; i++) {
+        if (nslices[i] != ncols) {
+            clear_all_slices(slices, nslices, nrows);
+            ndt_err_format(ctx, NDT_RuntimeError,
+                "equal subdivision in threaded apply loop failed");
+            return -1;
+        }
+    }
+
+    tinfo = ndt_calloc(nthreads, sizeof *tinfo);
+    if (tinfo == NULL) {
+        clear_all_slices(slices, nslices, nrows);
+        (void)ndt_memory_error(ctx);
+        return -1;
+    }
+
+    for (tnum = 0; tnum < ncols; tnum++) {
+        tinfo[tnum].tnum = tnum;
+        tinfo[tnum].kernel = kernel;
+        tinfo[tnum].nrows = nrows;
+        tinfo[tnum].ncols = ncols;
+        tinfo[tnum].slices = slices;
+        tinfo[tnum].outer_dims = outer_dims;
+        init_static_context(&tinfo[tnum].ctx);
+
+        int ret = pthread_create(&tinfo[tnum].tid, NULL, &apply_thread,
+                                 &tinfo[tnum]);
+        if (ret != 0) {
+            clear_all_slices(slices, nslices, nrows);
+            ndt_err_format(ctx, NDT_RuntimeError, "could not create thread");
+            return -1;
+        }
+    }
+
+    int ret = 0;
+    for (tnum = 0; tnum < ncols; tnum++) {
+        ret |= pthread_join(tinfo[tnum].tid, NULL);
+        if (ndt_err_occurred(&tinfo[tnum].ctx)) {
+            if (!ndt_err_occurred(ctx)) {
+                ndt_err_format(ctx, tinfo[tnum].ctx.err,
+                               ndt_context_msg(&tinfo[tnum].ctx));
+            }
+            ndt_err_clear(&tinfo[tnum].ctx);
+        }
+    }
+
+    if (ret != 0 && !ndt_err_occurred(ctx)) {
+        ndt_err_format(ctx, NDT_RuntimeError, "error in thread");
+    }
+ 
+    clear_all_slices(slices, nslices, nrows);
+
+    return ndt_err_occurred(ctx) ? -1 : 0;
+}
+#endif

data/ext/ruby_gumath/gumath/libgumath/xndloops.c

@@ -0,0 +1,130 @@
+/*
+* BSD 3-Clause License
+*
+* Copyright (c) 2017-2018, plures
+* All rights reserved.
+*
+* Redistribution and use in source and binary forms, with or without
+* modification, are permitted provided that the following conditions are met:
+*
+* 1. Redistributions of source code must retain the above copyright notice,
+*    this list of conditions and the following disclaimer.
+*
+* 2. Redistributions in binary form must reproduce the above copyright notice,
+*    this list of conditions and the following disclaimer in the documentation
+*    and/or other materials provided with the distribution.
+*
+* 3. Neither the name of the copyright holder nor the names of its
+*    contributors may be used to endorse or promote products derived from
+*    this software without specific prior written permission.
+*
+* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include <inttypes.h>
+#include "ndtypes.h"
+#include "xnd.h"
+#include "gumath.h"
+
+
+int
+gm_xnd_map(const gm_xnd_kernel_t f, xnd_t stack[], const int nargs,
+           const int outer_dims, ndt_context_t *ctx)
+{
+    ALLOCA(xnd_t, next, nargs);
+    const ndt_t *t;
+
+    if (outer_dims == 0 || nargs == 0) {
+        return f(stack, ctx);
+    }
+
+    t = stack[0].type;
+
+    switch (t->tag) {
+    case FixedDim: {
+        const int64_t shape = t->FixedDim.shape;
+
+        for (int k = 1; k < nargs; k++) {
+            const ndt_t *u = stack[k].type;
+
+            if (u->tag != FixedDim || u->FixedDim.shape != shape) {
+                ndt_err_format(ctx, NDT_RuntimeError,
+                    "type or shape mismatch in outer dimensions");
+                return -1;
+            }
+        }
+
+        for (int64_t i = 0; i < shape; i++) {
+            for (int k = 0; k < nargs; k++) {
+                next[k] = xnd_fixed_dim_next(&stack[k], i);
+            }
+
+            if (gm_xnd_map(f, next, nargs, outer_dims-1, ctx) < 0) {
+                return -1;
+            }
+        }
+
+        return 0;
+    }
+
+    case VarDim: {
+        ALLOCA(int64_t, start, nargs);
+        ALLOCA(int64_t, step, nargs);
+        const int64_t shape = ndt_var_indices(&start[0], &step[0], t,
+                                              stack[0].index, ctx);
+        if (shape < 0) {
+            return -1;
+        }
+
+        for (int k = 1; k < nargs; k++) {
+            const ndt_t *u = stack[k].type;
+
+            if (u->tag != VarDim) {
+                ndt_err_format(ctx, NDT_RuntimeError,
+                    "type mismatch in outer dimensions");
+                return -1;
+            }
+
+            int64_t n = ndt_var_indices(&start[k], &step[k], u, stack[k].index, ctx);
+            if (n < 0) {
+                return -1;
+            }
+
+            if (n != shape) {
+                ndt_err_format(ctx, NDT_RuntimeError,
+                    "shape mismatch in outer dimensions");
+                return -1;
+            }
+        }
+
+        for (int64_t i = 0; i < shape; i++) {
+            for (int k = 0; k < nargs; k++) {
+                next[k] = xnd_var_dim_next(&stack[k], start[k], step[k], i);
+            }
+
+            if (gm_xnd_map(f, next, nargs, outer_dims-1, ctx) < 0) {
+                return -1;
+            }
+        }
+
+        return 0;
+    }
+
+    default: 
+        ndt_err_format(ctx, NDT_NotImplementedError, "unsupported type");
+        return -1;
+    }
+}