diff --git a/src/buffer.rs b/src/buffer.rs index 32853270f3..7284256a32 100644 --- a/src/buffer.rs +++ b/src/buffer.rs @@ -17,6 +17,7 @@ use std::ops::Range; use std::ops::RangeFrom; use std::ops::RangeFull; use std::ops::RangeTo; +use std::os::raw::c_void as std_c_void; use std::ptr; use std::slice; use super::BufferTrait; @@ -65,7 +66,7 @@ impl Buffer { let msg = CStr::from_ptr(c_msg); panic!("Failed to allocate: {}", msg.to_str().unwrap()); } - (*inner).data = ptr; + (*inner).data = ptr as *mut std_c_void; (*inner).length = len; (*inner).data_deallocator = Some(deallocator); Buffer { @@ -81,7 +82,7 @@ impl Buffer { /// The underlying data is *not* freed when the buffer is destroyed. pub unsafe fn from_ptr(ptr: *mut T, len: usize) -> Self { let inner = tf::TF_NewBuffer(); - (*inner).data = ptr as *const c_void; + (*inner).data = ptr as *const std_c_void; (*inner).length = len; Buffer { inner: inner, @@ -155,8 +156,8 @@ impl BufferTrait for Buffer { } } -unsafe extern "C" fn deallocator(data: *mut c_void, _length: size_t) { - libc::free(data); +unsafe extern "C" fn deallocator(data: *mut std_c_void, _length: size_t) { + libc::free(data as *mut c_void); } impl Drop for Buffer { diff --git a/src/graph.rs b/src/graph.rs index 346a362162..02f1ea4f82 100644 --- a/src/graph.rs +++ b/src/graph.rs @@ -9,6 +9,7 @@ use std; use std::ffi::CStr; use std::ffi::CString; use std::ffi::NulError; +use std::os::raw::c_void as std_c_void; use std::ptr; use std::str::Utf8Error; use std::sync::Arc; @@ -302,7 +303,7 @@ impl Operation { pub fn output_type(&self, index: usize) -> DataType { unsafe { DataType::from_c(tf::TF_OperationOutputType(tf::TF_Output { - operation: self.inner, + oper: self.inner, index: index as c_int, })) } @@ -332,7 +333,7 @@ impl Operation { pub fn input_type(&self, index: usize) -> DataType { unsafe { DataType::from_c(tf::TF_OperationInputType(tf::TF_Input { - operation: self.inner, + oper: self.inner, index: index as c_int, })) } @@ -359,11 +360,11 @@ impl Operation { pub fn input(&self, index: usize) -> (Operation, usize) { unsafe { let port = tf::TF_OperationInput(tf::TF_Input { - operation: self.inner, + oper: self.inner, index: index as c_int, }); (Operation { - inner: port.operation, + inner: port.oper, gimpl: self.gimpl.clone(), }, port.index as usize) @@ -374,7 +375,7 @@ impl Operation { pub fn output_num_consumers(&self, index: usize) -> usize { unsafe { tf::TF_OperationOutputNumConsumers(tf::TF_Output { - operation: self.inner, + oper: self.inner, index: index as c_int, }) as usize } @@ -387,12 +388,12 @@ impl Operation { pub fn output_consumers(&self, index: usize) -> Vec<(Operation, usize)> { unsafe { let num_consumers = tf::TF_OperationOutputNumConsumers(tf::TF_Output { - operation: self.inner, + oper: self.inner, index: index as c_int, }); let mut vec = >::with_capacity(num_consumers as usize); let len = tf::TF_OperationOutputConsumers(tf::TF_Output { - operation: self.inner, + oper: self.inner, index: index as c_int, }, vec.as_mut_ptr(), @@ -401,7 +402,7 @@ impl Operation { vec.into_iter() .map(|port| { (Operation { - inner: port.operation, + inner: port.oper, gimpl: self.gimpl.clone(), }, port.index as usize) @@ -483,7 +484,7 @@ pub struct Input<'a> { impl<'a> Input<'a> { fn to_c(&self) -> tf::TF_Input { tf::TF_Input { - operation: self.operation.inner, + oper: self.operation.inner, index: self.index, } } @@ -505,7 +506,7 @@ pub struct Output<'a> { impl<'a> Output<'a> { fn to_c(&self) -> tf::TF_Output { tf::TF_Output { - operation: self.operation.inner, + oper: self.operation.inner, index: self.index, } } @@ -606,7 +607,7 @@ impl<'a> OperationDescription<'a> { unsafe { tf::TF_SetAttrString(self.inner, c_attr_name.as_ptr(), - c_value.as_ptr() as *const c_void, + c_value.as_ptr() as *const std_c_void, c_value.len() as size_t); } Ok(()) @@ -625,7 +626,7 @@ impl<'a> OperationDescription<'a> { unsafe { tf::TF_SetAttrStringList(self.inner, c_attr_name.as_ptr(), - ptrs.as_ptr(), + ptrs.as_ptr() as *const *const std_c_void, lens.as_ptr(), ptrs.len() as c_int); } @@ -821,7 +822,7 @@ impl<'a> OperationDescription<'a> { unsafe { tf::TF_SetAttrTensorShapeProto(self.inner, c_attr_name.as_ptr(), - value.as_ptr() as *const c_void, + value.as_ptr() as *const std_c_void, value.len() as size_t, status.inner()); } @@ -843,7 +844,7 @@ impl<'a> OperationDescription<'a> { unsafe { tf::TF_SetAttrTensorShapeProtoList(self.inner, c_attr_name.as_ptr(), - ptrs.as_ptr(), + ptrs.as_ptr() as *const *const std_c_void, lens.as_ptr(), ptrs.len() as c_int, status.inner()); @@ -878,7 +879,7 @@ impl<'a> OperationDescription<'a> { let ptrs: Vec<*mut tf::TF_Tensor> = value.into_iter().map(|x| x.into_ptr()).collect(); tf::TF_SetAttrTensorList(self.inner, c_attr_name.as_ptr(), - ptrs.as_ptr(), + ptrs.as_ptr() as *const *const tf::TF_Tensor, ptrs.len() as c_int, status.inner()); } @@ -893,7 +894,7 @@ impl<'a> OperationDescription<'a> { unsafe { tf::TF_SetAttrValueProto(self.inner, c_attr_name.as_ptr(), - value.as_ptr() as *const c_void, + value.as_ptr() as *const std_c_void, // Allow trivial_numeric_casts because usize is not // necessarily size_t. value.len() as size_t, diff --git a/src/lib.rs b/src/lib.rs index 90ed6be623..4b952f378e 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -30,6 +30,7 @@ use std::ops::Deref; use std::ops::DerefMut; use std::ops::Drop; use std::ops::Index; +use std::os::raw::c_void as std_c_void; use std::str::Utf8Error; //////////////////////// @@ -844,9 +845,9 @@ pub struct Tensor { owned: bool, } -unsafe extern "C" fn noop_deallocator(_: *mut c_void, _: size_t, _: *mut c_void) -> () {} +unsafe extern "C" fn noop_deallocator(_: *mut std_c_void, _: size_t, _: *mut std_c_void) -> () {} -unsafe extern "C" fn deallocator(_: *mut c_void, _: size_t, buffer: *mut c_void) -> () { +unsafe extern "C" fn deallocator(_: *mut std_c_void, _: size_t, buffer: *mut std_c_void) -> () { tf::TF_DeleteBuffer(buffer as *mut tf::TF_Buffer); } diff --git a/src/session.rs b/src/session.rs index 28a343b0d6..6cb79ac601 100644 --- a/src/session.rs +++ b/src/session.rs @@ -69,7 +69,7 @@ impl Session { tf::TF_SessionRun(self.inner, ptr::null(), step.input_ports.as_ptr(), - input_tensors.as_mut_ptr(), + input_tensors.as_ptr() as *const *const tf::TF_Tensor, input_tensors.len() as c_int, step.output_ports.as_ptr(), step.output_tensors.as_mut_ptr(), @@ -143,7 +143,7 @@ impl<'l> StepWithGraph<'l> { index: c_int, tensor: &'l Tensor) { self.input_ports.push(tf::TF_Output { - operation: operation.inner(), + oper: operation.inner(), index: index, }); self.input_tensors.push(tensor.inner); @@ -153,7 +153,7 @@ impl<'l> StepWithGraph<'l> { /// Returns an index that you can then use to fetch this output from the step after running it. pub fn request_output(&mut self, operation: &Operation, index: c_int) -> OutputToken { self.output_ports.push(tf::TF_Output { - operation: operation.inner(), + oper: operation.inner(), index: index, }); self.output_tensors.push(ptr::null_mut()); diff --git a/tensorflow-sys/examples/multiplication.rs b/tensorflow-sys/examples/multiplication.rs index 653629a5ee..ca9b1554fc 100644 --- a/tensorflow-sys/examples/multiplication.rs +++ b/tensorflow-sys/examples/multiplication.rs @@ -1,7 +1,7 @@ extern crate libc; extern crate tensorflow_sys as ffi; -use libc::{c_int, c_void, int64_t, size_t}; +use libc::{c_int, int64_t, size_t}; use std::ffi::{CStr, CString}; use std::path::Path; @@ -107,7 +107,7 @@ fn main() { ffi::TF_DeleteSessionOptions(options); } - unsafe extern "C" fn noop(_: *mut c_void, _: size_t, _: *mut c_void) {} + unsafe extern "C" fn noop(_: *mut std::os::raw::c_void, _: size_t, _: *mut std::os::raw::c_void) {} } fn read>(path: T) -> Vec { diff --git a/tensorflow-sys/generate_bindgen_rs.sh b/tensorflow-sys/generate_bindgen_rs.sh new file mode 100755 index 0000000000..c1a95f66bd --- /dev/null +++ b/tensorflow-sys/generate_bindgen_rs.sh @@ -0,0 +1,17 @@ +#!/bin/sh + +if ! which bindgen &> /dev/null; then + echo "ERROR: Please install 'bindgen' using cargo:" + echo " cargo install bindgen" + echo "See https://github.com/servo/rust-bindgen for more information." + exit 1 +fi + +# See https://github.com/servo/rust-bindgen/issues/550 as to why +# this is blacklisted. +bindgen_options="--blacklist-type max_align_t" +header="/usr/include/tensorflow/c_api.h" + +cmd="bindgen ${bindgen_options} ${header} --output src/bindgen.rs" +echo ${cmd} +${cmd} diff --git a/tensorflow-sys/src/bindgen.rs b/tensorflow-sys/src/bindgen.rs new file mode 100644 index 0000000000..2079c1950e --- /dev/null +++ b/tensorflow-sys/src/bindgen.rs @@ -0,0 +1,949 @@ +/* automatically generated by rust-bindgen */ + +pub const _STDINT_H: ::std::os::raw::c_uint = 1; +pub const _FEATURES_H: ::std::os::raw::c_uint = 1; +pub const _DEFAULT_SOURCE: ::std::os::raw::c_uint = 1; +pub const __USE_ISOC11: ::std::os::raw::c_uint = 1; +pub const __USE_ISOC99: ::std::os::raw::c_uint = 1; +pub const __USE_ISOC95: ::std::os::raw::c_uint = 1; +pub const __USE_POSIX_IMPLICITLY: ::std::os::raw::c_uint = 1; +pub const _POSIX_SOURCE: ::std::os::raw::c_uint = 1; +pub const _POSIX_C_SOURCE: ::std::os::raw::c_uint = 200809; +pub const __USE_POSIX: ::std::os::raw::c_uint = 1; +pub const __USE_POSIX2: ::std::os::raw::c_uint = 1; +pub const __USE_POSIX199309: ::std::os::raw::c_uint = 1; +pub const __USE_POSIX199506: ::std::os::raw::c_uint = 1; +pub const __USE_XOPEN2K: ::std::os::raw::c_uint = 1; +pub const __USE_XOPEN2K8: ::std::os::raw::c_uint = 1; +pub const _ATFILE_SOURCE: ::std::os::raw::c_uint = 1; +pub const __USE_MISC: ::std::os::raw::c_uint = 1; +pub const __USE_ATFILE: ::std::os::raw::c_uint = 1; +pub const __USE_FORTIFY_LEVEL: ::std::os::raw::c_uint = 0; +pub const _STDC_PREDEF_H: ::std::os::raw::c_uint = 1; +pub const __STDC_IEC_559__: ::std::os::raw::c_uint = 1; +pub const __STDC_IEC_559_COMPLEX__: ::std::os::raw::c_uint = 1; +pub const __STDC_ISO_10646__: ::std::os::raw::c_uint = 201505; +pub const __STDC_NO_THREADS__: ::std::os::raw::c_uint = 1; +pub const __GNU_LIBRARY__: ::std::os::raw::c_uint = 6; +pub const __GLIBC__: ::std::os::raw::c_uint = 2; +pub const __GLIBC_MINOR__: ::std::os::raw::c_uint = 24; +pub const _SYS_CDEFS_H: ::std::os::raw::c_uint = 1; +pub const __WORDSIZE: ::std::os::raw::c_uint = 64; +pub const __WORDSIZE_TIME64_COMPAT32: ::std::os::raw::c_uint = 1; +pub const __SYSCALL_WORDSIZE: ::std::os::raw::c_uint = 64; +pub const _BITS_WCHAR_H: ::std::os::raw::c_uint = 1; +pub const INT8_MIN: ::std::os::raw::c_int = -128; +pub const INT16_MIN: ::std::os::raw::c_int = -32768; +pub const INT32_MIN: ::std::os::raw::c_int = -2147483648; +pub const INT8_MAX: ::std::os::raw::c_uint = 127; +pub const INT16_MAX: ::std::os::raw::c_uint = 32767; +pub const INT32_MAX: ::std::os::raw::c_uint = 2147483647; +pub const UINT8_MAX: ::std::os::raw::c_uint = 255; +pub const UINT16_MAX: ::std::os::raw::c_uint = 65535; +pub const UINT32_MAX: ::std::os::raw::c_uint = 4294967295; +pub const INT_LEAST8_MIN: ::std::os::raw::c_int = -128; +pub const INT_LEAST16_MIN: ::std::os::raw::c_int = -32768; +pub const INT_LEAST32_MIN: ::std::os::raw::c_int = -2147483648; +pub const INT_LEAST8_MAX: ::std::os::raw::c_uint = 127; +pub const INT_LEAST16_MAX: ::std::os::raw::c_uint = 32767; +pub const INT_LEAST32_MAX: ::std::os::raw::c_uint = 2147483647; +pub const UINT_LEAST8_MAX: ::std::os::raw::c_uint = 255; +pub const UINT_LEAST16_MAX: ::std::os::raw::c_uint = 65535; +pub const UINT_LEAST32_MAX: ::std::os::raw::c_uint = 4294967295; +pub const INT_FAST8_MIN: ::std::os::raw::c_int = -128; +pub const INT_FAST16_MIN: ::std::os::raw::c_longlong = -9223372036854775808; +pub const INT_FAST32_MIN: ::std::os::raw::c_longlong = -9223372036854775808; +pub const INT_FAST8_MAX: ::std::os::raw::c_uint = 127; +pub const INT_FAST16_MAX: ::std::os::raw::c_ulonglong = 9223372036854775807; +pub const INT_FAST32_MAX: ::std::os::raw::c_ulonglong = 9223372036854775807; +pub const UINT_FAST8_MAX: ::std::os::raw::c_uint = 255; +pub const UINT_FAST16_MAX: ::std::os::raw::c_int = -1; +pub const UINT_FAST32_MAX: ::std::os::raw::c_int = -1; +pub const INTPTR_MIN: ::std::os::raw::c_longlong = -9223372036854775808; +pub const INTPTR_MAX: ::std::os::raw::c_ulonglong = 9223372036854775807; +pub const UINTPTR_MAX: ::std::os::raw::c_int = -1; +pub const PTRDIFF_MIN: ::std::os::raw::c_longlong = -9223372036854775808; +pub const PTRDIFF_MAX: ::std::os::raw::c_ulonglong = 9223372036854775807; +pub const SIG_ATOMIC_MIN: ::std::os::raw::c_int = -2147483648; +pub const SIG_ATOMIC_MAX: ::std::os::raw::c_uint = 2147483647; +pub const SIZE_MAX: ::std::os::raw::c_int = -1; +pub const WINT_MIN: ::std::os::raw::c_uint = 0; +pub const WINT_MAX: ::std::os::raw::c_uint = 4294967295; +pub type wchar_t = ::std::os::raw::c_int; +pub type int_least8_t = ::std::os::raw::c_char; +pub type int_least16_t = ::std::os::raw::c_short; +pub type int_least32_t = ::std::os::raw::c_int; +pub type int_least64_t = ::std::os::raw::c_long; +pub type uint_least8_t = ::std::os::raw::c_uchar; +pub type uint_least16_t = ::std::os::raw::c_ushort; +pub type uint_least32_t = ::std::os::raw::c_uint; +pub type uint_least64_t = ::std::os::raw::c_ulong; +pub type int_fast8_t = ::std::os::raw::c_char; +pub type int_fast16_t = ::std::os::raw::c_long; +pub type int_fast32_t = ::std::os::raw::c_long; +pub type int_fast64_t = ::std::os::raw::c_long; +pub type uint_fast8_t = ::std::os::raw::c_uchar; +pub type uint_fast16_t = ::std::os::raw::c_ulong; +pub type uint_fast32_t = ::std::os::raw::c_ulong; +pub type uint_fast64_t = ::std::os::raw::c_ulong; +pub type intmax_t = ::std::os::raw::c_long; +pub type uintmax_t = ::std::os::raw::c_ulong; +extern "C" { + pub fn TF_Version() -> *const ::std::os::raw::c_char; +} +pub const TF_DataType_TF_COMPLEX: TF_DataType = TF_DataType::TF_COMPLEX64; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum TF_DataType { + TF_FLOAT = 1, + TF_DOUBLE = 2, + TF_INT32 = 3, + TF_UINT8 = 4, + TF_INT16 = 5, + TF_INT8 = 6, + TF_STRING = 7, + TF_COMPLEX64 = 8, + TF_INT64 = 9, + TF_BOOL = 10, + TF_QINT8 = 11, + TF_QUINT8 = 12, + TF_QINT32 = 13, + TF_BFLOAT16 = 14, + TF_QINT16 = 15, + TF_QUINT16 = 16, + TF_UINT16 = 17, + TF_COMPLEX128 = 18, + TF_HALF = 19, + TF_RESOURCE = 20, +} +extern "C" { + pub fn TF_DataTypeSize(dt: TF_DataType) -> usize; +} +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum TF_Code { + TF_OK = 0, + TF_CANCELLED = 1, + TF_UNKNOWN = 2, + TF_INVALID_ARGUMENT = 3, + TF_DEADLINE_EXCEEDED = 4, + TF_NOT_FOUND = 5, + TF_ALREADY_EXISTS = 6, + TF_PERMISSION_DENIED = 7, + TF_UNAUTHENTICATED = 16, + TF_RESOURCE_EXHAUSTED = 8, + TF_FAILED_PRECONDITION = 9, + TF_ABORTED = 10, + TF_OUT_OF_RANGE = 11, + TF_UNIMPLEMENTED = 12, + TF_INTERNAL = 13, + TF_UNAVAILABLE = 14, + TF_DATA_LOSS = 15, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct TF_Status([u8; 0]); +extern "C" { + pub fn TF_NewStatus() -> *mut TF_Status; +} +extern "C" { + pub fn TF_DeleteStatus(arg1: *mut TF_Status); +} +extern "C" { + pub fn TF_SetStatus(s: *mut TF_Status, code: TF_Code, + msg: *const ::std::os::raw::c_char); +} +extern "C" { + pub fn TF_GetCode(s: *const TF_Status) -> TF_Code; +} +extern "C" { + pub fn TF_Message(s: *const TF_Status) -> *const ::std::os::raw::c_char; +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct TF_Buffer { + pub data: *const ::std::os::raw::c_void, + pub length: usize, + pub data_deallocator: ::std::option::Option, +} +#[test] +fn bindgen_test_layout_TF_Buffer() { + assert_eq!(::std::mem::size_of::() , 24usize , concat ! ( + "Size of: " , stringify ! ( TF_Buffer ) )); + assert_eq! (::std::mem::align_of::() , 8usize , concat ! ( + "Alignment of " , stringify ! ( TF_Buffer ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const TF_Buffer ) ) . data as * const _ as + usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( TF_Buffer ) , "::" , + stringify ! ( data ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const TF_Buffer ) ) . length as * const _ as + usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( TF_Buffer ) , "::" , + stringify ! ( length ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const TF_Buffer ) ) . data_deallocator as * + const _ as usize } , 16usize , concat ! ( + "Alignment of field: " , stringify ! ( TF_Buffer ) , "::" , + stringify ! ( data_deallocator ) )); +} +impl Clone for TF_Buffer { + fn clone(&self) -> Self { *self } +} +extern "C" { + pub fn TF_NewBufferFromString(proto: *const ::std::os::raw::c_void, + proto_len: usize) -> *mut TF_Buffer; +} +extern "C" { + pub fn TF_NewBuffer() -> *mut TF_Buffer; +} +extern "C" { + pub fn TF_DeleteBuffer(arg1: *mut TF_Buffer); +} +extern "C" { + pub fn TF_GetBuffer(buffer: *mut TF_Buffer) -> TF_Buffer; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct TF_Tensor([u8; 0]); +extern "C" { + pub fn TF_NewTensor(arg1: TF_DataType, dims: *const i64, + num_dims: ::std::os::raw::c_int, + data: *mut ::std::os::raw::c_void, len: usize, + deallocator: + ::std::option::Option, + deallocator_arg: *mut ::std::os::raw::c_void) + -> *mut TF_Tensor; +} +extern "C" { + pub fn TF_AllocateTensor(arg1: TF_DataType, dims: *const i64, + num_dims: ::std::os::raw::c_int, len: usize) + -> *mut TF_Tensor; +} +extern "C" { + pub fn TF_DeleteTensor(arg1: *mut TF_Tensor); +} +extern "C" { + pub fn TF_TensorType(arg1: *const TF_Tensor) -> TF_DataType; +} +extern "C" { + pub fn TF_NumDims(arg1: *const TF_Tensor) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn TF_Dim(tensor: *const TF_Tensor, dim_index: ::std::os::raw::c_int) + -> i64; +} +extern "C" { + pub fn TF_TensorByteSize(arg1: *const TF_Tensor) -> usize; +} +extern "C" { + pub fn TF_TensorData(arg1: *const TF_Tensor) + -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn TF_StringEncode(src: *const ::std::os::raw::c_char, src_len: usize, + dst: *mut ::std::os::raw::c_char, dst_len: usize, + status: *mut TF_Status) -> usize; +} +extern "C" { + pub fn TF_StringDecode(src: *const ::std::os::raw::c_char, src_len: usize, + dst: *mut *const ::std::os::raw::c_char, + dst_len: *mut usize, status: *mut TF_Status) + -> usize; +} +extern "C" { + pub fn TF_StringEncodedSize(len: usize) -> usize; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct TF_SessionOptions([u8; 0]); +extern "C" { + pub fn TF_NewSessionOptions() -> *mut TF_SessionOptions; +} +extern "C" { + pub fn TF_SetTarget(options: *mut TF_SessionOptions, + target: *const ::std::os::raw::c_char); +} +extern "C" { + pub fn TF_SetConfig(options: *mut TF_SessionOptions, + proto: *const ::std::os::raw::c_void, + proto_len: usize, status: *mut TF_Status); +} +extern "C" { + pub fn TF_DeleteSessionOptions(arg1: *mut TF_SessionOptions); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct TF_Graph([u8; 0]); +extern "C" { + pub fn TF_NewGraph() -> *mut TF_Graph; +} +extern "C" { + pub fn TF_DeleteGraph(arg1: *mut TF_Graph); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct TF_OperationDescription([u8; 0]); +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct TF_Operation([u8; 0]); +#[repr(C)] +#[derive(Debug, Copy)] +pub struct TF_Input { + pub oper: *mut TF_Operation, + pub index: ::std::os::raw::c_int, +} +#[test] +fn bindgen_test_layout_TF_Input() { + assert_eq!(::std::mem::size_of::() , 16usize , concat ! ( + "Size of: " , stringify ! ( TF_Input ) )); + assert_eq! (::std::mem::align_of::() , 8usize , concat ! ( + "Alignment of " , stringify ! ( TF_Input ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const TF_Input ) ) . oper as * const _ as usize + } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( TF_Input ) , "::" , + stringify ! ( oper ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const TF_Input ) ) . index as * const _ as + usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( TF_Input ) , "::" , + stringify ! ( index ) )); +} +impl Clone for TF_Input { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct TF_Output { + pub oper: *mut TF_Operation, + pub index: ::std::os::raw::c_int, +} +#[test] +fn bindgen_test_layout_TF_Output() { + assert_eq!(::std::mem::size_of::() , 16usize , concat ! ( + "Size of: " , stringify ! ( TF_Output ) )); + assert_eq! (::std::mem::align_of::() , 8usize , concat ! ( + "Alignment of " , stringify ! ( TF_Output ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const TF_Output ) ) . oper as * const _ as + usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( TF_Output ) , "::" , + stringify ! ( oper ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const TF_Output ) ) . index as * const _ as + usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( TF_Output ) , "::" , + stringify ! ( index ) )); +} +impl Clone for TF_Output { + fn clone(&self) -> Self { *self } +} +extern "C" { + pub fn TF_GraphSetTensorShape(graph: *mut TF_Graph, output: TF_Output, + dims: *const i64, + num_dims: ::std::os::raw::c_int, + status: *mut TF_Status); +} +extern "C" { + pub fn TF_GraphGetTensorNumDims(graph: *mut TF_Graph, output: TF_Output, + status: *mut TF_Status) + -> ::std::os::raw::c_int; +} +extern "C" { + pub fn TF_GraphGetTensorShape(graph: *mut TF_Graph, output: TF_Output, + dims: *mut i64, + num_dims: ::std::os::raw::c_int, + status: *mut TF_Status); +} +extern "C" { + pub fn TF_NewOperation(graph: *mut TF_Graph, + op_type: *const ::std::os::raw::c_char, + oper_name: *const ::std::os::raw::c_char) + -> *mut TF_OperationDescription; +} +extern "C" { + pub fn TF_SetDevice(desc: *mut TF_OperationDescription, + device: *const ::std::os::raw::c_char); +} +extern "C" { + pub fn TF_AddInput(desc: *mut TF_OperationDescription, input: TF_Output); +} +extern "C" { + pub fn TF_AddInputList(desc: *mut TF_OperationDescription, + inputs: *const TF_Output, + num_inputs: ::std::os::raw::c_int); +} +extern "C" { + pub fn TF_AddControlInput(desc: *mut TF_OperationDescription, + input: *mut TF_Operation); +} +extern "C" { + pub fn TF_ColocateWith(desc: *mut TF_OperationDescription, + op: *mut TF_Operation); +} +extern "C" { + pub fn TF_SetAttrString(desc: *mut TF_OperationDescription, + attr_name: *const ::std::os::raw::c_char, + value: *const ::std::os::raw::c_void, + length: usize); +} +extern "C" { + pub fn TF_SetAttrStringList(desc: *mut TF_OperationDescription, + attr_name: *const ::std::os::raw::c_char, + values: *const *const ::std::os::raw::c_void, + lengths: *const usize, + num_values: ::std::os::raw::c_int); +} +extern "C" { + pub fn TF_SetAttrInt(desc: *mut TF_OperationDescription, + attr_name: *const ::std::os::raw::c_char, + value: i64); +} +extern "C" { + pub fn TF_SetAttrIntList(desc: *mut TF_OperationDescription, + attr_name: *const ::std::os::raw::c_char, + values: *const i64, + num_values: ::std::os::raw::c_int); +} +extern "C" { + pub fn TF_SetAttrFloat(desc: *mut TF_OperationDescription, + attr_name: *const ::std::os::raw::c_char, + value: f32); +} +extern "C" { + pub fn TF_SetAttrFloatList(desc: *mut TF_OperationDescription, + attr_name: *const ::std::os::raw::c_char, + values: *const f32, + num_values: ::std::os::raw::c_int); +} +extern "C" { + pub fn TF_SetAttrBool(desc: *mut TF_OperationDescription, + attr_name: *const ::std::os::raw::c_char, + value: ::std::os::raw::c_uchar); +} +extern "C" { + pub fn TF_SetAttrBoolList(desc: *mut TF_OperationDescription, + attr_name: *const ::std::os::raw::c_char, + values: *const ::std::os::raw::c_uchar, + num_values: ::std::os::raw::c_int); +} +extern "C" { + pub fn TF_SetAttrType(desc: *mut TF_OperationDescription, + attr_name: *const ::std::os::raw::c_char, + value: TF_DataType); +} +extern "C" { + pub fn TF_SetAttrTypeList(desc: *mut TF_OperationDescription, + attr_name: *const ::std::os::raw::c_char, + values: *const TF_DataType, + num_values: ::std::os::raw::c_int); +} +extern "C" { + pub fn TF_SetAttrShape(desc: *mut TF_OperationDescription, + attr_name: *const ::std::os::raw::c_char, + dims: *const i64, num_dims: ::std::os::raw::c_int); +} +extern "C" { + pub fn TF_SetAttrShapeList(desc: *mut TF_OperationDescription, + attr_name: *const ::std::os::raw::c_char, + dims: *const *const i64, + num_dims: *const ::std::os::raw::c_int, + num_shapes: ::std::os::raw::c_int); +} +extern "C" { + pub fn TF_SetAttrTensorShapeProto(desc: *mut TF_OperationDescription, + attr_name: + *const ::std::os::raw::c_char, + proto: *const ::std::os::raw::c_void, + proto_len: usize, + status: *mut TF_Status); +} +extern "C" { + pub fn TF_SetAttrTensorShapeProtoList(desc: *mut TF_OperationDescription, + attr_name: + *const ::std::os::raw::c_char, + protos: + *const *const ::std::os::raw::c_void, + proto_lens: *const usize, + num_shapes: ::std::os::raw::c_int, + status: *mut TF_Status); +} +extern "C" { + pub fn TF_SetAttrTensor(desc: *mut TF_OperationDescription, + attr_name: *const ::std::os::raw::c_char, + value: *mut TF_Tensor, status: *mut TF_Status); +} +extern "C" { + pub fn TF_SetAttrTensorList(desc: *mut TF_OperationDescription, + attr_name: *const ::std::os::raw::c_char, + values: *const *const TF_Tensor, + num_values: ::std::os::raw::c_int, + status: *mut TF_Status); +} +extern "C" { + pub fn TF_SetAttrValueProto(desc: *mut TF_OperationDescription, + attr_name: *const ::std::os::raw::c_char, + proto: *const ::std::os::raw::c_void, + proto_len: usize, status: *mut TF_Status); +} +extern "C" { + pub fn TF_FinishOperation(desc: *mut TF_OperationDescription, + status: *mut TF_Status) -> *mut TF_Operation; +} +extern "C" { + pub fn TF_OperationName(oper: *mut TF_Operation) + -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn TF_OperationOpType(oper: *mut TF_Operation) + -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn TF_OperationDevice(oper: *mut TF_Operation) + -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn TF_OperationNumOutputs(oper: *mut TF_Operation) + -> ::std::os::raw::c_int; +} +extern "C" { + pub fn TF_OperationOutputType(oper_out: TF_Output) -> TF_DataType; +} +extern "C" { + pub fn TF_OperationOutputListLength(oper: *mut TF_Operation, + arg_name: + *const ::std::os::raw::c_char, + status: *mut TF_Status) + -> ::std::os::raw::c_int; +} +extern "C" { + pub fn TF_OperationNumInputs(oper: *mut TF_Operation) + -> ::std::os::raw::c_int; +} +extern "C" { + pub fn TF_OperationInputType(oper_in: TF_Input) -> TF_DataType; +} +extern "C" { + pub fn TF_OperationInputListLength(oper: *mut TF_Operation, + arg_name: + *const ::std::os::raw::c_char, + status: *mut TF_Status) + -> ::std::os::raw::c_int; +} +extern "C" { + pub fn TF_OperationInput(oper_in: TF_Input) -> TF_Output; +} +extern "C" { + pub fn TF_OperationOutputNumConsumers(oper_out: TF_Output) + -> ::std::os::raw::c_int; +} +extern "C" { + pub fn TF_OperationOutputConsumers(oper_out: TF_Output, + consumers: *mut TF_Input, + max_consumers: ::std::os::raw::c_int) + -> ::std::os::raw::c_int; +} +extern "C" { + pub fn TF_OperationNumControlInputs(oper: *mut TF_Operation) + -> ::std::os::raw::c_int; +} +extern "C" { + pub fn TF_OperationGetControlInputs(oper: *mut TF_Operation, + control_inputs: + *mut *mut TF_Operation, + max_control_inputs: + ::std::os::raw::c_int) + -> ::std::os::raw::c_int; +} +extern "C" { + pub fn TF_OperationNumControlOutputs(oper: *mut TF_Operation) + -> ::std::os::raw::c_int; +} +extern "C" { + pub fn TF_OperationGetControlOutputs(oper: *mut TF_Operation, + control_outputs: + *mut *mut TF_Operation, + max_control_outputs: + ::std::os::raw::c_int) + -> ::std::os::raw::c_int; +} +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum TF_AttrType { + TF_ATTR_STRING = 0, + TF_ATTR_INT = 1, + TF_ATTR_FLOAT = 2, + TF_ATTR_BOOL = 3, + TF_ATTR_TYPE = 4, + TF_ATTR_SHAPE = 5, + TF_ATTR_TENSOR = 6, + TF_ATTR_PLACEHOLDER = 7, + TF_ATTR_FUNC = 8, +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct TF_AttrMetadata { + pub is_list: ::std::os::raw::c_uchar, + pub list_size: i64, + pub type_: TF_AttrType, + pub total_size: i64, +} +#[test] +fn bindgen_test_layout_TF_AttrMetadata() { + assert_eq!(::std::mem::size_of::() , 32usize , concat ! ( + "Size of: " , stringify ! ( TF_AttrMetadata ) )); + assert_eq! (::std::mem::align_of::() , 8usize , concat ! + ( "Alignment of " , stringify ! ( TF_AttrMetadata ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const TF_AttrMetadata ) ) . is_list as * const + _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( TF_AttrMetadata ) , + "::" , stringify ! ( is_list ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const TF_AttrMetadata ) ) . list_size as * + const _ as usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( TF_AttrMetadata ) , + "::" , stringify ! ( list_size ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const TF_AttrMetadata ) ) . type_ as * const _ + as usize } , 16usize , concat ! ( + "Alignment of field: " , stringify ! ( TF_AttrMetadata ) , + "::" , stringify ! ( type_ ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const TF_AttrMetadata ) ) . total_size as * + const _ as usize } , 24usize , concat ! ( + "Alignment of field: " , stringify ! ( TF_AttrMetadata ) , + "::" , stringify ! ( total_size ) )); +} +impl Clone for TF_AttrMetadata { + fn clone(&self) -> Self { *self } +} +extern "C" { + pub fn TF_OperationGetAttrMetadata(oper: *mut TF_Operation, + attr_name: + *const ::std::os::raw::c_char, + status: *mut TF_Status) + -> TF_AttrMetadata; +} +extern "C" { + pub fn TF_OperationGetAttrString(oper: *mut TF_Operation, + attr_name: *const ::std::os::raw::c_char, + value: *mut ::std::os::raw::c_void, + max_length: usize, + status: *mut TF_Status); +} +extern "C" { + pub fn TF_OperationGetAttrStringList(oper: *mut TF_Operation, + attr_name: + *const ::std::os::raw::c_char, + values: + *mut *mut ::std::os::raw::c_void, + lengths: *mut usize, + max_values: ::std::os::raw::c_int, + storage: *mut ::std::os::raw::c_void, + storage_size: usize, + status: *mut TF_Status); +} +extern "C" { + pub fn TF_OperationGetAttrInt(oper: *mut TF_Operation, + attr_name: *const ::std::os::raw::c_char, + value: *mut i64, status: *mut TF_Status); +} +extern "C" { + pub fn TF_OperationGetAttrIntList(oper: *mut TF_Operation, + attr_name: + *const ::std::os::raw::c_char, + values: *mut i64, + max_values: ::std::os::raw::c_int, + status: *mut TF_Status); +} +extern "C" { + pub fn TF_OperationGetAttrFloat(oper: *mut TF_Operation, + attr_name: *const ::std::os::raw::c_char, + value: *mut f32, status: *mut TF_Status); +} +extern "C" { + pub fn TF_OperationGetAttrFloatList(oper: *mut TF_Operation, + attr_name: + *const ::std::os::raw::c_char, + values: *mut f32, + max_values: ::std::os::raw::c_int, + status: *mut TF_Status); +} +extern "C" { + pub fn TF_OperationGetAttrBool(oper: *mut TF_Operation, + attr_name: *const ::std::os::raw::c_char, + value: *mut ::std::os::raw::c_uchar, + status: *mut TF_Status); +} +extern "C" { + pub fn TF_OperationGetAttrBoolList(oper: *mut TF_Operation, + attr_name: + *const ::std::os::raw::c_char, + values: *mut ::std::os::raw::c_uchar, + max_values: ::std::os::raw::c_int, + status: *mut TF_Status); +} +extern "C" { + pub fn TF_OperationGetAttrType(oper: *mut TF_Operation, + attr_name: *const ::std::os::raw::c_char, + value: *mut TF_DataType, + status: *mut TF_Status); +} +extern "C" { + pub fn TF_OperationGetAttrTypeList(oper: *mut TF_Operation, + attr_name: + *const ::std::os::raw::c_char, + values: *mut TF_DataType, + max_values: ::std::os::raw::c_int, + status: *mut TF_Status); +} +extern "C" { + pub fn TF_OperationGetAttrShape(oper: *mut TF_Operation, + attr_name: *const ::std::os::raw::c_char, + value: *mut i64, + num_dims: ::std::os::raw::c_int, + status: *mut TF_Status); +} +extern "C" { + pub fn TF_OperationGetAttrShapeList(oper: *mut TF_Operation, + attr_name: + *const ::std::os::raw::c_char, + dims: *mut *mut i64, + num_dims: *mut ::std::os::raw::c_int, + num_shapes: ::std::os::raw::c_int, + storage: *mut i64, + storage_size: ::std::os::raw::c_int, + status: *mut TF_Status); +} +extern "C" { + pub fn TF_OperationGetAttrTensorShapeProto(oper: *mut TF_Operation, + attr_name: + *const ::std::os::raw::c_char, + value: *mut TF_Buffer, + status: *mut TF_Status); +} +extern "C" { + pub fn TF_OperationGetAttrTensorShapeProtoList(oper: *mut TF_Operation, + attr_name: + *const ::std::os::raw::c_char, + values: + *mut *mut TF_Buffer, + max_values: + ::std::os::raw::c_int, + status: *mut TF_Status); +} +extern "C" { + pub fn TF_OperationGetAttrTensor(oper: *mut TF_Operation, + attr_name: *const ::std::os::raw::c_char, + value: *mut *mut TF_Tensor, + status: *mut TF_Status); +} +extern "C" { + pub fn TF_OperationGetAttrTensorList(oper: *mut TF_Operation, + attr_name: + *const ::std::os::raw::c_char, + values: *mut *mut TF_Tensor, + max_values: ::std::os::raw::c_int, + status: *mut TF_Status); +} +extern "C" { + pub fn TF_OperationGetAttrValueProto(oper: *mut TF_Operation, + attr_name: + *const ::std::os::raw::c_char, + output_attr_value: *mut TF_Buffer, + status: *mut TF_Status); +} +extern "C" { + pub fn TF_GraphOperationByName(graph: *mut TF_Graph, + oper_name: *const ::std::os::raw::c_char) + -> *mut TF_Operation; +} +extern "C" { + pub fn TF_GraphNextOperation(graph: *mut TF_Graph, pos: *mut usize) + -> *mut TF_Operation; +} +extern "C" { + pub fn TF_GraphToGraphDef(graph: *mut TF_Graph, + output_graph_def: *mut TF_Buffer, + status: *mut TF_Status); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct TF_ImportGraphDefOptions([u8; 0]); +extern "C" { + pub fn TF_NewImportGraphDefOptions() -> *mut TF_ImportGraphDefOptions; +} +extern "C" { + pub fn TF_DeleteImportGraphDefOptions(opts: + *mut TF_ImportGraphDefOptions); +} +extern "C" { + pub fn TF_ImportGraphDefOptionsSetPrefix(opts: + *mut TF_ImportGraphDefOptions, + prefix: + *const ::std::os::raw::c_char); +} +extern "C" { + pub fn TF_GraphImportGraphDef(graph: *mut TF_Graph, + graph_def: *const TF_Buffer, + options: *const TF_ImportGraphDefOptions, + status: *mut TF_Status); +} +extern "C" { + pub fn TF_OperationToNodeDef(oper: *mut TF_Operation, + output_node_def: *mut TF_Buffer, + status: *mut TF_Status); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct TF_Session([u8; 0]); +extern "C" { + pub fn TF_NewSession(graph: *mut TF_Graph, opts: *const TF_SessionOptions, + status: *mut TF_Status) -> *mut TF_Session; +} +extern "C" { + pub fn TF_LoadSessionFromSavedModel(session_options: + *const TF_SessionOptions, + run_options: *const TF_Buffer, + export_dir: + *const ::std::os::raw::c_char, + tags: + *const *const ::std::os::raw::c_char, + tags_len: ::std::os::raw::c_int, + graph: *mut TF_Graph, + meta_graph_def: *mut TF_Buffer, + status: *mut TF_Status) + -> *mut TF_Session; +} +extern "C" { + pub fn TF_CloseSession(arg1: *mut TF_Session, status: *mut TF_Status); +} +extern "C" { + pub fn TF_DeleteSession(arg1: *mut TF_Session, status: *mut TF_Status); +} +extern "C" { + pub fn TF_SessionRun(session: *mut TF_Session, + run_options: *const TF_Buffer, + inputs: *const TF_Output, + input_values: *const *const TF_Tensor, + ninputs: ::std::os::raw::c_int, + outputs: *const TF_Output, + output_values: *mut *mut TF_Tensor, + noutputs: ::std::os::raw::c_int, + target_opers: *const *const TF_Operation, + ntargets: ::std::os::raw::c_int, + run_metadata: *mut TF_Buffer, arg1: *mut TF_Status); +} +extern "C" { + pub fn TF_SessionPRunSetup(arg1: *mut TF_Session, + inputs: *const TF_Output, + ninputs: ::std::os::raw::c_int, + outputs: *const TF_Output, + noutputs: ::std::os::raw::c_int, + target_opers: *const *const TF_Operation, + ntargets: ::std::os::raw::c_int, + handle: *mut *const ::std::os::raw::c_char, + arg2: *mut TF_Status); +} +extern "C" { + pub fn TF_SessionPRun(arg1: *mut TF_Session, + handle: *const ::std::os::raw::c_char, + inputs: *const TF_Output, + input_values: *const *const TF_Tensor, + ninputs: ::std::os::raw::c_int, + outputs: *const TF_Output, + output_values: *mut *mut TF_Tensor, + noutputs: ::std::os::raw::c_int, + target_opers: *const *const TF_Operation, + ntargets: ::std::os::raw::c_int, + arg2: *mut TF_Status); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct TF_DeprecatedSession([u8; 0]); +extern "C" { + pub fn TF_NewDeprecatedSession(arg1: *const TF_SessionOptions, + status: *mut TF_Status) + -> *mut TF_DeprecatedSession; +} +extern "C" { + pub fn TF_CloseDeprecatedSession(arg1: *mut TF_DeprecatedSession, + status: *mut TF_Status); +} +extern "C" { + pub fn TF_DeleteDeprecatedSession(arg1: *mut TF_DeprecatedSession, + status: *mut TF_Status); +} +extern "C" { + pub fn TF_Reset(opt: *const TF_SessionOptions, + containers: *mut *const ::std::os::raw::c_char, + ncontainers: ::std::os::raw::c_int, + status: *mut TF_Status); +} +extern "C" { + pub fn TF_ExtendGraph(arg1: *mut TF_DeprecatedSession, + proto: *const ::std::os::raw::c_void, + proto_len: usize, arg2: *mut TF_Status); +} +extern "C" { + pub fn TF_Run(arg1: *mut TF_DeprecatedSession, + run_options: *const TF_Buffer, + input_names: *mut *const ::std::os::raw::c_char, + inputs: *mut *mut TF_Tensor, ninputs: ::std::os::raw::c_int, + output_names: *mut *const ::std::os::raw::c_char, + outputs: *mut *mut TF_Tensor, + noutputs: ::std::os::raw::c_int, + target_oper_names: *mut *const ::std::os::raw::c_char, + ntargets: ::std::os::raw::c_int, + run_metadata: *mut TF_Buffer, arg2: *mut TF_Status); +} +extern "C" { + pub fn TF_PRunSetup(arg1: *mut TF_DeprecatedSession, + input_names: *mut *const ::std::os::raw::c_char, + ninputs: ::std::os::raw::c_int, + output_names: *mut *const ::std::os::raw::c_char, + noutputs: ::std::os::raw::c_int, + target_oper_names: *mut *const ::std::os::raw::c_char, + ntargets: ::std::os::raw::c_int, + handle: *mut *const ::std::os::raw::c_char, + arg2: *mut TF_Status); +} +extern "C" { + pub fn TF_PRun(arg1: *mut TF_DeprecatedSession, + handle: *const ::std::os::raw::c_char, + input_names: *mut *const ::std::os::raw::c_char, + inputs: *mut *mut TF_Tensor, + ninputs: ::std::os::raw::c_int, + output_names: *mut *const ::std::os::raw::c_char, + outputs: *mut *mut TF_Tensor, + noutputs: ::std::os::raw::c_int, + target_oper_names: *mut *const ::std::os::raw::c_char, + ntargets: ::std::os::raw::c_int, arg2: *mut TF_Status); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct TF_Library([u8; 0]); +extern "C" { + pub fn TF_LoadLibrary(library_filename: *const ::std::os::raw::c_char, + status: *mut TF_Status) -> *mut TF_Library; +} +extern "C" { + pub fn TF_GetOpList(lib_handle: *mut TF_Library) -> TF_Buffer; +} +extern "C" { + pub fn TF_DeleteLibraryHandle(lib_handle: *mut TF_Library); +} +extern "C" { + pub fn TF_GetAllOpList() -> *mut TF_Buffer; +} diff --git a/tensorflow-sys/src/lib.rs b/tensorflow-sys/src/lib.rs index 438c4933ff..eaf6ea0206 100644 --- a/tensorflow-sys/src/lib.rs +++ b/tensorflow-sys/src/lib.rs @@ -1,559 +1,9 @@ -//! Binding to [TensorFlow][1]. -//! -//! [1]: https://www.tensorflow.org - #![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] -extern crate libc; - -use libc::{c_char, c_uchar, c_int, c_void, int64_t, size_t, c_float}; +include!("bindgen.rs"); -#[repr(C)] -#[derive(Clone, Copy, Debug)] -pub struct TF_Buffer { - pub data: *const c_void, - pub length: size_t, - pub data_deallocator: Option, -} - -#[repr(C)] -#[derive(Clone, Copy, Debug, Eq, PartialEq)] -pub enum TF_Code { - TF_OK = 0, - TF_CANCELLED = 1, - TF_UNKNOWN = 2, - TF_INVALID_ARGUMENT = 3, - TF_DEADLINE_EXCEEDED = 4, - TF_NOT_FOUND = 5, - TF_ALREADY_EXISTS = 6, - TF_PERMISSION_DENIED = 7, - TF_UNAUTHENTICATED = 16, - TF_RESOURCE_EXHAUSTED = 8, - TF_FAILED_PRECONDITION = 9, - TF_ABORTED = 10, - TF_OUT_OF_RANGE = 11, - TF_UNIMPLEMENTED = 12, - TF_INTERNAL = 13, - TF_UNAVAILABLE = 14, - TF_DATA_LOSS = 15, -} pub use TF_Code::*; - -#[repr(C)] -#[derive(Clone, Copy, Debug, Eq, PartialEq)] -pub enum TF_DataType { - TF_FLOAT = 1, - TF_DOUBLE = 2, - TF_INT32 = 3, - TF_UINT8 = 4, - TF_INT16 = 5, - TF_INT8 = 6, - TF_STRING = 7, - TF_COMPLEX64 = 8, - TF_INT64 = 9, - TF_BOOL = 10, - TF_QINT8 = 11, - TF_QUINT8 = 12, - TF_QINT32 = 13, - TF_BFLOAT16 = 14, - TF_QINT16 = 15, - TF_QUINT16 = 16, - TF_UINT16 = 17, - TF_COMPLEX128 = 18, - TF_HALF = 19, - TF_RESOURCE = 20, -} pub use TF_DataType::*; - -#[derive(Clone, Copy, Debug)] -pub enum TF_Library {} - -#[derive(Clone, Copy, Debug)] -#[deprecated(since="0.5.0", note="Use TF_Session instead.")] -pub enum TF_DeprecatedSession {} - -#[derive(Clone, Copy, Debug)] -pub enum TF_SessionOptions {} - -#[derive(Clone, Copy, Debug)] -pub enum TF_Status {} - -#[derive(Clone, Copy, Debug)] -pub enum TF_Tensor {} - -#[derive(Clone, Copy, Debug)] -pub enum TF_Graph {} - -#[derive(Clone, Copy, Debug)] -pub enum TF_OperationDescription {} - -#[derive(Clone, Copy, Debug)] -pub enum TF_Operation {} - -#[derive(Clone, Copy, Debug)] -#[repr(C)] -pub struct TF_Input { - pub operation: *mut TF_Operation, - pub index: c_int, -} - -#[derive(Clone, Copy, Debug)] -#[repr(C)] -pub struct TF_Output { - pub operation: *mut TF_Operation, - pub index: c_int, -} - -#[derive(Clone, Copy, Debug)] -pub enum TF_Session {} - -#[derive(Clone, Copy, Debug, Eq, PartialEq)] -#[repr(C)] -pub enum TF_AttrType { - TF_ATTR_STRING = 0, - TF_ATTR_INT = 1, - TF_ATTR_FLOAT = 2, - TF_ATTR_BOOL = 3, - TF_ATTR_TYPE = 4, - TF_ATTR_SHAPE = 5, - TF_ATTR_TENSOR = 6, - TF_ATTR_PLACEHOLDER = 7, - TF_ATTR_FUNC = 8, -} pub use TF_AttrType::*; - -#[derive(Clone, Copy, Debug, Eq, PartialEq)] -#[repr(C)] -pub struct TF_AttrMetadata { - pub is_list: c_uchar, - pub list_size: int64_t, - pub type_: TF_AttrType, - pub total_size: int64_t, -} - -#[derive(Clone, Copy, Debug)] -pub enum TF_ImportGraphDefOptions {} - -extern "C" { - pub fn TF_NewBuffer() -> *mut TF_Buffer; - pub fn TF_NewBufferFromString(proto: *const c_void, length: size_t) -> *mut TF_Buffer; - pub fn TF_DeleteBuffer(buffer: *mut TF_Buffer); - pub fn TF_GetBuffer(buffer: *mut TF_Buffer) -> TF_Buffer; -} - -extern "C" { - pub fn TF_LoadLibrary(name: *const c_char, status: *mut TF_Status) -> *mut TF_Library; - pub fn TF_DeleteLibraryHandle(lib_handle: *mut TF_Library); - pub fn TF_GetOpList(library: *mut TF_Library) -> TF_Buffer; - pub fn TF_GetAllOpList() -> *mut TF_Buffer; -} - -extern "C" { - #[allow(deprecated)] - #[deprecated(since="0.5.0", note="Use TF_NewSession instead.")] - pub fn TF_NewDeprecatedSession(options: *const TF_SessionOptions, - status: *mut TF_Status) - -> *mut TF_DeprecatedSession; - #[allow(deprecated)] - #[deprecated(since="0.5.0", note="Use TF_DeleteSession instead.")] - pub fn TF_DeleteDeprecatedSession(session: *mut TF_DeprecatedSession, status: *mut TF_Status); - pub fn TF_Reset(opt: *const TF_SessionOptions, - containers: *const *const c_char, - ncontainers: c_int, - status: *mut TF_Status); - #[allow(deprecated)] - #[deprecated(since="0.5.0", note="Use TF_CloseSession instead.")] - pub fn TF_CloseDeprecatedSession(session: *mut TF_DeprecatedSession, status: *mut TF_Status); - #[allow(deprecated)] - #[deprecated(since="0.5.0", note="Use TF_Session API instead.")] - pub fn TF_ExtendGraph(session: *mut TF_DeprecatedSession, - proto: *const c_void, - length: size_t, - status: *mut TF_Status); - #[allow(deprecated)] - #[deprecated(since="0.5.0", note="Use TF_SessionRun instead.")] - pub fn TF_Run(session: *mut TF_DeprecatedSession, - run_options: *const TF_Buffer, - input_names: *mut *const c_char, - inputs: *mut *mut TF_Tensor, - ninputs: c_int, - output_names: *mut *const c_char, - outputs: *mut *mut TF_Tensor, - noutputs: c_int, - target_names: *mut *const c_char, - ntargets: c_int, - run_metadata: *mut TF_Buffer, - status: *mut TF_Status); - #[allow(deprecated)] - #[deprecated(since="0.5.0", note="Use TF_SessionPRunSetup instead.")] - pub fn TF_PRunSetup(session: *mut TF_DeprecatedSession, - input_names: *mut *const c_char, - ninputs: c_int, - output_names: *mut *const c_char, - noutputs: c_int, - target_names: *mut *const c_char, - ntargets: c_int, - handle: *mut *const c_char, - status: *mut TF_Status); - #[allow(deprecated)] - #[deprecated(since="0.5.0", note="Use TF_SessionPRun instead.")] - pub fn TF_PRun(session: *mut TF_DeprecatedSession, - handle: *const c_char, - input_names: *mut *const c_char, - inputs: *mut *mut TF_Tensor, - ninputs: c_int, - output_names: *mut *const c_char, - outputs: *mut *mut TF_Tensor, - noutputs: c_int, - target_names: *mut *const c_char, - ntargets: c_int, - status: *mut TF_Status); -} - -extern "C" { - pub fn TF_NewSessionOptions() -> *mut TF_SessionOptions; - pub fn TF_DeleteSessionOptions(options: *mut TF_SessionOptions); - pub fn TF_SetTarget(options: *mut TF_SessionOptions, target: *const c_char); - pub fn TF_SetConfig(options: *mut TF_SessionOptions, - proto: *const c_void, - length: size_t, - status: *mut TF_Status); -} - -extern "C" { - pub fn TF_NewStatus() -> *mut TF_Status; - pub fn TF_DeleteStatus(status: *mut TF_Status); - pub fn TF_SetStatus(status: *mut TF_Status, code: TF_Code, message: *const c_char); - pub fn TF_GetCode(status: *const TF_Status) -> TF_Code; - pub fn TF_Message(status: *const TF_Status) -> *const c_char; -} - -extern "C" { - pub fn TF_NewTensor(datatype: TF_DataType, - dims: *const int64_t, - ndims: c_int, - data: *mut c_void, - length: size_t, - deallocator: Option, - deallocator_arg: *mut c_void) - -> *mut TF_Tensor; - pub fn TF_AllocateTensor(datatype: TF_DataType, - dims: *const int64_t, - num_dims: c_int, - len: size_t) - -> *mut TF_Tensor; - pub fn TF_DeleteTensor(tensor: *mut TF_Tensor); - pub fn TF_TensorType(tensor: *const TF_Tensor) -> TF_DataType; - pub fn TF_NumDims(tensor: *const TF_Tensor) -> c_int; - pub fn TF_Dim(tensor: *const TF_Tensor, index: c_int) -> int64_t; - pub fn TF_TensorByteSize(tensor: *const TF_Tensor) -> size_t; - pub fn TF_TensorData(tensor: *const TF_Tensor) -> *mut c_void; -} - -extern "C" { - pub fn TF_NewGraph() -> *mut TF_Graph; - pub fn TF_DeleteGraph(graph: *mut TF_Graph); - pub fn TF_NewOperation(graph: *mut TF_Graph, - op_type: *const c_char, - operation_name: *const c_char) - -> *mut TF_OperationDescription; - pub fn TF_SetDevice(desc: *mut TF_OperationDescription, device: *const c_char); - pub fn TF_AddInput(desc: *mut TF_OperationDescription, input: TF_Output); - pub fn TF_AddInputList(desc: *mut TF_OperationDescription, - inputs: *const TF_Output, - num_inputs: c_int); - pub fn TF_AddControlInput(desc: *mut TF_OperationDescription, input: *mut TF_Operation); - pub fn TF_SetAttrString(desc: *mut TF_OperationDescription, - attr_name: *const c_char, - value: *const c_void, - length: size_t); - pub fn TF_SetAttrStringList(desc: *mut TF_OperationDescription, - attr_name: *const c_char, - values: *const *const c_void, - lengths: *const size_t, - num_values: c_int); - pub fn TF_SetAttrInt(desc: *mut TF_OperationDescription, - attr_name: *const c_char, - value: int64_t); - pub fn TF_SetAttrIntList(desc: *mut TF_OperationDescription, - attr_name: *const c_char, - values: *const int64_t, - num_values: c_int); - pub fn TF_SetAttrFloat(desc: *mut TF_OperationDescription, - attr_name: *const c_char, - value: c_float); - pub fn TF_SetAttrFloatList(desc: *mut TF_OperationDescription, - attr_name: *const c_char, - values: *const c_float, - num_values: c_int); - pub fn TF_SetAttrBool(desc: *mut TF_OperationDescription, - attr_name: *const c_char, - value: c_uchar); - pub fn TF_SetAttrBoolList(desc: *mut TF_OperationDescription, - attr_name: *const c_char, - values: *const c_uchar, - num_values: c_int); - pub fn TF_SetAttrType(desc: *mut TF_OperationDescription, - attr_name: *const c_char, - value: TF_DataType); - pub fn TF_SetAttrTypeList(desc: *mut TF_OperationDescription, - attr_name: *const c_char, - values: *const TF_DataType, - num_values: c_int); - pub fn TF_SetAttrShape(desc: *mut TF_OperationDescription, - attr_name: *const c_char, - dims: *const int64_t, - num_dims: c_int); - pub fn TF_SetAttrShapeList(desc: *mut TF_OperationDescription, - attr_name: *const c_char, - dims: *const *const int64_t, - num_dims: *const c_int, - num_shapes: c_int); - pub fn TF_SetAttrTensorShapeProto(desc: *mut TF_OperationDescription, - attr_name: *const c_char, - proto: *const c_void, - proto_len: size_t, - status: *mut TF_Status); - pub fn TF_SetAttrTensorShapeProtoList(desc: *mut TF_OperationDescription, - attr_name: *const c_char, - protos: *const *const c_void, - proto_lens: *const size_t, - num_shapes: c_int, - status: *mut TF_Status); - pub fn TF_SetAttrTensor(desc: *mut TF_OperationDescription, - attr_name: *const c_char, - value: *mut TF_Tensor, - status: *mut TF_Status); - pub fn TF_SetAttrTensorList(desc: *mut TF_OperationDescription, - attr_name: *const c_char, - values: *const *mut TF_Tensor, - num_values: c_int, - status: *mut TF_Status); - pub fn TF_SetAttrValueProto(desc: *mut TF_OperationDescription, - attr_name: *const c_char, - proto: *const c_void, - proto_len: size_t, - status: *mut TF_Status); - pub fn TF_FinishOperation(desc: *mut TF_OperationDescription, - status: *mut TF_Status) - -> *mut TF_Operation; - pub fn TF_OperationName(operation: *mut TF_Operation) -> *const c_char; - pub fn TF_OperationOpType(operation: *mut TF_Operation) -> *const c_char; - pub fn TF_OperationDevice(operation: *mut TF_Operation) -> *const c_char; - pub fn TF_OperationNumOutputs(operation: *mut TF_Operation) -> c_int; - pub fn TF_OperationOutputType(operation_out: TF_Output) -> TF_DataType; - pub fn TF_OperationOutputListLength(operation: *mut TF_Operation, - arg_name: *const c_char, - status: *mut TF_Status) - -> c_int; - pub fn TF_OperationNumInputs(operation: *mut TF_Operation) -> c_int; - pub fn TF_OperationInputType(operation_in: TF_Input) -> TF_DataType; - pub fn TF_OperationInputListLength(operation: *mut TF_Operation, - arg_name: *const c_char, - status: *mut TF_Status) - -> c_int; - pub fn TF_OperationInput(operation_in: TF_Input) -> TF_Output; - pub fn TF_OperationOutputNumConsumers(operation_out: TF_Output) -> c_int; - pub fn TF_OperationOutputConsumers(operation_out: TF_Output, - consumers: *mut TF_Input, - max_consumers: c_int) - -> c_int; - pub fn TF_OperationNumControlInputs(operation: *mut TF_Operation) -> c_int; - pub fn TF_OperationGetControlInputs(operation: *mut TF_Operation, - control_inputs: *mut *mut TF_Operation, - max_control_inputs: c_int) - -> c_int; - pub fn TF_OperationNumControlOutputs(operation: *mut TF_Operation) -> c_int; - pub fn TF_OperationGetControlOutputs(operation: *mut TF_Operation, - control_outputs: *mut *mut TF_Operation, - max_control_outputs: c_int) - -> c_int; - pub fn TF_OperationGetAttrValueProto(operation: *mut TF_Operation, - attr_name: *const c_char, - output_attr_value: *mut TF_Buffer, - status: *mut TF_Status); - pub fn TF_GraphOperationByName(graph: *mut TF_Graph, - operation_name: *const c_char) - -> *mut TF_Operation; - pub fn TF_GraphNextOperation(graph: *mut TF_Graph, pos: *mut size_t) -> *mut TF_Operation; - pub fn TF_GraphToGraphDef(graph: *mut TF_Graph, - output_graph_def: *mut TF_Buffer, - status: *mut TF_Status); - pub fn TF_OperationToNodeDef(operation: *mut TF_Operation, - output_operation_def: *mut TF_Buffer, - status: *mut TF_Status); - pub fn TF_GraphSetTensorShape(graph: *mut TF_Graph, - output: TF_Output, - dims: *const int64_t, - num_dims: c_int, - status: *mut TF_Status); - pub fn TF_GraphGetTensorNumDims(graph: *const TF_Graph, - output: TF_Output, - status: *mut TF_Status) - -> c_int; - pub fn TF_GraphGetTensorShape(graph: *const TF_Graph, - output: TF_Output, - dims: *mut int64_t, - num_dims: c_int, - status: *mut TF_Status); - pub fn TF_ColocateWith(desc: *mut TF_OperationDescription, op: *mut TF_Operation); - pub fn TF_OperationGetAttrMetadata(oper: *const TF_Operation, - attr_name: *const c_char, - status: *mut TF_Status) - -> TF_AttrMetadata; - pub fn TF_OperationGetAttrString(oper: *const TF_Operation, - attr_name: *const c_char, - value: *mut c_void, - max_length: size_t, - status: *mut TF_Status); - pub fn TF_OperationGetAttrStringList(oper: *const TF_Operation, - attr_name: *const c_char, - values: *mut *mut c_void, - lengths: *mut size_t, - max_values: c_int, - storage: *mut c_void, - storage_size: size_t, - status: *mut TF_Status); - pub fn TF_OperationGetAttrInt(oper: *const TF_Operation, - attr_name: *const c_char, - value: *mut int64_t, - status: *mut TF_Status); - pub fn TF_OperationGetAttrIntList(oper: *const TF_Operation, - attr_name: *const c_char, - values: *mut int64_t, - max_values: c_int, - status: *mut TF_Status); - pub fn TF_OperationGetAttrFloat(oper: *const TF_Operation, - attr_name: *const c_char, - value: *mut c_float, - status: *mut TF_Status); - pub fn TF_OperationGetAttrFloatList(oper: *const TF_Operation, - attr_name: *const c_char, - values: *mut c_float, - max_values: c_int, - status: *mut TF_Status); - pub fn TF_OperationGetAttrBool(oper: *const TF_Operation, - attr_name: *const c_char, - value: *mut c_uchar, - status: *mut TF_Status); - pub fn TF_OperationGetAttrBoolList(oper: *const TF_Operation, - attr_name: *const c_char, - values: *mut c_uchar, - max_values: c_int, - status: *mut TF_Status); - pub fn TF_OperationGetAttrType(oper: *const TF_Operation, - attr_name: *const c_char, - value: *mut TF_DataType, - status: *mut TF_Status); - pub fn TF_OperationGetAttrTypeList(oper: *const TF_Operation, - attr_name: *const c_char, - values: *mut TF_DataType, - max_values: c_int, - status: *mut TF_Status); - pub fn TF_OperationGetAttrShape(oper: *const TF_Operation, - attr_name: *const c_char, - value: *mut int64_t, - num_dims: c_int, - status: *mut TF_Status); - pub fn TF_OperationGetAttrShapeList(oper: *const TF_Operation, - attr_name: *const c_char, - dims: *mut *mut int64_t, - num_dims: *mut c_int, - num_shapes: c_int, - storage: *mut int64_t, - storage_size: c_int, - status: *mut TF_Status); - pub fn TF_OperationGetAttrTensorShapeProto(oper: *const TF_Operation, - attr_name: *const c_char, - value: *mut TF_Buffer, - status: *mut TF_Status); - pub fn TF_OperationGetAttrTensorShapeProtoList(oper: *const TF_Operation, - attr_name: *const c_char, - values: *mut *mut TF_Buffer, - max_values: c_int, - status: *mut TF_Status); - pub fn TF_OperationGetAttrTensor(oper: *const TF_Operation, - attr_name: *const c_char, - value: *mut *mut TF_Tensor, - status: *mut TF_Status); - pub fn TF_OperationGetAttrTensorList(oper: *const TF_Operation, - attr_name: *const c_char, - values: *mut *mut TF_Tensor, - max_values: c_int, - status: *mut TF_Status); - pub fn TF_NewImportGraphDefOptions() -> *mut TF_ImportGraphDefOptions; - pub fn TF_DeleteImportGraphDefOptions(opts: *mut TF_ImportGraphDefOptions); - pub fn TF_ImportGraphDefOptionsSetPrefix(opts: *mut TF_ImportGraphDefOptions, - prefix: *const c_char); - pub fn TF_GraphImportGraphDef(graph: *mut TF_Graph, - graph_def: *const TF_Buffer, - options: *const TF_ImportGraphDefOptions, - status: *mut TF_Status); -} - -extern "C" { - pub fn TF_NewSession(graph: *mut TF_Graph, - opts: *const TF_SessionOptions, - status: *mut TF_Status) - -> *mut TF_Session; - pub fn TF_CloseSession(session: *mut TF_Session, status: *mut TF_Status); - pub fn TF_DeleteSession(session: *mut TF_Session, status: *mut TF_Status); - pub fn TF_SessionRun(session: *mut TF_Session, - run_options: *const TF_Buffer, - inputs: *const TF_Output, - input_values: *const *mut TF_Tensor, - ninputs: c_int, - outputs: *const TF_Output, - output_values: *mut *mut TF_Tensor, - noutputs: c_int, - target_operations: *const *const TF_Operation, - ntargets: c_int, - run_metadata: *mut TF_Buffer, - status: *mut TF_Status); - pub fn TF_SessionPRunSetup(session: *mut TF_Session, - inputs: *const TF_Output, - ninputs: c_int, - outputs: *const TF_Output, - noutputs: c_int, - target_operations: *const *const TF_Operation, - ntargets: c_int, - handle: *const *const c_char, - status: *mut TF_Status); - pub fn TF_SessionPRun(session: *mut TF_Session, - handle: *const c_char, - inputs: *const TF_Output, - input_values: *const *mut TF_Tensor, - ninputs: c_int, - outputs: *const TF_Output, - output_values: *mut *mut TF_Tensor, - noutputs: c_int, - target_operations: *const *const TF_Operation, - ntargets: c_int, - status: *mut TF_Status); - pub fn TF_Version() -> *const c_char; - pub fn TF_StringEncode(src: *const c_char, - src_len: size_t, - dst: *mut c_char, - dst_len: size_t, - status: *mut TF_Status) - -> size_t; - pub fn TF_StringDecode(src: *const c_char, - src_len: size_t, - dst: *mut *const c_char, - dst_len: *mut size_t, - status: *mut TF_Status) - -> size_t; - pub fn TF_StringEncodedSize(len: size_t) -> size_t; -} - -#[deprecated(note="Use TF_SetAttrValueProto instead.")] -#[allow(non_snake_case)] -pub unsafe extern "C" fn TF_SetAttrToAttrValueProto(desc: *mut TF_OperationDescription, - attr_name: *const c_char, - proto: *const c_void, - proto_len: size_t, - status: *mut TF_Status) { - TF_SetAttrValueProto(desc, attr_name, proto, proto_len, status) -}