gumath 0.2.0dev5 → 0.2.0dev8

data/ext/ruby_gumath/gumath/libgumath/gumath.h

@@ -34,6 +34,17 @@
 #ifndef GUMATH_H
 #define GUMATH_H
 
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+  #include <cstdint>
+#else
+  #include <stdint.h>
+#endif
+
 #include "ndtypes.h"
 #include "xnd.h"
 
@@ -65,7 +76,8 @@
 #endif
 
 
-#define GM_MAX_KERNELS 512
+#define GM_MAX_KERNELS 8192
+#define GM_THREAD_CUTOFF 1000000
 
 typedef float float32_t;
 typedef double float64_t;
@@ -74,15 +86,25 @@ typedef double float64_t;
 typedef int (* gm_xnd_kernel_t)(xnd_t stack[], ndt_context_t *ctx);
 typedef int (* gm_strided_kernel_t)(char **args, intptr_t *dimensions, intptr_t *steps, void *data);
 
-/* Collection of specialized kernels for a single function signature. */
+/*
+ * Collection of specialized kernels for a single function signature.
+ *
+ * NOTE: The specialized kernel lookup scheme is transitional and may
+ * be replaced by something else.
+ *
+ * This should be considered as a first version of a kernel request
+ * protocol.
+ */
 typedef struct {
-    ndt_t *sig;
+    const ndt_t *sig;
     const ndt_constraint_t *constraint;
 
     /* Xnd signatures */
-    gm_xnd_kernel_t Opt;     /* dispatch ensures elementwise, at least 1D, contiguous in last dimensions */
-    gm_xnd_kernel_t C;       /* dispatch ensures c-contiguous in inner dimensions */
-    gm_xnd_kernel_t Fortran; /* dispatch ensures f-contiguous in inner dimensions */
+    gm_xnd_kernel_t OptC;    /* C in inner+1 dimensions */
+    gm_xnd_kernel_t OptZ;    /* C in inner dimensions, C or zero stride in (inner+1)th. */
+    gm_xnd_kernel_t OptS;    /* strided in (inner+1)th. */
+    gm_xnd_kernel_t C;       /* C in inner dimensions */
+    gm_xnd_kernel_t Fortran; /* Fortran in inner dimensions */
     gm_xnd_kernel_t Xnd;     /* selected if non-contiguous or the other fields are NULL */
 
     /* NumPy signature */
@@ -99,11 +121,17 @@ typedef struct {
     const char *name;
     const char *sig;
     const ndt_constraint_t *constraint;
+    uint32_t cap;
 
-    gm_xnd_kernel_t Opt;
+    /* Xnd signatures */
+    gm_xnd_kernel_t OptC;
+    gm_xnd_kernel_t OptZ;
+    gm_xnd_kernel_t OptS;
     gm_xnd_kernel_t C;
     gm_xnd_kernel_t Fortran;
     gm_xnd_kernel_t Xnd;
+
+    /* NumPy signature */
     gm_strided_kernel_t Strided;
 } gm_kernel_init_t;
 
@@ -115,7 +143,10 @@ typedef struct {
 
 /* Multimethod with associated kernels */
 typedef struct gm_func gm_func_t;
-typedef const gm_kernel_set_t *(*gm_typecheck_t)(ndt_apply_spec_t *spec, const gm_func_t *f, const ndt_t *in[], int nin, ndt_context_t *ctx);
+typedef const gm_kernel_set_t *(*gm_typecheck_t)(ndt_apply_spec_t *spec, const gm_func_t *f,
+                                                 const ndt_t *in[], const int64_t li[],
+                                                 int nin, int nout, bool check_broadcast,
+                                                 ndt_context_t *ctx);
 struct gm_func {
     char *name;
     gm_typecheck_t typecheck; /* Experimental optimized type-checking, may be NULL. */
@@ -139,10 +170,10 @@ GM_API int gm_add_kernel(gm_tbl_t *tbl, const gm_kernel_init_t *kernel, ndt_cont
 GM_API int gm_add_kernel_typecheck(gm_tbl_t *tbl, const gm_kernel_init_t *kernel, ndt_context_t *ctx, gm_typecheck_t f);
 
 GM_API 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_API int gm_apply(const gm_kernel_t *kernel, xnd_t stack[], int outer_dims, ndt_context_t *ctx);
-GM_API 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);
+GM_API int gm_apply_thread(const gm_kernel_t *kernel, xnd_t stack[], int outer_dims, const int64_t nthreads, ndt_context_t *ctx);
 
 
 /******************************************************************************/
@@ -171,6 +202,7 @@ GM_API int gm_np_map(const gm_strided_kernel_t f,
 /*                                  Xnd loops                                 */
 /******************************************************************************/
 
+GM_API int array_shape_check(xnd_t *x, const int64_t shape, ndt_context_t *ctx);
 GM_API int gm_xnd_map(const gm_xnd_kernel_t f, xnd_t stack[], const int nargs,
                       const int outer_dims, ndt_context_t *ctx);
 
@@ -191,10 +223,14 @@ GM_API int gm_tbl_map(const gm_tbl_t *tbl, int (*f)(const gm_func_t *, void *sta
 /******************************************************************************/
 
 GM_API void gm_init(void);
-GM_API int gm_init_unary_kernels(gm_tbl_t *tbl, ndt_context_t *ctx);
-GM_API int gm_init_binary_kernels(gm_tbl_t *tbl, ndt_context_t *ctx);
+GM_API int gm_init_cpu_unary_kernels(gm_tbl_t *tbl, ndt_context_t *ctx);
+GM_API int gm_init_cpu_binary_kernels(gm_tbl_t *tbl, ndt_context_t *ctx);
+GM_API int gm_init_bitwise_kernels(gm_tbl_t *tbl, ndt_context_t *ctx);
+
+GM_API int gm_init_cuda_unary_kernels(gm_tbl_t *tbl, ndt_context_t *ctx);
+GM_API int gm_init_cuda_binary_kernels(gm_tbl_t *tbl, ndt_context_t *ctx);
+
 GM_API int gm_init_example_kernels(gm_tbl_t *tbl, ndt_context_t *ctx);
-GM_API int gm_init_bfloat16_kernels(gm_tbl_t *tbl, ndt_context_t *ctx);
 GM_API int gm_init_graph_kernels(gm_tbl_t *tbl, ndt_context_t *ctx);
 GM_API int gm_init_quaternion_kernels(gm_tbl_t *tbl, ndt_context_t *ctx);
 GM_API int gm_init_pdist_kernels(gm_tbl_t *tbl, ndt_context_t *ctx);
@@ -202,4 +238,9 @@ GM_API int gm_init_pdist_kernels(gm_tbl_t *tbl, ndt_context_t *ctx);
 GM_API void gm_finalize(void);
 
 
+#ifdef __cplusplus
+} /* END extern "C" */
+#endif
+
+
 #endif /* GUMATH_H */

data/ext/ruby_gumath/gumath/libgumath/kernels/common.c

@@ -0,0 +1,513 @@
+/*
+* 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 <math.h>
+#include <complex.h>
+#include <inttypes.h>
+#include "ndtypes.h"
+#include "xnd.h"
+#include "gumath.h"
+#include "common.h"
+
+
+/****************************************************************************/
+/*                           Unary bitmap kernels                           */
+/****************************************************************************/
+
+void
+unary_update_bitmap_1D_S(xnd_t stack[])
+{
+    const int64_t N = xnd_fixed_shape(&stack[0]);
+    const int64_t li0 = stack[0].index;
+    const int64_t li1 = stack[1].index;
+    const int64_t s0 = xnd_fixed_step(&stack[0]);
+    const int64_t s1 = xnd_fixed_step(&stack[1]);
+    const uint8_t *b0 = get_bitmap1D(&stack[0]);
+    uint8_t *b1 = get_bitmap1D(&stack[1]);
+    int64_t i, k0, k1;
+
+    assert(b0 != NULL);
+    assert(b1 != NULL);
+
+    for (i=0, k0=li0, k1=li1; i<N; i++, k0+=s0, k1+=s1) {
+        bool x = is_valid(b0, k0);
+        set_bit(b1, k1, x);
+    }
+}
+
+void
+unary_reduce_bitmap_1D_S(xnd_t stack[])
+{
+    const int64_t N = xnd_fixed_shape(&stack[0]);
+    const int64_t li0 = stack[0].index;
+    const int64_t li1 = stack[1].index;
+    const int64_t s0 = xnd_fixed_step(&stack[0]);
+    const uint8_t *b0 = get_bitmap1D(&stack[0]);
+    uint8_t *b1 = get_bitmap(&stack[1]);
+    int64_t i, k0;
+
+    assert(b0 != NULL);
+    assert(b1 != NULL);
+
+    for (i=0, k0=li0; i<N; i++, k0+=s0) {
+        bool x = is_valid(b0, k0) && is_valid(b1, li1);
+        set_bit(b1, li1, x);
+    }
+}
+
+void
+unary_update_bitmap_0D(xnd_t stack[])
+{
+    const int64_t li0 = stack[0].index;
+    const int64_t li1 = stack[1].index;
+    const uint8_t *b0 = get_bitmap(&stack[0]);
+    uint8_t *b1 = get_bitmap(&stack[1]);
+
+    assert(b0 != NULL);
+    assert(b1 != NULL);
+
+    bool x = is_valid(b0, li0);
+    set_bit(b1, li1, x);
+}
+
+
+/****************************************************************************/
+/*                           Binary bitmap kernels                          */
+/****************************************************************************/
+
+void
+binary_update_bitmap_1D_S(xnd_t stack[])
+{
+    const int64_t N = xnd_fixed_shape(&stack[0]);
+    const int64_t li0 = stack[0].index;
+    const int64_t li1 = stack[1].index;
+    const int64_t li2 = stack[2].index;
+    const int64_t s0 = xnd_fixed_step(&stack[0]);
+    const int64_t s1 = xnd_fixed_step(&stack[1]);
+    const int64_t s2 = xnd_fixed_step(&stack[2]);
+    const uint8_t *b0 = get_bitmap1D(&stack[0]);
+    const uint8_t *b1 = get_bitmap1D(&stack[1]);
+    uint8_t *b2 = get_bitmap1D(&stack[2]);
+    int64_t i, k0, k1, k2;
+
+    if (b0 && b1) {
+        for (i=0, k0=li0, k1=li1, k2=li2; i<N; i++, k0+=s0, k1+=s1, k2+=s2) {
+            bool x = is_valid(b0, k0) && is_valid(b1, k1);
+            set_bit(b2, k2, x);
+        }
+    }
+    else if (b0) {
+        for (i=0, k0=li0, k2=li2; i<N; i++, k0+=s0, k2+=s2) {
+            bool x = is_valid(b0, k0);
+            set_bit(b2, k2, x);
+        }
+    }
+    else if (b1) {
+        for (i=0, k1=li1, k2=li2; i<N; i++, k1+=s1, k2+=s2) {
+            bool x = is_valid(b1, k1);
+            set_bit(b2, k2, x);
+        }
+    }
+}
+
+void
+binary_update_bitmap_0D(xnd_t stack[])
+{
+    const int64_t li0 = stack[0].index;
+    const int64_t li1 = stack[1].index;
+    const int64_t li2 = stack[2].index;
+    const uint8_t *b0 = get_bitmap(&stack[0]);
+    const uint8_t *b1 = get_bitmap(&stack[1]);
+    uint8_t *b2 = get_bitmap(&stack[2]);
+
+    assert(b2 != NULL);
+
+    if (b0 && b1) {
+        bool x = is_valid(b0, li0) && is_valid(b1, li1);
+        set_bit(b2, li2, x);
+    }
+    else if (b0) {
+        bool x = is_valid(b0, li0);
+        set_bit(b2, li2, x);
+    }
+    else if (b1) {
+        bool x = is_valid(b1, li1);
+        set_bit(b2, li2, x);
+    }
+}
+
+void
+binary_update_bitmap_1D_S_bool(xnd_t stack[])
+{
+    const int64_t N = xnd_fixed_shape(&stack[0]);
+    const int64_t li0 = stack[0].index;
+    const int64_t li1 = stack[1].index;
+    const int64_t li2 = stack[2].index;
+    const int64_t s0 = xnd_fixed_step(&stack[0]);
+    const int64_t s1 = xnd_fixed_step(&stack[1]);
+    const int64_t s2 = xnd_fixed_step(&stack[2]);
+    const uint8_t *b0 = get_bitmap1D(&stack[0]);
+    const uint8_t *b1 = get_bitmap1D(&stack[1]);
+    bool *x2 = (bool *)apply_index(&stack[2]);
+    int64_t i, k0, k1, k2;
+
+    assert(!ndt_is_optional(stack[2].type));
+
+    if (b0 && b1) {
+        for (i=0, k0=li0, k1=li1, k2=li2; i<N; i++, k0+=s0, k1+=s1, k2+=s2) {
+            bool x = is_valid(b0, k0);
+            bool y = is_valid(b1, k1);
+            bool z = x2[k2];
+            z = x && y ? z : !x && !y;
+            x2[k2] = z;
+        }
+    }
+    else if (b0) {
+        for (i=0, k0=li0, k2=li2; i<N; i++, k0+=s0, k2+=s2) {
+            bool x = is_valid(b0, k0);
+            bool z = x2[k2];
+            z = x ? z : x;
+            x2[k2] = z;
+        }
+    }
+    else if (b1) {
+        for (i=0, k1=li1, k2=li2; i<N; i++, k1+=s1, k2+=s2) {
+            bool x = is_valid(b1, k1);
+            bool z = x2[k2];
+            z = x ? z : x;
+            x2[k2] = z;
+        }
+    }
+}
+
+void
+binary_update_bitmap_0D_bool(xnd_t stack[])
+{
+    const int64_t li0 = stack[0].index;
+    const int64_t li1 = stack[1].index;
+    const int64_t li2 = stack[2].index;
+    const uint8_t *b0 = get_bitmap(&stack[0]);
+    const uint8_t *b1 = get_bitmap(&stack[1]);
+    bool *x2 = (bool *)stack[2].ptr;
+
+    assert(!ndt_is_optional(stack[2].type));
+
+    if (b0 && b1) {
+        bool x = is_valid(b0, li0);
+        bool y = is_valid(b1, li1);
+        bool z = x2[li2];
+        z = x && y ? z : !x && !y;
+        x2[li2] = z;
+    }
+    else if (b0) {
+        bool x = is_valid(b0, li0);
+        bool z = x2[li2];
+        z = x ? z : x;
+        x2[li2] = z;
+    }
+    else if (b1) {
+        bool x = is_valid(b1, li1);
+        bool z = x2[li2];
+        z = x ? z : x;
+        x2[li2] = z;
+    }
+}
+
+
+/****************************************************************************/
+/*                        Optimized unary typecheck                        */
+/****************************************************************************/
+
+const gm_kernel_set_t *
+cpu_unary_typecheck(int (*kernel_location)(const ndt_t *, const ndt_t *, ndt_context_t *),
+                    ndt_apply_spec_t *spec, const gm_func_t *f, const ndt_t *types[],
+                    const int64_t li[], int nin, int nout, bool check_broadcast,
+                    ndt_context_t *ctx)
+{
+    const ndt_t *t;
+    const ndt_t *u;
+    int n;
+
+    assert(spec->flags == 0);
+    assert(spec->outer_dims == 0);
+    assert(spec->nin == 0);
+    assert(spec->nout == 0);
+    assert(spec->nargs == 0);
+
+    if (nin != 1) {
+        ndt_err_format(ctx, NDT_ValueError,
+            "invalid number of arguments for %s(x): expected 1, got %d",
+            f->name, nin);
+        return NULL;
+
+    }
+
+    t = types[0];
+
+    if (nout) {
+        if (nout != 1) {
+            ndt_err_format(ctx, NDT_ValueError,
+                "%s(x) expects at most one 'out' argument, got %d",
+                f->name, nout);
+            return NULL;
+        }
+        u = types[1];
+    }
+    else {
+        u = types[0];
+    }
+
+    assert(ndt_is_concrete(t));
+    assert(ndt_is_concrete(u));
+
+    n = kernel_location(t, u, ctx);
+    if (n < 0) {
+        return NULL;
+    }
+    if (ndt_is_optional(ndt_dtype(t))) {
+        n++;
+    }
+
+    if (t->tag == VarDim || t->tag == VarDimElem) {
+        const gm_kernel_set_t *set = &f->kernels[n+2];
+        if (ndt_typecheck(spec, set->sig, types, li, nin, nout,
+                          check_broadcast, NULL, NULL, ctx) < 0) {
+            return NULL;
+        }
+        return set;
+    }
+
+    if (t->tag == Array) {
+        const gm_kernel_set_t *set = &f->kernels[n+4];
+        if (ndt_typecheck(spec, set->sig, types, li, nin, nout,
+                          check_broadcast, NULL, NULL, ctx) < 0) {
+            return NULL;
+        }
+        return set;
+    }
+
+    const gm_kernel_set_t *set = &f->kernels[n];
+
+    if (ndt_fast_unary_fixed_typecheck(spec, set->sig, types, nin, nout,
+                                       check_broadcast, ctx) < 0) {
+        return NULL;
+    }
+
+    return set;
+}
+
+const gm_kernel_set_t *
+cuda_unary_typecheck(int (*kernel_location)(const ndt_t *, const ndt_t *, ndt_context_t *),
+                     ndt_apply_spec_t *spec, const gm_func_t *f, const ndt_t *types[],
+                     const int64_t li[], int nin, int nout, bool check_broadcast,
+                     ndt_context_t *ctx)
+{
+    const ndt_t *t;
+    const ndt_t *u;
+    int n;
+    (void)li;
+
+    assert(spec->flags == 0);
+    assert(spec->outer_dims == 0);
+    assert(spec->nin == 0);
+    assert(spec->nout == 0);
+    assert(spec->nargs == 0);
+
+    if (nin != 1) {
+        ndt_err_format(ctx, NDT_ValueError,
+            "invalid number of arguments for %s(x): expected 1, got %d",
+            f->name, nin);
+        return NULL;
+    }
+
+    t = types[0];
+
+    if (nout) {
+        if (nout != 1) {
+            ndt_err_format(ctx, NDT_ValueError,
+                "%s(x) expects at most one 'out' argument, got %d",
+                f->name, nout);
+            return NULL;
+        }
+        u = types[1];
+    }
+    else {
+        u = types[0];
+    }
+
+    assert(ndt_is_concrete(t));
+    assert(ndt_is_concrete(u));
+
+    n = kernel_location(t, u, ctx);
+    if (n < 0) {
+        return NULL;
+    }
+    if (ndt_is_optional(ndt_dtype(t))) {
+        n++;
+    }
+
+    const gm_kernel_set_t *set = &f->kernels[n];
+
+    if (ndt_fast_unary_fixed_typecheck(spec, set->sig, types, nin, nout,
+                                       check_broadcast, ctx) < 0) {
+        return NULL;
+    }
+
+    return set;
+}
+
+
+/****************************************************************************/
+/*                        Optimized binary typecheck                        */
+/****************************************************************************/
+
+const gm_kernel_set_t *
+cpu_binary_typecheck(int (* kernel_location)(const ndt_t *in0, const ndt_t *in1, ndt_context_t *ctx),
+                     ndt_apply_spec_t *spec, const gm_func_t *f, const ndt_t *types[],
+                     const int64_t li[], int nin, int nout, bool check_broadcast,
+                     ndt_context_t *ctx)
+{
+    const ndt_t *t0;
+    const ndt_t *t1;
+    int n;
+
+    assert(spec->flags == 0);
+    assert(spec->outer_dims == 0);
+    assert(spec->nin == 0);
+    assert(spec->nout == 0);
+    assert(spec->nargs == 0);
+
+    if (nin != 2) {
+        ndt_err_format(ctx, NDT_ValueError,
+            "invalid number of arguments for %s(x, y): expected 2, got %d",
+            f->name, nin);
+        return NULL;
+    }
+
+    t0 = types[0];
+    t1 = types[1];
+    assert(ndt_is_concrete(t0));
+    assert(ndt_is_concrete(t1));
+
+    n = kernel_location(t0, t1, ctx);
+    if (n < 0) {
+        return NULL;
+    }
+    if (ndt_is_optional(ndt_dtype(t0))) {
+        n = ndt_is_optional(ndt_dtype(t1)) ? n+3 : n+1;
+    }
+    else if (ndt_is_optional(ndt_dtype(t1))) {
+        n = n+2;
+    }
+
+    if (t0->tag == VarDim || t0->tag == VarDimElem ||
+        t1->tag == VarDim || t1->tag == VarDimElem) {
+        const gm_kernel_set_t *set = &f->kernels[n+4];
+        if (ndt_typecheck(spec, set->sig, types, li, nin, nout,
+                          check_broadcast, NULL, NULL, ctx) < 0) {
+            return NULL;
+        }
+        return set;
+    }
+
+    if (t0->tag == Array || t1->tag == Array) {
+        const gm_kernel_set_t *set = &f->kernels[n+8];
+        if (ndt_typecheck(spec, set->sig, types, li, nin, nout,
+                          check_broadcast, NULL, NULL, ctx) < 0) {
+            return NULL;
+        }
+        return set;
+    }
+
+    const gm_kernel_set_t *set = &f->kernels[n];
+
+    if (ndt_fast_binary_fixed_typecheck(spec, set->sig, types, nin, nout,
+                                        check_broadcast, ctx) < 0) {
+        return NULL;
+    }
+
+    return set;
+}
+
+const gm_kernel_set_t *
+cuda_binary_typecheck(int (* kernel_location)(const ndt_t *in0, const ndt_t *in1, ndt_context_t *ctx),
+                      ndt_apply_spec_t *spec, const gm_func_t *f, const ndt_t *types[],
+                      const int64_t li[], int nin, int nout, bool check_broadcast,
+                      ndt_context_t *ctx)
+{
+    const ndt_t *t0;
+    const ndt_t *t1;
+    int n;
+    (void)li;
+
+    assert(spec->flags == 0);
+    assert(spec->outer_dims == 0);
+    assert(spec->nin == 0);
+    assert(spec->nout == 0);
+    assert(spec->nargs == 0);
+
+    if (nin != 2) {
+        ndt_err_format(ctx, NDT_ValueError,
+            "invalid number of arguments for %s(x, y): expected 2, got %d",
+            f->name, nin);
+        return NULL;
+    }
+
+    t0 = types[0];
+    t1 = types[1];
+    assert(ndt_is_concrete(t0));
+    assert(ndt_is_concrete(t1));
+
+    n = kernel_location(t0, t1, ctx);
+    if (n < 0) {
+        return NULL;
+    }
+    if (ndt_is_optional(ndt_dtype(t0))) {
+        n = ndt_is_optional(ndt_dtype(t1)) ? n+3 : n+1;
+    }
+    else if (ndt_is_optional(ndt_dtype(t1))) {
+        n = n+2;
+    }
+
+    const gm_kernel_set_t *set = &f->kernels[n];
+
+    if (ndt_fast_binary_fixed_typecheck(spec, set->sig, types, nin, nout,
+                                        check_broadcast, ctx) < 0) {
+        return NULL;
+    }
+
+    return set;
+}