esiur/esiur-dotnet
2
0
Fork 0
mirror of https://github.com/esiur/esiur-dotnet.git synced 2026-04-29 06:48:41 +00:00
Code Issues Projects Releases Wiki Activity

alignment

Browse Source
This commit is contained in:
ahmed
2026-04-09 14:03:04 +03:00
parent e0eaa450ee
commit 15479288cc
11 changed files with 796 additions and 2122 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Libraries/Esiur/Data/Gvwie/GroupUInt32Codec.cs
+105 -37
View File
@@ -1,19 +1,24 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Runtime.CompilerServices;
namespace Esiur.Data.Gvwie;
public static class GroupUInt32Codec
{
// ----------------- Encoder -----------------
public static byte[] Encode(IList<uint> values)
{
if (values is null) throw new ArgumentNullException(nameof(values));
// Header layout:
// 1 | ccccc | ww
//
// MSB = 1 => grouped form
// ccccc = 0..30 => short count = ccccc + 1 (1..31)
// ccccc = 31 => extended count, followed by varint(count - 32)
// ww = 0..3 => width = ww + 1 (1..4)
//
// MSB = 0 => literal fast path for values in 7 bits
// ----------------- Encoder -----------------
public static byte[] Encode(IList<uint> values, bool aligned = false)
{
var dst = new List<byte>(values.Count * 2);
int i = 0;
@@ -21,38 +26,58 @@ public static class GroupUInt32Codec
{
uint v = values[i];
// Fast path: single byte for 0..127
// Fast path: single byte (MSB=0) when value fits in 7 bits
if (v <= 0x7Fu)
{
dst.Add((byte)v); // MSB=0 implicitly
dst.Add((byte)v);
i++;
continue;
}
// Group path: up to 16 items sharing a common width (1..4 bytes for uint32)
int start = i;
int width = WidthFromValue(v, aligned);
int count = 1;
int width = WidthFromUnsigned(v);
while (count < 16 && (i + count) < values.Count)
// Build a run of same-width non-literal values
while ((i + count) < values.Count)
{
uint v2 = values[i + count];
int w2 = WidthFromUnsigned(v2);
if (w2 > width) width = w2;
// Do not absorb literal-fast-path values into groups
if (v2 <= 0x7Fu)
break;
int w2 = WidthFromValue(v2, aligned);
if (w2 != width)
break;
count++;
}
// Header: 1 | (count-1)[4b] | (width-1)[3b]
byte header = 0x80;
header |= (byte)(((count - 1) & 0xF) << 3);
header |= (byte)((width - 1) & 0x7);
dst.Add(header);
// Payload
for (int k = 0; k < count; k++)
if (count <= 31)
{
WriteLE(dst, values[start + k], width);
// Short group:
// Header: 1 | (count-1)[5 bits] | (width-1)[2 bits]
byte header = 0x80;
header |= (byte)(((count - 1) & 0x1F) << 2);
header |= (byte)((width - 1) & 0x03);
dst.Add(header);
}
else
{
// Extended group:
// Header: 1 | 11111 | (width-1)[2 bits]
// Followed by varint(count - 32)
byte header = 0x80;
header |= 0x7C; // count bits = 11111
header |= (byte)((width - 1) & 0x03);
dst.Add(header);
WriteVarUInt32(dst, (uint)(count - 32));
}
// Payload: 'count' values, LE, 'width' bytes each
for (int k = 0; k < count; k++)
WriteLE(dst, values[start + k], width);
i += count;
}
@@ -72,21 +97,29 @@ public static class GroupUInt32Codec
if ((h & 0x80) == 0)
{
// Fast path byte (0..127)
result.Add(h);
// Fast path: literal 7-bit unsigned value
result.Add((uint)(h & 0x7F));
continue;
}
int count = ((h >> 3) & 0xF) + 1; // 1..16
int width = (h & 0x7) + 1; // 1..8 (we expect 1..4)
int countField = (h >> 2) & 0x1F;
int width = (h & 0x03) + 1; // 1..4
if (width > 4)
throw new NotSupportedException($"Width {width} bytes exceeds uint32 capacity.");
int count;
if (countField == 31)
{
uint extra = ReadVarUInt32(src, ref pos);
count = checked(32 + (int)extra);
}
else
{
count = countField + 1;
}
for (int j = 0; j < count; j++)
{
uint val = (uint)ReadLE(src, ref pos, width);
result.Add(val);
uint raw = (uint)ReadLE(src, ref pos, width);
result.Add(raw);
}
}
@@ -94,12 +127,13 @@ public static class GroupUInt32Codec
}
// ----------------- Helpers -----------------
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private static int WidthFromUnsigned(uint v)
private static int WidthFromValue(uint v, bool aligned = false)
{
if (v <= 0xFFu) return 1;
if (v <= 0xFFFFu) return 2;
if (v <= 0xFFFFFFu) return 3;
if (v <= 0xFFFFFFu) return aligned ? 4 : 3;
return 4;
}
@@ -113,13 +147,47 @@ public static class GroupUInt32Codec
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private static ulong ReadLE(ReadOnlySpan<byte> src, ref int pos, int width)
{
if (pos + width > src.Length)
throw new ArgumentException("Buffer underflow while reading payload.");
if ((uint)(pos + width) > (uint)src.Length)
throw new ArgumentException("Buffer underflow while reading group payload.");
ulong v = 0;
for (int i = 0; i < width; i++)
v |= (ulong)src[pos++] << (8 * i);
return v;
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private static void WriteVarUInt32(List<byte> dst, uint value)
{
while (value >= 0x80)
{
dst.Add((byte)((value & 0x7F) | 0x80));
value >>= 7;
}
dst.Add((byte)value);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private static uint ReadVarUInt32(ReadOnlySpan<byte> src, ref int pos)
{
uint result = 0;
int shift = 0;
while (true)
{
if (pos >= src.Length)
throw new ArgumentException("Buffer underflow while reading varint.");
byte b = src[pos++];
result |= (uint)(b & 0x7F) << shift;
if ((b & 0x80) == 0)
return result;
shift += 7;
if (shift >= 35)
throw new ArgumentException("Varint is too long for UInt32.");
}
}
}