Multithreading with Keras. #890

Oceania2018 · Oceania2018 · commit 029779f1da50 · 2021-12-08T19:45:18.000-06:00
diff --git a/src/TensorFlowNET.Core/APIs/tf.graph.cs b/src/TensorFlowNET.Core/APIs/tf.graph.cs
@@ -20,8 +20,8 @@ namespace Tensorflow
 {
     public partial class tensorflow
     {
-        public graph_util_impl graph_util => new graph_util_impl();
-        public GraphTransformer graph_transforms => new GraphTransformer();
+        public graph_util_impl graph_util { get; } = new graph_util_impl();
+        public GraphTransformer graph_transforms { get; } = new GraphTransformer();
         public GraphKeys GraphKeys { get; } = new GraphKeys();
 
         public void reset_default_graph()
diff --git a/src/TensorFlowNET.Core/Contexts/Context.cs b/src/TensorFlowNET.Core/Contexts/Context.cs
@@ -171,7 +171,7 @@ public void restore_mode()
 
         public void reset_context()
         {
-            ops.reset_uid();
+            // ops.reset_uid();
             // tf.defaultSession = null;
             ops.reset_default_graph();
             context_switches.Clear();
diff --git a/src/TensorFlowNET.Core/Graphs/DefaultGraphStack.cs b/src/TensorFlowNET.Core/Graphs/DefaultGraphStack.cs
@@ -14,9 +14,8 @@ You may obtain a copy of the License at
    limitations under the License.
 ******************************************************************************/
 
+using System;
 using System.Collections.Generic;
-using System.Linq;
-using static Tensorflow.Binding;
 
 namespace Tensorflow
 {
@@ -25,19 +24,14 @@ namespace Tensorflow
     /// </summary>
     public class DefaultGraphStack
     {
-        private readonly Stack<Graph> _stack = new Stack<Graph>();
-        Graph _global_default_graph;
+        Stack<Graph> _stack = new Stack<Graph>();
 
         public Graph get_default()
         {
-            if (_stack.Count > 0)
-                return _stack.Peek();
-            else if (_global_default_graph != null)
-                return _global_default_graph;
-            else
-                _global_default_graph = new Graph();
+            if (_stack.Count == 0)
+                _stack.Push(new Graph());
 
-            return _global_default_graph;
+            return _stack.Peek();
         }
 
         public Graph get_controller(Graph g)
@@ -61,7 +55,6 @@ public void pop()
         public void reset()
         {
             _stack.Clear();
-            _global_default_graph = null;
         }
     }
 }
diff --git a/src/TensorFlowNET.Core/NumPy/NDArray.Index.cs b/src/TensorFlowNET.Core/NumPy/NDArray.Index.cs
@@ -107,7 +107,7 @@ unsafe NDArray GetData(Slice[] slices)
             if (tensor.Handle == null)
             {
                 if (tf.executing_eagerly())
-                    tensor = tf.defaultSession.eval(tensor);
+                    tensor = tf.get_default_session().eval(tensor);
             }
 
             return new NDArray(tensor, tf.executing_eagerly());
diff --git a/src/TensorFlowNET.Core/Numpy/NDArray.Creation.cs b/src/TensorFlowNET.Core/Numpy/NDArray.Creation.cs
@@ -38,7 +38,7 @@ public NDArray(Tensor tensor, bool clone = false) : base(tensor.Handle, clone: c
         {
             if (_handle is null)
             {
-                tensor = tf.defaultSession.eval(tensor);
+                tensor = tf.get_default_session().eval(tensor);
                 _handle = tensor.Handle;
             }
 
diff --git a/src/TensorFlowNET.Core/Variables/EagerResourceDeleter.cs b/src/TensorFlowNET.Core/Variables/EagerResourceDeleter.cs
@@ -23,7 +23,7 @@ protected override void DisposeUnmanagedResources(IntPtr handle)
         {
             // gen_resource_variable_ops.destroy_resource_op(_tensor, ignore_lookup_error: true);
 
-            tf.device(_handle_device);
+            // tf.device(_handle_device);
             tf.Runner.TFE_Execute(tf.Context, _handle_device, "DestroyResourceOp",
                 new[] { _tensor },
                 new object[] { "ignore_lookup_error", true }, 0);
diff --git a/src/TensorFlowNET.Core/ops.threading.cs b/src/TensorFlowNET.Core/ops.threading.cs
@@ -1,90 +1,26 @@
-﻿using System.Threading;
+﻿using System;
+using System.Threading;
 using static Tensorflow.Binding;
 
 namespace Tensorflow
 {
     public partial class ops
     {
-        private static readonly ThreadLocal<DefaultGraphStack> _defaultGraphFactory = new ThreadLocal<DefaultGraphStack>(() => new DefaultGraphStack());
-        private static volatile Session _singleSesson;
-        private static volatile DefaultGraphStack _singleGraphStack;
-        private static readonly object _threadingLock = new object();
-
-        public static DefaultGraphStack default_graph_stack
-        {
-            get
-            {
-                if (!isSingleThreaded)
-                    return _defaultGraphFactory.Value;
-
-                if (_singleGraphStack == null)
-                {
-                    lock (_threadingLock)
-                    {
-                        if (_singleGraphStack == null)
-                            _singleGraphStack = new DefaultGraphStack();
-                    }
-                }
-
-                return _singleGraphStack;
-            }
-        }
-
-        private static bool isSingleThreaded = false;
-
-        /// <summary>
-        ///     Does this library ignore different thread accessing.
-        /// </summary>
-        /// <remarks>https://github.com/SciSharp/TensorFlow.NET/wiki/Multithreading </remarks>
-        public static bool IsSingleThreaded
-        {
-            get => isSingleThreaded;
-            set
-            {
-                if (value)
-                    enforce_singlethreading();
-                else
-                    enforce_multithreading();
-            }
-        }
-
-        /// <summary>
-        ///     Forces the library to ignore different thread accessing.
-        /// </summary>
-        /// <remarks>https://github.com/SciSharp/TensorFlow.NET/wiki/Multithreading <br></br>Note that this discards any sessions and graphs used in a multithreaded manner</remarks>
-        public static void enforce_singlethreading()
-        {
-            isSingleThreaded = true;
-        }
-
-        /// <summary>
-        ///     Forces the library to provide a separate <see cref="Session"/> and <see cref="Graph"/> to every different thread accessing.
-        /// </summary>
-        /// <remarks>https://github.com/SciSharp/TensorFlow.NET/wiki/Multithreading <br></br>Note that this discards any sessions and graphs used in a singlethreaded manner</remarks>
-        public static void enforce_multithreading()
-        {
-            isSingleThreaded = false;
-        }
+        [ThreadStatic]
+        static DefaultGraphStack default_graph_stack = new DefaultGraphStack();
+        [ThreadStatic]
+        static Session defaultSession;
 
         /// <summary>
         /// Returns the default session for the current thread.
         /// </summary>
         /// <returns>The default `Session` being used in the current thread.</returns>
         public static Session get_default_session()
         {
-            if (!isSingleThreaded)
-                return tf.defaultSession;
+            if (defaultSession == null)
+                defaultSession = new Session(tf.get_default_graph());
 
-            if (_singleSesson == null)
-            {
-                lock (_threadingLock)
-                {
-                    if (_singleSesson == null)
-                        _singleSesson = new Session();
-                }
-            }
-
-            return _singleSesson;
+            return defaultSession;
         }
 
         /// <summary>
@@ -93,15 +29,8 @@ public static Session get_default_session()
         /// <returns>The default `Session` being used in the current thread.</returns>
         public static Session set_default_session(Session sess)
         {
-            if (!isSingleThreaded)
-                return tf.defaultSession = sess;
-
-            lock (_threadingLock)
-            {
-                _singleSesson = sess;
-            }
-
-            return _singleSesson;
+            defaultSession = sess;
+            return sess;
         }
 
         /// <summary>                                                                  
@@ -118,10 +47,18 @@ public static Session set_default_session(Session sess)
         /// </summary>
         /// <returns></returns>
         public static Graph get_default_graph()
-            => default_graph_stack.get_default();
+        {
+            if (default_graph_stack == null)
+                default_graph_stack = new DefaultGraphStack();
+            return default_graph_stack.get_default();
+        }
 
         public static Graph set_default_graph(Graph g)
-            => default_graph_stack.get_controller(g);
+        {
+            if (default_graph_stack == null)
+                default_graph_stack = new DefaultGraphStack();
+            return default_graph_stack.get_controller(g);
+        }
 
         /// <summary>
         ///     Clears the default graph stack and resets the global default graph.
@@ -135,6 +72,8 @@ public static Graph set_default_graph(Graph g)
         /// <returns></returns>
         public static void reset_default_graph()
         {
+            if (default_graph_stack == null)
+                return;
             //if (!_default_graph_stack.is_cleared())
             //    throw new InvalidOperationException("Do not use tf.reset_default_graph() to clear " +
             //                                    "nested graphs. If you need a cleared graph, " +
@@ -143,7 +82,11 @@ public static void reset_default_graph()
         }
 
         public static Graph peak_default_graph()
-            => default_graph_stack.peak_controller();
+        {
+            if (default_graph_stack == null)
+                default_graph_stack = new DefaultGraphStack();
+            return default_graph_stack.peak_controller();
+        }
 
         public static void pop_graph()
             => default_graph_stack.pop();
diff --git a/src/TensorFlowNET.Core/tensorflow.cs b/src/TensorFlowNET.Core/tensorflow.cs
@@ -16,6 +16,7 @@ limitations under the License.
 
 using Serilog;
 using Serilog.Core;
+using System.Threading;
 using Tensorflow.Contexts;
 using Tensorflow.Eager;
 using Tensorflow.Gradients;
@@ -38,25 +39,27 @@ public partial class tensorflow
         public TF_DataType chars = TF_DataType.TF_STRING;
         public TF_DataType @string = TF_DataType.TF_STRING;
 
-        public Status Status;
         public OpDefLibrary OpDefLib;
-        public Context Context;
-        public IEagerRunner Runner;
         public Logger Logger;
 
+        ThreadLocal<Status> _status = new ThreadLocal<Status>(() => new Status());
+        public Status Status => _status.Value;
+
+        ThreadLocal<Context> _context = new ThreadLocal<Context>(() => new Context());
+        public Context Context => _context.Value;
+
+        ThreadLocal<IEagerRunner> _runner = new ThreadLocal<IEagerRunner>(() => new EagerRunner());
+        public IEagerRunner Runner => _runner.Value;
+
         public tensorflow()
         {
             Logger = new LoggerConfiguration()
                 .MinimumLevel.Error()
                 .WriteTo.Console()
                 .CreateLogger();
 
-            Status = new Status();
-            Context = new Context();
             OpDefLib = new OpDefLibrary();
-            ConstructThreadingObjects();
             InitGradientEnvironment();
-            Runner = new EagerRunner();
         }
 
         public string VERSION => c_api.StringPiece(c_api.TF_Version());
diff --git a/src/TensorFlowNET.Core/tensorflow.threading.cs b/src/TensorFlowNET.Core/tensorflow.threading.cs
diff --git a/src/TensorFlowNET.Keras/KerasInterface.cs b/src/TensorFlowNET.Keras/KerasInterface.cs
@@ -12,6 +12,7 @@
 using Tensorflow.Keras.Optimizers;
 using Tensorflow.Keras.Saving;
 using Tensorflow.Keras.Utils;
+using System.Threading;
 
 namespace Tensorflow.Keras
 {
diff --git a/src/TensorFlowNET.Keras/Layers/TensorFlowOpLayer.cs b/src/TensorFlowNET.Keras/Layers/TensorFlowOpLayer.cs
@@ -9,6 +9,7 @@
 using Tensorflow.Keras.Engine;
 using static Tensorflow.Binding;
 using Tensorflow.Functions;
+using System.Threading;
 
 namespace Tensorflow.Keras.Layers
 {
@@ -40,24 +41,24 @@ protected override Tensors Call(Tensors inputs, Tensor state = null, bool? train
             return MakOp(inputs);
         }
 
-        ConcreteFunction function;
+        ThreadLocal<ConcreteFunction> function = new ThreadLocal<ConcreteFunction>();
         Tensors DeFunCall(Tensors inputs)
         {
-            if(function == null)
+            if (function.Value == null)
             {
-                function = new ConcreteFunction(name);
-                function.Enter();
+                function.Value = new ConcreteFunction(name);
+                function.Value.Enter();
 
                 int i = 0;
                 var graph_inputs = inputs.Select(x => tf.placeholder(x.dtype, shape: x.shape, name: $"defun_inputs_{i++}")).ToArray();
                 var graph_outputs = MakOp(graph_inputs);
                 graph_outputs = mark_as_return(graph_outputs);
 
-                function.ToGraph(graph_inputs, graph_outputs);
-                function.Exit();
+                function.Value.ToGraph(graph_inputs, graph_outputs);
+                function.Value.Exit();
             }
 
-            var outputs = function.FilteredCall(inputs);
+            var outputs = function.Value.FilteredCall(inputs);
             return outputs;
         }
 
diff --git a/test/TensorFlowNET.Graph.UnitTest/MultithreadingTests.cs b/test/TensorFlowNET.Graph.UnitTest/MultithreadingTests.cs
diff --git a/test/TensorFlowNET.Keras.UnitTest/MultiThreadsTest.cs b/test/TensorFlowNET.Keras.UnitTest/MultiThreadsTest.cs
diff --git a/test/TensorFlowNET.UnitTest/EnforcedSinglethreadingTests.cs b/test/TensorFlowNET.UnitTest/EnforcedSinglethreadingTests.cs

Original file line number	Diff line number	Diff line change
`@@ -20,8 +20,8 @@ namespace Tensorflow`
`20`	`20`	`{`
`21`	`21`	`public partial class tensorflow`
`22`	`22`	`{`
`23`		`- public graph_util_impl graph_util => new graph_util_impl();`
`24`		`- public GraphTransformer graph_transforms => new GraphTransformer();`
	`23`	`+ public graph_util_impl graph_util { get; } = new graph_util_impl();`
	`24`	`+ public GraphTransformer graph_transforms { get; } = new GraphTransformer();`
`25`	`25`	`public GraphKeys GraphKeys { get; } = new GraphKeys();`
`26`	`26`
`27`	`27`	`public void reset_default_graph()`
Original file line number	Diff line number	Diff line change
`@@ -171,7 +171,7 @@ public void restore_mode()`
`171`	`171`
`172`	`172`	`public void reset_context()`
`173`	`173`	`{`
`174`		`- ops.reset_uid();`
	`174`	`+ // ops.reset_uid();`
`175`	`175`	`// tf.defaultSession = null;`
`176`	`176`	`ops.reset_default_graph();`
`177`	`177`	`context_switches.Clear();`
Original file line number	Diff line number	Diff line change
`@@ -14,9 +14,8 @@ You may obtain a copy of the License at`
`14`	`14`	`limitations under the License.`
`15`	`15`	`******************************************************************************/`
`16`	`16`
	`17`	`+using System;`
`17`	`18`	`using System.Collections.Generic;`
`18`		`-using System.Linq;`
`19`		`-using static Tensorflow.Binding;`
`20`	`19`
`21`	`20`	`namespace Tensorflow`
`22`	`21`	`{`
`@@ -25,19 +24,14 @@ namespace Tensorflow`
`25`	`24`	`/// </summary>`
`26`	`25`	`public class DefaultGraphStack`
`27`	`26`	`{`
`28`		`- private readonly Stack<Graph> _stack = new Stack<Graph>();`
`29`		`- Graph _global_default_graph;`
	`27`	`+ Stack<Graph> _stack = new Stack<Graph>();`
`30`	`28`
`31`	`29`	`public Graph get_default()`
`32`	`30`	`{`
`33`		`- if (_stack.Count > 0)`
`34`		`- return _stack.Peek();`
`35`		`- else if (_global_default_graph != null)`
`36`		`- return _global_default_graph;`
`37`		`- else`
`38`		`- _global_default_graph = new Graph();`
	`31`	`+ if (_stack.Count == 0)`
	`32`	`+ _stack.Push(new Graph());`
`39`	`33`
`40`		`- return _global_default_graph;`
	`34`	`+ return _stack.Peek();`
`41`	`35`	`}`
`42`	`36`
`43`	`37`	`public Graph get_controller(Graph g)`
`@@ -61,7 +55,6 @@ public void pop()`
`61`	`55`	`public void reset()`
`62`	`56`	`{`
`63`	`57`	`_stack.Clear();`
`64`		`- _global_default_graph = null;`
`65`	`58`	`}`
`66`	`59`	`}`
`67`	`60`	`}`
Original file line number	Diff line number	Diff line change
`@@ -107,7 +107,7 @@ unsafe NDArray GetData(Slice[] slices)`
`107`	`107`	`if (tensor.Handle == null)`
`108`	`108`	`{`
`109`	`109`	`if (tf.executing_eagerly())`
`110`		`- tensor = tf.defaultSession.eval(tensor);`
	`110`	`+ tensor = tf.get_default_session().eval(tensor);`
`111`	`111`	`}`
`112`	`112`
`113`	`113`	`return new NDArray(tensor, tf.executing_eagerly());`
Original file line number	Diff line number	Diff line change
`@@ -38,7 +38,7 @@ public NDArray(Tensor tensor, bool clone = false) : base(tensor.Handle, clone: c`
`38`	`38`	`{`
`39`	`39`	`if (_handle is null)`
`40`	`40`	`{`
`41`		`- tensor = tf.defaultSession.eval(tensor);`
	`41`	`+ tensor = tf.get_default_session().eval(tensor);`
`42`	`42`	`_handle = tensor.Handle;`
`43`	`43`	`}`
`44`	`44`
Original file line number	Diff line number	Diff line change
`@@ -23,7 +23,7 @@ protected override void DisposeUnmanagedResources(IntPtr handle)`
`23`	`23`	`{`
`24`	`24`	`// gen_resource_variable_ops.destroy_resource_op(_tensor, ignore_lookup_error: true);`
`25`	`25`
`26`		`- tf.device(_handle_device);`
	`26`	`+ // tf.device(_handle_device);`
`27`	`27`	`tf.Runner.TFE_Execute(tf.Context, _handle_device, "DestroyResourceOp",`
`28`	`28`	`new[] { _tensor },`
`29`	`29`	`new object[] { "ignore_lookup_error", true }, 0);`
Original file line number	Diff line number	Diff line change
`@@ -12,6 +12,7 @@`
`12`	`12`	`using Tensorflow.Keras.Optimizers;`
`13`	`13`	`using Tensorflow.Keras.Saving;`
`14`	`14`	`using Tensorflow.Keras.Utils;`
	`15`	`+using System.Threading;`
`15`	`16`
`16`	`17`	`namespace Tensorflow.Keras`
`17`	`18`	`{`