Merge branch 'release/3.3.2'

Author: github-actions

src/PiWeb.Volume/Block/BlockInfo.cs

@@ -55,14 +55,13 @@ internal readonly record struct BlockInfo( ushort ValueCount, bool IsFirstValueS
 	#region methods
 
 	/// <summary>
-	/// Reads the <see cref="BlockInfo"/> from the specified <paramref name="reader"/>.
+	/// Reads the <see cref="BlockInfo"/> from the specified <paramref name="value"/>.
 	/// </summary>
-	public static BlockInfo Read( BinaryReader reader )
+	public static BlockInfo Create( ushort value )
 	{
-		var resultLength = reader.ReadUInt16();
-		var valueCount = resultLength & ValueCountMask;
-		var isFirstValueShort = ( resultLength & IsFirstValueShortMask ) >> IsFirstValueShortOffset;
-		var areOtherValuesShort = ( resultLength & AreOtherValuesShortMask ) >> AreOtherValuesShortOffset;
+		var valueCount = value & ValueCountMask;
+		var isFirstValueShort = ( value & IsFirstValueShortMask ) >> IsFirstValueShortOffset;
+		var areOtherValuesShort = ( value & AreOtherValuesShortMask ) >> AreOtherValuesShortOffset;
 
 		return new BlockInfo( (ushort)valueCount, isFirstValueShort > 0, areOtherValuesShort > 0 );
 	}

src/PiWeb.Volume/Block/BlockVolume.cs

@@ -190,8 +190,8 @@ public override void GetSlice(
 		CancellationToken ct = default )
 	{
 		var sw = Stopwatch.StartNew();
-		var sliceRangeCollector = new BlockVolumeSliceRangeCollector( this, slice, buffer );
-		sliceRangeCollector.CollectSliceRanges( progress, ct );
+		var sliceCollector = new BlockVolumeSliceCollector( this, slice, buffer );
+		sliceCollector.CollectSlice( progress, ct );
 
 		logger?.Log( LogLevel.Info, $"Extracted '{slice}' in {sw.ElapsedMilliseconds} ms." );
 	}

src/PiWeb.Volume/Block/BlockVolumeDecoder.cs

@@ -15,8 +15,8 @@ namespace Zeiss.PiWeb.Volume.Block;
 
 using System;
 using System.Buffers;
-using System.IO;
 using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics;
 using System.Threading;
 using System.Threading.Tasks;
 
@@ -41,37 +41,49 @@ internal static void Decode( byte[] data,
 		IProgress<VolumeSliceDefinition>? progress = null,
 		CancellationToken ct = default )
 	{
-		var reader = new BinaryReader( new MemoryStream( data ) );
-		var (_, sizeX, sizeY, sizeZ, quantization) = BlockVolumeMetaData.Read( reader );
+		var header = BlockVolumeMetaData.Create( data );
+		var (_, sizeX, sizeY, sizeZ, quantization) = header;
 		var (bcx, bcy, bcz) = BlockVolume.GetBlockCount( sizeX, sizeY, sizeZ );
 		var blockCount = bcx * bcy;
 		var encodedBlockInfos = new EncodedBlockInfo[ blockCount ];
+		var position = BlockVolumeMetaData.HeaderLength;
+		var dataSpan = data.AsSpan();
+
+		Quantization.Invert( quantization );
 
 		for( ushort biz = 0; biz < bcz; biz++ )
 		{
 			ct.ThrowIfCancellationRequested();
 
-			var layerLength = reader.ReadInt32();
+			var layerLength = MemoryMarshal.Read<int>( dataSpan.Slice( position, sizeof( int ) ) );
+			position += sizeof( int );
 			if( layerPredicate?.Invoke( biz ) is false )
 			{
-				reader.BaseStream.Seek( layerLength, SeekOrigin.Current );
+				position += layerLength;
 				continue;
 			}
 
-			ReadBlockInfos( reader, blockCount, encodedBlockInfos );
+			ReadLayer( dataSpan, position, blockCount, encodedBlockInfos );
 			DecodeLayer( data, encodedBlockInfos, bcx, bcy, biz, quantization, blockPredicate, blockAction );
 
 			progress?.Report( new VolumeSliceDefinition( Direction.Z, (ushort)( biz * BlockVolume.N ) ) );
+
+			position += layerLength;
 		}
 	}
 
-	private static void ReadBlockInfos( BinaryReader reader, int blockCount, EncodedBlockInfo[] encodedBlockInfos )
+	private static void ReadLayer( ReadOnlySpan<byte> dataSpan, int position, int blockCount, EncodedBlockInfo[] encodedBlockInfos )
 	{
 		for( var i = 0; i < blockCount; i++ )
 		{
-			var encodedBlockInfo = EncodedBlockInfo.Read( reader );
-			reader.BaseStream.Seek( encodedBlockInfo.Info.Length, SeekOrigin.Current );
+			var value = MemoryMarshal.Read<ushort>( dataSpan[ position.. ] );
+
+			position += sizeof( ushort );
+
+			var encodedBlockInfo = new EncodedBlockInfo( position, BlockInfo.Create( value ) );
 			encodedBlockInfos[ i ] = encodedBlockInfo;
+
+			position += encodedBlockInfo.Info.Length;
 		}
 	}
 
@@ -85,50 +97,71 @@ private static void DecodeLayer(
 		BlockPredicate? blockPredicate,
 		BlockAction blockAction )
 	{
-		Parallel.For( 0, blockCountX * blockCountY, () => (
-				ArrayPool<double>.Shared.Rent( BlockVolume.N3 ),
-				ArrayPool<double>.Shared.Rent( BlockVolume.N3 ),
-				ArrayPool<byte>.Shared.Rent( BlockVolume.N3 )
-			), ( index, _, buffers ) =>
-			{
-				var blockIndexX = index % blockCountX;
-				var blockIndexY = index / blockCountX;
-				var blockIndex = new BlockIndex( (ushort)blockIndexX, (ushort)blockIndexY, blockIndexZ );
+#if DEBUG
+		var buffers = new DecodingBuffers();
+		for( var index = 0; index < blockCountX * blockCountY; index++ )
+		{
+#else
+		Parallel.For( 0, blockCountX * blockCountY, () => new DecodingBuffers(), ( index, _, buffers ) =>
+		{
+#endif
+			var blockIndexX = index % blockCountX;
+			var blockIndexY = index / blockCountX;
+			var blockIndex = new BlockIndex( (ushort)blockIndexX, (ushort)blockIndexY, blockIndexZ );
 
-				if( blockPredicate?.Invoke( blockIndex ) == false )
-					return buffers;
+			if( blockPredicate?.Invoke( blockIndex ) == false )
+#if DEBUG
+				continue;
+#else
+				return buffers;
+#endif
 
-				var doubleBuffer1 = buffers.Item1.AsSpan( 0, BlockVolume.N3 );
-				var doubleBuffer2 = buffers.Item2.AsSpan( 0, BlockVolume.N3 );
-				var byteBuffer = buffers.Item3.AsSpan( 0, BlockVolume.N3 );
-				var encodedBlockInfo = encodedBlockInfos[ index ];
+			var inputSpan = buffers.InputBuffer.AsSpan( 0, BlockVolume.N3 );
+			var outputSpan = buffers.OutputBuffer.AsSpan( 0, BlockVolume.N3 );
+			var resultSpan = buffers.ResultBuffer.AsSpan( 0, BlockVolume.N3 );
+			var encodedBlockInfo = encodedBlockInfos[ index ];
 
-				//1. Dediscretization
-				ReadBlock( encodedBlocks.AsSpan(), encodedBlockInfo, doubleBuffer1 );
+			//1. Dediscretization
+			ReadBlock( encodedBlocks.AsSpan(), encodedBlockInfo, inputSpan );
 
-				//2. ZigZag
-				ZigZag.Reverse( doubleBuffer1, doubleBuffer2 );
+			//2. ZigZag
+			ZigZag.Reverse( inputSpan, outputSpan );
 
-				//3. Quantization
-				Quantization.Apply( quantization.AsSpan(), doubleBuffer2 );
+			var nonEmptyVectors = FindNonEmptyVectors( outputSpan );
 
-				//4. Cosine transform
-				DiscreteCosineTransform.Transform( doubleBuffer2, doubleBuffer1, true );
+			//3. Quantization
+			Quantization.Apply( quantization.AsSpan(), outputSpan );
 
-				//5. Discretization
-				for( var i = 0; i < BlockVolume.N3; i++ )
-					byteBuffer[ i ] = (byte)Math.Clamp( doubleBuffer1[ i ], byte.MinValue, byte.MaxValue );
+			//4. Cosine transform
+			DiscreteCosineTransform.Transform( outputSpan, inputSpan, true, nonEmptyVectors );
 
-				blockAction( byteBuffer, blockIndex );
+			//5. Discretization
+			for( var i = 0; i < BlockVolume.N3; i++ )
+				resultSpan[ i ] = (byte)Math.Clamp( inputSpan[ i ], byte.MinValue, byte.MaxValue );
 
-				return buffers;
-			},
-			buffers =>
-			{
-				ArrayPool<double>.Shared.Return( buffers.Item1 );
-				ArrayPool<double>.Shared.Return( buffers.Item2 );
-				ArrayPool<byte>.Shared.Return( buffers.Item3 );
-			} );
+			blockAction( resultSpan, blockIndex );
+#if DEBUG
+		}
+
+		buffers.Return();
+#else
+			return buffers;
+		}, buffers => buffers.Return() );
+#endif
+	}
+
+	private static ulong FindNonEmptyVectors( Span<double> values )
+	{
+		var vectors = MemoryMarshal.Cast<double, Vector512<double>>( values );
+		var result = 0UL;
+
+		for( ushort i = 0; i < BlockVolume.N2; i++ )
+		{
+			if( Vector512.Sum( Vector512.Abs( vectors[ i ] ) ) > 1e-12 )
+				result |= 1UL << i;
+		}
+
+		return result;
 	}
 
 	private static void ReadBlock( ReadOnlySpan<byte> data, EncodedBlockInfo blockInfo, Span<double> result )
@@ -167,24 +200,22 @@ private static void ReadBlock( ReadOnlySpan<byte> data, EncodedBlockInfo blockIn
 
 	#endregion
 
-	private readonly record struct EncodedBlockInfo( int StartIndex, BlockInfo Info )
+	private readonly struct DecodingBuffers()
 	{
-		#region methods
+		public double[] InputBuffer { get; } = ArrayPool<double>.Shared.Rent( BlockVolume.N3 );
+		public double[] OutputBuffer { get; } = ArrayPool<double>.Shared.Rent( BlockVolume.N3 );
+		public byte[] ResultBuffer { get; } = ArrayPool<byte>.Shared.Rent( BlockVolume.N3 );
 
-		/// <summary>
-		/// Reads the encoded block info from the specified <paramref name="reader"/>
-		/// </summary>
-		public static EncodedBlockInfo Read( BinaryReader reader )
+		public void Return()
 		{
-			var info = BlockInfo.Read( reader );
-			var startIndex = (int)reader.BaseStream.Position;
-
-			return new EncodedBlockInfo( startIndex, info );
+			ArrayPool<double>.Shared.Return( InputBuffer );
+			ArrayPool<double>.Shared.Return( OutputBuffer );
+			ArrayPool<byte>.Shared.Return( ResultBuffer );
 		}
-
-		#endregion
 	}
 
+	private readonly record struct EncodedBlockInfo( int StartIndex, BlockInfo Info );
+
 	internal delegate void BlockAction( ReadOnlySpan<byte> data, BlockIndex index );
 
 	internal delegate bool BlockPredicate( BlockIndex index );

src/PiWeb.Volume/Block/BlockVolumeDecompressor.cs

@@ -79,12 +79,13 @@ private void CopyBlockToResult( ReadOnlySpan<byte> block, BlockIndex index )
 		for( var bz = 0; bz < sz; bz++ )
 		{
 			var gz = index.Z * BlockVolume.N + bz;
+			var oz = bz * BlockVolume.N2;
 			var sliceData = _Result[ gz ].AsSpan();
 
 			for( var by = 0; by < sy; by++ )
 			{
 				var gy = index.Y * BlockVolume.N + by;
-				block.Slice( bz * BlockVolume.N2 + by * BlockVolume.N, sx ).CopyTo( sliceData.Slice( gy * _SizeX + gx, sx ) );
+				block.Slice( oz + by * BlockVolume.N, sx ).CopyTo( sliceData.Slice( gy * _SizeX + gx, sx ) );
 			}
 		}
 	}

src/PiWeb.Volume/Block/BlockVolumeMetaData.cs

@@ -14,13 +14,14 @@ namespace Zeiss.PiWeb.Volume.Block;
 
 using System;
 using System.IO;
+using System.Runtime.InteropServices;
 
 #endregion
 
 /// <summary>
 /// Holds information that are needed to encode and decode a block volume.
 /// </summary>
-public readonly record struct BlockVolumeMetaData( uint Version, ushort SizeX, ushort SizeY, ushort SizeZ, double[] Quantization )
+public record BlockVolumeMetaData( uint Version, ushort SizeX, ushort SizeY, ushort SizeZ, double[] Quantization )
 {
 	#region methods
 
@@ -40,26 +41,37 @@ public void Write( BinaryWriter writer )
 	}
 
 	/// <summary>
-	/// Reads the metadata from the specified <paramref name="reader"/>
+	/// Reads the metadata from the specified <paramref name="data"/>
 	/// </summary>
-	public static BlockVolumeMetaData Read( BinaryReader reader )
+	public static BlockVolumeMetaData Create( ReadOnlySpan<byte> data )
 	{
-		var header = reader.ReadUInt32();
+		var position = 0;
+		var header = MemoryMarshal.Read<uint>( data[ position.. ] );
+		position += sizeof( uint );
 		if( header != BlockVolume.FileHeader )
 			throw new FormatException( $"Encountered unexpected file header 0x{header:x8}, expected 0x{BlockVolume.FileHeader:x8}" );
 
-		var version = reader.ReadUInt32();
+		var version = MemoryMarshal.Read<uint>( data[ position.. ] );
+		position += sizeof( uint );
 		if( version != BlockVolume.Version )
 			throw new FormatException( $"Encountered unexpected file header '{version}', expected {BlockVolume.Version}" );
 
-		var sizeX = reader.ReadUInt16();
-		var sizeY = reader.ReadUInt16();
-		var sizeZ = reader.ReadUInt16();
+		var sizeX = MemoryMarshal.Read<ushort>( data[ position.. ] );
+		position += sizeof( ushort );
+		var sizeY = MemoryMarshal.Read<ushort>( data[ position.. ] );
+		position += sizeof( ushort );
+		var sizeZ = MemoryMarshal.Read<ushort>( data[ position.. ] );
+		position += sizeof( ushort );
 
-		var quantization = Block.Quantization.Read( reader, true );
+		var quantization = MemoryMarshal.Cast<byte, double>( data.Slice( position, BlockVolume.N3 * sizeof( double ) ) );
 
-		return new BlockVolumeMetaData( version, sizeX, sizeY, sizeZ, quantization );
+		return new BlockVolumeMetaData( version, sizeX, sizeY, sizeZ, quantization.ToArray() );
 	}
 
 	#endregion
+
+	/// <summary>
+	/// The number of bytes the header consists of.
+	/// </summary>
+	public static int HeaderLength => 2 * sizeof( uint ) + 3 * sizeof( ushort ) + BlockVolume.N3 * sizeof( double );
 }