Оптимизация производительности C#.NET (Алгоритм, Многопоточность, Debug, Release, .Net Core, Net Native) - C# - Ответ 10260661

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Threading.Tasks;
using System.Text;
using System.Linq;
using System.Runtime.CompilerServices;
 
namespace ConsoleApplication1
{
    //поиск переменных для решения уравнения x^3 + y^3 = z^3 - 1
    class Program
    {
        static TaskCompletionSource<object> source = new TaskCompletionSource<object>();
        static TaskScheduler scheduler = new CustomTaskScheduler();
 
        static long n;
        static long n3;
        static long[] a;
        static int threadsN = 4;
        //static StringBuilder _sb = new StringBuilder();
        static List<Test> listTest = new List<Test>(100);
 
        static void Main(string[] args)
        {
            for (int j = 0; j < 10; j++)
            {
                Stopwatch sw = Stopwatch.StartNew();
                //n = (long)Math.Pow(long.MaxValue, (1d / 3d));
                n = 100000;
                n3 = n * n * n;
                a = new long[n + 1];
 
                for (long i = 1; i <= n; i++)
                    a[i] = i * i * i;
 
                var task = new Task[threadsN];
                for (int i = 2; i - 2 < threadsN; i++)
                {
                    int k = i;
                    task[k - 2] = Func(k);
                }
 
 
                Task.WaitAll(task);
                sw.Stop();
 
                //Console.WriteLine(_sb.ToString().TrimEnd('\n'));
                //Console.WriteLine(string.Join("\n", listTest.Select(l => $"{l.Prop1} {l.Prop2} {l.Prop3}")));
                Console.WriteLine((j + 1) + " " + sw.Elapsed.TotalSeconds);
                //_sb = new StringBuilder();
            }
 
            Console.ReadLine();
        }
 
        static async Task Func(long start)
        => await Task.Run(() =>
        {
            long m = n;
 
            for (long x = start; x <= Math.Round(Math.Pow((n3 - 1) / 2, 1d / 3d)); x = x + threadsN)
            {
                long ax = a[x];
 
                while (a[m] > n3 - ax - 1)
                    m--;
 
                long z = 1;
                for (long y = x; y <= m; y++)
                {
                    long z3 = ax + a[y] + 1;
 
                    for (long az = a[z]; az <= z3; z++, az = a[z])
                    {
                        if (az == z3)
                        {
                            //Console.WriteLine(x + "   " + y + "   " + z);
                            //_sb.Append(x).Append(" ").Append(y).Append(" ").Append(z).Append(Environment.NewLine);
 
                            Test test = new Test { Prop1 = x, Prop2 = y, Prop3 = z };
                            listTest.Add(test);
                        }
                    }
                }
            }
        }).ConfigureScheduler(scheduler);
    }
 
    class Test
    {
        public long Prop1 { get; set; }
        public long Prop2 { get; set; }
        public long Prop3 { get; set; }
    }
 
    public struct CustomTaskAwaitable
    {
        CustomTaskAwaiter awaitable;
 
        public CustomTaskAwaitable(Task task, TaskScheduler scheduler)
        {
            awaitable = new CustomTaskAwaiter(task, scheduler);
        }
 
        public CustomTaskAwaiter GetAwaiter() { return awaitable; }
 
        public struct CustomTaskAwaiter : INotifyCompletion
        {
            Task task;
            TaskScheduler scheduler;
 
            public CustomTaskAwaiter(Task task, TaskScheduler scheduler)
            {
                this.task = task;
                this.scheduler = scheduler;
            }
 
            public void OnCompleted(Action continuation)
            {
                task.ContinueWith(x => continuation(), scheduler);
            }
 
            public bool IsCompleted { get { return task.IsCompleted; } }
            public void GetResult() { }
        }
    }
 
    public static class TaskExtension
    {
        public static CustomTaskAwaitable ConfigureScheduler(this Task task, TaskScheduler scheduler)
        {
            return new CustomTaskAwaitable(task, scheduler);
        }
    }
 
    public class CustomTaskScheduler : TaskScheduler
    {
        protected override IEnumerable<Task> GetScheduledTasks() { yield break; }
        protected override bool TryExecuteTaskInline(Task task, bool taskWasPreviouslyQueued) { return false; }
        protected override void QueueTask(Task task)
        {
            TryExecuteTask(task);
        }
    }
}