| /* Copyright 2019 The TensorFlow Authors. All Rights Reserved. |
| |
| Licensed under the Apache License, Version 2.0 (the "License"); |
| you may not use this file except in compliance with the License. |
| You may obtain a copy of the License at |
| |
| http://www.apache.org/licenses/LICENSE-2.0 |
| |
| Unless required by applicable law or agreed to in writing, software |
| distributed under the License is distributed on an "AS IS" BASIS, |
| WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| See the License for the specific language governing permissions and |
| limitations under the License. |
| ==============================================================================*/ |
| |
| #ifndef TENSORFLOW_C_TF_TENSOR_H_ |
| #define TENSORFLOW_C_TF_TENSOR_H_ |
| |
| #include <stdbool.h> |
| #include <stdint.h> |
| |
| #include "tensorflow/c/tf_datatype.h" |
| #include "tensorflow/c/tf_status.h" |
| |
| #include <iostream> |
| #include <string> |
| |
| // Macro to control visibility of exported symbols in the shared library (.so, |
| // .dylib, .dll). |
| // This duplicates the TF_EXPORT macro definition in |
| // tensorflow/core/platform/macros.h in order to keep this .h file independent |
| // of any other includes. |
| #ifdef SWIG |
| #define TF_CAPI_EXPORT |
| #else |
| #if defined(_WIN32) |
| #ifdef TF_COMPILE_LIBRARY |
| #define TF_CAPI_EXPORT __declspec(dllexport) |
| #else |
| #define TF_CAPI_EXPORT __declspec(dllimport) |
| #endif // TF_COMPILE_LIBRARY |
| #else |
| #define TF_CAPI_EXPORT __attribute__((visibility("default"))) |
| #endif // _WIN32 |
| #endif // SWIG |
| |
| #ifdef __cplusplus |
| extern "C" { |
| #endif |
| |
| // -------------------------------------------------------------------------- |
| // TF_Tensor holds a multi-dimensional array of elements of a single data type. |
| // For all types other than TF_STRING, the data buffer stores elements |
| // in row major order. E.g. if data is treated as a vector of TF_DataType: |
| // |
| // element 0: index (0, ..., 0) |
| // element 1: index (0, ..., 1) |
| // ... |
| // |
| // The format for TF_STRING tensors is: |
| // start_offset: array[uint64] |
| // data: byte[...] |
| // |
| // The string length (as a varint, start_offset[i + 1] - start_offset[i]), |
| // followed by the contents of the string is encoded at data[start_offset[i]]. |
| // TF_StringEncode and TF_StringDecode facilitate this encoding. |
| |
| typedef struct TF_Tensor TF_Tensor; |
| |
| // Return a new tensor that holds the bytes data[0,len-1]. |
| // |
| // The data will be deallocated by a subsequent call to TF_DeleteTensor via: |
| // (*deallocator)(data, len, deallocator_arg) |
| // Clients must provide a custom deallocator function so they can pass in |
| // memory managed by something like numpy. |
| // |
| // May return NULL (and invoke the deallocator) if the provided data buffer |
| // (data, len) is inconsistent with a tensor of the given TF_DataType |
| // and the shape specified by (dima, num_dims). |
| TF_CAPI_EXPORT extern TF_Tensor* TF_NewTensor( |
| TF_DataType, const int64_t* dims, int num_dims, void* data, size_t len, |
| void (*deallocator)(void* data, size_t len, void* arg), |
| void* deallocator_arg); |
| |
| // Allocate and return a new Tensor. |
| // |
| // This function is an alternative to TF_NewTensor and should be used when |
| // memory is allocated to pass the Tensor to the C API. The allocated memory |
| // satisfies TensorFlow's memory alignment preferences and should be preferred |
| // over calling malloc and free. |
| // |
| // The caller must set the Tensor values by writing them to the pointer returned |
| // by TF_TensorData with length TF_TensorByteSize. |
| TF_CAPI_EXPORT extern TF_Tensor* TF_AllocateTensor(TF_DataType, |
| const int64_t* dims, |
| int num_dims, size_t len); |
| |
| // Deletes `tensor` and returns a new TF_Tensor with the same content if |
| // possible. Returns nullptr and leaves `tensor` untouched if not. |
| TF_CAPI_EXPORT extern TF_Tensor* TF_TensorMaybeMove(TF_Tensor* tensor); |
| |
| // Destroy a tensor. |
| TF_CAPI_EXPORT extern void TF_DeleteTensor(TF_Tensor*); |
| |
| // Return the type of a tensor element. |
| TF_CAPI_EXPORT extern TF_DataType TF_TensorType(const TF_Tensor*); |
| |
| // Return the number of dimensions that the tensor has. |
| TF_CAPI_EXPORT extern int TF_NumDims(const TF_Tensor*); |
| |
| // Return the length of the tensor in the "dim_index" dimension. |
| // REQUIRES: 0 <= dim_index < TF_NumDims(tensor) |
| TF_CAPI_EXPORT extern int64_t TF_Dim(const TF_Tensor* tensor, int dim_index); |
| |
| // Return the size of the underlying data in bytes. |
| TF_CAPI_EXPORT extern size_t TF_TensorByteSize(const TF_Tensor*); |
| |
| // Return a pointer to the underlying data buffer. |
| TF_CAPI_EXPORT extern void* TF_TensorData(const TF_Tensor*); |
| |
| // Returns the number of elements in the tensor. |
| TF_CAPI_EXPORT extern int64_t TF_TensorElementCount(const TF_Tensor* tensor); |
| |
| // Copy the internal data representation of `from` to `to`. `new_dims` and |
| // `num_new_dims` specify the new shape of the `to` tensor, `type` specifies its |
| // data type. On success, *status is set to TF_OK and the two tensors share the |
| // same data buffer. |
| // |
| // This call requires that the `from` tensor and the given type and shape (dims |
| // and num_dims) are "compatible" (i.e. they occupy the same number of bytes). |
| // Specifically, given from_type_size = TF_DataTypeSize(TF_TensorType(from)): |
| // |
| // ShapeElementCount(dims, num_dims) * TF_DataTypeSize(type) |
| // |
| // must equal |
| // |
| // TF_TensorElementCount(from) * from_type_size |
| // |
| // where TF_ShapeElementCount would be the number of elements in a tensor with |
| // the given shape. |
| // |
| // In addition, this function requires: |
| // * TF_DataTypeSize(TF_TensorType(from)) != 0 |
| // * TF_DataTypeSize(type) != 0 |
| // |
| // If any of the requirements are not met, *status is set to |
| // TF_INVALID_ARGUMENT. |
| TF_CAPI_EXPORT extern void TF_TensorBitcastFrom(const TF_Tensor* from, |
| TF_DataType type, TF_Tensor* to, |
| const int64_t* new_dims, |
| int num_new_dims, |
| TF_Status* status); |
| |
| // -------------------------------------------------------------------------- |
| // Encode the string `src` (`src_len` bytes long) into `dst` in the format |
| // required by TF_STRING tensors. Does not write to memory more than `dst_len` |
| // bytes beyond `*dst`. `dst_len` should be at least |
| // TF_StringEncodedSize(src_len). |
| // |
| // On success returns the size in bytes of the encoded string. |
| // Returns an error into `status` otherwise. |
| TF_CAPI_EXPORT extern size_t TF_StringEncode(const char* src, size_t src_len, |
| char* dst, size_t dst_len, |
| TF_Status* status); |
| |
| // Decode a string encoded using TF_StringEncode. |
| // |
| // On success, sets `*dst` to the start of the decoded string and `*dst_len` to |
| // its length. Returns the number of bytes starting at `src` consumed while |
| // decoding. `*dst` points to memory within the encoded buffer. On failure, |
| // `*dst` and `*dst_len` are undefined and an error is set in `status`. |
| // |
| // Does not read memory more than `src_len` bytes beyond `src`. |
| TF_CAPI_EXPORT extern size_t TF_StringDecode(const char* src, size_t src_len, |
| const char** dst, size_t* dst_len, |
| TF_Status* status); |
| |
| // Return the size in bytes required to encode a string `len` bytes long into a |
| // TF_STRING tensor. |
| TF_CAPI_EXPORT extern size_t TF_StringEncodedSize(size_t len); |
| |
| // Returns bool iff this tensor is aligned. |
| TF_CAPI_EXPORT extern bool TF_TensorIsAligned(const TF_Tensor*); |
| |
| TF_CAPI_EXPORT extern std::string TF_ShapeDebugString(const TF_Tensor*); |
| |
| #ifdef __cplusplus |
| } /* end extern "C" */ |
| #endif |
| |
| #endif // TENSORFLOW_C_TF_TENSOR_H_ |