HurricanKai · April 8, 2019 11:54
diff --git a/Chunk.cs b/Chunk.cs
 using System;
 using System.Collections.Generic;
 using System.Runtime.CompilerServices;
 using System.Text;

 namespace WorldStructure
 {
    public struct Chunk
    {
        public const int WIDTH = 16;
        public const int HEIGHT = 256;
        public const int DEPTH = 16;

        private Memory<Block> blocks;

        public Block this[int x, int y, int z]
        {
            get => blocks.Span[Index(x, y, z)];
            set => blocks.Span[Index(x, y, z)] = value;
        }

        public Span<Block> Span => blocks.Span;

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public ChunkSlice GetSlice(
             int xMin,  int yMin,  int zMin,
             int xMax,  int yMax,  int zMax)
            => new ChunkSlice(
                blocks,
                xMin, yMin, zMin,
                xMax, yMax, zMax);

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public RefChunkSlice GetRefSlice(
             int xMin,  int yMin,  int zMin,
             int xMax,  int yMax,  int zMax)
            => new RefChunkSlice(
                blocks.Span,
                xMin, yMin, zMin,
                xMax, yMax, zMax);

        public void Fill(in BlockMaterial mat)
        {
            if (blocks.IsEmpty)
                blocks = new Memory<Block>(new Block[WIDTH * HEIGHT * DEPTH]);
            blocks.Span.Fill(mat.CreateBlock());
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static int Index( int x,  int y,  int z)
        {
            /*if (x >= WIDTH  || x < 0) IndexArgOutOfRange(nameof(x), WIDTH);
            if (y >= HEIGHT || x < 0) IndexArgOutOfRange(nameof(y), HEIGHT);
            if (z >= DEPTH  || x < 0) IndexArgOutOfRange(nameof(z), DEPTH);*/

            return x + WIDTH * (y + HEIGHT * z);
        }

        private static void IndexArgOutOfRange( string param,  int max)
            => throw new IndexOutOfRangeException($"{param} has to be 0 < {param} < {max}");
    }
 }
diff --git a/ChunkSlice.cs b/ChunkSlice.cs
 using System;
 using System.Runtime.CompilerServices;

 namespace WorldStructure
 {
    public struct ChunkSlice
    {
        private Memory<Block> _blocks;

        public readonly int XMin, YMin, ZMin;
        public readonly int XMax, YMax, ZMax;
        public readonly int Width, Height, Depth;

        public Span<Block> Span => _blocks.Span;


        public ChunkSlice(
            Memory<Block> memory,
            int xMin, int yMin, int zMin,
            int xMax, int yMax, int zMax)
        {
            XMin = xMin;
            YMin = yMin;
            ZMin = zMin;
            XMax = xMax;
            YMax = yMax;
            ZMax = zMax;

            Width = XMax - XMin;
            Height = YMax - YMin;
            Depth = ZMax - ZMin;

            var startIndex = Chunk.Index(xMin, yMin, zMin);
            var endIndex = Chunk.Index(xMax, yMax, zMax);

            _blocks = memory.Slice(
                startIndex,
                endIndex - startIndex);
        }

        public Block this[int relX, int relY, int relZ]
        {
            get => Span[Index(relX, relY, relZ)];
            set => Span[Index(relX, relY, relZ)] = value;
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public int Index(int x, int y, int z)
        {
            /*if (x >= Width  || x < 0) IndexArgOutOfRange(nameof(x),  Width);
            if (y >= Height || x < 0) IndexArgOutOfRange(nameof(y),  Height);
            if (z >= Depth  || x < 0) IndexArgOutOfRange(nameof(z),  Depth);*/

            return x + Width * (y + Height * z);
        }

        /*private static void IndexArgOutOfRange( string param,  int max)
            => throw new IndexOutOfRangeException($"{param} has to be 0 < {param} < {max}");*/
    }
 }
diff --git a/Program.cs b/Program.cs
 using BenchmarkDotNet.Attributes;
 using BenchmarkDotNet.Order;
 using BenchmarkDotNet.Running;
 using System;
 using WorldStructure;

 namespace WorldStructureBenchmarks
 {
    class Program
    {
        static void Main(string[] args)
        {
            BenchmarkRunner.Run<SliceVsRefSliceVsLoopFillBenchmark>();
        }
    }

    [Orderer(SummaryOrderPolicy.FastestToSlowest)] // Order the result
    [MemoryDiagnoser] // Analyse the memory usage
    [CoreJob]
    [GcForce(true)]
    [IterationsColumn]
    public class SliceVsRefSliceVsLoopFillBenchmark
    {
        public Chunk Chunk;
        public BlockMaterial Material;

        [Params(2)]
        public int xMin, yMin, zMin;
        [Params(8)]
        public int xMax, yMax, zMax;

        [GlobalSetup]
        public void Setup()
        {
            Chunk = new Chunk();
            Chunk.Fill(Materials.Air);
            Material = Materials.Dirt;
        }

        [IterationSetup]
        public void IterationSetup()
        {
            Chunk.Fill(Materials.Air);
        }

        [Benchmark]
        public void Loop()
        {
            var span = Chunk.Span;
            var block = Material.CreateBlock();

            for (int x = xMin; x < xMax; x++)
            {
                for (int z = zMin; z < zMax; z++)
                {
                    for (int y = yMin; y < yMax; y++)
                    {
                        span[Chunk.Index(x, y, z)] = block;
                    }
                }
            }
        }

        [Benchmark]
        public void SliceFill()
        {
            Chunk.GetSlice(xMin, yMin, zMin, xMax, yMax, zMax).Span.Fill(Material.CreateBlock());
        }

        [Benchmark]
        public void RefSliceFill()
        {
            Chunk.GetRefSlice(xMin, yMin, zMin, xMax, yMax, zMax).Span.Fill(Material.CreateBlock());
        }

        [Benchmark]
        public void SliceLoop()
        {
            var slice = Chunk.GetSlice(xMin, yMin, zMin, xMax, yMax, zMax);
            var span = slice.Span;
            var block = Material.CreateBlock();

            for (int x = 0; x < slice.Width; x++)
            {
                for (int z = 0; z < slice.Depth; z++)
                {
                    for (int y = 0; y < slice.Height; y++)
                    {
                        span[Chunk.Index(x, y, z)] = block;
                    }
                }
            }
        }

        [Benchmark]
        public void RefSliceLoop()
        {
            var slice = Chunk.GetRefSlice(xMin, yMin, zMin, xMax, yMax, zMax);
            var span = slice.Span;
            var block = Material.CreateBlock();

            for (int x = 0; x < slice.Width; x++)
            {
                for (int z = 0; z < slice.Depth; z++)
                {
                    for (int y = 0; y < slice.Height; y++)
                    {
                        span[Chunk.Index(x, y, z)] = block;
                    }
                }
            }
        }
    }
 }
diff --git a/RefChunkSlice.cs b/RefChunkSlice.cs
 using System;
 using System.Runtime.CompilerServices;

 namespace WorldStructure
 {
    public ref struct RefChunkSlice
    {
        public readonly int XMin, YMin, ZMin;
        public readonly int XMax, YMax, ZMax;
        public readonly int Width, Height, Depth;

        public Span<Block> Span;


        public RefChunkSlice(
            Span<Block> span,
            int xMin, int yMin, int zMin,
            int xMax, int yMax, int zMax)
        {
            XMin = xMin;
            YMin = yMin;
            ZMin = zMin;
            XMax = xMax;
            YMax = yMax;
            ZMax = zMax;

            Width = XMax - XMin;
            Height = YMax - YMin;
            Depth = ZMax - ZMin;

            var startIndex = Chunk.Index(xMin, yMin, zMin);
            var endIndex = Chunk.Index(xMax, yMax, zMax);

            Span = span.Slice(
                startIndex,
                endIndex - startIndex);
        }

        public Block this[int relX, int relY, int relZ]
        {
            get => Span[Index(relX, relY, relZ)];
            set => Span[Index(relX, relY, relZ)] = value;
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public int Index(int x, int y, int z)
        {
            /*if (x >= Width  || x < 0) IndexArgOutOfRange(nameof(x),  Width);
            if (y >= Height || x < 0) IndexArgOutOfRange(nameof(y),  Height);
            if (z >= Depth  || x < 0) IndexArgOutOfRange(nameof(z),  Depth);*/

            return x + Width * (y + Height * z);
        }

        /*private static void IndexArgOutOfRange( string param,  int max)
            => throw new IndexOutOfRangeException($"{param} has to be 0 < {param} < {max}");*/
    }
 }
diff --git a/WorldStructureBenchmarks.LoopVsSpanFill-report-github.md b/WorldStructureBenchmarks.LoopVsSpanFill-report-github.md
diff --git a/WorldStructureBenchmarks.SliceVsRefSliceVsLoopFillBenchmark-report-github-extended.md b/WorldStructureBenchmarks.SliceVsRefSliceVsLoopFillBenchmark-report-github-extended.md
diff --git a/WorldStructureBenchmarks.SliceVsRefSliceVsLoopFillBenchmark-report-github.md b/WorldStructureBenchmarks.SliceVsRefSliceVsLoopFillBenchmark-report-github.md
	using System;
	using System.Collections.Generic;
	using System.Runtime.CompilerServices;
	using System.Text;

	namespace WorldStructure
	{
	public struct Chunk
	{
	public const int WIDTH = 16;
	public const int HEIGHT = 256;
	public const int DEPTH = 16;

	private Memory<Block> blocks;

	public Block this[int x, int y, int z]
	{
	get => blocks.Span[Index(x, y, z)];
	set => blocks.Span[Index(x, y, z)] = value;
	}

	public Span<Block> Span => blocks.Span;

	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	public ChunkSlice GetSlice(
	int xMin, int yMin, int zMin,
	int xMax, int yMax, int zMax)
	=> new ChunkSlice(
	blocks,
	xMin, yMin, zMin,
	xMax, yMax, zMax);

	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	public RefChunkSlice GetRefSlice(
	int xMin, int yMin, int zMin,
	int xMax, int yMax, int zMax)
	=> new RefChunkSlice(
	blocks.Span,
	xMin, yMin, zMin,
	xMax, yMax, zMax);

	public void Fill(in BlockMaterial mat)
	{
	if (blocks.IsEmpty)
	blocks = new Memory<Block>(new Block[WIDTH * HEIGHT * DEPTH]);
	blocks.Span.Fill(mat.CreateBlock());
	}

	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	public static int Index( int x, int y, int z)
	{
	/*if (x >= WIDTH \|\| x < 0) IndexArgOutOfRange(nameof(x), WIDTH);
	if (y >= HEIGHT \|\| x < 0) IndexArgOutOfRange(nameof(y), HEIGHT);
	if (z >= DEPTH \|\| x < 0) IndexArgOutOfRange(nameof(z), DEPTH);*/

	return x + WIDTH * (y + HEIGHT * z);
	}

	private static void IndexArgOutOfRange( string param, int max)
	=> throw new IndexOutOfRangeException($"{param} has to be 0 < {param} < {max}");
	}
	}
	using BenchmarkDotNet.Attributes;
	using BenchmarkDotNet.Order;
	using BenchmarkDotNet.Running;
	using System;
	using WorldStructure;

	namespace WorldStructureBenchmarks
	{
	class Program
	{
	static void Main(string[] args)
	{
	BenchmarkRunner.Run<SliceVsRefSliceVsLoopFillBenchmark>();
	}
	}

	[Orderer(SummaryOrderPolicy.FastestToSlowest)] // Order the result
	[MemoryDiagnoser] // Analyse the memory usage
	[CoreJob]
	[GcForce(true)]
	[IterationsColumn]
	public class SliceVsRefSliceVsLoopFillBenchmark
	{
	public Chunk Chunk;
	public BlockMaterial Material;

	[Params(2)]
	public int xMin, yMin, zMin;
	[Params(8)]
	public int xMax, yMax, zMax;

	[GlobalSetup]
	public void Setup()
	{
	Chunk = new Chunk();
	Chunk.Fill(Materials.Air);
	Material = Materials.Dirt;
	}

	[IterationSetup]
	public void IterationSetup()
	{
	Chunk.Fill(Materials.Air);
	}

	[Benchmark]
	public void Loop()
	{
	var span = Chunk.Span;
	var block = Material.CreateBlock();

	for (int x = xMin; x < xMax; x++)
	{
	for (int z = zMin; z < zMax; z++)
	{
	for (int y = yMin; y < yMax; y++)
	{
	span[Chunk.Index(x, y, z)] = block;
	}
	}
	}
	}

	[Benchmark]
	public void SliceFill()
	{
	Chunk.GetSlice(xMin, yMin, zMin, xMax, yMax, zMax).Span.Fill(Material.CreateBlock());
	}

	[Benchmark]
	public void RefSliceFill()
	{
	Chunk.GetRefSlice(xMin, yMin, zMin, xMax, yMax, zMax).Span.Fill(Material.CreateBlock());
	}

	[Benchmark]
	public void SliceLoop()
	{
	var slice = Chunk.GetSlice(xMin, yMin, zMin, xMax, yMax, zMax);
	var span = slice.Span;
	var block = Material.CreateBlock();

	for (int x = 0; x < slice.Width; x++)
	{
	for (int z = 0; z < slice.Depth; z++)
	{
	for (int y = 0; y < slice.Height; y++)
	{
	span[Chunk.Index(x, y, z)] = block;
	}
	}
	}
	}

	[Benchmark]
	public void RefSliceLoop()
	{
	var slice = Chunk.GetRefSlice(xMin, yMin, zMin, xMax, yMax, zMax);
	var span = slice.Span;
	var block = Material.CreateBlock();

	for (int x = 0; x < slice.Width; x++)
	{
	for (int z = 0; z < slice.Depth; z++)
	{
	for (int y = 0; y < slice.Height; y++)
	{
	span[Chunk.Index(x, y, z)] = block;
	}
	}
	}
	}
	}
	}
Method	N	Mean	Error	StdDev	Median	Iterations	Gen 0/1k Op	Gen 1/1k Op	Gen 2/1k Op	Allocated Memory/Op
SpanFill	1000	1.081 us	0.1068 us	0.3046 us	1.070 us	94.00	-	-	-	-
Loop	1000	1.165 us	0.0256 us	0.0738 us	1.210 us	96.00	-	-	-	-
SpanFill	10000	7.583 us	0.4377 us	1.2345 us	6.980 us	92.00	-	-	-	-
Loop	10000	11.767 us	0.3977 us	1.1217 us	11.595 us	92.00	-	-	-	-
SpanFill	100000	367.905 us	74.6713 us	220.1701 us	421.010 us	100.00	-	-	-	-
Loop	100000	371.141 us	71.8670 us	209.6394 us	444.710 us	98.00	-	-	-	-
Method	xMin	yMin	zMin	xMax	yMax	zMax	Mean	Error	StdDev	Median	Iterations	Gen 0/1k Op	Gen 1/1k Op	Gen 2/1k Op	Allocated Memory/Op
RefSliceLoop	2	2	2	8	8	8	5.094 us	0.2490 us	0.7145 us	5.010 us	95.00	-	-	-	40 B
Loop	2	2	2	8	8	8	5.112 us	0.2223 us	0.6160 us	5.105 us	89.00	-	-	-	40 B
SliceLoop	2	2	2	8	8	8	5.576 us	0.2479 us	0.6829 us	5.475 us	88.00	-	-	-	40 B
RefSliceFill	2	2	2	8	8	8	148.552 us	3.6644 us	3.2484 us	147.695 us	14.00	-	-	-	40 B
SliceFill	2	2	2	8	8	8	154.590 us	4.3911 us	12.0945 us	148.965 us	88.00	-	-	-	40 B