JacksonDunstan.com

[BurstCompile]
struct MyJob : IJob

[BurstCompile(FloatPrecision.High, FloatMode.Strict)]
struct MyJob : IJob

/// <summary>
/// Представляет собой точность вычислений с плавающей точкой для определенных встроенных операций, синус/косинус и т.д.
/// </summary>
public enum FloatPrecision
{
    /// <summary>
    /// Использует точность по умолчанию, смотри FloatPrecision.Medium
    /// </summary>
    Standard = 0,
    /// <summary>
    /// Вычисления с точностью до 1 ULP - очень точные, но медленнее выполняются, не должны использоваться для большинства целей
    /// </summary>
    High = 1,
    /// <summary>
    /// Вычисления с точностью 3.5 ULP - считаются приемлемыми для большинства задач.
    /// </summary>
    Medium = 2,
    /// <summary>
    /// Зарезервировано на будущее
    /// </summary>
    Low = 3,
}
 
/// <summary>
/// Представляет собой режим оптимизаций компилятора для вычислений с плавающей точкой
/// </summary>
public enum FloatMode
{
    /// <summary>
    /// Использует режим по умолчанию, смотри FloatMode.Strict.
    /// </summary>
    Default = 0,
    /// <summary>
    /// Не выполняется никаких оптимизаций
    /// </summary>
    Strict = 1,
    /// <summary>
    /// Зарезервировано на будущее
    /// </summary>
    Deterministic = 2,
    /// <summary>
    /// Допускает алгебраический эквивалент оптимизации (который может поменять результат вычислений), это подразумевает, что:
    /// <para/> оптимизации могут предполагать, что результаты и аргументы не содержат NaN или +/- бесконечность и не учитывают знак нуля.
    /// <para/> оптимизации могут использовать обратные операции - 1/x * y, вместо y/x.
    /// <para/> оптимизации могут использовать совмещенные инструкции, например, madd.
    /// </summary>
    Fast = 3,
}

using System;
using System.Diagnostics;
using Unity.Burst;
using Unity.Collections;
using Unity.Jobs;
using Unity.Mathematics;
using UnityEngine;
 
class TestScript : MonoBehaviour
{
    [BurstCompile(FloatPrecision.High, FloatMode.Strict)]
    struct AddHighStrictJob : IJob
    {
        public NativeArray<float4> A;
        public NativeArray<float4> B;
        public NativeArray<float4> C;
 
        public void Execute()
        {
            for (int i = 0; i < A.Length; ++i)
            {
                C[i] = A[i] + B[i];
            }
        }
    }
 
    [BurstCompile(FloatPrecision.High, FloatMode.Fast)]
    struct AddHighFastJob : IJob
    {
        public NativeArray<float4> A;
        public NativeArray<float4> B;
        public NativeArray<float4> C;
 
        public void Execute()
        {
            for (int i = 0; i < A.Length; ++i)
            {
                C[i] = A[i] + B[i];
            }
        }
    }
 
    [BurstCompile(FloatPrecision.Medium, FloatMode.Strict)]
    struct AddMedStrictJob : IJob
    {
        public NativeArray<float4> A;
        public NativeArray<float4> B;
        public NativeArray<float4> C;
 
        public void Execute()
        {
            for (int i = 0; i < A.Length; ++i)
            {
                C[i] = A[i] + B[i];
            }
        }
    }
 
    [BurstCompile(FloatPrecision.Medium, FloatMode.Fast)]
    struct AddMedFastJob : IJob
    {
        public NativeArray<float4> A;
        public NativeArray<float4> B;
        public NativeArray<float4> C;
 
        public void Execute()
        {
            for (int i = 0; i < A.Length; ++i)
            {
                C[i] = A[i] + B[i];
            }
        }
    }
 
    [BurstCompile(FloatPrecision.High, FloatMode.Strict)]
    struct DotHighStrictJob : IJob
    {
        public NativeArray<float4> A;
        public NativeArray<float4> B;
        public NativeArray<float4> C;
 
        public void Execute()
        {
            for (int i = 0; i < A.Length; ++i)
            {
                C[i] = math.dot(A[i], B[i]);
            }
        }
    }
 
    [BurstCompile(FloatPrecision.High, FloatMode.Fast)]
    struct DotHighFastJob : IJob
    {
        public NativeArray<float4> A;
        public NativeArray<float4> B;
        public NativeArray<float4> C;
 
        public void Execute()
        {
            for (int i = 0; i < A.Length; ++i)
            {
                C[i] = math.dot(A[i], B[i]);
            }
        }
    }
 
    [BurstCompile(FloatPrecision.Medium, FloatMode.Strict)]
    struct DotMedStrictJob : IJob
    {
        public NativeArray<float4> A;
        public NativeArray<float4> B;
        public NativeArray<float4> C;
 
        public void Execute()
        {
            for (int i = 0; i < A.Length; ++i)
            {
                C[i] = math.dot(A[i], B[i]);
            }
        }
    }
 
    [BurstCompile(FloatPrecision.Medium, FloatMode.Fast)]
    struct DotMedFastJob : IJob
    {
        public NativeArray<float4> A;
        public NativeArray<float4> B;
        public NativeArray<float4> C;
 
        public void Execute()
        {
            for (int i = 0; i < A.Length; ++i)
            {
                C[i] = math.dot(A[i], B[i]);
            }
        }
    }
 
    void Start()
    {
        const int size = 1000000;
        const Allocator alloc = Allocator.TempJob;
        NativeArray<float4> a = new NativeArray<float4>(size, alloc);
        NativeArray<float4> b = new NativeArray<float4>(size, alloc);
        NativeArray<float4> c = new NativeArray<float4>(size, alloc);
        for (int i = 0; i < size; ++i)
        {
            a[i] = float4.zero;
            b[i] = float4.zero;
            c[i] = float4.zero;
        }
 
        AddHighStrictJob ahsj = new AddHighStrictJob { A = a, B = b, C = c };
        AddHighFastJob ahfj = new AddHighFastJob { A = a, B = b, C = c };
        AddMedStrictJob amsj = new AddMedStrictJob { A = a, B = b, C = c };
        AddMedFastJob amfj = new AddMedFastJob { A = a, B = b, C = c };
        DotHighStrictJob dhsj = new DotHighStrictJob { A = a, B = b, C = c };
        DotHighFastJob dhfj = new DotHighFastJob { A = a, B = b, C = c };
        DotMedStrictJob dmsj = new DotMedStrictJob { A = a, B = b, C = c };
        DotMedFastJob dmfj = new DotMedFastJob { A = a, B = b, C = c };
 
        const int reps = 100;
        long[] ahst = new long[reps];
        long[] ahft = new long[reps];
        long[] amst = new long[reps];
        long[] amft = new long[reps];
        long[] dhst = new long[reps];
        long[] dhft = new long[reps];
        long[] dmst = new long[reps];
        long[] dmft = new long[reps];
        Stopwatch sw = new Stopwatch();
        for (int i = 0; i < reps; ++i)
        {
            sw.Restart();
            ahsj.Run();
            ahst[i] = sw.ElapsedTicks;
 
            sw.Restart();
            ahfj.Run();
            ahft[i] = sw.ElapsedTicks;
 
            sw.Restart();
            amsj.Run();
            amst[i] = sw.ElapsedTicks;
 
            sw.Restart();
            amfj.Run();
            amft[i] = sw.ElapsedTicks;
 
            sw.Restart();
            dhsj.Run();
            dhst[i] = sw.ElapsedTicks;
 
            sw.Restart();
            dhfj.Run();
            dhft[i] = sw.ElapsedTicks;
 
            sw.Restart();
            dmsj.Run();
            dmst[i] = sw.ElapsedTicks;
 
            sw.Restart();
            dmfj.Run();
            dmft[i] = sw.ElapsedTicks;
        }
 
        print(
            "Operation,High-Strict,High-Fast,Medium-Strict,Medium-Fastn" +
            "Add,"
                + Median(ahst) + ","
                + Median(ahft) + ","
                + Median(amst) + ","
                + Median(amft) + "n" +
            "Dot," + Median(dhst)
                + "," + Median(dhft)
                + "," + Median(dmst)
                + "," + Median(dmft));
 
        a.Dispose();
        b.Dispose();
        c.Dispose();
 
        Application.Quit();
    }
 
    static long Median(long[] values)
    {
        Array.Sort(values);
        return values[values.Length / 2];
    }
}