xnd 0.2.0dev6 → 0.2.0dev7

data/ext/ruby_xnd/xnd/libxnd/inline.h

@@ -80,6 +80,23 @@ _var_dim_next(const xnd_t *x, const int64_t start, const int64_t step,
     return next;
 }
 
+static inline xnd_t
+_array_next(const xnd_t *x, const int64_t i)
+{
+    const ndt_t *t = x->type;
+    const ndt_t *u = t->Array.type;
+    xnd_t next;
+
+    assert(t->tag == Array);
+
+    next.bitmap = xnd_bitmap_empty;
+    next.index = 0;
+    next.type = u;
+    next.ptr = XND_ARRAY_DATA(x->ptr) + i * next.type->datasize;
+
+    return next;
+}
+
 static inline xnd_t
 _tuple_next(const xnd_t *x, const int64_t i)
 {
@@ -108,6 +125,21 @@ _record_next(const xnd_t *x, const int64_t i)
     return next;
 }
 
+static inline xnd_t
+_union_next(const xnd_t *x)
+{
+    uint8_t i = XND_UNION_TAG(x->ptr);
+    const ndt_t *t = x->type;
+    xnd_t next;
+
+    next.bitmap = xnd_bitmap_empty;
+    next.index = 0;
+    next.type = t->Union.types[i];
+    next.ptr = x->ptr+1;
+
+    return next;
+}
+
 static inline xnd_t
 _ref_next(const xnd_t *x)
 {

data/ext/ruby_xnd/xnd/libxnd/libxnd.so

@@ -0,0 +1 @@
+ext/ruby_xnd/xnd/libxnd/libxnd.so.0.2.0dev3

data/ext/ruby_xnd/xnd/libxnd/libxnd.so.0

@@ -0,0 +1 @@
+ext/ruby_xnd/xnd/libxnd/libxnd.so.0.2.0dev3

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

@@ -0,0 +1,207 @@
+/*
+* 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 "contrib.h"
+#include "overflow.h"
+
+
+static bool
+shape_equal(const ndt_ndarray_t *dest, const ndt_ndarray_t *src)
+{
+    if (dest->ndim != src->ndim) {
+        return false;
+    }
+
+    for (int i = 0; i < src->ndim; i++) {
+        if (dest->shape[i] != src->shape[i]) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+static int64_t
+prod(const int64_t shape[], int N)
+{
+    bool overflow = false;
+    int64_t p = 1;
+
+    for (int64_t i = 0; i < N; i++) {
+        p = MULi64(p, shape[i], &overflow);
+        if (overflow) {
+            return -1;
+        }
+    }
+
+    return p;
+}
+
+static inline bool
+zero_in_shape(const ndt_ndarray_t *x)
+{
+    for (int i = 0; i < x->ndim; i++) {
+        if (x->shape[i] == 0) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+static void
+init_contiguous_c_strides(ndt_ndarray_t *dest, const ndt_ndarray_t *src)
+{
+    int64_t q;
+    int64_t i;
+
+    if (src->ndim == 0 && dest->ndim == 0) {
+        return;
+    }
+
+    q = 1;
+    for (i = dest->ndim-1; i >= 0; i--) {
+        dest->steps[i] = q;
+        q *= dest->shape[i];
+    }
+}
+
+static void
+init_contiguous_f_strides(ndt_ndarray_t *dest, const ndt_ndarray_t *src)
+{
+    int64_t q;
+    int64_t i;
+
+    if (src->ndim == 0 && dest->ndim == 0) {
+        return;
+    }
+
+    q = 1;
+    for (i = 0; i < dest->ndim; i++) {
+        dest->steps[i] = q;
+        q *= dest->shape[i];
+    }
+}
+
+xnd_t
+xnd_reshape(const xnd_t *x, int64_t shape[], int ndim, char order,
+            ndt_context_t *ctx)
+{
+    const ndt_t *t = x->type;
+    ndt_ndarray_t src, dest;
+    int64_t p, q;
+    int ret;
+    int use_fortran = 0;
+
+    if (order == 'F') {
+        use_fortran = 1;
+    }
+    else if (order == 'A') {
+        use_fortran = ndt_is_f_contiguous(t);
+    }
+    else if (order != 'C') {
+        ndt_err_format(ctx, NDT_ValueError, "'order' must be 'C', 'F' or 'A'");
+        return xnd_error;
+    }
+
+    if (ndt_as_ndarray(&src, t, ctx) < 0) {
+        return xnd_error;
+    }
+
+    dest.ndim = ndim;
+    dest.itemsize = src.itemsize;
+    for (int i = 0; i < ndim; i++) {
+        dest.shape[i] = shape[i];
+        dest.steps[i] = 0;
+        dest.strides[i] = 0;
+    }
+
+    p = prod(src.shape, src.ndim);
+    q = prod(dest.shape, dest.ndim);
+    if (p < 0 || q < 0) {
+        ndt_err_format(ctx, NDT_ValueError,
+            "reshaped array has too many elements");
+        return xnd_error;
+    }
+    if (p != q) {
+        ndt_err_format(ctx, NDT_ValueError,
+            "shapes do not have the same number of elements");
+        return xnd_error;
+    }
+
+    if (shape_equal(&dest, &src)) {
+        dest = src;
+    }
+    else if (zero_in_shape(&dest)) {
+        ;
+    }
+    else if (!use_fortran && ndt_is_c_contiguous(t)) {
+        init_contiguous_c_strides(&dest, &src);
+    }
+    else if (use_fortran && ndt_is_f_contiguous(t)) {
+        init_contiguous_f_strides(&dest, &src);
+    }
+    else {
+        ret = xnd_nocopy_reshape(dest.shape, dest.steps, dest.ndim,
+                                 src.shape, src.steps, src.ndim, use_fortran);
+        if (!ret) {
+            ndt_err_format(ctx, NDT_ValueError, "inplace reshape not possible");
+            return xnd_error;
+        }
+    }
+
+    xnd_t res = *x;
+
+    const ndt_t *u = ndt_copy(ndt_dtype(t), ctx);
+    if (u == NULL) {
+        return xnd_error;
+    }
+
+    for (int i = dest.ndim-1; i >= 0; i--) {
+        const ndt_t *v = ndt_fixed_dim(u, dest.shape[i], dest.steps[i], ctx);
+        ndt_decref(u);
+        if (v == NULL) {
+            return xnd_error;
+        }
+        u = v;
+    }
+
+    res.type = u;
+    return res;
+}

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

@@ -56,7 +56,7 @@ static void
 free_slices(xnd_t *lst, int64_t len)
 {
     for (int64_t i = 0; i < len; i++) {
-        ndt_del((ndt_t *)lst[i].type);
+        ndt_decref(lst[i].type);
     }
 
     ndt_free(lst);
@@ -269,7 +269,7 @@ xnd_split(const xnd_t *x, int64_t *nparts, int max_outer, ndt_context_t *ctx)
     }
 
     for (int64_t i = 0; i < nrows; i++) {
-        result[i] = xnd_multikey(x, indices+(i*ncols), nindices[i], ctx);
+        result[i] = xnd_subscript(x, indices+(i*ncols), nindices[i], ctx);
         if (ndt_err_occurred(ctx)) {
             ndt_free(nindices);
             ndt_free(indices);

data/ext/ruby_xnd/xnd/libxnd/tests/Makefile

@@ -0,0 +1,39 @@
+
+SRCDIR = ..
+
+CC = gcc
+LIBSTATIC = libxnd.a
+LIBSHARED = libxnd.so.0.2.0dev3
+
+INCLUDES = /home/sameer/.rvm/gems/ruby-2.4.1/gems/ndtypes-0.2.0dev6/ext/ruby_ndtypes/include
+LIBS = ../../ndtypes/libndtypes
+
+CONFIGURE_CFLAGS =  -Wall -Wextra -std=c11 -pedantic  -O2 -g
+XND_CFLAGS = $(strip $(CONFIGURE_CFLAGS) $(CFLAGS))
+
+
+default: runtest runtest_shared
+
+
+runtest:\
+Makefile runtest.c test_fixed.c test.h $(SRCDIR)/xnd.h $(SRCDIR)/$(LIBSTATIC)
+	$(CC) -I$(SRCDIR) -I$(INCLUDES) $(XND_CFLAGS) \
+	-o runtest runtest.c test_fixed.c $(SRCDIR)/libxnd.a \
+	$(LIBS)/libndtypes.a
+
+runtest_shared:\
+Makefile runtest.c test_fixed.c test.h $(SRCDIR)/xnd.h $(SRCDIR)/$(LIBSHARED)
+	$(CC) -I$(SRCDIR) -I$(INCLUDES) -L$(SRCDIR) -L$(LIBS) \
+	$(XND_CFLAGS) -o runtest_shared runtest.c test_fixed.c -lxnd -lndtypes
+
+
+FORCE:
+
+clean: FORCE
+	rm -f *.o *.gch *.gcda *.gcno *.gcov *.dyn *.dpi *.lock
+	rm -f runtest runtest_shared
+
+distclean: clean
+	rm -rf Makefile
+
+

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

@@ -35,15 +35,20 @@
 #include <stdint.h>
 #include <inttypes.h>
 #include <string.h>
+#include <math.h>
 #include <assert.h>
 #include "ndtypes.h"
 #include "xnd.h"
 #include "inline.h"
 #include "contrib.h"
+#include "contrib/bfloat16.h"
+#include "cuda/cuda_memory.h"
+#ifndef _MSC_VER
+#include "config.h"
+#endif
 
 
 static int xnd_init(xnd_t * const x, const uint32_t flags, ndt_context_t *ctx);
-static void xnd_clear(xnd_t * const x, const uint32_t flags);
 
 
 /*****************************************************************************/
@@ -72,32 +77,104 @@ xnd_err_occurred(const xnd_t *x)
 static bool
 requires_init(const ndt_t * const t)
 {
-    const ndt_t *dtype = ndt_dtype(t);
+    return !ndt_is_ref_free(t);
+}
 
-    switch (dtype->tag) {
-    case Categorical:
-    case Bool:
-    case Int8: case Int16: case Int32: case Int64:
-    case Uint8: case Uint16: case Uint32: case Uint64:
-    case Float16: case Float32: case Float64:
-    case Complex32: case Complex64: case Complex128:
-    case FixedString: case FixedBytes:
-    case String: case Bytes:
+static bool
+is_primary_type(const ndt_t * const t, ndt_context_t *ctx)
+{
+    if (ndt_is_abstract(t)) {
+        ndt_err_format(ctx, NDT_ValueError,
+            "cannot create xnd container from abstract type");
+        return false;
+    }
+
+    if (t->flags & NDT_CHAR) {
+        ndt_err_format(ctx, NDT_NotImplementedError, "char is not implemented");
         return false;
+    }
+
+    switch (t->tag) {
+    case FixedDim: {
+        if (!ndt_is_c_contiguous(t) && !ndt_is_f_contiguous(t)) {
+            ndt_err_format(ctx, NDT_ValueError,
+                "cannot create xnd container from non-contiguous type");
+            return false;
+        }
+        return true;
+    }
+    case VarDim: case VarDimElem: {
+        if (!ndt_is_var_contiguous(t)) {
+            ndt_err_format(ctx, NDT_ValueError,
+                "cannot create xnd container from non-contiguous type");
+            return false;
+        }
+        return true;
+    }
+    case Array: {
+        if (requires_init(t)) {
+            ndt_err_format(ctx, NDT_ValueError,
+                "flexible arrays cannot have dtypes that require "
+                "initialization");
+            return false;
+        }
+        return true;
+    }
     default:
         return true;
     }
+
+    ndt_err_format(ctx, NDT_ValueError,
+        "cannot create xnd container from non-contiguous type");
+    return false;
 }
 
+
 /* Create and initialize memory with type 't'. */
+#ifdef HAVE_CUDA
+static char *
+xnd_cuda_new(const ndt_t * const t, ndt_context_t *ctx)
+{
+    void *ptr;
+
+    if (!is_primary_type(t, ctx)) {
+        return NULL;
+    }
+
+    if (!ndt_is_pointer_free(t)) {
+        ndt_err_format(ctx, NDT_ValueError,
+            "only pointer-free types are supported on cuda");
+        return NULL;
+    }
+
+    ptr = xnd_cuda_calloc_managed(t->align, t->datasize, ctx);
+    if (ptr == NULL) {
+        return NULL;
+    }
+
+    return ptr;
+}
+#else
+static char *
+xnd_cuda_new(const ndt_t * const t, ndt_context_t *ctx)
+{
+    (void)t;
+
+    ndt_err_format(ctx, NDT_ValueError, "xnd compiled without cuda support");
+    return NULL;
+}
+#endif
+
 static char *
 xnd_new(const ndt_t * const t, const uint32_t flags, ndt_context_t *ctx)
 {
     xnd_t x;
 
-    if (ndt_is_abstract(t)) {
-        ndt_err_format(ctx, NDT_ValueError,
-            "cannot create xnd container from abstract type");
+    if (flags & XND_CUDA_MANAGED) {
+        return xnd_cuda_new(t, ctx);
+    }
+
+    if (!is_primary_type(t, ctx)) {
         return NULL;
     }
 
@@ -136,6 +213,13 @@ xnd_init(xnd_t * const x, const uint32_t flags, ndt_context_t *ctx)
 {
     const ndt_t * const t = x->type;
 
+    if (flags & XND_CUDA_MANAGED) {
+        ndt_err_format(ctx, NDT_RuntimeError,
+            "internal error: cannot initialize cuda memory with a type "
+            "that contains pointers");
+        return -1;
+    }
+
     if (ndt_is_abstract(t)) {
         ndt_err_format(ctx, NDT_ValueError,
             "cannot initialize concrete memory from abstract type");
@@ -199,6 +283,16 @@ xnd_init(xnd_t * const x, const uint32_t flags, ndt_context_t *ctx)
         return 0;
     }
 
+    case Union: {
+        xnd_t next = _union_next(x);
+        if (xnd_init(&next, flags, ctx) < 0) {
+            xnd_clear(&next, flags);
+            return -1;
+        }
+
+        return 0;
+    }
+
     /*
      * Ref represents a pointer to an explicit type. If XND_OWN_POINTERS
      * is set, allocate memory for that type and set the pointer.
@@ -247,10 +341,19 @@ xnd_init(xnd_t * const x, const uint32_t flags, ndt_context_t *ctx)
         return 0;
     }
 
+    /* Array is already initialized by calloc(). */
+    case Array:
+        return 0;
+
     /* Categorical is already initialized by calloc(). */
     case Categorical:
         return 0;
 
+    case VarDimElem:
+        ndt_err_format(ctx, NDT_ValueError,
+           "cannot initialize var elem dimension");
+        return -1;
+
     case Char:
         ndt_err_format(ctx, NDT_NotImplementedError, "char not implemented");
         return -1;
@@ -259,8 +362,8 @@ xnd_init(xnd_t * const x, const uint32_t flags, ndt_context_t *ctx)
     case Bool:
     case Int8: case Int16: case Int32: case Int64:
     case Uint8: case Uint16: case Uint32: case Uint64:
-    case Float16: case Float32: case Float64:
-    case Complex32: case Complex64: case Complex128:
+    case BFloat16: case Float16: case Float32: case Float64:
+    case BComplex32: case Complex32: case Complex64: case Complex128:
     case FixedString: case FixedBytes:
     case String: case Bytes:
         return 0;
@@ -288,7 +391,7 @@ xnd_empty_from_string(const char *s, uint32_t flags, ndt_context_t *ctx)
 {
     xnd_bitmap_t b = {.data=NULL, .size=0, .next=NULL};
     xnd_master_t *x;
-    ndt_t *t;
+    const ndt_t *t;
     char *ptr;
 
     if (!(flags & XND_OWN_TYPE)) {
@@ -310,13 +413,13 @@ xnd_empty_from_string(const char *s, uint32_t flags, ndt_context_t *ctx)
 
     if (!ndt_is_concrete(t)) {
         ndt_err_format(ctx, NDT_ValueError, "type must be concrete");
-        ndt_del(t);
+        ndt_decref(t);
         ndt_free(x);
         return NULL;
     }
 
     if (xnd_bitmap_init(&b, t,ctx) < 0) {
-        ndt_del(t);
+        ndt_decref(t);
         ndt_free(x);
         return NULL;
     }
@@ -324,7 +427,7 @@ xnd_empty_from_string(const char *s, uint32_t flags, ndt_context_t *ctx)
     ptr = xnd_new(t, flags, ctx);
     if (ptr == NULL) {
         xnd_bitmap_clear(&b);
-        ndt_del(t);
+        ndt_decref(t);
         ndt_free(x);
         return NULL;
     }
@@ -401,10 +504,13 @@ xnd_from_xnd(xnd_t *src, uint32_t flags, ndt_context_t *ctx)
 {
     xnd_master_t *x;
 
+    /* XXX xnd_from_xnd() will probably be replaced. */
+    assert(!(flags & XND_CUDA_MANAGED));
+
     x = ndt_alloc(1, sizeof *x);
     if (x == NULL) {
         xnd_clear(src, XND_OWN_ALL);
-        ndt_del((ndt_t *)src->type);
+        ndt_decref(src->type);
         ndt_aligned_free(src->ptr);
         xnd_bitmap_clear(&src->bitmap);
         return ndt_memory_error(ctx);
@@ -424,6 +530,10 @@ xnd_from_xnd(xnd_t *src, uint32_t flags, ndt_context_t *ctx)
 static bool
 requires_clear(const ndt_t * const t)
 {
+    if (t->tag == Array) {
+        return true;
+    }
+
     const ndt_t *dtype = ndt_dtype(t);
 
     switch (dtype->tag) {
@@ -431,8 +541,8 @@ requires_clear(const ndt_t * const t)
     case Bool:
     case Int8: case Int16: case Int32: case Int64:
     case Uint8: case Uint16: case Uint32: case Uint64:
-    case Float16: case Float32: case Float64:
-    case Complex32: case Complex64: case Complex128:
+    case BFloat16: case Float16: case Float32: case Float64:
+    case BComplex32: case Complex32: case Complex64: case Complex128:
     case FixedString: case FixedBytes:
         return false;
     default:
@@ -445,6 +555,7 @@ static void
 xnd_clear_ref(xnd_t *x, const uint32_t flags)
 {
     assert(x->type->tag == Ref);
+    assert(!(flags & XND_CUDA_MANAGED));
 
     if (flags & XND_OWN_POINTERS) {
         ndt_aligned_free(XND_POINTER_DATA(x->ptr));
@@ -457,6 +568,7 @@ static void
 xnd_clear_string(xnd_t *x, const uint32_t flags)
 {
     assert(x->type->tag == String);
+    assert(!(flags & XND_CUDA_MANAGED));
 
     if (flags & XND_OWN_STRINGS) {
         ndt_free(XND_POINTER_DATA(x->ptr));
@@ -469,21 +581,38 @@ static void
 xnd_clear_bytes(xnd_t *x, const uint32_t flags)
 {
     assert(x->type->tag == Bytes);
+    assert(!(flags & XND_CUDA_MANAGED));
 
     if (flags & XND_OWN_BYTES) {
         ndt_aligned_free(XND_BYTES_DATA(x->ptr));
+        XND_BYTES_SIZE(x->ptr) = 0;
         XND_BYTES_DATA(x->ptr) = NULL;
     }
 }
 
-/* Clear embedded pointers in the data according to flags. */
+/* Flexible array data must always be allocated by aligned allocators. */
 static void
+xnd_clear_array(xnd_t *x, const uint32_t flags)
+{
+    assert(x->type->tag == Array);
+    assert(!(flags & XND_CUDA_MANAGED));
+
+    if (flags & XND_OWN_ARRAYS) {
+        ndt_aligned_free(XND_ARRAY_DATA(x->ptr));
+        XND_ARRAY_SHAPE(x->ptr) = 0;
+        XND_ARRAY_DATA(x->ptr) = NULL;
+    }
+}
+
+/* Clear embedded pointers in the data according to flags. */
+void
 xnd_clear(xnd_t * const x, const uint32_t flags)
 {
     NDT_STATIC_CONTEXT(ctx);
     const ndt_t * const t = x->type;
 
     assert(ndt_is_concrete(t));
+    assert(!(flags & XND_CUDA_MANAGED));
 
     switch (t->tag) {
     case FixedDim: {
@@ -516,6 +645,23 @@ xnd_clear(xnd_t * const x, const uint32_t flags)
         return;
     }
 
+    case VarDimElem: {
+        fprintf(stderr, "xnd_clear: internal error: unexpected var elem dimension\n");
+        return;
+    }
+
+    case Array: {
+        const int64_t shape = XND_ARRAY_SHAPE(x->ptr);
+
+        for (int64_t i = 0; i < shape; i++) {
+            xnd_t next = _array_next(x, i);
+            xnd_clear(&next, flags);
+        }
+
+        xnd_clear_array(x, flags);
+        return;
+    }
+
     case Tuple: {
         for (int64_t i = 0; i < t->Tuple.shape; i++) {
             xnd_t next = _tuple_next(x, i);
@@ -534,6 +680,12 @@ xnd_clear(xnd_t * const x, const uint32_t flags)
         return;
     }
 
+    case Union: {
+        xnd_t next = _union_next(x);
+        xnd_clear(&next, flags);
+        return;
+    }
+
     case Ref: {
         if (flags & XND_OWN_POINTERS) {
             xnd_t next = _ref_next(x);
@@ -559,8 +711,8 @@ xnd_clear(xnd_t * const x, const uint32_t flags)
     case Bool:
     case Int8: case Int16: case Int32: case Int64:
     case Uint8: case Uint16: case Uint32: case Uint64:
-    case Float16: case Float32: case Float64:
-    case Complex32: case Complex64: case Complex128:
+    case BFloat16: case Float16: case Float32: case Float64:
+    case BComplex32: case Complex32: case Complex64: case Complex128:
     case FixedString: case FixedBytes:
         return;
 
@@ -603,11 +755,22 @@ xnd_del_buffer(xnd_t *x, uint32_t flags)
             }
 
             if (flags & XND_OWN_TYPE) {
-                ndt_del((ndt_t *)x->type);
+                ndt_decref(x->type);
             }
 
             if (flags & XND_OWN_DATA) {
-                ndt_aligned_free(x->ptr);
+                if (flags & XND_CUDA_MANAGED) {
+                #ifdef HAVE_CUDA
+                    xnd_cuda_free(x->ptr);
+                #else
+                    fprintf(stderr,
+                        "xnd_del_buffer: internal error: XND_CUDA_MANAGED set "
+                        "without cuda support\n");
+                #endif
+                }
+                else {
+                    ndt_aligned_free(x->ptr);
+                }
             }
         }
 
@@ -632,23 +795,48 @@ xnd_del(xnd_master_t *x)
 
 
 /*****************************************************************************/
-/*                 Subtrees (single elements are a special case)             */
+/*                                Index checks                               */
 /*****************************************************************************/
 
 static int64_t
 get_index(const xnd_index_t *key, int64_t shape, ndt_context_t *ctx)
+{
+    switch (key->tag) {
+    case Index:
+        return adjust_index(key->Index, shape, ctx);
+
+    case FieldName:
+        ndt_err_format(ctx, NDT_ValueError,
+            "expected integer index, got field name: '%s'", key->FieldName);
+        return -1;
+
+    case Slice:
+        ndt_err_format(ctx, NDT_ValueError,
+            "expected integer index, got slice");
+        return -1;
+    }
+
+    /* NOT REACHED: tags should be exhaustive */
+    ndt_err_format(ctx, NDT_RuntimeError, "invalid index tag");
+    return -1;
+}
+
+/*
+ * Ragged arrays have multiple shapes in a single dimension that are not known
+ * when a VarDimElem is created.  Adjusting the index must be done when the
+ * VarDimElem is accessed and the slices have been applied.
+ */
+static int64_t
+get_index_var_elem(const xnd_index_t *key, ndt_context_t *ctx)
 {
     switch (key->tag) {
     case Index: {
         int64_t i = key->Index;
-        if (i < 0) {
-            i += shape;
-        }
 
-        if (i < 0 || i >= shape || i > XND_SSIZE_MAX) {
+        if (i < INT32_MIN || i > INT32_MAX) {
             ndt_err_format(ctx, NDT_IndexError,
                 "index with value %" PRIi64 " out of bounds", key->Index);
-            return -1;
+            return INT64_MIN;
         }
 
         return i;
@@ -657,17 +845,17 @@ get_index(const xnd_index_t *key, int64_t shape, ndt_context_t *ctx)
     case FieldName:
         ndt_err_format(ctx, NDT_ValueError,
             "expected integer index, got field name: '%s'", key->FieldName);
-        return -1;
+        return INT64_MIN;
 
     case Slice:
         ndt_err_format(ctx, NDT_ValueError,
             "expected integer index, got slice");
-        return -1;
+        return INT64_MIN;
     }
 
     /* NOT REACHED: tags should be exhaustive */
     ndt_err_format(ctx, NDT_RuntimeError, "invalid index tag");
-    return -1;
+    return INT64_MIN;
 }
 
 static int64_t
@@ -698,6 +886,34 @@ get_index_record(const ndt_t *t, const xnd_index_t *key, ndt_context_t *ctx)
     return -1;
 }
 
+static int64_t
+get_index_union(const ndt_t *t, const xnd_index_t *key, ndt_context_t *ctx)
+{
+    assert(t->tag == Union);
+
+    switch (key->tag) {
+    case FieldName: {
+        int64_t i;
+
+        for (i = 0; i < t->Union.ntags; i++) {
+            if (strcmp(key->FieldName, t->Union.tags[i]) == 0) {
+                return i;
+            }
+        }
+
+        ndt_err_format(ctx, NDT_ValueError,
+            "invalid field name '%s'", key->FieldName);
+        return -1;
+    }
+    case Index: case Slice:
+        return get_index(key, t->Union.ntags, ctx);
+    }
+
+    /* NOT REACHED: tags should be exhaustive */
+    ndt_err_format(ctx, NDT_RuntimeError, "invalid index tag");
+    return -1;
+}
+
 static void
 set_index_exception(bool indexable, ndt_context_t *ctx)
 {
@@ -709,11 +925,72 @@ set_index_exception(bool indexable, ndt_context_t *ctx)
     }
 }
 
-/* Return a typed subtree of a memory block */
+
+/*****************************************************************************/
+/*                               Stored indices                              */
+/*****************************************************************************/
+
+bool
+have_stored_index(const ndt_t *t)
+{
+    return t->tag == VarDimElem;
+}
+
+int64_t
+get_stored_index(const ndt_t *t)
+{
+    return t->VarDimElem.index;
+}
+
+/* skip stored indices */
 xnd_t
-xnd_subtree_index(const xnd_t *x, const int64_t *indices, int len, ndt_context_t *ctx)
+apply_stored_index(const xnd_t *x, ndt_context_t *ctx)
 {
     const ndt_t * const t = x->type;
+    int64_t start, step, shape;
+
+    if (t->tag != VarDimElem) {
+        ndt_err_format(ctx, NDT_RuntimeError,
+                       "apply_stored_index: need VarDimElem");
+        return xnd_error;
+    }
+
+    shape = ndt_var_indices(&start, &step, t, x->index, ctx);
+    if (shape < 0) {
+        return xnd_error;
+    }
+
+    const int64_t i = adjust_index(t->VarDimElem.index, shape, ctx);
+    if (i < 0) {
+        return xnd_error;
+    }
+
+    return xnd_var_dim_next(x, start, step, i);
+}
+
+xnd_t
+apply_stored_indices(const xnd_t *x, ndt_context_t *ctx)
+{
+    xnd_t tl = *x;
+
+    while (tl.type->tag == VarDimElem) {
+        tl = apply_stored_index(&tl, ctx);
+    }
+
+    return tl;
+}
+
+
+/*****************************************************************************/
+/*                 Subtrees (single elements are a special case)             */
+/*****************************************************************************/
+
+/* Return a typed subtree of a memory block */
+static xnd_t
+_xnd_subtree_index(const xnd_t *x, const int64_t *indices, int len, ndt_context_t *ctx)
+{
+    APPLY_STORED_INDICES_XND(x)
+    const ndt_t * const t = x->type;
 
     assert(ndt_is_concrete(t));
 
@@ -731,14 +1008,13 @@ xnd_subtree_index(const xnd_t *x, const int64_t *indices, int len, ndt_context_t
 
     switch (t->tag) {
     case FixedDim: {
-        if (i < 0 || i >= t->FixedDim.shape) {
-            ndt_err_format(ctx, NDT_ValueError,
-                "fixed dim index out of bounds");
+        const int64_t k = adjust_index(i, t->FixedDim.shape, ctx);
+        if (k < 0) {
             return xnd_error;
         }
 
-        const xnd_t next = xnd_fixed_dim_next(x, i);
-        return xnd_subtree_index(&next, indices+1, len-1, ctx);
+        const xnd_t next = xnd_fixed_dim_next(x, k);
+        return _xnd_subtree_index(&next, indices+1, len-1, ctx);
     }
 
     case VarDim: {
@@ -749,41 +1025,74 @@ xnd_subtree_index(const xnd_t *x, const int64_t *indices, int len, ndt_context_t
             return xnd_error;
         }
 
-        if (i < 0 || i >= shape) {
-            ndt_err_format(ctx, NDT_ValueError, "var dim index out of bounds");
+        const int64_t k = adjust_index(i, shape, ctx);
+        if (k < 0) {
             return xnd_error;
         }
 
-        const xnd_t next = xnd_var_dim_next(x, start, step, i);
-        return xnd_subtree_index(&next, indices+1, len-1, ctx);
+        const xnd_t next = xnd_var_dim_next(x, start, step, k);
+        return _xnd_subtree_index(&next, indices+1, len-1, ctx);
     }
 
     case Tuple: {
-        if (i < 0 || i >= t->Tuple.shape) {
-            ndt_err_format(ctx, NDT_ValueError, "tuple index out of bounds");
+        const int64_t k = adjust_index(i, t->Tuple.shape, ctx);
+        if (k < 0) {
             return xnd_error;
         }
 
-        const xnd_t next = xnd_tuple_next(x, i, ctx);
+        const xnd_t next = xnd_tuple_next(x, k, ctx);
         if (next.ptr == NULL) {
             return xnd_error;
         }
 
-        return xnd_subtree_index(&next, indices+1, len-1, ctx);
+        return _xnd_subtree_index(&next, indices+1, len-1, ctx);
     }
 
     case Record: {
-        if (i < 0 || i >= t->Record.shape) {
-            ndt_err_format(ctx, NDT_ValueError, "record index out of bounds");
+        const int64_t k = adjust_index(i, t->Record.shape, ctx);
+        if (k < 0) {
             return xnd_error;
         }
 
-        const xnd_t next = xnd_record_next(x, i, ctx);
+        const xnd_t next = xnd_record_next(x, k, ctx);
+        if (next.ptr == NULL) {
+            return xnd_error;
+        }
+
+        return _xnd_subtree_index(&next, indices+1, len-1, ctx);
+    }
+
+    case Union: {
+        const int64_t k = adjust_index(i, t->Union.ntags, ctx);
+        if (k < 0) {
+            return xnd_error;
+        }
+
+        const uint8_t l = XND_UNION_TAG(x->ptr);
+        if (k != l) {
+            ndt_err_format(ctx, NDT_ValueError,
+                "tag mismatch in union addressing: expected '%s', got '%s'",
+                t->Union.tags[l], t->Union.tags[k]);
+            return xnd_error;
+        }
+
+        const xnd_t next = xnd_union_next(x, ctx);
         if (next.ptr == NULL) {
             return xnd_error;
         }
 
-        return xnd_subtree_index(&next, indices+1, len-1, ctx);
+        return _xnd_subtree_index(&next, indices+1, len-1, ctx);
+    }
+
+    case Array: {
+        const int64_t shape = XND_ARRAY_SHAPE(x->ptr);
+        const int64_t k = adjust_index(i, shape, ctx);
+        if (k < 0) {
+            return xnd_error;
+        }
+
+        const xnd_t next = xnd_array_next(x, k);
+        return _xnd_subtree_index(&next, indices+1, len-1, ctx);
     }
 
     case Ref: {
@@ -792,7 +1101,7 @@ xnd_subtree_index(const xnd_t *x, const int64_t *indices, int len, ndt_context_t
             return xnd_error;
         }
 
-        return xnd_subtree_index(&next, indices, len, ctx);
+        return _xnd_subtree_index(&next, indices, len, ctx);
     }
 
     case Constr: {
@@ -801,16 +1110,16 @@ xnd_subtree_index(const xnd_t *x, const int64_t *indices, int len, ndt_context_t
             return xnd_error;
         }
 
-        return xnd_subtree_index(&next, indices, len, ctx);
+        return _xnd_subtree_index(&next, indices, len, ctx);
     }
 
-   case Nominal: {
+    case Nominal: {
         const xnd_t next = xnd_nominal_next(x, ctx);
         if (next.ptr == NULL) {
             return xnd_error;
         }
 
-        return xnd_subtree_index(&next, indices, len, ctx);
+        return _xnd_subtree_index(&next, indices, len, ctx);
     }
 
     default:
@@ -819,6 +1128,17 @@ xnd_subtree_index(const xnd_t *x, const int64_t *indices, int len, ndt_context_t
     }
 }
 
+xnd_t
+xnd_subtree_index(const xnd_t *x, const int64_t *indices, int len, ndt_context_t *ctx)
+{
+    if (len < 0 || len > NDT_MAX_DIM) {
+        ndt_err_format(ctx, NDT_IndexError, "too many indices");
+        return xnd_error;
+    }
+
+    return _xnd_subtree_index(x, indices, len, ctx);
+}
+
 /*
  * Return a zero copy view of an xnd object.  If a dtype is indexable,
  * descend into the dtype.
@@ -827,6 +1147,7 @@ static xnd_t
 _xnd_subtree(const xnd_t *x, const xnd_index_t indices[], int len, bool indexable,
              ndt_context_t *ctx)
 {
+    APPLY_STORED_INDICES_XND(x)
     const ndt_t *t = x->type;
     const xnd_index_t *key;
 
@@ -846,7 +1167,7 @@ _xnd_subtree(const xnd_t *x, const xnd_index_t indices[], int len, bool indexabl
 
     switch (t->tag) {
     case FixedDim: {
-        int64_t i = get_index(key, t->FixedDim.shape, ctx);
+        const int64_t i = get_index(key, t->FixedDim.shape, ctx);
         if (i < 0) {
             return xnd_error;
         }
@@ -857,14 +1178,13 @@ _xnd_subtree(const xnd_t *x, const xnd_index_t indices[], int len, bool indexabl
 
     case VarDim: {
         int64_t start, step, shape;
-        int64_t i;
 
         shape = ndt_var_indices(&start, &step, t, x->index, ctx);
         if (shape < 0) {
             return xnd_error;
         }
 
-        i = get_index(key, shape, ctx);
+        const int64_t i = get_index(key, shape, ctx);
         if (i < 0) {
             return xnd_error;
         }
@@ -888,7 +1208,7 @@ _xnd_subtree(const xnd_t *x, const xnd_index_t indices[], int len, bool indexabl
     }
 
     case Record: {
-        int64_t i = get_index_record(t, key, ctx);
+        const int64_t i = get_index_record(t, key, ctx);
         if (i < 0) {
             return xnd_error;
         }
@@ -901,6 +1221,39 @@ _xnd_subtree(const xnd_t *x, const xnd_index_t indices[], int len, bool indexabl
         return _xnd_subtree(&next, indices+1, len-1, true, ctx);
     }
 
+    case Union: {
+        const int64_t i = get_index_union(t, key, ctx);
+        if (i < 0) {
+            return xnd_error;
+        }
+
+        const uint8_t k = XND_UNION_TAG(x->ptr);
+        if (i != k) {
+            ndt_err_format(ctx, NDT_ValueError,
+                "tag mismatch in union addressing: expected '%s', got '%s'",
+                t->Union.tags[k], t->Union.tags[i]);
+            return xnd_error;
+        }
+
+        const xnd_t next = xnd_union_next(x, ctx);
+        if (next.ptr == NULL) {
+            return xnd_error;
+        }
+
+        return _xnd_subtree(&next, indices+1, len-1, true, ctx);
+    }
+
+    case Array: {
+        const int64_t shape = XND_ARRAY_SHAPE(x->ptr);
+        const int64_t i = get_index(key, shape, ctx);
+        if (i < 0) {
+            return xnd_error;
+        }
+
+        const xnd_t next = xnd_array_next(x, i);
+        return _xnd_subtree(&next, indices+1, len-1, true, ctx);
+    }
+
     case Ref: {
         const xnd_t next = xnd_ref_next(x, ctx);
         if (next.ptr == NULL) {
@@ -941,13 +1294,18 @@ _xnd_subtree(const xnd_t *x, const xnd_index_t indices[], int len, bool indexabl
 xnd_t
 xnd_subtree(const xnd_t *x, const xnd_index_t indices[], int len, ndt_context_t *ctx)
 {
+    if (len < 0 || len > NDT_MAX_DIM) {
+        ndt_err_format(ctx, NDT_IndexError, "too many indices");
+        return xnd_error;
+    }
+
     return _xnd_subtree(x, indices, len, false, ctx);
 }
 
 static xnd_t xnd_index(const xnd_t *x, const xnd_index_t indices[], int len, ndt_context_t *ctx);
 static xnd_t xnd_slice(const xnd_t *x, const xnd_index_t indices[], int len, ndt_context_t *ctx);
 
-xnd_t
+static xnd_t
 xnd_multikey(const xnd_t *x, const xnd_index_t indices[], int len, ndt_context_t *ctx)
 {
     const ndt_t *t = x->type;
@@ -957,18 +1315,14 @@ xnd_multikey(const xnd_t *x, const xnd_index_t indices[], int len, ndt_context_t
     assert(ndt_is_concrete(t));
     assert(x->ptr != NULL);
 
-    if (len > t->ndim) {
+    if (len > ndt_logical_ndim(t)) {
         ndt_err_format(ctx, NDT_IndexError, "too many indices");
         return xnd_error;
     }
 
     if (len == 0) {
         xnd_t next = *x;
-        next.type = ndt_copy(t, ctx);
-        if (next.type == NULL) {
-            return xnd_error;
-        }
-
+        ndt_incref(next.type);
         return next;
     }
 
@@ -997,6 +1351,7 @@ xnd_multikey(const xnd_t *x, const xnd_index_t indices[], int len, ndt_context_t
 static xnd_t
 xnd_index(const xnd_t *x, const xnd_index_t indices[], int len, ndt_context_t *ctx)
 {
+    xnd_index_t xindices[NDT_MAX_DIM+1];
     const ndt_t *t = x->type;
     const xnd_index_t *key;
 
@@ -1004,6 +1359,17 @@ xnd_index(const xnd_t *x, const xnd_index_t indices[], int len, ndt_context_t *c
     assert(ndt_is_concrete(t));
     assert(x->ptr != NULL);
 
+    /* Hidden element type, insert the stored index. */
+    if (have_stored_index(t)) {
+        xindices[0].tag = Index;
+        xindices[0].Index = get_stored_index(t);
+        for (int k = 0; k < len; k++) {
+            xindices[k+1] = indices[k];
+        }
+        indices = xindices;
+        len = len+1;
+    }
+
     key = &indices[0];
     assert(key->tag == Index);
 
@@ -1018,10 +1384,35 @@ xnd_index(const xnd_t *x, const xnd_index_t indices[], int len, ndt_context_t *c
         return xnd_multikey(&next, indices+1, len-1, ctx);
     }
 
-    case VarDim: {
-        ndt_err_format(ctx, NDT_IndexError,
-            "mixed indexing and slicing is not supported for var dimensions");
-        return xnd_error;
+    case VarDim: case VarDimElem: {
+        const ndt_t *u;
+
+        if (ndt_is_optional(t)) {
+            ndt_err_format(ctx, NDT_NotImplementedError,
+                "optional dimensions are temporarily disabled");
+            return xnd_error;
+        }
+
+        const int64_t i = get_index_var_elem(key, ctx);
+        if (i == INT64_MIN) {
+            return xnd_error;
+        }
+
+        const xnd_t next = xnd_var_dim_next(x, 0, 1, 0);
+        const xnd_t tail = xnd_multikey(&next, indices+1, len-1, ctx);
+        if (xnd_err_occurred(&tail)) {
+            return xnd_error;
+        }
+
+        u = ndt_convert_to_var_elem(t, tail.type, i, ctx);
+        ndt_decref(tail.type);
+        if (u == NULL) {
+            return xnd_error;
+        }
+
+        xnd_t ret = *x;
+        ret.type = u;
+        return ret;
     }
 
     default:
@@ -1059,9 +1450,10 @@ xnd_slice(const xnd_t *x, const xnd_index_t indices[], int len, ndt_context_t *c
         }
 
         xnd_t ret = *x;
-        ret.type = ndt_fixed_dim((ndt_t *)sliced.type, shape,
+        ret.type = ndt_fixed_dim(sliced.type, shape,
                                  t->Concrete.FixedDim.step * step,
                                  ctx);
+        ndt_decref(sliced.type);
         if (ret.type == NULL) {
             return xnd_error;
         }
@@ -1093,15 +1485,14 @@ xnd_slice(const xnd_t *x, const xnd_index_t indices[], int len, ndt_context_t *c
 
         slices = ndt_var_add_slice(&nslices, t, start, stop, step, ctx);
         if (slices == NULL) {
+            ndt_decref(next.type);
             return xnd_error;
         }
 
         xnd_t ret = *x;
-        ret.type = ndt_var_dim((ndt_t *)next.type,
-                                ExternalOffsets,
-                                t->Concrete.VarDim.noffsets, t->Concrete.VarDim.offsets,
-                                nslices, slices,
-                                ctx);
+        ret.type = ndt_var_dim(next.type, t->Concrete.VarDim.offsets,
+                               nslices, slices, false, ctx);
+        ndt_decref(next.type);
         if (ret.type == NULL) {
             return xnd_error;
         }
@@ -1111,6 +1502,32 @@ xnd_slice(const xnd_t *x, const xnd_index_t indices[], int len, ndt_context_t *c
         return ret;
     }
 
+    case VarDimElem: {
+        int64_t i = t->VarDimElem.index;
+
+        if (ndt_is_optional(t)) {
+            ndt_err_format(ctx, NDT_NotImplementedError,
+                "optional dimensions are temporarily disabled");
+            return xnd_error;
+        }
+
+        const xnd_t next = xnd_var_dim_next(x, 0, 1, 0);
+        const xnd_t tail = xnd_multikey(&next, indices, len, ctx);
+        if (xnd_err_occurred(&tail)) {
+            return xnd_error;
+        }
+
+        const ndt_t *u = ndt_convert_to_var_elem(t, tail.type, i, ctx);
+        ndt_decref(tail.type);
+        if (u == NULL) {
+            return xnd_error;
+        }
+
+        xnd_t ret = *x;
+        ret.type = u;
+        return ret;
+    }
+
     case Tuple: {
         ndt_err_format(ctx, NDT_NotImplementedError,
             "slicing tuples is not supported");
@@ -1123,42 +1540,108 @@ xnd_slice(const xnd_t *x, const xnd_index_t indices[], int len, ndt_context_t *c
         return xnd_error;
     }
 
+    case Union: {
+        ndt_err_format(ctx, NDT_NotImplementedError,
+            "slicing unions is not supported");
+        return xnd_error;
+    }
+
     default:
         ndt_err_format(ctx, NDT_IndexError, "type not sliceable");
         return xnd_error;
     }
 }
 
+/* Validate indices for mixed indexed/sliced var dimensions. */
+static bool
+validate_indices(const xnd_t *x, ndt_context_t *ctx)
+{
+    const ndt_t * const t = x->type;
+
+    assert(ndt_is_concrete(t));
+
+    switch (t->tag) {
+    case VarDim: {
+        int64_t start, step, shape;
+
+        shape = ndt_var_indices_non_empty(&start, &step, t, x->index, ctx);
+        if (shape < 0) {
+            return false;
+        }
+
+        for (int64_t i = 0; i < shape; i++) {
+            const xnd_t next = xnd_var_dim_next(x, start, step, i);
+            if (!validate_indices(&next, ctx)) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    case VarDimElem: {
+        int64_t start, step, shape;
+
+        shape = ndt_var_indices(&start, &step, t, x->index, ctx);
+        if (shape < 0) {
+            return false;
+        }
+
+        const int64_t k = adjust_index(t->VarDimElem.index, shape, ctx);
+        if (k < 0) {
+            return false;
+        }
+
+        const xnd_t next = xnd_var_dim_next(x, start, step, k);
+        return validate_indices(&next, ctx);
+    }
+
+    default:
+        return true;
+    }
+}
+
 xnd_t
 xnd_subscript(const xnd_t *x, const xnd_index_t indices[], int len,
               ndt_context_t *ctx)
 {
+    bool have_index = false;
     bool have_slice = false;
 
+    if (len < 0 || len > NDT_MAX_DIM) {
+        ndt_err_format(ctx, NDT_IndexError, "too many indices");
+        return xnd_error;
+    }
+
     for (int i = 0; i < len; i++) {
+        if (indices[i].tag == Index) {
+            have_index = true;
+        }
         if (indices[i].tag == Slice) {
             have_slice = true;
-            break;
         }
     }
 
     if (have_slice) {
-        return xnd_multikey(x, indices, len, ctx);
-    }
-    else {
-        xnd_t res = xnd_subtree(x, indices, len, ctx);
-        const ndt_t *t;
+        xnd_t res = xnd_multikey(x, indices, len, ctx);
+        if (xnd_err_occurred(&res)) {
+            return xnd_error;
+        }
 
-        if (res.ptr == NULL) {
+        if (have_index && !validate_indices(&res, ctx)) {
+            ndt_decref(res.type);
             return xnd_error;
         }
 
-        t = ndt_copy(res.type, ctx);
-        if (t == NULL) {
+        return res;
+    }
+    else {
+        xnd_t res = xnd_subtree(x, indices, len, ctx);
+        if (res.ptr == NULL) {
             return xnd_error;
         }
 
-        res.type = t;
+        ndt_incref(res.type);
         return res;
     }
 }
@@ -1302,3 +1785,42 @@ xnd_double_is_big_endian(void)
 {
     return xnd_double_format==IEEE_BIG_ENDIAN;
 }
+
+static float
+bfloat16_to_float(uint16_t b)
+{
+    float f = 0;
+    uint16_t *p = (uint16_t *)((char *)&f);
+
+    if (xnd_float_is_big_endian()) {
+        p[0] = b;
+    }
+    else {
+        p[1] = b;
+    }
+
+    return f;
+}
+
+/*
+ * Unlike the corresponding Python conversion functions, Tensorflow does
+ * not raise OverflowError.
+ */
+void
+xnd_bfloat_pack(char *p, double x)
+{
+    float f = (float)x;
+    uint16_t u16;
+
+    u16 = xnd_round_to_bfloat16(f);
+    PACK_SINGLE(p, u16, uint16_t, 0);
+}
+
+double
+xnd_bfloat_unpack(char *p)
+{
+    uint16_t u16;
+
+    UNPACK_SINGLE(u16, p, uint16_t, 0);
+    return bfloat16_to_float(u16);
+}