Написание повторяющихся параллельных циклов для анимации, избегая System.Threading.Tasks.Parallel.For

Я пишу плагин для Rhino, который анимирует некоторые данные с трассировкой лучей. Rhino занимается всем рисованием; Мне просто нужно предоставить ему что-нибудь для рисования.

Следующая функция Animate вызывается из потока пользовательского интерфейса с помощью Task.Run(() => Animate(doc, cts.Token, Embree);. Внутри функции есть цикл while, который повторяется до тех пор, пока не будет выброшен CancellationToken или lengthtraveled > maxTimeLength (оба устанавливаются потоком пользовательского интерфейса). Цикл while вычисляет каждый кадр анимации; т. е. шаг отдельных точек на их пути. Когда граница достигнута, Embree вычисляет пересечение приближающегося луча с границей и определяет направление и длину отраженного луча.

Я хотел бы воспользоваться преимуществами многоядерного процессора, стоящего передо мной, и разделить основной цикл for (int i = 0; i < sphereNum; i++) (отмечен ниже) на несколько параллельных потоков.

В настоящее время я достигаю частоты обновления около 45 Гц в одном потоке, но было бы неплохо, если бы она была более производительной для менее производительных (но все же многоядерных) машин.

У меня сложилось впечатление, что Parallel.For(int fromInclusive, int toExclusive, Action<int> body) требует изрядного количества накладных расходов и будет запускать новый набор потоков каждый раз, когда его вызывают, что кажется расточительным, поскольку я знаю, что одна и та же процедура будет просто повторяться до тошноты. Так почему бы не загрузить несколько потоков, каждый из которых вычисляет часть точек (25 000+), а затем ждет отрисовки данных, после чего будет дана команда для расчета следующего шага анимации.

Вот функция Animate:

private void Animate(RhinoDoc doc, CancellationToken cts, EMBContainer Embree)
{
    double refreshInterval = 1.0 / 45.0;
    int refreshMS = (int)(refreshInterval * 1000.0);
    double slowdownFactor = 1.0 / 20.0;
    double Speed = 10.0;
    double spherestep = refreshInterval * slowdownFactor * Speed;
    double lengthtraveled = 0.0;

    int sphereNum = 25000;
    spheres = new RaySphereData[sphereNum];
    points = new Rhino.Geometry.PointCloud(Enumerable.Repeat(StartPoint, sphereNum));
    int refreshcounter = 1, resettozero = 0;
    long waited = 0;

    System.Numerics.Vector3 start, direction;

    var vectors = StartingVectors();
    start = StartPoint.;
    for (int i = 0; i < sphereNum; i++)
    {
        direction  = vectors[i];
        Embree.RTCRayHit hits = Embree.Intersect(start, direction);

        points[i].Location = StartPoint;
        spheres[i].step = direction; 
        spheres[i].step *= spherestep;
        spheres[i].pathlength = hits.Ray.tfar;
        spheres[i].done = false;

        hits.Hit.Normalize();
        spheres[i].nextdirection = Vector3.Reflect(direction, hits.Hit.normal);
        spheres[i].nextstart = start + direction * hits.Ray.tfar;
    }

    Stopwatch stopwatch2 = new Stopwatch();
    Stopwatch stopwatch3 = new Stopwatch();
    double interimlength;

    Stopwatch stopwatch = Stopwatch.StartNew();
    Stopwatch stopwatch1 = Stopwatch.StartNew();

    while (true)
    {
        stopwatch2.Start();
        if (cts.IsCancellationRequested) return;

        var delay = Task.Delay(refreshMS); 

        doc.Views.Redraw();
        lengthtraveled += spherestep;
        if (lengthtraveled > maxTimeLength)
        {
            return;
        }
        else
        {
// start multi-threading here; i.e. send Monitor, Barrier or Semaphore signal to the animation frame compute function
            for (int i = 0; i < sphereNum; i++)
            {
                if (lengthtraveled > spheres[i].pathlength)
                {
                    do
                    {
                        interimlength = lengthtraveled - spheres[i].pathlength;
                        direction = spheres[i].nextdirection;
                        start = spheres[i].nextstart;
                        var hits = Embree.Intersect(start, direction);
                        spheres[i].pathlength += hits.Ray.tfar;
                        spheres[i].step = direction.ToVector3d();
                        spheres[i].step.Unitize();
                        points[i].Location = spheres[i].nextstart.ToPoint3d() + (spheres[i].step * interimlength);
                        spheres[i].nextstart = start + direction * hits.Ray.tfar;
                        hits.Hit.Normalize();
                        spheres[i].nextdirection = Vector3.Reflect(direction, hits.Hit.normal);
                    }
                    while (lengthtraveled > spheres[i].pathlength);

                    spheres[i].step *= spherestep;
                }
                else
                {
                    points[i].Location += spheres[i].step;
                }
            }
// end multi-threading
        }
        stopwatch3.Start();
        await delay;
        stopwatch3.Stop();
        stopwatch2.Stop();
        waited += stopwatch3.ElapsedMilliseconds;
        stopwatch3.Reset();
        stopwatch2.Reset();
        if (refreshcounter % 100 == 0)
        {
            stopwatch1.Stop();
            refreshInterval = (stopwatch1.ElapsedMilliseconds - waited) / (1000.0 * refreshcounter);
            refreshMS = (int)(refreshInterval * 1000.0);
            spherestep = refreshInterval * slowdownFactor * Speed;
            for (int i = 0; i < sphereNum; i++)
            {
                spheres[i].step.Unitize();
                spheres[i].step *= spherestep;
            }
            stopwatch1.Start();
        }
        refreshcounter++;
    }
}

private struct RaySphereData
{
    public double pathlength;
    public Rhino.Geometry.Vector3d step;
    public System.Numerics.Vector3 nextstart;
    public System.Numerics.Vector3 nextdirection;
}

Я изучил Barrier, Monitor и SemaphoreSlim, но либо из-за моего непонимания, либо из-за недостаточности документации по этим функциям .NET я не смог заставить их работать. Есть ли предложения? (Кроме того, если есть какие-нибудь лучшие предложения по адаптации частоты обновления, я полностью за.)