using System.Diagnostics;
A>using System.IO;
A>using Unity.Burst;
A>using Unity.Collections;
A>using Unity.Collections.LowLevel.Unsafe;
A>using Unity.Jobs;
A>using Unity.Mathematics;
A>using UnityEngine;
A>using UnityEngine.UI;

A>public class Benchmark : MonoBehaviour
A>{
A>    private const int COUNT = 1000;
A>    private const int WIDTH = 1600, HEIGHT = 900;

A>    private Texture2D texture;
A>    private NativeArray<int> image;
A>    private NativeArray<int> buffer;
A>    private NativeArray<int> results;
A>    private ProcessJob processJob;

A>    public void Start()
A>    {
A>        image = new NativeArray<int>(WIDTH * HEIGHT, Allocator.TempJob);
A>        buffer = new NativeArray<int>(image.Length, Allocator.TempJob);
A>        results = new NativeArray<int>(length: 1, Allocator.TempJob);
A>        processJob = new ProcessJob
A>        {
A>            image = image,
A>            buffer = buffer,
A>            count = COUNT,
A>            height = HEIGHT,
A>            results = results,
A>        };

A>        var filename = Path.Combine(Directory.GetCurrentDirectory(), "results.txt");
A>        using (var writer = File.AppendText(filename))
A>        {
A>            var sw = new Stopwatch();
A>            for (int i = 0; i < 10; i++)
A>            {
A>                LoadImage(image, WIDTH, HEIGHT);

A>                sw.Restart();
A>                processJob.Run();
A>                sw.Stop();

A>                writer.Write($"{i}. {sw.ElapsedMilliseconds} ms, image[12345]={results[0]}\n");
A>                writer.Flush();
A>            }

A>            writer.Write("done\n\n");
A>        }

A>        LoadImage(image, WIDTH, HEIGHT);
A>        processJob.count = 1;

A>        texture = new Texture2D(WIDTH, HEIGHT, TextureFormat.RGBA32, false);
A>        GetComponent<RawImage>().texture = texture;
A>        image.CopyTo(texture.GetRawTextureData<int>());
A>        texture.Apply();
A>    }

A>    private void OnDestroy()
A>    {
A>        image.Dispose();
A>        buffer.Dispose();
A>        results.Dispose();
A>    }

A>    private JobHandle handle = default;

A>    private void Update()
A>    {
A>        handle.Complete();

A>        if (Input.GetKey(KeyCode.Space))
A>        {
A>            image.CopyTo(texture.GetRawTextureData<int>());
A>            texture.Apply();

A>            handle = processJob.Schedule();
A>            JobHandle.ScheduleBatchedJobs();
A>        }
A>    }

A>    private static void LoadImage(NativeArray<int> image, int width, int height)
A>    {
A>        for (int i = 0; i < image.Length; i++) image[i] = 0;
A>        for (int i = 0; i < width; i++) image[i] = 0xffffff;
A>        for (int i = 0; i < width; i++) image[(height - 1) * width + i] = 0xffffff;
A>        for (int i = 0; i < height; i++) image[width * i] = 0xffffff;
A>        for (int i = 0; i < height; i++) image[width * i + width - 1] = 0xffffff;
A>        for (int i = width / 2 - 100; i < width / 2 + 100; i++) image[width * height / 2 + i] = 0xffffff;
A>        for (int i = height / 2 - 100; i < height / 2 + 100; i++) image[width * i + width / 2] = 0xffffff;
A>    }

A>    [BurstCompile(CompileSynchronously = true)]
A>    internal unsafe struct ProcessJob : IJob
A>    {
A>        public NativeArray<int> image;
A>        public NativeArray<int> buffer;
A>        public int height;
A>        public int count;
A>        public NativeArray<int> results;

A>        public void Execute()
A>        {
A>            image.CopyTo(buffer);

A>            var imagePtr = (int*)image.GetUnsafePtr();
A>            var bufferPtr = (int*)buffer.GetUnsafePtr();

A>            int width = image.Length / height;
A>            for (int i = 0; i < count; i++)
A>            {
A>                ProcessImage(imagePtr, bufferPtr, width, height);
A>                ProcessImage(bufferPtr, imagePtr, width, height);
A>            }

A>            results[0] = image[12345];
A>        }

A>        private static void ProcessImage(int* input, int* output, int width, int height)
A>        {
A>            for (int y = 1; y < height - 1; y++)
A>            {
A>                var s = input + y * width + 1;
A>                var d = output + y * width;

A>                for (int x = 1; x < width - 1; x++)
A>                {
A>                    int sum = (s[-width - 1] + s[-width] + s[-width + 1] +
A>                               s[-1] + s[1] +
A>                               s[width - 1] + s[width] + s[width + 1]) >> 3;
A>                    d[x] = math.select(d[x], sum, *s++ != 0xffffff);
A>                }
A>            }
A>        }
A>    }
A>}