public static Span <BitVector8> partition(BitVector32 src, Span <BitVector8> dst)
{
var bs = dst.AsBytes();
BitParts.part32x8(src, bs);
return(dst);
}
public static Span <BitVector16> partition(BitVector32 src, Span <BitVector16> dst)
{
var bs = dst.AsUInt16();
BitParts.part32x16(src, bs);
return(dst);
}
public void bitblock32_pack()
{
for (var i = 0; i < SampleSize; i++)
{
var src = Random.Next <uint>();
var block = BitBlock32.Alloc();
var dst = 0u;
BitParts.part32x1(src, ref block);
BitParts.pack32x1(in block, ref dst);
Claim.eq(dst, src);
}
}
public void bitpart_32x4_bench()
{
var opcount = RoundCount * CycleCount;
var sw = stopwatch(false);
var opname = $"bitpart_32x4";
var count = (int)Part32x4.Count;
Span <byte> dst = stackalloc byte[count];
for (var k = 0; k < opcount; k++)
{
var x = Random.Next <uint>();
sw.Start();
BitParts.part32x4(x, dst);
sw.Stop();
}
Collect((opcount, sw, opname));
}
public void bitpart_32x4()
{
var count = (int)Part32x4.Count;
var width = (int)Part32x4.Width;
Span <byte> dst = stackalloc byte[count];
for (var sample = 0; sample < SampleSize; sample++)
{
var x = Random.Next <uint>();
BitParts.part32x4(x, dst);
Span <byte> dstRef = stackalloc byte[count];
part32x4_ref(x, dstRef);
var xbs = x.ToBitString();
var bsparts = xbs.Partition(width).Map(bs => bs.ToBitVector(n8));
for (var i = 0; i < count; i++)
{
Claim.eq(bsparts[i], dst[i].ToBitVector());
Claim.eq(bsparts[i], dstRef[i].ToBitVector());
}
}
}
public void bitpart_32x1_bench()
{
void bitstring()
{
var opname = "part32x1_bitstring";
var sw = stopwatch(false);
var bs = default(BitString);
for (var i = 0; i < OpCount; i++)
{
var src = Random.Next <uint>();
sw.Start();
bs = src.ToBitString();
sw.Stop();
}
Collect((OpCount, sw, opname));
}
void blockstyle()
{
var opname = "part32x1_block32";
var sw = stopwatch(false);
BitBlock32 last = default;
for (var i = 0; i < OpCount; i++)
{
var src = Random.Next <uint>();
sw.Start();
BitParts.part32x1(src, ref last);
sw.Stop();
}
Collect((OpCount, sw, opname));
}
void spanstyle()
{
var opname = "part32x1";
var sw = stopwatch(false);
Span <byte> dst = stackalloc byte[32];
for (var i = 0; i < OpCount; i++)
{
var src = Random.Next <uint>();
sw.Start();
BitParts.part32x1(src, dst);
sw.Stop();
}
Collect((OpCount, sw, opname));
}
void bittest()
{
var opname = "part32x1_test";
var sw = stopwatch(false);
Span <byte> dst = stackalloc byte[32];
for (var i = 0; i < OpCount; i++)
{
var src = Random.Next <uint>();
sw.Start();
part32x1_test(src, dst);
sw.Stop();
}
Collect((OpCount, sw, opname));
}
spanstyle();
}
/// <summary>
/// Populates a target span with 64 bits from the source
/// </summary>
/// <param name="src">The source bits</param>
/// <param name="dst">The target span</param>
public static Span <byte> unpack(ulong src, Span <byte> dst)
{
BitParts.unpack64x1(src, dst);
return(dst);
}
/// <summary>
/// Populates a target span with 32 bits from the source
/// </summary>
/// <param name="src">The source bits</param>
/// <param name="dst">The target span</param>
public static Span <byte> unpack(uint src, Span <byte> dst)
{
BitParts.unpack32x1(src, dst);
return(dst);
}
/// <summary>
/// Populates a target span with 16 bits from the source
/// </summary>
/// <param name="src">The source bits</param>
/// <param name="dst">The target span</param>
public static Span <byte> unpack(ushort src, Span <byte> dst)
{
BitParts.unpack16x1(src, dst);
return(dst);
}
/// <summary>
/// Populates a target span with 8 bits from the source
/// </summary>
/// <param name="src">The source bits</param>
/// <param name="dst">The target span</param>
public static Span <byte> unpack(byte src, Span <byte> dst)
{
BitParts.unpack8x1(src, dst);
return(dst);
}
