System.Threading.Tasks.Parallel.For(long, long, System.Threading.Tasks.ParallelOptions, System.Func, System.Func, System.Action)

private async void CreateClientsButton_Click(object sender, RoutedEventArgs e)
        {
            DeviceExpander.IsExpanded = true;

            string BaseName = NewClientName.Text;
            int CountOfMachines = (Int32.TryParse(NumberOfClients.Text, out int unUsed)) ? Int32.Parse(NumberOfClients.Text) : 1;
            int BeginningWith = (!StartingNumber.Text.Length.Equals(0)) ? Int32.Parse(StartingNumber.Text) : 0;
            List<String> DeviceList = new List<string>();
            int current = 0;
            object lockCurrent = new object();
            var progress = new Progress<int>(_ => IdCounter++) as IProgress<int>;

            for (int i = BeginningWith; i <= CountOfMachines; i++)
            {
                string ThisClient = BaseName + i;
                DeviceList.Add(ThisClient);
            }

            var myTask = Task.Run(() =>
            {
                Parallel.For(0, DeviceList.Count,
                    new ParallelOptions { MaxDegreeOfParallelism = MaxThreads },
                    (ii, loopState) =>
                    {
                        int thisCurrent = 0;
                        lock (lockCurrent)
                        {
                            thisCurrent = current;
                            current++;
                        }
                        string device = DeviceList[thisCurrent];
                        Device ThisDevice = new Device() { Name = device, Status = "Starting...", ImageSource = "Images\\step01.png", ProcessProgress = 10 };
                        Devices.Add(ThisDevice);
                        int thisIndex = Devices.IndexOf(ThisDevice);
                        RegisterClient(thisIndex);

                        progress.Report(0);
                    });
            });

            await myTask;
        }

public PointCloud CropCloud(PointCloud cloud, List<Curve> curves, bool inverse = false, double scale = 1e10, double tol = 0.001) {

            bool[] flags = new bool[cloud.Count];

       

            foreach (Curve crv in curves) {

                bool f = crv.TryGetPolyline(out Polyline polyline_); if (!f) continue;


                PointCloud cloud_ = new PointCloud(cloud);


                Polyline polyline = new Polyline(polyline_);
                Plane plane;
                Plane.FitPlaneToPoints(polyline, out plane);
                Transform xform = Transform.PlaneToPlane(plane, Plane.WorldXY);

                polyline.Transform(xform);
                cloud_.Transform(xform);
                var input = Geometry.RhinClip.PolylineToIntPoint(polyline, scale);

                System.Threading.Tasks.Parallel.For(0, cloud.Count, i => {
                    // for (int i = 0; i < cloud_.Count; i++) {

                    if (flags[i]) return;

                    Point3d p = new Point3d(cloud_[i].Location);
                    var inputP = new IntPoint(p.X * scale, p.Y * scale);

                    bool flag = Clipper642.Clipper.PointInPolygon(inputP, input) != 0;//;: Clipper642.Clipper.PointInPolygon(inputP, input) == 0;
                    if (flag)
                        flags[i] = true;
                    // }
                });



            }


            int count = 0;
            List<int> idList = new List<int>();
            //System.Threading.Tasks.Parallel.For(0, cloud.Count, i => {
                for (int i = 0; i < cloud.Count; i++) {
                    bool f = inverse ? !flags[i] : flags[i];
                    if (f) {
                        idList.Add(i);
                        count++;
                    }
                }
            //});

            int[] idArray = idList.ToArray();
            Point3d[] points = new Point3d[count];
            Vector3d[] normals = new Vector3d[count];
            Color[] colors = new Color[count];

            System.Threading.Tasks.Parallel.For(0, idArray.Length, i => {


                int id = idArray[i];
                var p = cloud[(int)id];
                points[i] = p.Location;
                normals[i] = p.Normal;
                colors[i] = p.Color;

            });

            PointCloud croppedCloud = new PointCloud();
            croppedCloud.AddRange(points, normals, colors);

            //PointCloud croppedCloud = new PointCloud();
            //for (int i = 0; i < cloud.Count; i++) {
            //    bool f = inverse ? !flags[i] : flags[i];
            //    if (f) {
            //        if (cloud.ContainsNormals) {
            //            croppedCloud.Add(cloud[i].Location, cloud[i].Normal, cloud[i].Color);
            //        } else {
            //            croppedCloud.Add(cloud[i].Location, cloud[i].Color);
            //        }
            //    }
            //}
            return croppedCloud;

        }

protected override void SolveInstance(IGH_DataAccess DA) {

            GH_Cloud cloud = new GH_Cloud();
            DA.GetData(0, ref cloud);

            string txt = "CPN";
            DA.GetData(1, ref txt);

            char[] characters = txt.ToCharArray();

            if (characters == null) return;
            if (characters.Length != 3) return;

            Point3d[] points = new Point3d[cloud.Value.Count];
            Vector3d[] normals = new Vector3d[cloud.Value.Count];
            System.Drawing.Color[] colors = new System.Drawing.Color[cloud.Value.Count];

            //PointCloud swapCloud = new PointCloud();

            System.Threading.Tasks.Parallel.For(0, cloud.Value.Count, i => {
                //for (int i = 0; i < cloud.Value.Count; i++) {

                //swapCloud.AppendNew();

                //Points

                switch (characters[0]) {

                    case ('p'):
                    case ('P'):
                        points[i] = cloud.Value[i].Location;

                        break;

                    case ('c'):
                    case ('C'):
                        var color = cloud.Value[i].Color;
                        points[i] = new Point3d(color.R, color.G, color.B);
                        break;

                    case ('n'):
                    case ('N'):
                        points[i] = new Point3d(cloud.Value[i].Normal);
                        break;

                }

                switch (characters[1]) {

                    case ('p'):
                    case ('P'):
                        normals[i] = new Vector3d(cloud.Value[i].Location);

                        break;

                    case ('c'):
                    case ('C'):
                        var color = cloud.Value[i].Color;
                        normals[i] = new Vector3d(color.R, color.G, color.B);
                        break;

                    case ('n'):
                    case ('N'):
                        normals[i] = new Vector3d(cloud.Value[i].Normal);
                        break;

                }

                switch (characters[2]) {

                    case ('p'):
                    case ('P'):
                        colors[i] = cloud.Value[i].Color;

                        break;

                    case ('c'):
                    case ('C'):

                        colors[i] = cloud.Value[i].Color;
                        break;

                    case ('n'):
                    case ('N'):
                        colors[i] = cloud.Value[i].Color;
                        break;

                }

           // }
            });

            PointCloud c = new PointCloud();
            c.AddRange(points,normals,colors);

            DA.SetData(0,new GH_Cloud(c));
        }

[Test]
        public void should_test_append()
        {

            Console.WriteLine("Starting test");
            var sw = Stopwatch.StartNew();

            Parallel.For(0, _nbThreads, threadId =>
            {
                var logger = LogManager.GetLogger(typeof(IntegrationTests).Name + threadId.ToString());
                for (var i = 0; i < _count; i++)
                {
                    var timestamp = Stopwatch.GetTimestamp();
                    logger.InfoFormat("{0}", timestamp);
                    _enqueueMicros[threadId][i] = ToMicroseconds(Stopwatch.GetTimestamp() - timestamp);
                }
            });

            LogManager.Shutdown();
            var throughput = _count / sw.Elapsed.TotalSeconds;

            Console.WriteLine($"Finished test, throughput is: {throughput:N0} msgs/second");

            _performanceAppender.PrintTimeTaken();

            var streamWriter = new StreamWriter(new FileStream("write-times.csv", FileMode.Create));
            foreach (var thread in _enqueueMicros)
            {
                foreach (var timeTaken in thread)
                {
                    streamWriter.WriteLine(timeTaken);
                }
            }
            Console.WriteLine("Printed total time taken csv");
        }

public void Populate()
        {
            _rng = new Random(Seed);
            People = new Person[Population];

#if !SILVERLIGHT 
            Parallel.For(0, People.Length, i =>
                {
                    var pos = new Point(NextRandomDouble(), NextRandomDouble());
                    People[i] = NextRandomDouble() < VictimFraction ? (Person) new Victim(pos) : new Defender(pos);
                });
#else
            for (int i = 0; i < People.Length; i++)
            {
                var pos = new Point(NextRandomDouble(), NextRandomDouble());
                People[i] = NextRandomDouble() < VictimFraction ? (Person)new Victim(pos) : new Defender(pos);
            }
#endif

            for (int i = 0; i < People.Length; ++i)
            {
                People[i].Initialize(this);
            }
            PropChanged("People");
        }

public void Tick(int cpuCount = 2)
        {
            if (People != null)
            {
                int chunkSize = People.Length/cpuCount;
                Parallel.For(0, cpuCount, cpu =>
                    {
                        int nextChunk = cpu*chunkSize + chunkSize;
                        for (int i = cpu*chunkSize; i < nextChunk; i++)
                        {
                            Person person = People[i];
                            person.CalculateTarget();
                            person.UpdatePosition(_deltaT);
                        }
                    });      


                if (OnWorldTick != null)
                {
                    OnWorldTick(this, EventArgs.Empty);
                }
            }
        }

private static async Task<List<IRenderableSeriesViewModel>> CreateSeriesAsync(int seriesCount, int pointCount)
        {
            return await Task.Run(() =>
            {
                // Create N series of M points async. Return to calling code to set on the chart 
                IRenderableSeriesViewModel[] series = new IRenderableSeriesViewModel[seriesCount];

                // We generate data in parallel as just generating 1,000,000,000 points takes a long time no matter how fast your chart is! 
                Parallel.For(0, seriesCount, i =>
                {
                    // Temporary buffer for fast filling of DataSeries
                    var xBuffer = new float[AppendCount];
                    var yBuffer = new float[AppendCount];

                    int randomSeed = i * short.MaxValue;
                    var randomWalkGenerator = new Rand(randomSeed);
                    var xyDataSeries = new XyDataSeries<float, float>
                    {
                        // Required for scrolling / streaming 'first in first out' charts
                        FifoCapacity = pointCount,

                        Capacity = pointCount,

                        // Optional to improve performance when you know in advance whether 
                        // data is sorted ascending and contains float.NaN or not 
                        DataDistributionCalculator = new UserDefinedDistributionCalculator<float, float>
                        {
                            ContainsNaN = false,
                            IsEvenlySpaced = true,
                            IsSortedAscending = true,
                        },

                        // Just replacedociate a random walk generator with the series for more consistent random generation
                        Tag = randomWalkGenerator
                    };

                    int yOffset = i + i;
                    for (int j = 0; j < pointCount; j += AppendCount)
                    {
                        for (int k = 0; k < AppendCount; k++)
                        {
                            xBuffer[k] = j + k;
                            yBuffer[k] = randomWalkGenerator.NextWalk() + yOffset;
                        }

                        xyDataSeries.Append(xBuffer, yBuffer);
                    }

                    // Store the series 
                    series[i] = new LineRenderableSeriesViewModel
                    {
                        DataSeries = xyDataSeries,
                        Stroke = GetRandomColor()
                    };
                });

                // Force a GC Collect before we begin
                GC.Collect(GC.MaxGeneration, GCCollectionMode.Forced, true);

                return series.ToList();
            });
        }

private static async Task<List<IRenderableSeriesViewModel>> CreateSeries(int seriesCount, int pointCount)
        {
            return await Task.Run(() =>
            {
                // Create N series of M points async. Return to calling code to set on the chart 
                IRenderableSeriesViewModel[] series = new IRenderableSeriesViewModel[seriesCount];

                // We generate data in parallel as just generating 1,000,000,000 points takes a long time no matter how fast your chart is! 
                Parallel.For(0, seriesCount, i =>
                {
                    // Temporary buffer for fast filling of DataSeries
                    var xBuffer = new float[AppendCount];
                    var yBuffer = new float[AppendCount];

                    int randomSeed = i * short.MaxValue;
                    var randomWalkGenerator = new Rand(randomSeed);
                    var xyDataSeries = new XyDataSeries<float, float>()
                    {
                        // Required for scrolling / streaming 'first in first out' charts
                        FifoCapacity = pointCount,

                        Capacity = pointCount,

                        // Optional to improve performance when you know in advance whether 
                        // data is sorted ascending and contains float.NaN or not 
                        // see https://www.scichart.com/doreplacedentation/v5.x/webframe.html#Performance_Tips_&_Tricks.html for why
                        DataDistributionCalculator = new UserDefinedDistributionCalculator<float, float>()
                        {
                            ContainsNaN = false,
                            IsEvenlySpaced = true,
                            IsSortedAscending = true,
                        },

                        // Just replacedociate a random walk generator with the series for more consistent random generation
                        Tag = randomWalkGenerator,
                    };

                    int yOffset = i + i;
                    for (int j = 0; j < pointCount; j += AppendCount)
                    {
                        for (int k = 0; k < AppendCount; k++)
                        {
                            xBuffer[k] = j + k;
                            yBuffer[k] = randomWalkGenerator.NextWalk() + yOffset;
                        }

                        // Append blocks of 10k points for performance
                        // see https://www.scichart.com/doreplacedentation/v5.x/webframe.html#Performance_Tips_&_Tricks.html for why
                        xyDataSeries.Append(xBuffer, yBuffer);
                    }

                    // Store the series 
                    series[i] = new LineRenderableSeriesViewModel()
                    {
                        DataSeries = xyDataSeries,
                        Stroke = Colors.RandomColor()
                    };
                });

                // Force a GC Collect before we begin
                GC.Collect(GC.MaxGeneration, GCCollectionMode.Forced, true, true);

                return series.ToList();
            });
        }

private static async Task Main(string[] args)
        {
            var configuration = new ConfigurationBuilder()
                .AddJsonFile("appsettings.json")
                .Build();

            var services = new ServiceCollection();

            services.AddLogging(builder =>
            {
                builder.AddConfiguration(configuration.GetSection("Logging"));

                // register our customized file logger instead of the "standard" one
                builder.AddFile<CustomFileLoggerProvider>(configure: o => o.RootPath = AppContext.BaseDirectory);
            });

            await using (ServiceProvider sp = services.BuildServiceProvider())
            {
                // create logger factory
                var loggerFactory = sp.GetRequiredService<ILoggerFactory>();

                // generate a larger amount of messages
                Parallel.For(0, 1000, i =>
                {
                    var logger = loggerFactory.CreateLogger("Thread" + Thread.CurrentThread.ManagedThreadId);
                    var logLevel = (LogLevel)(i % (int)(LogLevel.Critical + 1));
                    logger.Log(logLevel, 0, "Msg" + i, null, (s, _) => s);
                });
            }
        }

public static float[,] SetValues(float[,] array, float value, Area dmns = null)
        {
            if (dmns == null)
                dmns = AreaManager.ActiveArea;

            Parallel.For(dmns.x0, dmns.x1, i =>
            {
                for (int j = dmns.z0; j < dmns.z1; j++)
                    array[i, j] = value;
            });
            return array;
        }

public static bool[,] SetValues(bool[,] array, bool value, Area dmns = null)
        {
            if (dmns == null)
                dmns = new Area(AreaManager.ActiveArea.x0, AreaManager.ActiveArea.x1 * 2, AreaManager.ActiveArea.z0, AreaManager.ActiveArea.z1 * 2);

            Parallel.For(dmns.x0, dmns.x1, i =>
            {
                for (int j = dmns.z0; j < dmns.z1; j++)
                    array[i, j] = value;
            });
            return array;
        }

public static float[,,] SetRange(float[,,] array, float[,] range, int channel, float rangeLow, float rangeHigh, Area dmns = null)
        {
            if (dmns == null)
                dmns = AreaManager.ActiveArea;

            int channelCount = array.GetLength(2);
            Parallel.For(dmns.x0, dmns.x1, i =>
            {
                for (int j = dmns.z0; j < dmns.z1; j++)
                {
                    if (range[i, j] >= rangeLow && range[i, j] <= rangeHigh)
                    {
                        for (int k = 0; k < channelCount; k++)
                            array[i, j, k] = 0;

                        array[i, j, channel] = 1;
                    }
                }
            });
            return array;
        }

public static float[,,] SetRangeBlend(float[,,] array, float[,] range, int channel, float rangeLow, float rangeHigh, float rangeBlendLow, float rangeBlendHigh, Area dmns = null)
        {
            if (dmns == null)
                dmns = AreaManager.ActiveArea;

            int channelLength = array.GetLength(2);
            for (int i = dmns.x0; i < dmns.x1; i++)
            {
                Parallel.For(dmns.z0, dmns.z1, j =>
                {
                    float[] normalised = new float[channelLength];
                    if (range[i, j] >= rangeLow && range[i, j] <= rangeHigh)
                    {
                        for (int k = 0; k < channelLength; k++)
                            array[i, j, k] = 0;

                        array[i, j, channel] = 1;
                    }
                    else if (range[i, j] >= rangeBlendLow && range[i, j] < rangeLow)
                    {
                        float normalisedRange = range[i, j] - rangeBlendLow;
                        float newRange = rangeLow - rangeBlendLow;
                        float rangeBlend = normalisedRange / newRange; // Holds data about the texture weight between the blend ranges.
                        for (int k = 0; k < channelLength; k++) // Gets the weights of the textures in the pos. 
                        {
                            if (k == channel)
                                array[i, j, channel] = rangeBlend;
                            else
                                array[i, j, k] = array[i, j, k] * Mathf.Clamp01(1f - rangeBlend);

                            normalised[k] = array[i, j, k];
                        }
                        float normalisedWeights = normalised.Sum();
                        for (int k = 0; k < channelLength; k++)
                        {
                            normalised[k] /= normalisedWeights;
                            array[i, j, k] = normalised[k];
                        }
                    }
                    else if (range[i, j] > rangeHigh && range[i, j] <= rangeBlendHigh)
                    {
                        float normalisedRange = range[i, j] - rangeHigh;
                        float newRange = rangeBlendHigh - rangeHigh;
                        float rangeBlend = normalisedRange / newRange; // Holds data about the texture weight between the blend ranges.
                        float rangeBlendInverted = 1 - rangeBlend;
                        for (int k = 0; k < channelLength; k++) // Gets the weights of the textures in the pos. 
                        {
                            if (k == channel)
                                array[i, j, channel] = rangeBlendInverted;
                            else
                                array[i, j, k] = array[i, j, k] * Mathf.Clamp01(1f - rangeBlendInverted);

                            normalised[k] = array[i, j, k];
                        }
                        float normalisedWeights = normalised.Sum();
                        for (int k = 0; k < channelLength; k++)
                        {
                            normalised[k] /= normalisedWeights;
                            array[i, j, k] = normalised[k];
                        }
                    }
                });
            }
            return array;
        }

public static float[,] ClampValues(float[,] array, float minValue, float maxValue, Area dmns = null)
        {
            if (dmns == null)
                dmns = AreaManager.ActiveArea;

            Parallel.For(dmns.x0, dmns.x1, i =>
            {
                for (int j = dmns.z0; j < dmns.z1; j++)
                    array[i, j] = Mathf.Clamp(array[i, j], minValue, maxValue);
            });
            return array;
        }

public static float[,] Rotate(float[,] array, bool CW, Area dmns = null)
        {
            if (dmns == null)
                dmns = AreaManager.ActiveArea;

            float[,] newArray = new float[array.GetLength(0), array.GetLength(1)];
            if (CW)
            {
                Parallel.For(dmns.x0, dmns.x1, i =>
                {
                    for (int j = dmns.z0; j < dmns.z1; j++)
                        newArray[i, j] = array[j, dmns.x1 - i - 1];
                });
            }
            else
            {
                Parallel.For(dmns.x0, dmns.x1, i =>
                {
                    for (int j = dmns.z0; j < dmns.z1; j++)
                        newArray[i, j] = array[dmns.z1 - j - 1, i];
                });
            }
            return newArray;
        }

public static float[,,] Rotate(float[,,] array, bool CW, Area dmns = null)
        {
            if (dmns == null)
                dmns = AreaManager.ActiveArea;

            int channelLength = array.GetLength(2);
            float[,,] newArray = new float[array.GetLength(0), array.GetLength(1), array.GetLength(2)];
            if (CW)
            {
                Parallel.For(dmns.x0, dmns.x1, i =>
                {
                    for (int j = dmns.z0; j < dmns.z1; j++)
                    {
                        for (int k = 0; k < channelLength; k++)
                            newArray[i, j, k] = array[j, dmns.x1 - i - 1, k];
                    }
                });
            }
            else
            {
                Parallel.For(dmns.x0, dmns.x1, i =>
                {
                    for (int j = dmns.z0; j < dmns.z1; j++)
                    {
                        for (int k = 0; k < channelLength; k++)
                            newArray[i, j, k] = array[dmns.z1 - j - 1, i, k];
                    }
                });
            }
            return newArray;
        }

public static float[,] ShortMapToFloatArray(TerrainMap<short> terrainMap)
        {
            float[,] array = new float[terrainMap.res, terrainMap.res];
            int arrayLength = array.GetLength(0);
            Parallel.For(0, arrayLength, i =>
            {
                for (int j = 0; j < arrayLength; j++)
                    array[i, j] = BitUtility.Short2Float(terrainMap[i, j]);
            });
            return array;
        }

public static byte[] FloatArrayToByteArray(float[,] array)
        {
            short[] shortArray = new short[array.GetLength(0) * array.GetLength(1)];
            int arrayLength = array.GetLength(0);
            Parallel.For(0, arrayLength, i =>
            {
                for (int j = 0; j < arrayLength; j++)
                    shortArray[(i * arrayLength) + j] = BitUtility.Float2Short(array[i, j]);
            });

            byte[] byteArray = new byte[shortArray.Length * 2];

            Buffer.BlockCopy(shortArray, 0, byteArray, 0, byteArray.Length);

            return byteArray;
        }

public static PrefabDataHolder[] PrefabDataFromSelection(PrefabHierarchyTreeView treeView)
        {
			var selection = treeView.GetSelection();
			var treeList = treeView.treeModel.m_Data.ToList();
			PrefabDataHolder[] prefabDataList = new PrefabDataHolder[selection.Count];
			Parallel.For(0, selection.Count, i => 
			{
				prefabDataList[i] = treeList.Find(x => x.id == selection.ElementAt(i)).prefabDataHolder;
			});
			return prefabDataList;
		}

private static IEnumerator SetSplatMaps(MapInfo mapInfo, int progressID)
        {
            SplatMapRes = mapInfo.splatRes;

            SetSplatMap(mapInfo.splatMap, LayerType.Ground);
            SetSplatMap(mapInfo.biomeMap, LayerType.Biome);
            SetAlphaMap(mapInfo.alphaMap);
            yield return null;
            Progress.Report(progressID, .8f, "Loaded: Splats.");

            TopologyData.Set(mapInfo.topology);
            Parallel.For(0, TerrainTopology.COUNT, i =>
            {
                if (CurrentLayerType != LayerType.Topology || TopologyLayer != i)
                    SetSplatMap(TopologyData.GetTopologyLayer(TerrainTopology.IndexToType(i)), LayerType.Topology, i);
            });
            SetSplatMap(TopologyData.GetTopologyLayer(TerrainTopology.IndexToType(TopologyLayer)), LayerType.Topology, TopologyLayer);
            Progress.Report(progressID, .9f, "Loaded: Topologies.");
        }

public static float[,,] SetValues(float[,,] array, int channel, Area dmns = null)
        {
            if (dmns == null)
                dmns = AreaManager.ActiveArea;

            int channelLength = array.GetLength(2);
            Parallel.For(dmns.x0, dmns.x1, i =>
            {
                for (int j = dmns.z0; j < dmns.z1; j++)
                {
                    for (int k = 0; k < channelLength; k++)
                        array[i, j, k] = 0;

                    array[i, j, channel] = 1;
                }
            });
            return array;
        }

public static bool[,] SetRange(bool[,] array, float[,] range, bool value, float rangeLow, float rangeHigh, Area dmns = null)
        {
            if (dmns == null)
                dmns = new Area(AreaManager.ActiveArea.x0, AreaManager.ActiveArea.x1 * 2, AreaManager.ActiveArea.z0, AreaManager.ActiveArea.z1 * 2);

            Parallel.For(dmns.x0, dmns.x1, i =>
            {
                for (int j = dmns.z0; j < dmns.z1; j++)
                {
                    if (range[i * 2, j * 2] > rangeLow && range[i * 2, j * 2] < rangeHigh)
                        array[i, j] = value;
                }
            });
            return array;
        }

public static float[,,] SetRiver(float[,,] array, float[,] landHeights, float[,] waterHeights, bool aboveTerrain, int channel, Area dmns = null)
        {
            if (dmns == null)
                dmns = AreaManager.ActiveArea;

            int channelLength = array.GetLength(2);
            if (aboveTerrain)
            {
                Parallel.For(dmns.x0, dmns.x1, i =>
                {
                    for (int j = dmns.z0; j < dmns.z1; j++)
                    {
                        if (waterHeights[i, j] > 500 && waterHeights[i, j] > landHeights[i, j])
                        {
                            for (int k = 0; k < channelLength; k++)
                                array[i, j, k] = 0;

                            array[i, j, channel] = 1;
                        }
                    }
                });
            }
            else
            {
                Parallel.For(dmns.x0, dmns.x1, i =>
                {
                    for (int j = dmns.z0; j < dmns.z1; j++)
                    {
                        if (waterHeights[i, j] > 500)
                        {
                            for (int k = 0; k < channelLength; k++)
                                array[i, j, k] = 0;

                            array[i, j, channel] = 1;
                        }
                    }
                });
            }
            return array;
        }

public static bool[,] SetRiver(bool[,] array, float[,] landHeights, float[,] waterHeights, bool aboveTerrain, bool value, Area dmns = null)
        {
            if (dmns == null)
                dmns = new Area(AreaManager.ActiveArea.x0, AreaManager.ActiveArea.x1 * 2, AreaManager.ActiveArea.z0, AreaManager.ActiveArea.z1 * 2);

            if (aboveTerrain)
            {
                Parallel.For(dmns.x0, dmns.x1, i =>
                {
                    for (int j = dmns.z0; j < dmns.z1; j++)
                    {
                        if (waterHeights[i, j] > 500 && waterHeights[i, j] > landHeights[i, j])
                            array[i, j] = value;
                    }
                });
            }
            else
            {
                Parallel.For(dmns.x0, dmns.x1, i =>
                {
                    for (int j = dmns.z0; j < dmns.z1; j++)
                    {
                        if (waterHeights[i, j] > 500)
                            array[i, j] = value;
                    }
                });
            }
            return array;
        }

public static bool[,] Rotate(bool[,] array, bool CW, Area dmns = null)
        {
            if (dmns == null)
                dmns = new Area(AreaManager.ActiveArea.x0, AreaManager.ActiveArea.x1 * 2, AreaManager.ActiveArea.z0, AreaManager.ActiveArea.z1 * 2);

            bool[,] newArray = new bool[array.GetLength(0), array.GetLength(1)];
            if (CW)
            {
                Parallel.For(dmns.x0, dmns.x1, i =>
                {
                    for (int j = dmns.z0; j < dmns.z1; j++)
                        newArray[i, j] = array[j, dmns.x1 - i - 1];
                });
            }
            else
            {
                Parallel.For(dmns.x0, dmns.x1, i =>
                {
                    for (int j = dmns.z0; j < dmns.z1; j++)
                        newArray[i, j] = array[dmns.z1 - j - 1, i];
                });
            }
            return newArray;
        }

public static float[,] Invert(float[,] array, Area dmns = null)
        {
            if (dmns == null)
                dmns = AreaManager.ActiveArea;

            Parallel.For(dmns.x0, dmns.x1, i =>
            {
                for (int j = dmns.z0; j < dmns.z1; j++)
                    array[i, j] = 1 - array[i, j];
            });
            return array;
        }

public static float[,,] Invert(float[,,] array, Area dmns = null)
        {
            if (dmns == null)
                dmns = AreaManager.ActiveArea;

            int channelLength = array.GetLength(2);
            Parallel.For(dmns.x0, dmns.x1, i =>
            {
                for (int j = dmns.z0; j < dmns.z1; j++)
                {
                    for (int k = 0; k < channelLength; k++)
                        array[i, j, k] = 1 - array[i, j, k];
                }
            });
            return array;
        }

public static bool[,] Invert(bool[,] array, Area dmns = null)
        {
            if (dmns == null)
                dmns = new Area(AreaManager.ActiveArea.x0, AreaManager.ActiveArea.x1 * 2, AreaManager.ActiveArea.z0, AreaManager.ActiveArea.z1 * 2);

            Parallel.For(dmns.x0, dmns.x1, i =>
            {
                for (int j = dmns.z0; j < dmns.z1; j++)
                    array[i, j] = !array[i, j];
            });
            return array;
        }

public static float[,] Normalise(float[,] array, float normaliseLow, float normaliseHigh, Area dmns = null)
        {
            if (dmns == null)
                dmns = AreaManager.ActiveArea;

            float highestPoint = 0f, lowestPoint = 1f, heightRange = 0f, normalisedHeightRange = 0f;
            Parallel.For(dmns.x0, dmns.x1, i =>
            {
                for (int j = dmns.z0; j < dmns.z1; j++)
                {
                    if (array[i, j] < lowestPoint)
                        lowestPoint = array[i, j];

                    else if (array[i, j] > highestPoint)
                        highestPoint = array[i, j];
                }
            });
            heightRange = highestPoint - lowestPoint;
            normalisedHeightRange = normaliseHigh - normaliseLow;
            Parallel.For(dmns.x0, dmns.x1, i =>
            {
                for (int j = dmns.z0; j < dmns.z1; j++)
                    array[i, j] = normaliseLow + ((array[i, j] - lowestPoint) / heightRange) * normalisedHeightRange;
            });
            return array;
        }

public static float[,] Offset(float[,] array, float offset, bool clampOffset, Area dmns = null)
        {
            float[,] tempArray = array;
            CancellationTokenSource source = new CancellationTokenSource();
            ParallelOptions options = new ParallelOptions() { CancellationToken = source.Token};
            try
            {
                if (dmns == null)
                    dmns = AreaManager.ActiveArea;

                Parallel.For(dmns.x0, dmns.x1, options, i =>
                {
                    for (int j = dmns.z0; j < dmns.z1; j++)
                    {
                        if (clampOffset == true)
                        {
                            if ((array[i, j] + offset > 1f || array[i, j] + offset < 0f))
                                source.Cancel();
                            else
                                tempArray[i, j] += offset;
                        }
                        else
                            tempArray[i, j] += offset;
                    }
                });
            }
            catch (OperationCanceledException)
            {
                return array;
            }
            return tempArray;
        }

public static MapInfo ConvertMaps(MapInfo terrains, TerrainMap<byte> splatMap, TerrainMap<byte> biomeMap, TerrainMap<byte> alphaMap)
    {
        terrains.splatMap = new float[splatMap.res, splatMap.res, 8];
        terrains.biomeMap = new float[biomeMap.res, biomeMap.res, 4];
        terrains.alphaMap = new bool[alphaMap.res, alphaMap.res];

        var groundTask = Task.Run(() =>
        {
            Parallel.For(0, terrains.splatRes, i =>
            {
                for (int j = 0; j < terrains.splatRes; j++)
                    for (int k = 0; k < 8; k++)
                        terrains.splatMap[i, j, k] = BitUtility.Byte2Float(splatMap[k, i, j]);
            });
        });

        var biomeTask = Task.Run(() =>
        {
            Parallel.For(0, terrains.splatRes, i =>
            {
                for (int j = 0; j < terrains.splatRes; j++)
                    for (int k = 0; k < 4; k++)
                        terrains.biomeMap[i, j, k] = BitUtility.Byte2Float(biomeMap[k, i, j]);
            });
        });

        var alphaTask = Task.Run(() =>
        {
            Parallel.For(0, terrains.splatRes, i =>
            {
                for (int j = 0; j < terrains.splatRes; j++)
                {
                    if (alphaMap[0, i, j] > 0)
                        terrains.alphaMap[i, j] = true;
                    else
                        terrains.alphaMap[i, j] = false;
                }
            });
        });
        Task.WaitAll(groundTask, biomeTask, alphaTask);
        return terrains;
    }

public static WorldSerialization TerrainToWorld(Terrain land, Terrain water, (int prefab, int path, int terrain) ID) 
    {
        WorldSerialization world = new WorldSerialization();
        world.world.size = (uint) land.terrainData.size.x;

        var textureResolution = SplatMapRes;

        byte[] splatBytes = new byte[textureResolution * textureResolution * 8];
        var splatMap = new TerrainMap<byte>(splatBytes, 8);
        var splatTask = Task.Run(() =>
        {
            Parallel.For(0, 8, i =>
            {
                for (int j = 0; j < textureResolution; j++)
                    for (int k = 0; k < textureResolution; k++)
                        splatMap[i, j, k] = BitUtility.Float2Byte(Ground[j, k, i]);
            });
            splatBytes = splatMap.ToByteArray();
        });

        byte[] biomeBytes = new byte[textureResolution * textureResolution * 4];
        var biomeMap = new TerrainMap<byte>(biomeBytes, 4);
        var biomeTask = Task.Run(() =>
        {
            Parallel.For(0, 4, i =>
            {
                for (int j = 0; j < textureResolution; j++)
                    for (int k = 0; k < textureResolution; k++)
                        biomeMap[i, j, k] = BitUtility.Float2Byte(Biome[j, k, i]);
            });
            biomeBytes = biomeMap.ToByteArray();
        });

        byte[] alphaBytes = new byte[textureResolution * textureResolution * 1];
        var alphaMap = new TerrainMap<byte>(alphaBytes, 1);
        bool[,] terrainHoles = GetAlphaMap();
        var alphaTask = Task.Run(() =>
        {
            Parallel.For(0, textureResolution, i =>
            {
                for (int j = 0; j < textureResolution; j++)
                    alphaMap[0, i, j] = BitUtility.Bool2Byte(terrainHoles[i, j]);
            });
            alphaBytes = alphaMap.ToByteArray();
        });

        var topologyTask = Task.Run(() => TopologyData.SaveTopologyLayers());

        foreach (PrefabDataHolder p in PrefabManager.CurrentMapPrefabs)
        {
            if (p.prefabData != null)
            {
                p.UpdatePrefabData(); // Updates the prefabdata before saving.
                world.world.prefabs.Insert(0, p.prefabData);
            }
        }
        Progress.Report(ID.prefab, 0.99f, "Saved " + PrefabManager.CurrentMapPrefabs.Length + " prefabs.");

        foreach (PathDataHolder p in PathManager.CurrentMapPaths)
        {
            if (p.pathData != null)
            {
                p.pathData.nodes = new VectorData[p.transform.childCount];
                for (int i = 0; i < p.transform.childCount; i++)
                {
                    Transform g = p.transform.GetChild(i);
                    p.pathData.nodes[i] = g.position - MapOffset;
                }
                world.world.paths.Insert(0, p.pathData);
            }
        }
        Progress.Report(ID.path, 0.99f, "Saved " + PathManager.CurrentMapPaths.Length + " paths.");

        byte[] landHeightBytes = FloatArrayToByteArray(land.terrainData.GetHeights(0, 0, HeightMapRes, HeightMapRes));
        byte[] waterHeightBytes = FloatArrayToByteArray(water.terrainData.GetHeights(0, 0, HeightMapRes, HeightMapRes));

        Task.WaitAll(splatTask, biomeTask, alphaTask, topologyTask);
        Progress.Report(ID.terrain, 0.99f, "Saved " + TerrainSize.x + " size map.");

        world.AddMap("terrain", landHeightBytes);
        world.AddMap("height", landHeightBytes);
        world.AddMap("water", waterHeightBytes);
        world.AddMap("splat", splatBytes);
        world.AddMap("biome", biomeBytes);
        world.AddMap("alpha", alphaBytes);
        world.AddMap("topology", TopologyData.GetTerrainMap().ToByteArray());
        return world;
    }

public static float[,,] GetTopologyLayer(int layer)
    {
        TerrainMap<int> topology = GetTerrainMap();
        float[,,] splatMap = new float[topology.res, topology.res, 2];
        Parallel.For(0, topology.res, i =>
        {
            for (int j = 0; j < topology.res; j++)
            {
                if ((topology[i, j] & layer) != 0)
                    splatMap[i, j, 0] = 1f;
                else
                    splatMap[i, j, 1] = 1f;
            }
        });
        return splatMap;
    }

public static void SaveTopologyLayers()
    {
        TerrainMap<int> topologyMap = GetTerrainMap();
        Parallel.For(0, TerrainTopology.COUNT, i =>
        {
            Parallel.For(0, topologyMap.res, j =>
            {
                for (int k = 0; k < topologyMap.res; k++)
                {
                    if (Topology[i][j, k, 0] > 0)
                        topologyMap[j, k] = topologyMap[j, k] | TerrainTopology.IndexToType(i);

                    if (Topology[i][j, k, 1] > 0)
                        topologyMap[j, k] = topologyMap[j, k] & ~TerrainTopology.IndexToType(i);
                }
            });
        });
        Data = topologyMap.ToByteArray();
    }

public static string GenericWrite()
		{
			string filePath;
			using (var context = ContextFactory.GetWriteContext("用户数据"))
			{
				Parallel.For(0, 4, index =>
				{
					var sheetName = $"Sheet{index}";
					var sheet = context.CrateSheet<UserExportDto>(sheetName);

					for (int i = 0; i < 102000; i++)
					{
						sheet.AppendData(sheetName, new UserExportDto { Account = $"{index}-{i}-2010211", Name = $"{index}-{i}-用户用户", IsConfirm = i % 2 == 0, IsMan = i % 2 == 0 });
					}
				});

				filePath = context.Save();
				Console.WriteLine($"文件路径：{filePath}");
			}

			return filePath;
		}

private void Run()
        {
            var configs = ZeroApplication.Config.GetConfigs(p => p.StationType != ZeroStationType.Dispatcher);
            ZSocket[] sockets = new ZSocket[configs.Length * 2];
            int idx = 0;

            foreach (var config in configs)
            {
                sockets[idx++] = ZSocket.CreateServiceSocket($"inproc://{config.StationName}_Proxy", ZSocketType.ROUTER);
                sockets[idx++] = ZSocket.CreateClientSocket(config.RequestAddress, ZSocketType.DEALER);
            }

            WaitCount = 0;
            ZeroTrace.SystemLog("ConnectionProxy", "Listen");
            
            using (var pool = ZmqPool.CreateZmqPool())
            {
                pool.Prepare(sockets, ZPollEvent.In);
                _waitToken.Release();
                //SystemManager.Instance.HeartReady(StationName, RealName);
                while (!RunTaskCancel.Token.IsCancellationRequested)
                {
                    if (!pool.Poll())
                        continue;
                    Parallel.For(0, configs.Length, index =>
                    {
                        CheckCall(pool, index * 2);
                        CheckResult(pool, index * 2 + 1);
                    });

                }

            }
            _waitToken.Release();
        }

async void showMbTiles(string path, string stylePath, int minX, int minY, int maxX, int maxY, int zoom, double size = 512, double scale = 1)
        {
            var watch = System.Diagnostics.Stopwatch.StartNew();

            // load style and font
            var style = new VectorTileRenderer.Style(stylePath);
            style.FontDirectory = mainDir + @"styles/fonts/";

            // set pbf as tile provider
            var provider = new VectorTileRenderer.Sources.MbTilesSource(path);
            style.SetSourceProvider(0, provider);

            BitmapSource[,] bitmapSources = new BitmapSource[maxX - minX + 1, maxY - minY + 1];

            // loop through tiles and render them
            Parallel.For(minX, maxX + 1, (int x) =>
            {
                Parallel.For(minY, maxY + 1, async (int y) =>
                {
                    var canvas = new SkiaCanvas();
                    var bitmapR = await Renderer.Render(style, canvas, x, y, zoom, size, size, scale);

                    if (bitmapR == null)
                    {

                    }

                    bitmapSources[x - minX, maxY - y] = bitmapR;
                });
            });

            // merge the tiles and show it
            var bitmap = mergeBitmaps(bitmapSources);
            demoImage.Source = bitmap;

            scrollViewer.Background = new SolidColorBrush(style.GetBackgroundColor(zoom));

            watch.Stop();
            var elapsedMs = watch.ElapsedMilliseconds;
            Console.WriteLine(elapsedMs + "ms time");
        }

protected virtual StageResult Transform(int? recordBatchSize = null, int? recordLimit = null, Dictionary<string, string> options = null)
        {
            if (!ParallelExecution || InputRecords.Count < 100 || ((RecordLimitSize > 0) && (RecordLimitSize < 100)))
            {
                using (Operation transformOp = Begin("Transforming {0} records using sequential execution", InputRecords.Count))
                {
                    for (int i = 0; i < InputRecords.Count; i++)
                    {
                        OutputRecords.Add(TransformInputToOutput(this, WriterOptions, InputRecords[i]));
                        if ((i + 1) % 1000 == 0)
                        {
                            Info("Transformed range {0} to {1} of {2} records...", (i + 1) - 1000, i + 1, InputRecords.Count);
                        }
                        if ((RecordLimitSize > 0) && (i + 1 == RecordLimitSize))
                        {
                            Info("Stopping transformation at record limit {0}.", i + 1);
                            transformOp.Complete();
                            break;
                        }
                    }
                    transformOp.Complete();
                }
            }
            else
            {
                int limit = RecordLimitSize > 0 ? RecordLimitSize <= InputRecords.Count ? RecordLimitSize : InputRecords.Count : InputRecords.Count;
                using (Operation transformOp = Begin("Transforming {0} records using parallel execution", limit))
                {
                    ConcurrentDictionary<int, TRecord> concurrentOutputDictionary = new ConcurrentDictionary<int, TRecord>();
                    
                    Parallel.For(0, limit, (i, loop) =>
                    {
                        TRecord output = TransformInputToOutput(this, WriterOptions, InputRecords[i]);
                        concurrentOutputDictionary.TryAdd(i, output);
                        if ((i + 1) % 1000 == 0)
                        {
                            Info("Transformed range {0} to {1} of {2} records...", (i + 1) - 1000, i + 1, InputRecords.Count);
                        }
                    });
                    OutputRecords = concurrentOutputDictionary.Values.ToList();
                    transformOp.Complete();
                     
                }
            }
            Info("Transformed {0} records with maximum {1} features to {2}.", OutputRecords.Count, OutputRecords.Max(r => r.Features.Count), OutputFileName);
            return StageResult.SUCCESS;
        }

[Test, Description("Integration Test")]
        public void IntegrationTest()
        {
            Parallel.For(0, 2, i =>
            {
                AllureLifecycle cycle = AllureLifecycle.Instance;
                var container = DataGenerator.GetTestResultContainer();
                var beforeFeature = DataGenerator.GetFixture(Fixture.BeforeFeature);
                var afterFeature = DataGenerator.GetFixture(Fixture.AfterFeature);
                var beforeScenario = DataGenerator.GetFixture(Fixture.BeforeScenario);
                var afterScenario = DataGenerator.GetFixture(Fixture.AfterScenario);
                var test = DataGenerator.GetTestResult();
                var fixtureStep = DataGenerator.GetStep();
                var step1 = DataGenerator.GetStep();
                var step2 = DataGenerator.GetStep();
                var step3 = DataGenerator.GetStep();
                var txtAttach = DataGenerator.GetAttachment(".txt");
                var txtAttachWithNoExt = DataGenerator.GetAttachment();

                cycle
                    .StartTestContainer(container)

                    .StartBeforeFixture(container.uuid, beforeFeature.uuid, beforeFeature.fixture)

                    .StartStep(fixtureStep.uuid, fixtureStep.step)
                    .StopStep(x => x.status = Status.preplaceded)

                    .AddAttachment("text file", "text/xml", txtAttach.path)
                    .AddAttachment(txtAttach.path)
                    .UpdateFixture(beforeFeature.uuid, f => f.status = Status.preplaceded)
                    .StopFixture(beforeFeature.uuid)

                    .StartBeforeFixture(container.uuid, beforeScenario.uuid, beforeScenario.fixture)
                    .UpdateFixture(beforeScenario.uuid, f => f.status = Status.preplaceded)
                    .StopFixture(beforeScenario.uuid)

                    .StartTestCase(container.uuid, test)

                    .StartStep(step1.uuid, step1.step)
                    .StopStep(x => x.status = Status.preplaceded)

                    .StartStep(step2.uuid, step2.step)
                    .AddAttachment("unknown file", "text/xml", txtAttachWithNoExt.content)
                    .StopStep(x => x.status = Status.broken)

                    .StartStep(step3.uuid, step3.step)
                    .StopStep(x => x.status = Status.skipped)

                    .AddScreenDiff(test.uuid, "expected.png", "actual.png", "diff.png")

                    .StopTestCase(x =>
                    {
                        x.status = Status.broken;
                        x.statusDetails = new StatusDetails()
                        {
                            flaky = true,
                            known = true,
                            message = "Oh my!",
                            trace = "That was really bad...",
                            muted = true
                        };
                    })

                    .StartAfterFixture(container.uuid, afterScenario.uuid, afterScenario.fixture)
                    .UpdateFixture(afterScenario.uuid, f => f.status = Status.preplaceded)
                    .StopFixture(afterScenario.uuid)

                    .StartAfterFixture(container.uuid, afterFeature.uuid, afterFeature.fixture)
                    .StopFixture(f => f.status = Status.preplaceded)

                    .WriteTestCase(test.uuid)
                    .StopTestContainer(container.uuid)
                    .WriteTestContainer(container.uuid);
            });

        }

[Fact]
        public void TestSpeed()
        {
            System.Diagnostics.Stopwatch stopwatch = new System.Diagnostics.Stopwatch();
            stopwatch.Start();
            Parallel.For(1, 1000000, index =>
            {
                IdGenerater.GetNextId();
            });
            stopwatch.Stop();
            //持续时间: 517 毫秒
            _output.WriteLine(stopwatch.ElapsedMilliseconds.ToString());
            stopwatch.Reset();
        }

public static void Reference(NaiveMatrix result, NaiveMatrix A, NaiveMatrix B)
        {
            Parallel.For(0, A.Height, (i) => 
            {
                for (int j = 0; j < B.Width; ++j)
                {
                    float acreplaced = 0.0F;
                    for (int k = 0; k < A.Width; ++k)
                    {
                        acreplaced += A[A.Width * i + k] * B[B.Width * k + j];
                    }
                    result[B.Width * i + j] = acreplaced;
                }
            });
        }

static void Main(string[] args)
        {
            if (args.Length == 0)
            {
                args = new string[] { "512", "512", "512", "512" };
            }
            const int redo = 10;

            int heightA = Convert.ToInt32(args[0]);
            int widthA = Convert.ToInt32(args[1]);
            int heightB = Convert.ToInt32(args[2]);
            int widthB = Convert.ToInt32(args[3]);
            if (widthA != heightB)
            {
                throw new ArgumentException("invalid data -- incompatible matrices");
            }

            Console.WriteLine("Execution Naive matrix mul with sizes ({0}, {1}) x ({2}, {3})", heightA, widthA, heightB, widthB);

            NaiveMatrix matrixA = new NaiveMatrix(widthA, heightA);
            NaiveMatrix matrixB = new NaiveMatrix(widthB, heightB);

            NaiveMatrix res_net = new NaiveMatrix(widthB, heightA);
            NaiveMatrix res_cuda = new NaiveMatrix(widthB, heightA);

            double numberCompute = ((double)matrixA.Height * (double)matrixA.Width * (double)matrixB.Width) * 3.0E-9;
            
            matrixA.FillMatrix();
            matrixB.FillMatrix();

            Random rand = new Random();

            #region CUDA 

            HybRunner runner = HybRunner.Cuda("NaiveMatrix_CUDA.dll").SetDistrib(4, 5, 8, 32, 32, 0);
            dynamic wrapper = runner.Wrap(new Program());
            
            for (int i = 0; i < redo; ++i)
            {
                wrapper.ComputeRowsOfProduct(res_cuda, matrixA, matrixB, 0, res_cuda.Height);
            }
            #endregion

            #region C#

            for (int i = 0; i < redo; ++i)
            {
                Parallel.For(0, res_net.Height, (line) =>
                {
                    ComputeRowsOfProduct(res_net, matrixA, matrixB, line, line + 1);
                });
            }
            #endregion
            
            Console.Out.WriteLine("DONE");
        }

static void Main(string[] args)
        {
            if (args.Length == 0)
            {
                args = new string[] { "512", "512", "512", "512" };
            }
            const int redo = 10;

            int heightA = Convert.ToInt32(args[0]);
            int widthA = Convert.ToInt32(args[1]);
            int heightB = Convert.ToInt32(args[2]);
            int widthB = Convert.ToInt32(args[3]);
            if (widthA != heightB)
            {
                throw new ArgumentException("invalid data -- incompatible matrices");
            }

            Console.WriteLine("Execution Naive matrix mul with sizes ({0}, {1}) x ({2}, {3})", heightA, widthA, heightB, widthB);

            NaiveMatrix matrixA = new NaiveMatrix(widthA, heightA);
            NaiveMatrix matrixB = new NaiveMatrix(widthB, heightB);

            NaiveMatrix res_net = new NaiveMatrix(widthB, heightA);
            NaiveMatrix res_cuda = new NaiveMatrix(widthB, heightA);

            double numberCompute = ((double)matrixA.Height * (double)matrixA.Width * (double)matrixB.Width) * 3.0E-9;
            
            matrixA.FillMatrix();
            matrixB.FillMatrix();

            Random rand = new Random();

            #region CUDA 

            HybRunner runner = HybRunner.Cuda().SetDistrib(4, 5, 8, 32, 32, 0);
            dynamic wrapper = runner.Wrap(new Program());
            
            for (int i = 0; i < redo; ++i)
            {
                wrapper.ComputeRowsOfProduct(res_cuda, matrixA, matrixB, 0, res_cuda.Height);
            }
            #endregion

            #region C#

            for (int i = 0; i < redo; ++i)
            {
                Parallel.For(0, res_net.Height, (line) =>
                {
                    ComputeRowsOfProduct(res_net, matrixA, matrixB, line, line + 1);
                });
            }
            #endregion
            
            Console.Out.WriteLine("DONE");
        }

[EntryPoint]
        public static void ParForGPU(ushort[] output, ushort[] input, int width, int height)
        {
            Parallel.For(window, height - window, j =>
            {
                // var buffer = new ushort[windowCount * windowCount];
                var buffer = new StackArray<ushort>(windowCount * windowCount);
                for (int i = window; i < width - window; ++i)
                {
                    for (int k = -window; k <= window; ++k)
                    {
                        for (int p = -window; p <= window; ++p)
                        {
                            int bufferIndex = (k + window) * windowCount + p + window;
                            int pixelIndex = (j + k) * width + (i + p);
                            buffer[bufferIndex] = input[pixelIndex];
                        }
                    }

                    Bitonic.Sort(buffer.data, 0, windowCount * windowCount);
                    output[j * width + i] = buffer[(windowCount * windowCount) / 2];
                }
            }) ;
        }

[EntryPoint]
        public static void ParForGPU(ushort[] output, ushort[] input, int width, int height)
        {
            // change for a Parallel2D.For
            Parallel.For(window, height - window, j =>
            {
                var buffer = new StackArray<ushort>(windowCount * windowCount);
                for (int i = window; i < width - window; ++i)
                {
                    for (int k = -window; k <= window; ++k)
                    {
                        for (int p = -window; p <= window; ++p)
                        {
                            int bufferIndex = (k + window) * windowCount + p + window;
                            int pixelIndex = (j + k) * width + (i + p);
                            buffer[bufferIndex] = input[pixelIndex];
                        }
                    }

                    Bitonic.Sort(buffer.data, 0, windowCount * windowCount);
                    output[j * width + i] = buffer[(windowCount * windowCount) / 2];
                }
            }) ;
        }

private void render()
        {
            int[] iterCount = new int[W * H];

            Stopwatch watch = new Stopwatch();
            long elapsedMilliseconds;
         
            watch.Start();
            switch (flavor)
            {
                case Flavors.AVX:
                    MandelbrotAVX.Render(iterCount, fromX, fromY, sX, sY, 1.0F / W, 1.0F / H, H, W, 0, H, maxiter);
                    break;
                case Flavors.AVX2:
                    MandelbrotAVX2.Render(iterCount, fromX, fromY, sX, sY, 1.0F / W, 1.0F / H, H, W, 0, H, maxiter);
                    break;
                case Flavors.AVX512:
                    MandelbrotAVX512.Render(iterCount, fromX, fromY, sX, sY, 1.0F / W, 1.0F / H, H, W, 0, H, maxiter);
                    break;
                case Flavors.CUDA:
                    MandelbrotCUDA.Render2D(iterCount, fromX, fromY, sX, sY, 1.0F / W, 1.0F / H, H, W, maxiter);
                    cuda.DeviceSynchronize();
                    break;
                case Flavors.Source:
                default:
                    int slice = H / Environment.ProcessorCount;
                    Parallel.For(0, Environment.ProcessorCount, tid =>
                    {
                        int lineFrom = tid * slice;
                        int lineTo = Math.Min(H, lineFrom + slice);
                        Mandelbrots.Mandelbrot.Render(iterCount, fromX, fromY, sX, sY, 1.0F / W, 1.0F / H, H, W, lineFrom, lineTo, maxiter);
                    });
                    break;
            }
            watch.Stop();

            for (int j = 0; j < H; ++j)
            {
                for (int i = 0; i < W; ++i)
                {
                    int color = GetMandelbrotColor(iterCount[j * W + i], maxiter);
                    image.SetPixel(i, j, Color.FromArgb(color));
                }
            }
            elapsedMilliseconds = watch.ElapsedMilliseconds;
            if(flavor == Flavors.CUDA)
            {
                elapsedMilliseconds = runnerCUDA.LastKernelDuration.ElapsedMilliseconds;
            }

            label2.Text = "Rendering Time : " + watch.ElapsedMilliseconds + " ms";
            
            Rendering.Refresh();
        }

private void DrawValueSaturationBitmap()
        {
			using (var lok = (_tempBitmap as WriteableBitmap).Lock())
			{
				unsafe
				{
					var pixels = (uint*)(void*)lok.Address;
					var count = _defBitmapSize * _defBitmapSize;
					var hue = Hue;
					float size = _defBitmapSize;

					Parallel.For(0, _defBitmapSize, i =>
					{
						int start = i * _defBitmapSize;
						uint x = 0;
						var sat = (1 - (i / (size - 1)));
						for (int j = start; j < start + _defBitmapSize; j++)
						{
							var value = (x / (size - 1));
							Color2.HSVToUInt(hue, sat, value, out uint num);
							pixels[j] = num;
							x++;
						}
					});
				}
			}
		}

private void DrawValueHueBitmap()
        {
			using (var lok = (_tempBitmap as WriteableBitmap).Lock())
			{
				unsafe
				{
					var pixels = (uint*)(void*)lok.Address;
					var count = _defBitmapSize * _defBitmapSize;
					var sat = Color.Saturationf;
					float size = _defBitmapSize;

					Parallel.For(0, _defBitmapSize, i =>
					{
						int start = i * _defBitmapSize;
						uint x = 0;
						var hue = 360 - ((i / size) * 360);
						//var sat = (1 - (i / (size - 1)));
						for (int j = start; j < start + _defBitmapSize; j++)
						{
							var value = x / size;
							Color2.HSVToUInt(hue, sat, value, out uint num);
							pixels[j] = num;
							x++;
						}
					});
				}
			}
		}

private void DrawSaturationHueBitmap()
        {
			using (var lok = (_tempBitmap as WriteableBitmap).Lock())
			{
				unsafe
				{
					var pixels = (uint*)(void*)lok.Address;
					var count = _defBitmapSize * _defBitmapSize;
					var value = Color.Valuef;
					float size = _defBitmapSize;

					Parallel.For(0, _defBitmapSize, i =>
					{
						int start = i * _defBitmapSize;
						uint x = 0;
						var hue = 360 - ((i / size) * 360);
						//var sat = (1 - (i / (size - 1)));
						for (int j = start; j < start + _defBitmapSize; j++)
						{
							var sat = x / size;
							Color2.HSVToUInt(hue, sat, value, out uint num);
							pixels[j] = num;
							x++;
						}
					});
				}
			}
		}

public async Task Run(IJobExecutionContext context)
        {

            // 可以直接获取 JobDetail 的值
            var jobKey = context.JobDetail.Key;
            var jobId = jobKey.Name;
            // 也可以通过数据库配置，获取传递过来的参数
            JobDataMap data = context.JobDetail.JobDataMap;

            var lastestLogDatetime = (await _accessTrendLogServices.Query(null, d => d.UpdateTime, false)).FirstOrDefault()?.UpdateTime;
            if (lastestLogDatetime == null)
            {
                lastestLogDatetime = Convert.ToDateTime("2021-09-01");
            }

            var accLogs = GetAccessLogs().Where(d => d.User != "" && d.BeginTime.ObjToDate() >= lastestLogDatetime).ToList();
            var logUpdate = DateTime.Now;

            var activeUsers = (from n in accLogs
                               group n by new { n.User } into g
                               select new ActiveUserVM
                               {
                                   user = g.Key.User,
                                   count = g.Count(),
                               }).ToList();

            foreach (var item in activeUsers)
            {
                var user = (await _accessTrendLogServices.Query(d => d.User != "" && d.User == item.user)).FirstOrDefault();
                if (user != null)
                {
                    user.Count += item.count;
                    user.UpdateTime = logUpdate;
                    await _accessTrendLogServices.Update(user);
                }
                else
                {
                    await _accessTrendLogServices.Add(new AccessTrendLog()
                    {
                        Count = item.count,
                        UpdateTime = logUpdate,
                        User = item.user
                    });
                }
            }

            // 重新拉取
            var actUsers = await _accessTrendLogServices.Query(d => d.User != "", d => d.Count, false);
            actUsers = actUsers.Take(15).ToList();

            List<ActiveUserVM> activeUserVMs = new();
            foreach (var item in actUsers)
            {
                activeUserVMs.Add(new ActiveUserVM()
                {
                    user = item.User,
                    count = item.Count
                });
            }

            Parallel.For(0, 1, e =>
            {
                LogLock.OutSql2Log("ACCESSTRENDLOG", new string[] { JsonConvert.SerializeObject(activeUserVMs) }, false, true);
            });
        }