class MyParallel
    {
        private struct Work {
            public Action<int> body;
            public int start;
            public int stop;
        }
        public static void For(int fromInclusive, int toExclusive, Action<int> body) 
        {
            int noCpu = Environment.ProcessorCount;
            Thread[]threads=new Thread[noCpu];
            Work[] work = new Work[noCpu];

            int Step=(toExclusive-fromInclusive)/noCpu;

            for (int i = 0, Index=fromInclusive; i < noCpu; i++,Index+=Step)
            {
                threads[i] = new Thread(ParameterizedThreadStart);
                work[i] = new Work();
                work[i].start = Index;
                work[i].stop = Index + Step;
                work[i].body = body;
            }

            work[noCpu - 1].stop = toExclusive;

            for (int i = 0; i < noCpu; i++)
                threads[i].Start(work[i]);

            for (int i = 0; i < noCpu; i++)
                threads[i].Join();
        }
        private static void ParameterizedThreadStart(object obj)
        {

            for (int i = ((Work)obj).start; i < ((Work)obj).stop; i++)
                ((Work)obj).body(i);
        }
    }

            For(1, 1000000, (i) =>
            {
                double x = 0;
                for (int j = 0; j < 100000; j++)
                {
                    x = x + Math.Sin(j);
                }
            });

а С# паралелил при помощи Parallel.For — какая-то жуть — накидывает 5% нагрузки в лучшем случае
а иногда так глючит что распараллеленый код выполняется за большее количество времени

            For(1, 1000000, async (i) =>
            {
                double x = 0;
                for (int j = 0; j < 1000; j++)
                {
                    x = x + Math.Sin(j);
                    await Task.Delay(1);
                }

            });

private struct MyDataThread {
            public double[][] tmp;
            public FilterSections[] fs;
            public double[] src;
            public long no_point;
        }
        private static MyDataThread MyAction(int ic, ParallelLoopState p, MyDataThread obj)
        {
            obj.tmp[ic] = new double[obj.no_point];
            obj.fs[ic].Next(obj.tmp[ic], obj.src);
            return obj;
        }


.................
Parallel.For<MyDataThread>(0, no_channel, () => {
                MyDataThread dt = new MyDataThread();
                dt.tmp = tmp;
                dt.fs = fs;
                dt.src = src;
                dt.no_point = no_point;
                return dt; 
            }, MyAction, (MyDataThread obg) => {
                tmp = obg.tmp;
            });

public void Next(double[] y, double[] x)
        {

            for (int i = 0; i < no_filtres; i++)
                filters[i].Next(y, x);
        }

public void Next(double[] y, double[] x)
        {
            for (long i = 0; i < x.LongLength; i++)
            {
                double v0 = pregain * x[i] - a2 * v1 - a3 * v2;
                y[i] = v0 + b2 * v1 + v2;

                v2 = v1; v1 = v0;
            }
        }

VYR>public void Next(double[] y, double[] x)
VYR>        {

VYR>            for (int i = 0; i < no_filtres; i++)
VYR>                filters[i].Next(y, x);
VYR>        }

VYR>public void Next(double[] y, double[] x)
VYR>        {
VYR>            for (long i = 0; i < x.LongLength; i++)
VYR>            {
VYR>                double v0 = pregain * x[i] - a2 * v1 - a3 * v2;
VYR>                y[i] = v0 + b2 * v1 + v2;

VYR>                v2 = v1; v1 = v0;
VYR>            }
VYR>        }
VYR>

for (long i = 0; i < x.LongLength; i++)

for (int i = 0; i < x.Length; i++)

public double M(double[] arr)
{
    double sum = 0;
    for (long i = 0; i < arr.LongLength; i++)
        sum += arr[i];
    return sum;
}

    L0000: sub rsp, 0x28
    L0004: vzeroupper
    L0007: vxorpd xmm0, xmm0, xmm0
    L000c: xor eax, eax
    L000e: mov ecx, [rdx+0x8]
    L0011: movsxd rcx, ecx
    L0014: test rcx, rcx
    L0017: jle L002d
    L0019: cmp rax, rcx
    L001c: jae L0032
    L001e: vaddsd xmm0, xmm0, [rdx+rax*8+0x10]
    L0025: inc rax
    L0028: cmp rcx, rax
    L002b: jg L0019
    L002d: add rsp, 0x28
    L0031: ret
    L0032: call 0x7ffdb9ec2660
    L0037: int3

public double M(double[] arr)
{
    double sum = 0;
    for (int i = 0; i < arr.Length; i++)
        sum += arr[i];
    return sum;
}

    L0000: vzeroupper
    L0003: vxorpd xmm0, xmm0, xmm0
    L0008: xor eax, eax
    L000a: mov ecx, [rdx+0x8]
    L000d: test ecx, ecx
    L000f: jle L0021
    L0011: movsxd r8, eax
    L0014: vaddsd xmm0, xmm0, [rdx+r8*8+0x10]
    L001b: inc eax
    L001d: cmp ecx, eax
    L001f: jg L0011
    L0021: ret

double[] val = new double[no];
for (int j = 0; j < no; j++)
        val[j] = x[j];

for (int j = 0; j < val.Length; j++)
        val[j] = x[j];