int64_t dims[] = {2, 2};
  double data[] = {1.0, 2.0, 3.0, 4.0};
  TF_Status* status = TF_NewStatus();
  TF_Tensor* t = TFE_AllocateHostTensor(ctx, TF_DOUBLE, &dims[0],
                                        sizeof(dims) / sizeof(int64_t), status);
  memcpy(TF_TensorData(t), &data[0], TF_TensorByteSize(t));
  TFE_TensorHandle* th = TFE_NewTensorHandleFromTensor(ctx, t, status);
  CHECK_EQ(TF_OK, TF_GetCode(status)) << TF_Message(status);

    [[0,0],    *   [[0,0],    =   [[0,0],
     [0,0]]         [0,0]]         [0,0]]
  */

  // Build an abstract input tensor.
  int64_t dims[] = {2, 2};  // Matrices will be 2 x 2
  int num_dims = sizeof(dims) / sizeof(dims[0]);

  float vals[] = {0.0f, 0.0f, 0.0f, 0.0f};
  TFE_Context* eager_ctx = TF_ExecutionContextGetTFEContext(ctx, status.get());
  TFE_TensorHandle* t =

		// if modification time is the only timestamp being encoded.
		var mbuf [9]byte // 2*SizeOf(uint16) + SizeOf(uint8) + SizeOf(uint32)
		mt := uint32(fh.Modified.Unix())
		eb := writeBuf(mbuf[:])
		eb.uint16(extTimeExtraID)
		eb.uint16(5)  // Size: SizeOf(uint8) + SizeOf(uint32)
		eb.uint8(1)   // Flags: ModTime
		eb.uint32(mt) // ModTime
		fh.Extra = append(fh.Extra, mbuf[:]...)
	}

static void BoolDeallocator(void* data, size_t, void* arg) {
  delete[] static_cast<bool*>(data);
}

static void Int32Deallocator(void* data, size_t, void* arg) {
  delete[] static_cast<int32_t*>(data);
}

static void DoubleDeallocator(void* data, size_t, void* arg) {
  delete[] static_cast<double*>(data);
}

static void FloatDeallocator(void* data, size_t, void* arg) {
  delete[] static_cast<float*>(data);
}

    CHECK_EQ(TF_OK, TF_GetCode(status)) << TF_Message(status);
    size_t size = TFE_TensorHandleDeviceMemorySize(copy, status);
    CHECK_EQ(TF_OK, TF_GetCode(status)) << TF_Message(status);
    int64_t dims[] = {2, 2};
    TFE_TensorHandle* copy_aliased = TFE_NewTensorHandleFromDeviceMemory(
        ctx, name, TF_FLOAT, dims, 2, data, size, &Deleter, copy, status);
    CHECK_EQ(TF_OK, TF_GetCode(status)) << TF_Message(status);

  TF_Tensor* t = TFE_TensorHandleResolve(retvals[0], status);
  ASSERT_EQ(TF_GetCode(status), TF_OK) << TF_Message(status);
  TFE_DeleteTensorHandle(retvals[0]);
  float sum = 0;
  EXPECT_EQ(sizeof(sum), TF_TensorByteSize(t));
  memcpy(&sum, TF_TensorData(t), TF_TensorByteSize(t));
  TF_DeleteTensor(t);
  EXPECT_EQ(sum, 6.0);

  TFE_DeleteTensorHandle(h0);
  TFE_DeleteTensorHandle(h1);

}

const char* TF_GraphDebugString(TF_Graph* graph, size_t* len) {
  tensorflow::mutex_lock c(graph->mu);
  const auto& debug_str = graph->graph.ToGraphDefDebug().DebugString();
  *len = debug_str.size();
  char* ret = static_cast<char*>(malloc(*len + 1));
  memcpy(ret, debug_str.c_str(), *len + 1);
  return ret;
}

char* TF_FunctionDebugString(TF_Function* func, size_t* len) {

  std::unique_ptr<float[]> actual_values(new float[expected_values.size()]);
  EXPECT_EQ(sizeof(float) * expected_values.size(), TF_TensorByteSize(t));
  memcpy(actual_values.get(), TF_TensorData(t), TF_TensorByteSize(t));
  TF_DeleteTensor(t);

  for (int i = 0; i < expected_values.size(); i++) {
    EXPECT_EQ(expected_values[i], actual_values[i])

        assertEquals(16L, MemoryUtil.sizeOf(Boolean.TRUE));
        assertEquals(32L, MemoryUtil.sizeOf(new Date()));
        assertEquals(80L, MemoryUtil.sizeOf(LocalDateTime.now()));
        assertEquals(2128L, MemoryUtil.sizeOf(ZonedDateTime.now()));
        assertEquals(66L, MemoryUtil.sizeOf("1234567890"));
        assertEquals(76L, MemoryUtil.sizeOf("12345678901234567890"));
        assertEquals(66L, MemoryUtil.sizeOf(new String[] { "1234567890" }));

pkg go/types, type SelectionKind int
pkg go/types, type Signature struct
pkg go/types, type Sizes interface { Alignof, Offsetsof, Sizeof }
pkg go/types, type Sizes interface, Alignof(Type) int64
pkg go/types, type Sizes interface, Offsetsof([]*Var) []int64
pkg go/types, type Sizes interface, Sizeof(Type) int64
pkg go/types, type Slice struct
pkg go/types, type StdSizes struct