Experimental support for pooling/reusing JavaScript engines to improve performance. References #13

Author: Daniel15

src/React.Sample.Mvc4/App_Start/ReactConfig.cs

@@ -17,6 +17,7 @@ public static void Configure()
 		{
 			ReactSiteConfiguration.Configuration
 				.SetUseHarmony(true)
+				.SetReuseJavaScriptEngines(true)
 				.AddScript("~/Content/Sample.jsx");
 		}
 	}

src/React.Sample.Mvc4/App_Start/RouteConfig.cs

@@ -17,6 +17,7 @@ public class RouteConfig
 		public static void RegisterRoutes(RouteCollection routes)
 		{
 			routes.IgnoreRoute("{resource}.axd/{*pathInfo}");
+			routes.IgnoreRoute("favicon.ico");
 
 			routes.MapRoute(
 				name: "Comments",

src/React.Tests/Core/JavaScriptEngineFactoryTest.cs

@@ -19,6 +19,7 @@ public class JavaScriptEngineFactoryTest
 	{
 		private JavaScriptEngineFactory CreateFactory()
 		{
+			var config = new Mock<IReactSiteConfiguration>();
 			var registration = new JavaScriptEngineFactory.Registration
 			{
 				Factory = () =>
@@ -29,34 +30,7 @@ private JavaScriptEngineFactory CreateFactory()
 				},
 				Priority = 1
 			};
-			return new JavaScriptEngineFactory(new[] { registration });
-		}
-
-		[Test]
-		public void ShouldCallOnNewEngineWhenCreatingNew()
-		{
-			var factory = CreateFactory();
-			var called = false;
-			factory.GetEngineForCurrentThread(engine =>
-			{
-				Assert.NotNull(engine);
-				called = true;
-			});
-			factory.DisposeEngineForCurrentThread();
-
-			Assert.True(called);
-		}
-
-		[Test]
-		public void ShouldNotCallOnNewEngineWhenUsingExisting()
-		{
-			var factory = CreateFactory();
-			var called = false;
-			factory.GetEngineForCurrentThread();
-			factory.GetEngineForCurrentThread(engine => { called = true; });
-			factory.DisposeEngineForCurrentThread();
-
-			Assert.False(called);
+			return new JavaScriptEngineFactory(new[] { registration }, config.Object);
 		}
 
 		[Test]

src/React.Tests/Core/ReactEnvironmentTest.cs

@@ -42,7 +42,7 @@ public void ExecuteWithLargerStackIfRequiredWithNewThread()
 
 			environment.ExecuteWithLargerStackIfRequired<int>("foo");
 			mocks.EngineFactory.Verify(
-				x => x.GetEngineForCurrentThread(It.IsAny<Action<IJsEngine>>()), 
+				x => x.GetEngineForCurrentThread(), 
 				Times.Exactly(2),
 				"Two engines should be created (initial thread and new thread)"
 			);
@@ -111,7 +111,7 @@ public Mocks()
 				FileSystem = new Mock<IFileSystem>();
 				FileCacheHash = new Mock<IFileCacheHash>();
 
-				EngineFactory.Setup(x => x.GetEngineForCurrentThread(It.IsAny<Action<IJsEngine>>())).Returns(Engine.Object);
+				EngineFactory.Setup(x => x.GetEngineForCurrentThread()).Returns(Engine.Object);
 			}
 
 			public ReactEnvironment CreateReactEnvironment()
@@ -126,4 +126,4 @@ public ReactEnvironment CreateReactEnvironment()
 			}
 		}
 	}
-}
+}

src/React/IJavaScriptEngineFactory.cs

@@ -9,18 +9,28 @@ namespace React
 	public interface IJavaScriptEngineFactory
 	{
 		/// <summary>
-		/// Gets the JavaScript engine for the current thread
+		/// Gets the JavaScript engine for the current thread. It is recommended to use 
+		/// <see cref="GetEngine"/> instead, which will pool/reuse engines.
 		/// </summary>
-		/// <param name="onNewEngine">
-		/// Called if a brand new JavaScript engine is being created for this thread.
-		/// Should handle initialisation.
-		/// </param>
 		/// <returns>The JavaScript engine</returns>
-		IJsEngine GetEngineForCurrentThread(Action<IJsEngine> onNewEngine);
+		IJsEngine GetEngineForCurrentThread();
 
 		/// <summary>
-		/// Disposes the JavaScript engine for the current thread.
+		/// Disposes the JavaScript engine for the current thread. This should only be used
+		/// if the engine was acquired through <see cref="GetEngineForCurrentThread"/>.
 		/// </summary>
 		void DisposeEngineForCurrentThread();
+
+		/// <summary>
+		/// Gets a JavaScript engine from the pool.
+		/// </summary>
+		/// <returns>The JavaScript engine</returns>
+		IJsEngine GetEngine();
+
+		/// <summary>
+		/// Returns an engine to the pool so it can be reused
+		/// </summary>
+		/// <param name="engine">Engine to return</param>
+		void ReturnEngineToPool(IJsEngine engine);
 	}
 }

src/React/IReactSiteConfiguration.cs

@@ -44,6 +44,16 @@ public interface IReactSiteConfiguration
 		/// </summary>
 		IReactSiteConfiguration SetUseHarmony(bool useHarmony);
 
+		/// <summary>
+		/// Gets or sets whether JavaScript engines should be reused across requests.
+		/// </summary>
+		/// 
+		bool ReuseJavaScriptEngines { get; set; }
+		/// <summary>
+		/// Sets whether JavaScript engines should be reused across requests.
+		/// </summary>
+		IReactSiteConfiguration SetReuseJavaScriptEngines(bool value);
+
 		/// <summary>
 		/// Gets or sets the configuration for JSON serializer.
 		/// </summary>
@@ -53,7 +63,7 @@ public interface IReactSiteConfiguration
 		/// Sets the configuration for json serializer.
 		/// </summary>
 		/// <remarks>
-		/// Thic confiquration is used when component initialization script
+		/// This confiquration is used when component initialization script
 		/// is being generated server-side.
 		/// </remarks>
 		/// <param name="settings">The settings.</param>

src/React/JavaScriptEngineFactory.cs

@@ -5,6 +5,7 @@
 using System.Linq;
 using System.Threading;
 using JavaScriptEngineSwitcher.Core;
+using JSPool;
 using React.Exceptions;
 
 namespace React
@@ -14,6 +15,10 @@ namespace React
 	/// </summary>
 	public class JavaScriptEngineFactory : IDisposable, IJavaScriptEngineFactory
 	{
+		/// <summary>
+		/// React configuration for the current site
+		/// </summary>
+		protected readonly IReactSiteConfiguration _config;
 		/// <summary>
 		/// Function used to create new JavaScript engine instances.
 		/// </summary>
@@ -23,32 +28,56 @@ public class JavaScriptEngineFactory : IDisposable, IJavaScriptEngineFactory
 		/// </summary>
 		protected readonly ConcurrentDictionary<int, IJsEngine> _engines 
 			= new ConcurrentDictionary<int, IJsEngine>();
+		/// <summary>
+		/// Pool of JavaScript engines to use
+		/// </summary>
+		protected readonly IJsPool _pool;
 
 		/// <summary>
 		/// Initializes a new instance of the <see cref="JavaScriptEngineFactory"/> class.
 		/// </summary>
-		public JavaScriptEngineFactory(IEnumerable<Registration> availableFactories)
+		public JavaScriptEngineFactory(IEnumerable<Registration> availableFactories, IReactSiteConfiguration config)
 		{
+			_config = config;
 			_factory = GetFactory(availableFactories);
+			if (_config.ReuseJavaScriptEngines)
+			{
+				_pool = new JsPool(new JsPoolConfig
+				{
+					EngineFactory = _factory,
+					Initializer = InitialiseEngine,
+				});	
+			}
+		}
+
+		/// <summary>
+		/// Loads standard React and JSXTransformer scripts into the engine.
+		/// </summary>
+		protected virtual void InitialiseEngine(IJsEngine engine)
+		{
+			var thisAssembly = typeof(ReactEnvironment).Assembly;
+			engine.ExecuteResource("React.Resources.shims.js", thisAssembly);
+			engine.ExecuteResource("React.Resources.react-with-addons.js", thisAssembly);
+			engine.Execute("var React = global.React");
+
+			// Only load JSX Transformer if engine supports it
+			if (engine.SupportsJsxTransformer())
+			{
+				engine.ExecuteResource("React.Resources.JSXTransformer.js", thisAssembly);
+			}
 		}
 
 		/// <summary>
-		/// Gets the JavaScript engine for the current thread
+		/// Gets the JavaScript engine for the current thread. It is recommended to use 
+		/// <see cref="GetEngine"/> instead, which will pool/reuse engines.
 		/// </summary>
-		/// <param name="onNewEngine">
-		/// Called if a brand new JavaScript engine is being created for this thread.
-		/// Should handle initialisation.
-		/// </param>
 		/// <returns>The JavaScript engine</returns>
-		public virtual IJsEngine GetEngineForCurrentThread(Action<IJsEngine> onNewEngine = null)
+		public virtual IJsEngine GetEngineForCurrentThread()
 		{
 			return _engines.GetOrAdd(Thread.CurrentThread.ManagedThreadId, id =>
 			{
 				var engine = _factory();
-				if (onNewEngine != null)
-				{
-					onNewEngine(engine);
-				}
+				InitialiseEngine(engine);
 				return engine;
 			});
 		}
@@ -68,6 +97,24 @@ public virtual void DisposeEngineForCurrentThread()
 			}
 		}
 
+		/// <summary>
+		/// Gets a JavaScript engine from the pool.
+		/// </summary>
+		/// <returns>The JavaScript engine</returns>
+		public virtual IJsEngine GetEngine()
+		{
+			return _pool.GetEngine();
+		}
+
+		/// <summary>
+		/// Returns an engine to the pool so it can be reused
+		/// </summary>
+		/// <param name="engine">Engine to return</param>
+		public virtual void ReturnEngineToPool(IJsEngine engine)
+		{
+			_pool.ReturnEngineToPool(engine);
+		}
+
 		/// <summary>
 		/// Gets a factory for the most appropriate JavaScript engine for the current environment.
 		/// The first functioning JavaScript engine with the lowest priority will be used.

src/React/React.csproj

@@ -62,6 +62,10 @@
       <HintPath>..\packages\JavaScriptEngineSwitcher.Jint.1.2.1\lib\net40\Jint.dll</HintPath>
       <Private>True</Private>
     </Reference>
+    <Reference Include="JSPool, Version=0.1.0.0, Culture=neutral, PublicKeyToken=2fc7775f73072640, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\packages\JSPool.0.1.1\lib\net40-Client\JSPool.dll</HintPath>
+    </Reference>
     <Reference Include="MsieJavaScriptEngine">
       <HintPath>..\packages\MsieJavaScriptEngine.1.5.0\lib\net40\MsieJavaScriptEngine.dll</HintPath>
       <Private>True</Private>

src/React/ReactEnvironment.cs

@@ -68,7 +68,12 @@ public class ReactEnvironment : IReactEnvironment, IDisposable
 		/// <summary>
 		/// Version number of ReactJS.NET
 		/// </summary>
-		protected readonly Lazy<string> _version = new Lazy<string>(GetVersion); 
+		protected readonly Lazy<string> _version = new Lazy<string>(GetVersion);
+		/// <summary>
+		/// Contains an engine acquired from a pool of engines. Only used if 
+		/// <see cref="IReactSiteConfiguration.ReuseJavaScriptEngines"/> is enabled.
+		/// </summary>
+		protected readonly Lazy<IJsEngine> _engineFromPool;
 
 		/// <summary>
 		/// Number of components instantiated in this environment
@@ -103,17 +108,19 @@ IFileCacheHash fileCacheHash
 			_jsxTransformer = new Lazy<IJsxTransformer>(() => 
 				new JsxTransformer(this, _cache, _fileSystem, _fileCacheHash, _config)
 			);
+			_engineFromPool = new Lazy<IJsEngine>(() => _engineFactory.GetEngine());
 		}
 
 		/// <summary>
-		/// Gets the JavaScript engine for the current thread. If an engine has not yet been 
-		/// created, create it and execute the startup scripts.
+		/// Gets the JavaScript engine to use for this environment.
 		/// </summary>
 		protected virtual IJsEngine Engine
 		{
 			get
 			{
-				return _engineFactory.GetEngineForCurrentThread(InitialiseEngine);
+				return _config.ReuseJavaScriptEngines
+					? _engineFromPool.Value
+					: _engineFactory.GetEngineForCurrentThread();
 			}
 		}
 
@@ -149,23 +156,6 @@ public virtual string Version
 			get { return _version.Value; }
 		}
 
-		/// <summary>
-		/// Loads standard React and JSXTransformer scripts into the engine.
-		/// </summary>
-		protected virtual void InitialiseEngine(IJsEngine engine)
-		{
-			var thisAssembly = typeof(ReactEnvironment).Assembly;
-			engine.ExecuteResource("React.Resources.shims.js", thisAssembly);
-			engine.ExecuteResource("React.Resources.react-with-addons.js", thisAssembly);
-			engine.Execute("var React = global.React");
-
-			// Only load JSX Transformer if engine supports it
-			if (engine.SupportsJsxTransformer())
-			{
-				engine.ExecuteResource("React.Resources.JSXTransformer.js", thisAssembly);
-			}
-		}
-
 		/// <summary>
 		/// Ensures any user-provided scripts have been loaded
 		/// </summary>
@@ -362,6 +352,13 @@ public string TransformJsx(string input)
 		/// <returns>Result returned from JavaScript code</returns>
 		public virtual T ExecuteWithLargerStackIfRequired<T>(string function, params object[] args)
 		{
+			// This hack is not required when pooling JavaScript engines, since pooled MSIE
+			// engines already execute on their own thread with a larger stack.
+			if (_config.ReuseJavaScriptEngines)
+			{
+				return Execute<T>(function, args);
+			}
+
 			try
 			{
 				return Execute<T>(function, args);
@@ -375,10 +372,11 @@ public virtual T ExecuteWithLargerStackIfRequired<T>(string function, params obj
 				Exception innerEx = null;
 				var thread = new Thread(() =>
 				{
+					// New engine will be created here (as this is a new thread)
+					var engine = _engineFactory.GetEngineForCurrentThread();
 					try
 					{
-						// New engine will be created here (as this is a new thread)
-						result = Execute<T>(function, args);
+						result = engine.CallFunction<T>(function, args);
 					}
 					catch (Exception threadEx)
 					{
@@ -421,6 +419,10 @@ private static string GetVersion()
 		public virtual void Dispose()
 		{
 			_engineFactory.DisposeEngineForCurrentThread();
+			if (_engineFromPool.IsValueCreated)
+			{
+				_engineFactory.ReturnEngineToPool(_engineFromPool.Value);
+			}
 		}
 
 		/// <summary>