Merge pull request #366 from SciSharp/perf-ops

Performance optimization, refactoring and revamping.

Author: Oceania2018

src/TensorFlowNET.Core/Assembly/Properties.cs

@@ -0,0 +1,4 @@
+using System.Runtime.CompilerServices;
+#if DEBUG
+[assembly: InternalsVisibleTo("TensorFlowNET.UnitTest, PublicKey=00240000048000009400000006020000002400005253413100040000010001004b86c4cb78549b34bab61a3b1800e23bfeb5b3ec390074041536a7e3cbd97f5f04cf0f857155a8928eaa29ebfd11cfbbad3ba70efea7bda3226c6a8d370a4cd303f714486b6ebc225985a638471e6ef571cc92a4613c00b8fa65d61ccee0cbe5f36330c9a01f4183559f1bef24cc2917c6d913e3a541333a1d05d9bed22b38cb")]
+#endif

src/TensorFlowNET.Core/Binding.Util.cs

@@ -178,13 +178,18 @@ public static float time()
 
         public static IEnumerable<(TKey, TValue)> enumerate<TKey, TValue>(KeyValuePair<TKey, TValue>[] values)
         {
-            foreach (var item in values)
+            var len = values.Length;
+            for (var i = 0; i < len; i++)
+            {
+                var item = values[i];
                 yield return (item.Key, item.Value);
+            }
         }
 
         public static IEnumerable<(int, T)> enumerate<T>(IList<T> values)
         {
-            for (int i = 0; i < values.Count; i++)
+            var len = values.Count;
+            for (int i = 0; i < len; i++)
                 yield return (i, values[i]);
         }
 

src/TensorFlowNET.Core/Buffers/Buffer.cs

@@ -15,58 +15,116 @@ limitations under the License.
 ******************************************************************************/
 
 using System;
+using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
+using NumSharp.Backends.Unmanaged;
+using static Tensorflow.c_api;
 
 namespace Tensorflow
 {
+    /// <summary>
+    ///     Represents a TF_Buffer that can be passed to Tensorflow.
+    /// </summary>
     public class Buffer : DisposableObject
     {
-        private TF_Buffer buffer => Marshal.PtrToStructure<TF_Buffer>(_handle);
+        private unsafe TF_Buffer buffer
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get => *bufferptr;
+        }
+
+        private unsafe TF_Buffer* bufferptr
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get => (TF_Buffer*) _handle;
+        }
 
-        public byte[] Data 
+        /// <summary>
+        ///     The memory block representing this buffer.
+        /// </summary>
+        /// <remarks>The deallocator is set to null.</remarks>
+        public UnmanagedMemoryBlock<byte> MemoryBlock
         {
-            get 
+            get
             {
-                var data = new byte[buffer.length];
-                if (data.Length > 0)
-                    Marshal.Copy(buffer.data, data, 0, data.Length);
-                return data;
+                unsafe
+                {
+                    EnsureNotDisposed();
+                    var buff = (TF_Buffer*) _handle;
+                    return new UnmanagedMemoryBlock<byte>((byte*) buff->data.ToPointer(), (long) buff->length);
+                }
             }
         }
 
-        public int Length => (int)buffer.length;
-
-        public Buffer()
+        /// <summary>
+        ///     The bytes length of this buffer.
+        /// </summary>
+        public ulong Length
         {
-            _handle = c_api.TF_NewBuffer();
+            get
+            {
+                EnsureNotDisposed();
+                return buffer.length;
+            }
         }
 
-        public Buffer(IntPtr handle)
+        public Buffer() => _handle = TF_NewBuffer();
+
+        internal Buffer(IntPtr handle)
         {
+            if (handle == IntPtr.Zero)
+                throw new ArgumentException("Handle (IntPtr) can't be zero.", nameof(handle));
+
             _handle = handle;
         }
 
-        public Buffer(byte[] data)
-        {
-            var dst = Marshal.AllocHGlobal(data.Length);
-            Marshal.Copy(data, 0, dst, data.Length);
+        public Buffer(byte[] data) : this(_toBuffer(data))
+        { }
 
-            _handle = c_api.TF_NewBufferFromString(dst, (ulong)data.Length);
+        private static IntPtr _toBuffer(byte[] data)
+        {
+            if (data == null)
+                throw new ArgumentNullException(nameof(data));
 
-            Marshal.FreeHGlobal(dst);
+            unsafe
+            {
+                fixed (byte* src = data)
+                    return TF_NewBufferFromString(new IntPtr(src), (ulong) data.LongLength);
+            }
         }
 
         public static implicit operator IntPtr(Buffer buffer)
         {
+            buffer.EnsureNotDisposed();
             return buffer._handle;
         }
 
-        public static implicit operator byte[](Buffer buffer)
+        public static explicit operator byte[](Buffer buffer) => buffer.ToArray(); //has to be explicit, developer will assume it doesn't cost.
+
+        /// <summary>
+        ///     Copies this buffer's contents onto a <see cref="byte"/> array.
+        /// </summary>
+        public byte[] ToArray()
         {
-            return buffer.Data;
+            EnsureNotDisposed();
+
+            unsafe
+            {
+                var len = buffer.length;
+                if (len == 0)
+                    return Array.Empty<byte>();
+
+                byte[] data = new byte[len];
+                fixed (byte* dst = data)
+                    System.Buffer.MemoryCopy((void*) bufferptr->data, dst, len, len);
+
+                return data;
+            }
         }
 
         protected override void DisposeUnmanagedResources(IntPtr handle)
-            => c_api.TF_DeleteBuffer(handle);
+        {
+            TF_DeleteBuffer(handle);
+        }
     }
-}
+}

src/TensorFlowNET.Core/DisposableObject.cs

@@ -16,6 +16,8 @@ limitations under the License.
 
 using System;
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
 using System.Text;
 
 namespace Tensorflow
@@ -26,27 +28,33 @@ namespace Tensorflow
     public abstract class DisposableObject : IDisposable
     {
         protected IntPtr _handle;
+        protected bool _disposed;
 
-        protected DisposableObject() { }
+        [SuppressMessage("ReSharper", "UnusedMember.Global")]
+        protected DisposableObject()
+        { }
 
-        protected DisposableObject(IntPtr handle) 
+        protected DisposableObject(IntPtr handle)
             => _handle = handle;
 
+        [SuppressMessage("ReSharper", "InvertIf")]
         private void internal_dispose(bool disposing)
         {
-            if (disposing)
-            {
-                // free unmanaged resources (unmanaged objects) and override a finalizer below.
-                if (_handle != IntPtr.Zero)
-                {
-                    // dispose managed state (managed objects).
-                    DisposeManagedResources();
+            if (_disposed)
+                return;
+
+            _disposed = true;
 
-                    // set large fields to null.
-                    DisposeUnmanagedResources(_handle);
+            //first handle managed, they might use the unmanaged resources.
+            if (disposing)
+                // dispose managed state (managed objects).
+                DisposeManagedResources();
 
-                    _handle = IntPtr.Zero;
-                }
+            //free unmanaged memory
+            if (_handle != IntPtr.Zero)
+            {
+                DisposeUnmanagedResources(_handle);
+                _handle = IntPtr.Zero;
             }
         }
 
@@ -55,28 +63,33 @@ private void internal_dispose(bool disposing)
         /// </summary>
         /// <remarks>Equivalent to what you would perform inside <see cref="Dispose()"/></remarks>
         protected virtual void DisposeManagedResources()
-        {
-        }
+        { }
 
         /// <summary>
         ///     Dispose any unmanaged resources related to given <paramref name="handle"/>.
         /// </summary>
         protected abstract void DisposeUnmanagedResources(IntPtr handle);
 
-        // override a finalizer only if Dispose(bool disposing) above has code to free unmanaged resources.
         ~DisposableObject()
         {
-            // Do not change this code. Put cleanup code in Dispose(bool disposing) above.
             internal_dispose(false);
         }
 
-        // This code added to correctly implement the disposable pattern.
         public void Dispose()
         {
-            // Do not change this code. Put cleanup code in Dispose(bool disposing) above.
             internal_dispose(true);
-            // uncomment the following line if the finalizer is overridden above.
             GC.SuppressFinalize(this);
         }
+
+        /// <summary>
+        ///     If <see cref="_handle"/> is <see cref="IntPtr.Zero"/> then throws <see cref="ObjectDisposedException"/>
+        /// </summary>
+        /// <exception cref="ObjectDisposedException">When <see cref="_handle"/> is <see cref="IntPtr.Zero"/></exception>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        protected void EnsureNotDisposed()
+        {
+            if (_disposed)
+                throw new ObjectDisposedException($"Unable to access disposed object, Type: {GetType().Name}");
+        }
     }
 }

src/TensorFlowNET.Core/Eager/Context.cs

@@ -2,12 +2,10 @@
 
 namespace Tensorflow.Eager
 {
-    public class Context : IDisposable
+    public class Context : DisposableObject
     {
-        private IntPtr _handle;
-
-        public static int GRAPH_MODE = 0;
-        public static int EAGER_MODE = 1;
+        public const int GRAPH_MODE = 0;
+        public const int EAGER_MODE = 1;
 
         public int default_execution_mode;
 
@@ -17,19 +15,16 @@ public Context(ContextOptions opts, Status status)
             status.Check(true);
         }
 
-        public void Dispose()
-        {
-            c_api.TFE_DeleteContext(_handle);
-        }
+        /// <summary>
+        ///     Dispose any unmanaged resources related to given <paramref name="handle"/>.
+        /// </summary>
+        protected sealed override void DisposeUnmanagedResources(IntPtr handle) 
+            => c_api.TFE_DeleteContext(_handle);
 
-        public bool executing_eagerly()
-        {
-            return false;
-        }
 
-        public static implicit operator IntPtr(Context ctx)
-        {
-            return ctx._handle;
-        }
+        public bool executing_eagerly() => false;
+
+        public static implicit operator IntPtr(Context ctx) 
+            => ctx._handle;
     }
 }

src/TensorFlowNET.Core/Eager/ContextOptions.cs

@@ -3,23 +3,20 @@
 
 namespace Tensorflow.Eager
 {
-    public class ContextOptions : IDisposable //TODO! Eli: Shouldn't this inherieting DisposableObject?
+    public class ContextOptions : DisposableObject
     {
-        private IntPtr _handle;
+        public ContextOptions() : base(c_api.TFE_NewContextOptions())
+        { }
 
-        public ContextOptions()
-        {
-            _handle = c_api.TFE_NewContextOptions();
-        }
+        /// <summary>
+        ///     Dispose any unmanaged resources related to given <paramref name="handle"/>.
+        /// </summary>
+        protected sealed override void DisposeUnmanagedResources(IntPtr handle) 
+            => c_api.TFE_DeleteContextOptions(_handle);
 
-        public void Dispose()
-        {
-            c_api.TFE_DeleteContextOptions(_handle);
-        }
 
-        public static implicit operator IntPtr(ContextOptions opts)
-        {
-            return opts._handle;
-        }
+        public static implicit operator IntPtr(ContextOptions opts) 
+            => opts._handle;
     }
+
 }

src/TensorFlowNET.Core/Exceptions/KeyError.cs

@@ -2,7 +2,7 @@
 
 namespace Tensorflow
 {
-    public class KeyError : Exception
+    public class KeyError : TensorflowException
     {
         public KeyError() : base()
         {

src/TensorFlowNET.Core/Exceptions/RuntimeError.cs

@@ -2,7 +2,7 @@
 
 namespace Tensorflow
 {
-    public class RuntimeError : Exception
+    public class RuntimeError : TensorflowException
     {
         public RuntimeError() : base()
         {

src/TensorFlowNET.Core/Exceptions/TensorflowException.cs

@@ -0,0 +1,36 @@
+using System;
+using System.Runtime.Serialization;
+
+namespace Tensorflow
+{
+
+    /// <summary>
+    ///     Serves as a base class to all exceptions of Tensorflow.NET.
+    /// </summary>
+    [Serializable]
+    public class TensorflowException : Exception
+    {
+        /// <summary>Initializes a new instance of the <see cref="T:System.Exception"></see> class.</summary>
+        public TensorflowException()
+        { }
+
+        /// <summary>Initializes a new instance of the <see cref="T:System.Exception"></see> class with serialized data.</summary>
+        /// <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"></see> that holds the serialized object data about the exception being thrown.</param>
+        /// <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext"></see> that contains contextual information about the source or destination.</param>
+        /// <exception cref="T:System.ArgumentNullException">The <paramref name="info">info</paramref> parameter is null.</exception>
+        /// <exception cref="T:System.Runtime.Serialization.SerializationException">The class name is null or <see cref="P:System.Exception.HResult"></see> is zero (0).</exception>
+        protected TensorflowException(SerializationInfo info, StreamingContext context) : base(info, context)
+        { }
+
+        /// <summary>Initializes a new instance of the <see cref="T:System.Exception"></see> class with a specified error message.</summary>
+        /// <param name="message">The message that describes the error.</param>
+        public TensorflowException(string message) : base(message)
+        { }
+
+        /// <summary>Initializes a new instance of the <see cref="T:System.Exception"></see> class with a specified error message and a reference to the inner exception that is the cause of this exception.</summary>
+        /// <param name="message">The error message that explains the reason for the exception.</param>
+        /// <param name="innerException">The exception that is the cause of the current exception, or a null reference (Nothing in Visual Basic) if no inner exception is specified.</param>
+        public TensorflowException(string message, Exception innerException) : base(message, innerException)
+        { }
+    }
+}