xnd 0.2.0dev6 → 0.2.0dev7

data/ext/ruby_xnd/xnd/libxnd/cuda/cuda_memory.cu

@@ -0,0 +1,121 @@
+/*
+* 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 <stdint.h>
+#include "ndtypes.h"
+
+
+/*****************************************************************************/
+/*                  Expose some cuda memory functions                        */
+/*****************************************************************************/
+
+extern "C" void *
+xnd_cuda_calloc_managed(uint16_t align, int64_t size, ndt_context_t *ctx)
+{
+    char *ptr;
+    cudaError_t err;
+
+    size = size == 0 ? 1 : size;
+
+    if (size < 0 || (uint64_t)size > SIZE_MAX) {
+        ndt_err_format(ctx, NDT_ValueError,
+            "cudaMallocManaged: invalid size");
+        return NULL;
+    }
+
+    err = cudaMallocManaged(&ptr, (size_t)size);
+    if (err != cudaSuccess) {
+        ndt_err_format(ctx, NDT_MemoryError,
+            "cudaMallocManaged: allocation failed");
+        return NULL;
+    }
+
+    if (((uintptr_t)ptr) % align != 0) {
+        ndt_err_format(ctx, NDT_ValueError,
+            "cudaMallocManaged: alignment requirement too large");
+        cudaFree(ptr);
+        return NULL;
+    }
+
+    memset(ptr, '\0', (size_t)size);
+
+    return ptr;
+}
+
+extern "C" void
+xnd_cuda_free(void *ptr)
+{
+    cudaError_t err;
+
+    err = cudaFree(ptr);
+    if (err != cudaSuccess) {
+        fprintf(stderr, "cudaFree: unexpected failure\n");
+    }
+}
+
+extern "C" int
+xnd_cuda_mem_prefetch_async(const void *ptr, int64_t count, int dev,
+                            ndt_context_t *ctx)
+{
+    cudaError_t err;
+
+    if (count < 0 || (uint64_t)count > SIZE_MAX) {
+        ndt_err_format(ctx, NDT_ValueError,
+            "cudaMemPrefetchAsync: invalid count");
+        return -1;
+    }
+
+    err = cudaMemPrefetchAsync(ptr, (size_t)count, dev);
+    if (err != cudaSuccess) {
+        ndt_err_format(ctx, NDT_MemoryError,
+            "cudaMemPrefetchAsync: prefetching failed");
+        return -1;
+    }
+
+    return 0;
+}
+
+extern "C" int
+xnd_cuda_device_synchronize(ndt_context_t *ctx)
+{
+    cudaError_t err;
+
+    err = cudaDeviceSynchronize();
+    if (err != cudaSuccess) {
+        ndt_err_format(ctx, NDT_RuntimeError,
+            "cuda device synchronization failed");
+        return -1;
+    }
+
+    return 0;
+}

data/ext/ruby_xnd/xnd/libxnd/cuda/cuda_memory.h

@@ -0,0 +1,58 @@
+/*
+* 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.
+*/
+
+
+#ifndef CUDA_MEMORY_H
+#define CUDA_MEMORY_H
+
+#include <stdint.h>
+#include "ndtypes.h"
+
+
+/*****************************************************************************/
+/*                  Expose some cuda memory functions                        */
+/*****************************************************************************/
+
+#ifdef __cpplusplus
+extern "C" void *xnd_cuda_calloc_managed(uint16_t align, int64_t size, ndt_context_t *ctx);
+extern "C" void xnd_cuda_free(void *ptr);
+extern "C" int xnd_cuda_mem_prefetch_async(const void *ptr, int64_t count, int dev, ndt_context_t *ctx);
+extern "C" int xnd_cuda_device_synchronize(ndt_context_t *ctx);
+#else
+void *xnd_cuda_calloc_managed(uint16_t align, int64_t size, ndt_context_t *ctx);
+void xnd_cuda_free(void *ptr);
+int xnd_cuda_mem_prefetch_async(const void *ptr, int64_t count, int dev, ndt_context_t *ctx);
+int xnd_cuda_device_synchronize(ndt_context_t *ctx);
+#endif
+
+
+#endif /* CUDA_MEMORY_H */

data/ext/ruby_xnd/xnd/libxnd/equal.c

@@ -55,9 +55,7 @@ xnd_strict_equal(const xnd_t *x, const xnd_t *y, ndt_context_t *ctx)
     assert(ndt_is_concrete(t) && ndt_is_concrete(u));
 
     if (t->tag != u->tag) {
-        ndt_err_format(ctx, NDT_TypeError,
-            "mixed type comparisons are not implemented");
-        return -1;
+        return 0;
     }
 
     if (xnd_is_na(x) || xnd_is_na(y)) {
@@ -111,6 +109,20 @@ xnd_strict_equal(const xnd_t *x, const xnd_t *y, ndt_context_t *ctx)
         return 1;
     }
 
+    case VarDimElem: {
+        const xnd_t xnext = apply_stored_index(x, ctx);
+        if (xnd_err_occurred(&xnext)) {
+            return -1;
+        }
+
+        const xnd_t ynext = apply_stored_index(y, ctx);
+        if (xnd_err_occurred(&ynext)) {
+            return -1;
+        }
+
+        return xnd_strict_equal(&xnext, &ynext, ctx);
+    }
+
     case Tuple: {
         if (u->Tuple.shape != t->Tuple.shape) {
             return 0;
@@ -161,6 +173,20 @@ xnd_strict_equal(const xnd_t *x, const xnd_t *y, ndt_context_t *ctx)
         return 1;
     }
 
+    case Union: {
+        const xnd_t xnext = xnd_union_next(x, ctx);
+        if (xnext.ptr == NULL) {
+            return -1;
+        }
+
+        const xnd_t ynext = xnd_union_next(y, ctx);
+        if (ynext.ptr == NULL) {
+            return -1;
+        }
+
+        return xnd_strict_equal(&xnext, &ynext, ctx);
+    }
+
     case Ref: {
         const xnd_t xnext = xnd_ref_next(x, ctx);
         if (xnext.ptr == NULL) {
@@ -296,6 +322,12 @@ xnd_strict_equal(const xnd_t *x, const xnd_t *y, ndt_context_t *ctx)
         return a == b;
     }
 
+    case BFloat16: {
+        double a = xnd_bfloat_unpack(x->ptr);
+        double b = xnd_bfloat_unpack(y->ptr);
+        return a == b;
+    }
+
     case Float16: {
         double a = xnd_float_unpack2((unsigned char *)x->ptr, le(t->flags));
         double b = xnd_float_unpack2((unsigned char *)y->ptr, le(u->flags));
@@ -314,6 +346,19 @@ xnd_strict_equal(const xnd_t *x, const xnd_t *y, ndt_context_t *ctx)
         return a == b;
     }
 
+    case BComplex32: {
+        double a_real, a_imag;
+        double b_real, b_imag;
+
+        a_real = xnd_bfloat_unpack(x->ptr);
+        a_imag = xnd_bfloat_unpack(x->ptr+2);
+
+        b_real = xnd_bfloat_unpack(y->ptr);
+        b_imag = xnd_bfloat_unpack(y->ptr+2);
+
+        return a_real == b_real && a_imag == b_imag;
+    }
+
     case Complex32: {
         double a_real, a_imag;
         double b_real, b_imag;
@@ -371,8 +416,8 @@ xnd_strict_equal(const xnd_t *x, const xnd_t *y, ndt_context_t *ctx)
     }
 
     case String: {
-        const char *a = XND_POINTER_DATA(x->ptr);
-        const char *b = XND_POINTER_DATA(y->ptr);
+        const char *a = XND_STRING_DATA(x->ptr);
+        const char *b = XND_STRING_DATA(y->ptr);
         return strcmp(a, b) == 0;
     }
 
@@ -393,6 +438,26 @@ xnd_strict_equal(const xnd_t *x, const xnd_t *y, ndt_context_t *ctx)
         return memcmp(a, b, (size_t)asize) == 0;
     }
 
+    case Array: {
+        int64_t ashape, bshape;
+
+        ashape = XND_ARRAY_SHAPE(x->ptr);
+        bshape = XND_ARRAY_SHAPE(y->ptr);
+
+        if (ashape != bshape) {
+            return 0;
+        }
+
+        for (int64_t i = 0; i < ashape; i++) {
+            const xnd_t xnext = xnd_array_next(x, i);
+            const xnd_t ynext = xnd_array_next(y, i);
+            n = xnd_strict_equal(&xnext, &ynext, ctx);
+            if (n <= 0) return n;
+        }
+
+        return 1;
+    }
+
     /* NOT REACHED: xnd types must be concrete. */
     case Module: case Function:
     case AnyKind: case SymbolicDim: case EllipsisDim: case Typevar:
@@ -495,6 +560,11 @@ equal_int64(const int64_t a, const xnd_t * const x)
         return a >= 0 ? (uint64_t)a == b : 0;
     }
 
+    case BFloat16: {
+        double b = xnd_bfloat_unpack(x->ptr);
+        return llabs(a) <= 4503599627370496LL ? (double)a == b : 0;
+    }
+
     case Float16: {
         double b = xnd_float_unpack2((unsigned char *)x->ptr, le(t->flags));
         return llabs(a) <= 4503599627370496LL ? (double)a == b : 0;
@@ -510,6 +580,17 @@ equal_int64(const int64_t a, const xnd_t * const x)
         return llabs(a) <= 4503599627370496LL ? (double)a == b : 0;
     }
 
+    case BComplex32: {
+        double real = xnd_bfloat_unpack(x->ptr);
+        double imag = xnd_bfloat_unpack(x->ptr+2);
+
+        if (imag == 0.0 && llabs(a) <= 4503599627370496LL) {
+            return (double)a == real;
+        }
+
+        return 0;
+    }
+
     case Complex32: {
         double real = xnd_float_unpack2((unsigned char *)x->ptr, le(t->flags));
         double imag = xnd_float_unpack2((unsigned char *)(x->ptr+2), le(t->flags));
@@ -601,6 +682,11 @@ equal_uint64(const uint64_t a, const xnd_t * const x)
         return a == b;
     }
 
+    case BFloat16: {
+        double b = xnd_bfloat_unpack(x->ptr);
+        return a <= 4503599627370496ULL ? (double)a == b : 0;
+    }
+
     case Float16: {
         double b = xnd_float_unpack2((unsigned char *)x->ptr, le(t->flags));
         return a <= 4503599627370496ULL ? (double)a == b : 0;
@@ -616,6 +702,17 @@ equal_uint64(const uint64_t a, const xnd_t * const x)
         return a <= 4503599627370496ULL ? (double)a == b : 0;
     }
 
+    case BComplex32: {
+        double real = xnd_bfloat_unpack(x->ptr);
+        double imag = xnd_bfloat_unpack(x->ptr+2);
+
+        if (imag == 0.0 && a <= 4503599627370496ULL) {
+            return (double)a == real;
+        }
+
+        return 0;
+    }
+
     case Complex32: {
         double real = xnd_float_unpack2((unsigned char *)x->ptr, le(t->flags));
         double imag = xnd_float_unpack2((unsigned char *)(x->ptr+2), le(t->flags));
@@ -707,6 +804,11 @@ equal_float64(const double a, const xnd_t * const x)
         return b <= 4503599627370496ULL ? a == (double)b : 0;
     }
 
+    case BFloat16: {
+        double b = xnd_bfloat_unpack(x->ptr);
+        return a == b;
+    }
+
     case Float16: {
         double b = xnd_float_unpack2((unsigned char *)x->ptr, le(t->flags));
         return a == b;
@@ -722,6 +824,19 @@ equal_float64(const double a, const xnd_t * const x)
         return a == b;
     }
 
+    case BComplex32: {
+        double real, imag;
+
+        real = xnd_bfloat_unpack(x->ptr);
+        imag = xnd_bfloat_unpack(x->ptr+2);
+
+        if (imag == 0.0) {
+            return a == real;
+        }
+
+        return 0;
+    }
+
     case Complex32: {
         double real, imag;
 
@@ -819,6 +934,11 @@ equal_complex128(const double real, const double imag, const xnd_t * const x)
         return b <= 4503599627370496ULL ? real == (double)b : 0;
     }
 
+    case BFloat16: {
+        double b = xnd_bfloat_unpack(x->ptr);
+        return imag == 0.0 && real == b;
+    }
+
     case Float16: {
         double b = xnd_float_unpack2((unsigned char *)x->ptr, le(t->flags));
         return imag == 0.0 && real == b;
@@ -834,6 +954,12 @@ equal_complex128(const double real, const double imag, const xnd_t * const x)
         return imag == 0.0 && real == b;
     }
 
+    case BComplex32: {
+        double a = xnd_bfloat_unpack(x->ptr);
+        double b = xnd_bfloat_unpack(x->ptr+2);
+        return real == a && imag == b;
+    }
+
     case Complex32: {
         double a = xnd_float_unpack2((unsigned char *)x->ptr, le(t->flags));
         double b = xnd_float_unpack2((unsigned char *)(x->ptr+2), le(t->flags));
@@ -859,6 +985,8 @@ equal_complex128(const double real, const double imag, const xnd_t * const x)
 int
 xnd_equal(const xnd_t *x, const xnd_t *y, ndt_context_t *ctx)
 {
+    APPLY_STORED_INDICES_INT(x)
+    APPLY_STORED_INDICES_INT(y)
     const ndt_t * const t = x->type;
     const ndt_t * const u = y->type;
     int n;
@@ -972,6 +1100,20 @@ xnd_equal(const xnd_t *x, const xnd_t *y, ndt_context_t *ctx)
         return 1;
     }
 
+    case Union: {
+        const xnd_t xnext = xnd_union_next(x, ctx);
+        if (xnext.ptr == NULL) {
+            return -1;
+        }
+
+        const xnd_t ynext = xnd_union_next(y, ctx);
+        if (ynext.ptr == NULL) {
+            return -1;
+        }
+
+        return xnd_equal(&xnext, &ynext, ctx);
+    }
+
     case Constr: {
         if (u->tag != Constr || strcmp(u->Constr.name, t->Constr.name) != 0) {
             return 0;
@@ -1094,6 +1236,11 @@ xnd_equal(const xnd_t *x, const xnd_t *y, ndt_context_t *ctx)
         return equal_uint64(a, y);
     }
 
+    case BFloat16: {
+        double a = xnd_bfloat_unpack(x->ptr);
+        return equal_float64(a, y);
+    }
+
     case Float16: {
         double a = xnd_float_unpack2((unsigned char *)x->ptr, le(t->flags));
         return equal_float64(a, y);
@@ -1109,6 +1256,19 @@ xnd_equal(const xnd_t *x, const xnd_t *y, ndt_context_t *ctx)
         return equal_float64(a, y);
     }
 
+    case BComplex32: {
+        double real, imag;
+
+        real = xnd_bfloat_unpack(x->ptr);
+        imag = xnd_bfloat_unpack(x->ptr+2);
+
+        if (imag == 0.0) {
+            return equal_float64(real, y);
+        }
+
+        return equal_complex128(real, imag, y);
+    }
+
     case Complex32: {
         double real, imag;
 
@@ -1172,8 +1332,8 @@ xnd_equal(const xnd_t *x, const xnd_t *y, ndt_context_t *ctx)
             return 0;
         }
 
-        const char *a = XND_POINTER_DATA(x->ptr);
-        const char *b = XND_POINTER_DATA(y->ptr);
+        const char *a = XND_STRING_DATA(x->ptr);
+        const char *b = XND_STRING_DATA(y->ptr);
         return strcmp(a, b) == 0;
     }
 
@@ -1198,8 +1358,36 @@ xnd_equal(const xnd_t *x, const xnd_t *y, ndt_context_t *ctx)
         return memcmp(a, b, (size_t)asize) == 0;
     }
 
+    case Array: {
+        int64_t ashape, bshape;
+
+        if (u->tag != Array) {
+            return 0;
+        }
+
+        ashape = XND_ARRAY_SHAPE(x->ptr);
+        bshape = XND_ARRAY_SHAPE(y->ptr);
+
+        if (ashape != bshape) {
+            return 0;
+        }
+
+        for (int64_t i = 0; i < ashape; i++) {
+            const xnd_t xnext = xnd_array_next(x, i);
+            const xnd_t ynext = xnd_array_next(y, i);
+            n = xnd_equal(&xnext, &ynext, ctx);
+            if (n <= 0) return n;
+        }
+
+        return 1;
+    }
+
+    /* NOT REACHED: intercepted by apply_stored_indices(). */
+    case VarDimElem:
     /* NOT REACHED: intercepted by equal_ref(). */
     case Ref:
+        ndt_err_format(ctx, NDT_RuntimeError, "unexpected VarDimElem or Ref");
+        return -1;
 
     /* NOT REACHED: xnd types must be concrete. */
     case Module: case Function: