In JavaScriptEngineSwitcher.ChakraCore was optimized a memory usage in version for Unix

Author: Taritsyn

Licenses/dotnet-corefx-license.txt

@@ -0,0 +1,23 @@
+The MIT License (MIT)
+
+Copyright (c) .NET Foundation and Contributors
+
+All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

NuGet/JavaScriptEngineSwitcher.ChakraCore/JavaScriptEngineSwitcher.ChakraCore.nuspec

@@ -20,7 +20,7 @@ This package does not contain the native implementations of ChakraCore. Therefor
  * JavaScriptEngineSwitcher.ChakraCore.Native.linux-x64
  * JavaScriptEngineSwitcher.ChakraCore.Native.osx-x64</description>
 		<summary>JavaScriptEngineSwitcher.ChakraCore contains adapter `ChakraCoreJsEngine` (wrapper for the ChakraCore).</summary>
-		<releaseNotes>ChakraCore was updated to version 1.11.1.</releaseNotes>
+		<releaseNotes>Optimized a memory usage in version for Unix.</releaseNotes>
 		<copyright>Copyright (c) 2013-2018 Andrey Taritsyn - http://www.taritsyn.ru</copyright>
 		<language>en-US</language>
 		<tags>JavaScriptEngineSwitcher JavaScript ECMAScript ChakraCore</tags>
@@ -29,10 +29,12 @@ This package does not contain the native implementations of ChakraCore. Therefor
 				<dependency id="JavaScriptEngineSwitcher.Core" version="2.4.10" />
 			</group>
 			<group targetFramework=".NETFramework4.5">
+				<dependency id="System.Buffers" version="4.0.0" />
 				<dependency id="JavaScriptEngineSwitcher.Core" version="2.4.10" />
 			</group>
 			<group targetFramework=".NETStandard1.3">
 				<dependency id="NETStandard.Library" version="1.6.0" />
+				<dependency id="System.Buffers" version="4.0.0" />
 				<dependency id="System.Reflection.TypeExtensions" version="4.1.0" />
 				<dependency id="System.Threading.Thread" version="4.0.0" />
 				<dependency id="JavaScriptEngineSwitcher.Core" version="2.4.10" />

NuGet/JavaScriptEngineSwitcher.ChakraCore/build-package.cmd

@@ -30,6 +30,7 @@ xcopy "%dotnet_project_bin_dir%\netstandard1.3\%project_name%.xml" lib\netstanda
 xcopy "%dotnet_project_bin_dir%\netstandard1.3\ru-ru\%project_name%.resources.dll" lib\netstandard1.3\ru-ru\
 
 copy "%licenses_dir%\chakra-samples-license.txt" chakra-samples-license.txt /Y
+copy "%licenses_dir%\dotnet-corefx-license.txt" dotnet-corefx-license.txt /Y
 copy "%licenses_dir%\jsrt-dotnet-license.txt" jsrt-dotnet-license.txt /Y
 
 %nuget_package_manager% pack "..\%project_name%\%project_name%.nuspec"

NuGet/JavaScriptEngineSwitcher.ChakraCore/readme.txt

@@ -30,7 +30,7 @@
    =============
    RELEASE NOTES
    =============
-   ChakraCore was updated to version 1.11.1.
+   Optimized a memory usage in version for Unix.
 
    =============
    DOCUMENTATION

src/JavaScriptEngineSwitcher.ChakraCore.Net4/JavaScriptEngineSwitcher.ChakraCore.Net40.csproj

@@ -29,6 +29,7 @@
     <DefineConstants>TRACE;NET40</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
   </PropertyGroup>
   <PropertyGroup>
     <SignAssembly>true</SignAssembly>
@@ -199,6 +200,11 @@
     <Compile Include="..\JavaScriptEngineSwitcher.ChakraCore\ScriptDispatcher.cs">
       <Link>ScriptDispatcher.cs</Link>
     </Compile>
+    <Compile Include="Polyfills\System\Buffers\ArrayPool.cs" />
+    <Compile Include="Polyfills\System\Buffers\DefaultArrayPool.cs" />
+    <Compile Include="Polyfills\System\Buffers\DefaultArrayPoolBucket.cs" />
+    <Compile Include="Polyfills\System\Buffers\Utilities.cs" />
+    <Compile Include="Polyfills\System\Threading\Volatile.cs" />
   </ItemGroup>
   <ItemGroup>
     <EmbeddedResource Include="..\JavaScriptEngineSwitcher.ChakraCore\Resources\Strings.resx">

src/JavaScriptEngineSwitcher.ChakraCore.Net4/Polyfills/System/Buffers/ArrayPool.cs

@@ -0,0 +1,93 @@
+#if NET40
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Runtime.CompilerServices;
+using System.Threading;
+
+using JavaScriptEngineSwitcher.ChakraCore.Polyfills.System.Threading;
+
+namespace JavaScriptEngineSwitcher.ChakraCore.Polyfills.System.Buffers
+{
+	/// <summary>
+	/// Provides a resource pool that enables reusing instances of type <see cref="T:T[]"/>
+	/// </summary>
+	/// <remarks>
+	/// <para>
+	/// Renting and returning buffers with an <see cref="ArrayPool{T}"/> can increase performance
+	/// in situations where arrays are created and destroyed frequently, resulting in significant
+	/// memory pressure on the garbage collector.
+	/// </para>
+	/// <para>
+	/// This class is thread-safe. All members may be used by multiple threads concurrently.
+	/// </para>
+	/// </remarks>
+	internal abstract class ArrayPool<T>
+	{
+		/// <summary>
+		/// The lazily-initialized shared pool instance
+		/// </summary>
+		private static ArrayPool<T> s_sharedInstance = null;
+
+		/// <summary>
+		/// Retrieves a shared <see cref="ArrayPool{T}"/> instance
+		/// </summary>
+		/// <remarks>
+		/// The shared pool provides a default implementation of <see cref="ArrayPool{T}"/>
+		/// that's intended for general applicability. It maintains arrays of multiple sizes, and
+		/// may hand back a larger array than was actually requested, but will never hand back a smaller
+		/// array than was requested. Renting a buffer from it with <see cref="Rent"/> will result in an
+		/// existing buffer being taken from the pool if an appropriate buffer is available or in a new
+		/// buffer being allocated if one is not available.
+		/// </remarks>
+		public static ArrayPool<T> Shared
+		{
+			[MethodImpl((MethodImplOptions)256 /* AggressiveInlining */)]
+			get
+			{
+				return Volatile.Read(ref s_sharedInstance) ?? EnsureSharedCreated();
+			}
+		}
+
+
+		/// <summary>
+		/// Ensures that <see cref="s_sharedInstance"/> has been initialized to a pool and returns it
+		/// </summary>
+		[MethodImpl(MethodImplOptions.NoInlining)]
+		private static ArrayPool<T> EnsureSharedCreated()
+		{
+			Interlocked.CompareExchange(ref s_sharedInstance, new DefaultArrayPool<T>(), null);
+			return s_sharedInstance;
+		}
+
+		/// <summary>
+		/// Retrieves a buffer that is at least the requested length
+		/// </summary>
+		/// <remarks>
+		/// This buffer is loaned to the caller and should be returned to the same pool via
+		/// <see cref="Return"/> so that it may be reused in subsequent usage of <see cref="Rent"/>.
+		/// It is not a fatal error to not return a rented buffer, but failure to do so may lead to
+		/// decreased application performance, as the pool may need to create a new buffer to replace
+		/// the one lost.
+		/// </remarks>
+		/// <param name="minimumLength">The minimum length of the array needed</param>
+		/// <returns>An <see cref="T:T[]"/> that is at least <paramref name="minimumLength"/> in length</returns>
+		public abstract T[] Rent(int minimumLength);
+
+		/// <summary>
+		/// Returns to the pool an array that was previously obtained via <see cref="Rent"/> on the same
+		/// <see cref="ArrayPool{T}"/> instance
+		/// </summary>
+		/// <remarks>
+		/// Once a buffer has been returned to the pool, the caller gives up all ownership of the buffer
+		/// and must not use it. The reference returned from a given call to <see cref="Rent"/> must only be
+		/// returned via <see cref="Return"/> once. The default <see cref="ArrayPool{T}"/>
+		/// may hold onto the returned buffer in order to rent it again, or it may release the returned buffer
+		/// if it's determined that the pool already has enough buffers stored.
+		/// </remarks>
+		/// <param name="array">The buffer previously obtained from <see cref="Rent"/> to return to the pool</param>
+		public abstract void Return(T[] array);
+	}
+}
+#endif

src/JavaScriptEngineSwitcher.ChakraCore.Net4/Polyfills/System/Buffers/DefaultArrayPool.cs

@@ -0,0 +1,158 @@
+#if NET40
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+
+namespace JavaScriptEngineSwitcher.ChakraCore.Polyfills.System.Buffers
+{
+	internal sealed partial class DefaultArrayPool<T> : ArrayPool<T>
+	{
+		/// <summary>
+		/// The default maximum length of each array in the pool (2^20)
+		/// </summary>
+		private const int DefaultMaxArrayLength = 1024 * 1024;
+
+		/// <summary>
+		/// The default maximum number of arrays per bucket that are available for rent
+		/// </summary>
+		private const int DefaultMaxNumberOfArraysPerBucket = 50;
+
+		/// <summary>
+		/// Lazily-allocated empty array used when arrays of length 0 are requested
+		/// </summary>
+		private static T[] s_emptyArray; // we support contracts earlier than those with Array.Empty<T>()
+
+		private readonly Bucket[] _buckets;
+
+		/// <summary>
+		/// Gets an ID for the pool to use with events
+		/// </summary>
+		private int Id
+		{
+			get { return GetHashCode(); }
+		}
+
+
+		internal DefaultArrayPool()
+			: this(DefaultMaxArrayLength, DefaultMaxNumberOfArraysPerBucket)
+		{ }
+
+		internal DefaultArrayPool(int maxArrayLength, int maxArraysPerBucket)
+		{
+			if (maxArrayLength <= 0)
+			{
+				throw new ArgumentOutOfRangeException("maxArrayLength");
+			}
+
+			if (maxArraysPerBucket <= 0)
+			{
+				throw new ArgumentOutOfRangeException("maxArraysPerBucket");
+			}
+
+			// Our bucketing algorithm has a min length of 2^4 and a max length of 2^30.
+			// Constrain the actual max used to those values.
+			const int MinimumArrayLength = 0x10, MaximumArrayLength = 0x40000000;
+			if (maxArrayLength > MaximumArrayLength)
+			{
+				maxArrayLength = MaximumArrayLength;
+			}
+			else if (maxArrayLength < MinimumArrayLength)
+			{
+				maxArrayLength = MinimumArrayLength;
+			}
+
+			// Create the buckets.
+			int poolId = Id;
+			int maxBuckets = Utilities.SelectBucketIndex(maxArrayLength);
+			var buckets = new Bucket[maxBuckets + 1];
+
+			for (int i = 0; i < buckets.Length; i++)
+			{
+				buckets[i] = new Bucket(Utilities.GetMaxSizeForBucket(i), maxArraysPerBucket, poolId);
+			}
+
+			_buckets = buckets;
+		}
+
+
+		public override T[] Rent(int minimumLength)
+		{
+			// Arrays can't be smaller than zero. We allow requesting zero-length arrays (even though
+			// pooling such an array isn't valuable) as it's a valid length array, and we want the pool
+			// to be usable in general instead of using `new`, even for computed lengths.
+			if (minimumLength < 0)
+			{
+				throw new ArgumentOutOfRangeException("minimumLength");
+			}
+			else if (minimumLength == 0)
+			{
+				// No need for events with the empty array. Our pool is effectively infinite
+				// and we'll never allocate for rents and never store for returns.
+				return s_emptyArray ?? (s_emptyArray = new T[0]);
+			}
+
+			T[] buffer = null;
+
+			int index = Utilities.SelectBucketIndex(minimumLength);
+			if (index < _buckets.Length)
+			{
+				// Search for an array starting at the 'index' bucket. If the bucket is empty, bump up to the
+				// next higher bucket and try that one, but only try at most a few buckets.
+				const int MaxBucketsToTry = 2;
+				int i = index;
+
+				do
+				{
+					// Attempt to rent from the bucket. If we get a buffer from it, return it.
+					buffer = _buckets[i].Rent();
+					if (buffer != null)
+					{
+						return buffer;
+					}
+				}
+				while (++i < _buckets.Length && i != index + MaxBucketsToTry);
+
+				// The pool was exhausted for this buffer size. Allocate a new buffer with a size corresponding
+				// to the appropriate bucket.
+				buffer = new T[_buckets[index]._bufferLength];
+			}
+			else
+			{
+				// The request was for a size too large for the pool. Allocate an array of exactly the requested
+				// length. When it's returned to the pool, we'll simply throw it away.
+				buffer = new T[minimumLength];
+			}
+
+			return buffer;
+		}
+
+		public override void Return(T[] array)
+		{
+			if (array == null)
+			{
+				throw new ArgumentNullException("array");
+			}
+			else if (array.Length == 0)
+			{
+				// Ignore empty arrays. When a zero-length array is rented, we return a singleton
+				// rather than actually taking a buffer out of the lowest bucket.
+				return;
+			}
+
+			// Determine with what bucket this array length is associated
+			int bucket = Utilities.SelectBucketIndex(array.Length);
+
+			// If we can tell that the buffer was allocated, drop it. Otherwise, check if we have space in the pool
+			if (bucket < _buckets.Length)
+			{
+				// Return the buffer to its bucket. In the future, we might consider having Return return false
+				// instead of dropping a bucket, in which case we could try to return to a lower-sized bucket,
+				// just as how in Rent we allow renting from a higher-sized bucket.
+				_buckets[bucket].Return(array);
+			}
+		}
+	}
+}
+#endif