gumath 0.2.0dev5 → 0.2.0dev8

data/ext/ruby_gumath/gumath/libgumath/Makefile.vc

@@ -27,10 +27,14 @@ LIBXNDDIR = ..\xnd\libxnd
 
 OPT = /MT /Ox /GS /EHsc /fp:strict
 OPT_SHARED = /DGM_EXPORT /DNDT_IMPORT /DXND_IMPORT /MD /Ox /GS /EHsc /fp:strict /Fo.objs^\
+OPT_NOFP = /MT /Ox /GS /EHsc
+OPT_SHARED_NOFP = /DGM_EXPORT /DNDT_IMPORT /DXND_IMPORT /MD /Ox /GS /EHsc /Fo.objs^\
 
 COMMON_CFLAGS = /nologo /W4 /wd4200 /wd4201 /wd4204
 CFLAGS = $(COMMON_CFLAGS) $(OPT)
 CFLAGS_SHARED = $(COMMON_CFLAGS) $(OPT_SHARED)
+CFLAGS_NOFP = $(COMMON_CFLAGS) $(OPT_NOFP)
+CFLAGS_SHARED_NOFP = $(COMMON_CFLAGS) $(OPT_SHARED_NOFP)
 
 
 default: $(LIBSTATIC) $(LIBSHARED)
@@ -40,11 +44,14 @@ default: $(LIBSTATIC) $(LIBSHARED)
 	copy /y $(LIBSHARED) ..\python\gumath
 
 
-OBJS = apply.obj func.obj nploops.obj tbl.obj xndloops.obj \
-       unary.obj binary.obj examples.obj graph.obj pdist.obj
+OBJS = apply.obj func.obj nploops.obj tbl.obj xndloops.obj cpu_host_unary.obj \
+       cpu_device_unary.obj cpu_host_binary.obj cpu_device_binary.obj cpu_device_msvc.obj \
+       common.obj examples.obj graph.obj pdist.obj
 
 SHARED_OBJS = .objs/apply.obj .objs/func.obj .objs/nploops.obj .objs/tbl.obj .objs/xndloops.obj \
-              .objs/unary.obj .objs/binary.obj .objs/examples.obj .objs/graph.obj .objs/pdist.obj
+              .objs/cpu_host_unary.obj .objs/cpu_device_unary.obj .objs/cpu_host_binary.obj \
+              .objs/cpu_device_binary.obj .objs/cpu_device_msvc.obj .objs/common.obj \
+              .objs/examples.obj .objs/graph.obj .objs/pdist.obj
 
 
 $(LIBSTATIC):\
@@ -101,21 +108,53 @@ Makefile xndloops.c gumath.h
 Makefile xndloops.c gumath.h
 	$(CC) "-I$(LIBNDTYPESINCLUDE)" "-I$(LIBXNDINCLUDE)" $(CFLAGS_SHARED) -c xndloops.c
 
-unary.obj:\
-Makefile kernels\unary.c gumath.h
-	$(CC) -I. "-I$(LIBNDTYPESINCLUDE)" "-I$(LIBXNDINCLUDE)" $(CFLAGS) -c kernels\unary.c
+cpu_host_unary.obj:\
+Makefile kernels\cpu_host_unary.c kernels\common.h gumath.h
+	$(CC) -I. "-I$(LIBNDTYPESINCLUDE)" "-I$(LIBXNDINCLUDE)" $(CFLAGS) -c kernels\cpu_host_unary.c
 
-.objs\unary.obj:\
-Makefile kernels\unary.c gumath.h
-	$(CC) -I. "-I$(LIBNDTYPESINCLUDE)" "-I$(LIBXNDINCLUDE)" $(CFLAGS_SHARED) -c kernels\unary.c
+.objs\cpu_host_unary.obj:\
+Makefile kernels\cpu_host_unary.c kernels\common.h gumath.h
+	$(CC) -I. "-I$(LIBNDTYPESINCLUDE)" "-I$(LIBXNDINCLUDE)" $(CFLAGS_SHARED) -c kernels\cpu_host_unary.c
 
-binary.obj:\
-Makefile kernels\binary.c gumath.h
-	$(CC) -I. "-I$(LIBNDTYPESINCLUDE)" "-I$(LIBXNDINCLUDE)" $(CFLAGS) -c kernels\binary.c
+cpu_device_unary.obj:\
+Makefile kernels\cpu_device_unary.cc kernels\common.h gumath.h
+	$(CC) -I. "-I$(LIBNDTYPESINCLUDE)" "-I$(LIBXNDINCLUDE)" $(CFLAGS) -c kernels\cpu_device_unary.cc
 
-.objs\binary.obj:\
-Makefile kernels\binary.c gumath.h
-	$(CC) -I. "-I$(LIBNDTYPESINCLUDE)" "-I$(LIBXNDINCLUDE)" $(CFLAGS_SHARED) -c kernels\binary.c
+.objs\cpu_device_unary.obj:\
+Makefile kernels\cpu_device_unary.cc kernels\common.h gumath.h
+	$(CC) -I. "-I$(LIBNDTYPESINCLUDE)" "-I$(LIBXNDINCLUDE)" $(CFLAGS_SHARED) -c kernels\cpu_device_unary.cc
+
+cpu_host_binary.obj:\
+Makefile kernels\cpu_host_binary.c kernels\common.h gumath.h
+	$(CC) -I. "-I$(LIBNDTYPESINCLUDE)" "-I$(LIBXNDINCLUDE)" $(CFLAGS) -c kernels\cpu_host_binary.c
+
+.objs\cpu_host_binary.obj:\
+Makefile kernels\cpu_host_binary.c kernels\common.h gumath.h
+	$(CC) -I. "-I$(LIBNDTYPESINCLUDE)" "-I$(LIBXNDINCLUDE)" $(CFLAGS_SHARED) -c kernels\cpu_host_binary.c
+
+cpu_device_binary.obj:\
+Makefile kernels\cpu_device_binary.cc kernels\common.h gumath.h
+	$(CC) -I. "-I$(LIBNDTYPESINCLUDE)" "-I$(LIBXNDINCLUDE)" $(CFLAGS) -c kernels\cpu_device_binary.cc
+
+.objs\cpu_device_binary.obj:\
+Makefile kernels\cpu_device_binary.cc kernels\common.h gumath.h
+	$(CC) -I. "-I$(LIBNDTYPESINCLUDE)" "-I$(LIBXNDINCLUDE)" $(CFLAGS_SHARED) -c kernels\cpu_device_binary.cc
+
+cpu_device_msvc.obj:\
+Makefile kernels\cpu_device_msvc.cc kernels\common.h gumath.h
+	$(CC) -I. "-I$(LIBNDTYPESINCLUDE)" "-I$(LIBXNDINCLUDE)" $(CFLAGS_NOFP) -c kernels\cpu_device_msvc.cc
+
+.objs\cpu_device_msvc.obj:\
+Makefile kernels\cpu_device_msvc.cc kernels\common.h gumath.h
+	$(CC) -I. "-I$(LIBNDTYPESINCLUDE)" "-I$(LIBXNDINCLUDE)" $(CFLAGS_SHARED_NOFP) -c kernels\cpu_device_msvc.cc
+
+common.obj:\
+Makefile kernels\common.c kernels\common.h gumath.h
+	$(CC) -I. "-I$(LIBNDTYPESINCLUDE)" "-I$(LIBXNDINCLUDE)" $(CFLAGS) -c kernels\common.c
+
+.objs\common.obj:\
+Makefile kernels\common.c kernels\common.h gumath.h
+	$(CC) -I. "-I$(LIBNDTYPESINCLUDE)" "-I$(LIBXNDINCLUDE)" $(CFLAGS_SHARED) -c kernels\common.c
 
 examples.obj:\
 Makefile extending\examples.c gumath.h

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

@@ -40,6 +40,29 @@
 #include "gumath.h"
 
 
+/* flags that apply to all arguments */
+#define OPT_Z  (NDT_EXT_ZERO|NDT_INNER_C)
+#define OPT_C  (NDT_EXT_C|NDT_INNER_C)
+#define OPT_S  (NDT_EXT_STRIDED|NDT_INNER_STRIDED)
+#define OPT_SC (NDT_EXT_STRIDED|NDT_INNER_C)
+#define OPT_SF (NDT_EXT_STRIDED|NDT_INNER_F)
+
+#define INNER_C (NDT_INNER_C)
+#define INNER_F (NDT_INNER_F)
+#define INNER_S (NDT_INNER_STRIDED)
+#define INNER_X (NDT_INNER_XND)
+
+/* kernel requests */
+#define REQ_LOOP_C(flags) ((flags&OPT_C) == OPT_C)
+#define REQ_LOOP_Z(flags) ((flags&OPT_C) == OPT_C || (flags&OPT_Z) == OPT_Z)
+#define REQ_LOOP_S(flags) ((flags&OPT_S) == OPT_S)
+
+#define REQ_INNER_C(flags) ((flags&INNER_C) == INNER_C)
+#define REQ_INNER_F(flags) ((flags&INNER_F) == INNER_F)
+#define REQ_INNER_S(flags) ((flags&INNER_S) == INNER_S)
+#define REQ_INNER_X(flags) ((flags&INNER_X) == INNER_X)
+
+
 static int
 sum_inner_dimensions(const xnd_t stack[], int nargs, int outer_dims)
 {
@@ -55,6 +78,18 @@ sum_inner_dimensions(const xnd_t stack[], int nargs, int outer_dims)
     return sum;
 }
 
+static inline bool
+opt_safe(int outer, ndt_context_t *ctx)
+{
+    if (outer == 0) {
+        ndt_err_format(ctx, NDT_RuntimeError,
+            "internal error: optimized kernel called with outer_dims==0");
+        return false;
+    }
+
+    return true;
+}
+
 int
 gm_apply(const gm_kernel_t *kernel, xnd_t stack[], int outer_dims,
          ndt_context_t *ctx)
@@ -62,30 +97,43 @@ gm_apply(const gm_kernel_t *kernel, xnd_t stack[], int outer_dims,
     const int nargs = (int)kernel->set->sig->Function.nargs;
 
     switch (kernel->flag) {
-    case NDT_ELEMWISE_1D: {
-        if (outer_dims == 0) {
-            ndt_err_format(ctx, NDT_RuntimeError,
-                "gm_xnd_map: optimized elementwise kernel called with "
-                "outer_dims==0");
+    case OPT_C: {
+        if (!opt_safe(outer_dims, ctx)) {
             return -1;
         }
 
-        return gm_xnd_map(kernel->set->Opt, stack, nargs, outer_dims-1, ctx);
+        return gm_xnd_map(kernel->set->OptC, stack, nargs, outer_dims-1, ctx);
     }
 
-    case NDT_C: {
+    case OPT_Z: {
+        if (!opt_safe(outer_dims, ctx)) {
+            return -1;
+        }
+
+        return gm_xnd_map(kernel->set->OptZ, stack, nargs, outer_dims-1, ctx);
+    }
+
+    case OPT_S: {
+        if (!opt_safe(outer_dims, ctx)) {
+            return -1;
+        }
+
+        return gm_xnd_map(kernel->set->OptS, stack, nargs, outer_dims-1, ctx);
+    }
+
+    case INNER_C: {
         return gm_xnd_map(kernel->set->C, stack, nargs, outer_dims, ctx);
     }
 
-    case NDT_FORTRAN: {
+    case INNER_F: {
         return gm_xnd_map(kernel->set->Fortran, stack, nargs, outer_dims, ctx);
     }
 
-    case NDT_XND: {
+    case INNER_X: {
         return gm_xnd_map(kernel->set->Xnd, stack, nargs, outer_dims, ctx);
     }
 
-    case NDT_STRIDED: {
+    case INNER_S: {
         const int sum_inner = sum_inner_dimensions(stack, nargs, outer_dims);
         const int dims_size = outer_dims + sum_inner;
         const int steps_size = nargs * outer_dims + sum_inner;
@@ -105,8 +153,9 @@ gm_apply(const gm_kernel_t *kernel, xnd_t stack[], int outer_dims,
       }
     }
 
-    /* NOT REACHED: tags should be exhaustive. */
-    ndt_internal_error("invalid tag");
+    ndt_err_format(ctx, NDT_RuntimeError,
+                   "internal error: kernel selection failed");
+    return -1;
 }
 
 static gm_kernel_t
@@ -117,35 +166,48 @@ select_kernel(const ndt_apply_spec_t *spec, const gm_kernel_set_t *set,
 
     kernel.set = set;
 
-    if (set->Opt != NULL && (spec->flags&NDT_ELEMWISE_1D)) {
-        kernel.flag = NDT_ELEMWISE_1D;
+    if (REQ_LOOP_C(spec->flags) && set->OptC != NULL) {
+        kernel.flag = OPT_C;
+        return kernel;
+    }
+
+    if (REQ_LOOP_Z(spec->flags) && set->OptZ != NULL) {
+        kernel.flag = OPT_Z;
+        return kernel;
+    }
+
+    if (REQ_LOOP_S(spec->flags) && set->OptS != NULL) {
+        kernel.flag = OPT_S;
         return kernel;
     }
 
-    if (set->C != NULL && (spec->flags&NDT_C)) {
-        kernel.flag = NDT_C;
+    if (REQ_INNER_C(spec->flags) && set->C != NULL) {
+        kernel.flag = INNER_C;
         return kernel;
     }
 
-    if (set->Fortran != NULL && (spec->flags&NDT_FORTRAN)) {
-        kernel.flag = NDT_FORTRAN;
+    if (REQ_INNER_F(spec->flags) && set->Fortran != NULL) {
+        kernel.flag = INNER_F;
         return kernel;
     }
 
-    if (set->Strided != NULL && (spec->flags&NDT_STRIDED)) {
-        kernel.flag = NDT_STRIDED;
+    if (REQ_INNER_S(spec->flags) && set->Strided != NULL) {
+        kernel.flag = INNER_S;
         return kernel;
     }
 
-    if (set->Xnd != NULL && (spec->flags&NDT_XND)) {
-        kernel.flag = NDT_XND;
+    if (REQ_INNER_X(spec->flags) && set->Xnd != NULL) {
+        kernel.flag = INNER_X;
         return kernel;
     }
 
     kernel.set = NULL;
     ndt_err_format(ctx, NDT_RuntimeError,
-        "could not find specialized kernel for '%s' input (available: %s, %s, %s, %s)",
+        "could not find specialized kernel for '%s' input (available: %s, %s, %s, %s, %s, %s, %s)",
         ndt_apply_flags_as_string(spec),
+        set->OptC ? "OptC" : "_",
+        set->OptZ ? "OptZ" : "_",
+        set->OptS ? "OptS" : "_",
         set->C ? "C" : "_",
         set->Fortran ? "Fortran" : "_",
         set->Xnd ? "Xnd" : "_",
@@ -157,8 +219,8 @@ select_kernel(const ndt_apply_spec_t *spec, const gm_kernel_set_t *set,
 /* Look up a multimethod by name and select a kernel. */
 gm_kernel_t
 gm_select(ndt_apply_spec_t *spec, const gm_tbl_t *tbl, const char *name,
-          const ndt_t *in_types[], int nin, const xnd_t args[],
-          ndt_context_t *ctx)
+          const ndt_t *types[], const int64_t li[], int nin, int nout,
+          bool check_broadcast, const xnd_t args[], ndt_context_t *ctx)
 {
     gm_kernel_t empty_kernel = {0U, NULL};
     const gm_func_t *f;
@@ -171,7 +233,8 @@ gm_select(ndt_apply_spec_t *spec, const gm_tbl_t *tbl, const char *name,
     }
 
     if (f->typecheck != NULL) {
-        const gm_kernel_set_t *set = f->typecheck(spec, f, in_types, nin, ctx);
+        const gm_kernel_set_t *set = f->typecheck(spec, f, types, li, nin, nout,
+                                                  check_broadcast, ctx);
         if (set == NULL) {
             return empty_kernel;
         }
@@ -180,7 +243,8 @@ gm_select(ndt_apply_spec_t *spec, const gm_tbl_t *tbl, const char *name,
 
     for (i = 0; i < f->nkernels; i++) {
         const gm_kernel_set_t *set = &f->kernels[i];
-        if (ndt_typecheck(spec, set->sig, in_types, nin, set->constraint, args,
+        if (ndt_typecheck(spec, set->sig, types, li, nin, nout,
+                          check_broadcast, set->constraint, args,
                           ctx) < 0) {
             ndt_err_clear(ctx);
             continue;
@@ -188,7 +252,7 @@ gm_select(ndt_apply_spec_t *spec, const gm_tbl_t *tbl, const char *name,
         return select_kernel(spec, set, ctx);
     }
 
-    s = ndt_list_as_string(in_types, nin, ctx);
+    s = ndt_list_as_string(types, nin, ctx);
     if (s == NULL) {
         return empty_kernel;
     }

data/ext/ruby_gumath/gumath/libgumath/extending/graph.c

@@ -181,9 +181,10 @@ static xnd_t
 mk_return_array(int32_t p[], const int64_t N, const int32_t u,
                 ndt_context_t *ctx)
 {
-    int32_t *ndim2_offsets = NULL;
-    int32_t *ndim1_offsets = NULL;
-    ndt_t *t;
+    ndt_offsets_t *ndim2_offsets = NULL;
+    ndt_offsets_t *ndim1_offsets = NULL;
+    int32_t *ptr;
+    const ndt_t *t, *type;
     int64_t sum;
     int32_t v;
 
@@ -191,45 +192,51 @@ mk_return_array(int32_t p[], const int64_t N, const int32_t u,
         goto offset_overflow;
     }
 
-    ndim2_offsets = ndt_alloc(2, sizeof *ndim2_offsets);
+    ndim2_offsets = ndt_offsets_new(2, ctx);
     if (ndim2_offsets == NULL) {
-        (void)ndt_memory_error(ctx);
         return xnd_error;
     }
-    ndim2_offsets[0] = 0;
-    ndim2_offsets[1] = (int32_t)N;
+    ptr = (int32_t *)ndim2_offsets->v;
+    ptr[0] = 0;
+    ptr[1] = (int32_t)N;
 
 
-    ndim1_offsets = ndt_alloc(N+1, sizeof *ndim1_offsets);
+    ndim1_offsets = ndt_offsets_new((int32_t)(N+1), ctx);
     if (ndim1_offsets == NULL) {
-        (void)ndt_memory_error(ctx);
+        ndt_decref_offsets(ndim2_offsets);
         return xnd_error;
     }
 
     sum = 0;
+    ptr = (int32_t *)ndim1_offsets->v;
     for (v = 0; v < N; v++) {
-        ndim1_offsets[v] = (int32_t)sum;
+        ptr[v] = (int32_t)sum;
         int64_t n = write_path(NULL, 0, p, N, u, v);
         sum += n;
         if (sum > INT32_MAX) {
             goto offset_overflow;
         }
     }
-    ndim1_offsets[v] = (int32_t)sum;
+    ptr[v] = (int32_t)sum;
 
 
-    t = ndt_from_string("node", ctx);
-    if (t == NULL) {
+    type = ndt_from_string("node", ctx);
+    if (type == NULL) {
         goto error;
     }
 
-    t = ndt_var_dim(t, InternalOffsets, (int32_t)(N+1), ndim1_offsets, 0, NULL, ctx);
+    t = ndt_var_dim(type, ndim1_offsets, 0, NULL, false, ctx);
+    ndt_decref(type);
+    ndt_decref_offsets(ndim1_offsets);
     ndim1_offsets = NULL;
     if (t == NULL) {
         goto error;
     }
+    type = t;
 
-    t = ndt_var_dim(t, InternalOffsets, 2, ndim2_offsets, 0, NULL, ctx);
+    t = ndt_var_dim(type, ndim2_offsets, 0, NULL, false, ctx);
+    ndt_decref(type);
+    ndt_decref_offsets(ndim2_offsets);
     ndim2_offsets = NULL;
     if (t == NULL) {
         goto error;
@@ -244,16 +251,16 @@ mk_return_array(int32_t p[], const int64_t N, const int32_t u,
 
     t = out.type->VarDim.type;
     for (v = 0; v < N; v++) {
-        int32_t shape = t->Concrete.VarDim.offsets[v+1]-t->Concrete.VarDim.offsets[v];
-        char *ptr = out.ptr + t->Concrete.VarDim.offsets[v] * t->Concrete.VarDim.itemsize;
-        (void)write_path((int32_t *)ptr, shape, p, N, u, v);
+        int32_t shape = t->Concrete.VarDim.offsets->v[v+1]-t->Concrete.VarDim.offsets->v[v];
+        char *cp = out.ptr + t->Concrete.VarDim.offsets->v[v] * t->Concrete.VarDim.itemsize;
+        (void)write_path((int32_t *)cp, shape, p, N, u, v);
     }
 
     return out;
 
 error:
-    ndt_free(ndim2_offsets);
-    ndt_free(ndim1_offsets);
+    ndt_decref_offsets(ndim2_offsets);
+    ndt_decref_offsets(ndim1_offsets);
     return xnd_error;
 
 offset_overflow:

data/ext/ruby_gumath/gumath/libgumath/extending/pdist.c

@@ -82,7 +82,7 @@ pdist(xnd_t stack[], ndt_context_t *ctx)
  * Validate N, M and compute unknown output dimension P.
  *
  * shape[0] = N
- * shape[1] = N
+ * shape[1] = M
  * shape[2] = P
  *
  * 'args' is unused here.  Other functions may inspect the incoming xnd

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

@@ -73,7 +73,7 @@ gm_func_del(gm_func_t *f)
     ndt_free(f->name);
 
     for (int i = 0; i < f->nkernels; i++) {
-        ndt_del(f->kernels[i].sig);
+        ndt_decref(f->kernels[i].sig);
     }
 
     ndt_free(f);
@@ -101,7 +101,7 @@ gm_add_kernel(gm_tbl_t *tbl, const gm_kernel_init_t *k, ndt_context_t *ctx)
 {
     gm_func_t *f = gm_tbl_find(tbl, k->name, ctx);
     gm_kernel_set_t kernel;
-    ndt_t *t;
+    const ndt_t *t;
 
     if (f == NULL) {
         ndt_err_clear(ctx);
@@ -117,7 +117,7 @@ gm_add_kernel(gm_tbl_t *tbl, const gm_kernel_init_t *k, ndt_context_t *ctx)
     }
 
     if (f->nkernels == GM_MAX_KERNELS) {
-        ndt_del(t);
+        ndt_decref(t);
         ndt_err_format(ctx, NDT_RuntimeError,
             "%s: maximum number of kernels reached for", f->name);
         return -1;
@@ -125,11 +125,13 @@ gm_add_kernel(gm_tbl_t *tbl, const gm_kernel_init_t *k, ndt_context_t *ctx)
 
     kernel.sig = t;
     kernel.constraint = k->constraint;
-    kernel.Opt = k->Opt;
+    kernel.OptC = k->OptC;
+    kernel.OptZ = k->OptZ;
+    kernel.OptS = k->OptS;
     kernel.C = k->C;
     kernel.Fortran = k->Fortran;
-    kernel.Strided = k->Strided;
     kernel.Xnd = k->Xnd;
+    kernel.Strided = k->Strided;
 
     f->kernels[f->nkernels++] = kernel;
     return 0;
@@ -141,7 +143,7 @@ gm_add_kernel_typecheck(gm_tbl_t *tbl, const gm_kernel_init_t *k, ndt_context_t
 {
     gm_func_t *f = gm_tbl_find(tbl, k->name, ctx);
     gm_kernel_set_t kernel;
-    ndt_t *t;
+    const ndt_t *t;
 
     if (f == NULL) {
         ndt_err_clear(ctx);
@@ -158,7 +160,7 @@ gm_add_kernel_typecheck(gm_tbl_t *tbl, const gm_kernel_init_t *k, ndt_context_t
     }
 
     if (f->nkernels == GM_MAX_KERNELS) {
-        ndt_del(t);
+        ndt_decref(t);
         ndt_err_format(ctx, NDT_RuntimeError,
             "%s: maximum number of kernels reached for", f->name);
         return -1;
@@ -166,11 +168,13 @@ gm_add_kernel_typecheck(gm_tbl_t *tbl, const gm_kernel_init_t *k, ndt_context_t
 
     kernel.sig = t;
     kernel.constraint = k->constraint;
-    kernel.Opt = k->Opt;
+    kernel.OptC = k->OptC;
+    kernel.OptZ = k->OptZ;
+    kernel.OptS = k->OptS;
     kernel.C = k->C;
     kernel.Fortran = k->Fortran;
-    kernel.Strided = k->Strided;
     kernel.Xnd = k->Xnd;
+    kernel.Strided = k->Strided;
 
     f->kernels[f->nkernels++] = kernel;
     return 0;