public void BitScanner_NB1_64()
{
Assert.AreEqual(0, BitScanner.NumberOfBit1(0UL));
Assert.AreEqual(1, BitScanner.NumberOfBit1(1UL));
Assert.AreEqual(1, BitScanner.NumberOfBit1(0x4000000000000000UL));
Assert.AreEqual(2, BitScanner.NumberOfBit1(0x4000000000000001UL));
Assert.AreEqual(63, BitScanner.NumberOfBit1(0x7FFFFFFFFFFFFFFFUL));
Assert.AreEqual(63, BitScanner.NumberOfBit1(0xFFFFFFFFFFFFFFFEUL));
Assert.AreEqual(64, BitScanner.NumberOfBit1(0xFFFFFFFFFFFFFFFFUL));
}
public void BitScanner_NB1_32()
{
Assert.AreEqual(0, BitScanner.NumberOfBit1(0U));
Assert.AreEqual(1, BitScanner.NumberOfBit1(1U));
Assert.AreEqual(1, BitScanner.NumberOfBit1(0x40000000U));
Assert.AreEqual(2, BitScanner.NumberOfBit1(0x40000001U));
Assert.AreEqual(31, BitScanner.NumberOfBit1(0x7FFFFFFFU));
Assert.AreEqual(31, BitScanner.NumberOfBit1(0xFFFFFFFEU));
Assert.AreEqual(32, BitScanner.NumberOfBit1(0xFFFFFFFFU));
}
public void BitScanner_NLZ_64()
{
Assert.AreEqual(64, BitScanner.NumberOfLeadingZeros64(0));
Assert.AreEqual(63, BitScanner.NumberOfLeadingZeros64(1));
Assert.AreEqual(62, BitScanner.NumberOfLeadingZeros64(2));
Assert.AreEqual(62, BitScanner.NumberOfLeadingZeros64(3));
Assert.AreEqual(0, BitScanner.NumberOfLeadingZeros64(0xFFFFFFFFFFFFFFFFUL));
Assert.AreEqual(0, BitScanner.NumberOfLeadingZeros64(0x8000000000000000UL));
Assert.AreEqual(1, BitScanner.NumberOfLeadingZeros64(0x7FFFFFFFFFFFFFFFUL));
Assert.AreEqual(1, BitScanner.NumberOfLeadingZeros64(0x4000000000000000UL));
}
public void BitScanner_NLZ_32()
{
Assert.AreEqual(32, BitScanner.NumberOfLeadingZeros32(0));
Assert.AreEqual(31, BitScanner.NumberOfLeadingZeros32(1));
Assert.AreEqual(30, BitScanner.NumberOfLeadingZeros32(2));
Assert.AreEqual(30, BitScanner.NumberOfLeadingZeros32(3));
Assert.AreEqual(0, BitScanner.NumberOfLeadingZeros32(0xFFFFFFFFU));
Assert.AreEqual(0, BitScanner.NumberOfLeadingZeros32(0x80000000U));
Assert.AreEqual(1, BitScanner.NumberOfLeadingZeros32(0x7FFFFFFFU));
Assert.AreEqual(1, BitScanner.NumberOfLeadingZeros32(0x40000000U));
}
public void BitScanner_NTZ_64()
{
Assert.AreEqual(0, BitScanner.NumberOfTrailingZeros64(0x0000000000000001UL));
Assert.AreEqual(1, BitScanner.NumberOfTrailingZeros64(0x0000000000000002UL));
Assert.AreEqual(0, BitScanner.NumberOfTrailingZeros64(0x0000000000000003UL));
Assert.AreEqual(0, BitScanner.NumberOfTrailingZeros64(0x8000000000000001UL));
Assert.AreEqual(0, BitScanner.NumberOfTrailingZeros64(0x4000000000000001UL));
Assert.AreEqual(0, BitScanner.NumberOfTrailingZeros64(0xFFFFFFFFFFFFFFF1UL));
Assert.AreEqual(0, BitScanner.NumberOfTrailingZeros64(0xFFFFFFFFFFFFFFFFUL));
Assert.AreEqual(64, BitScanner.NumberOfTrailingZeros64(0x0000000000000000UL));
Assert.AreEqual(63, BitScanner.NumberOfTrailingZeros64(0x8000000000000000UL));
Assert.AreEqual(62, BitScanner.NumberOfTrailingZeros64(0x4000000000000000UL));
}
public void BitScanner_NTZ_32()
{
Assert.AreEqual(0, BitScanner.NumberOfTrailingZeros32(0x00000001U));
Assert.AreEqual(1, BitScanner.NumberOfTrailingZeros32(0x00000002U));
Assert.AreEqual(0, BitScanner.NumberOfTrailingZeros32(0x00000003U));
Assert.AreEqual(0, BitScanner.NumberOfTrailingZeros32(0x80000001U));
Assert.AreEqual(0, BitScanner.NumberOfTrailingZeros32(0x40000001U));
Assert.AreEqual(0, BitScanner.NumberOfTrailingZeros32(0xFFFFFFF1U));
Assert.AreEqual(0, BitScanner.NumberOfTrailingZeros32(0xFFFFFFFFU));
Assert.AreEqual(32, BitScanner.NumberOfTrailingZeros32(0x00000000U));
Assert.AreEqual(31, BitScanner.NumberOfTrailingZeros32(0x80000000U));
Assert.AreEqual(30, BitScanner.NumberOfTrailingZeros32(0x40000000U));
}
/// <summary>
/// The UnbindAllValid
/// </summary>
public void UnbindAllValid()
{
StaleRootParamsBitMap = 0;
var tableParams = (uint)RootDescriptorTablesBitMap;
while (BitScanner.BitScanForward(tableParams, out var rootIndex))
{
tableParams ^= (uint)(1 << rootIndex);
if (RootDescriptorTable[rootIndex].AssignedHandleBitMap != 0)
{
StaleRootParamsBitMap |= (uint)(1 << rootIndex);
}
}
}
public void BitScanner_Mask()
{
Assert.AreEqual(1U, BitScanner.Mask(1));
Assert.AreEqual(3U, BitScanner.Mask(2));
Assert.AreEqual(3U, BitScanner.Mask(3));
Assert.AreEqual(7U, BitScanner.Mask(4));
Assert.AreEqual(7U, BitScanner.Mask(5));
Assert.AreEqual(7U, BitScanner.Mask(6));
Assert.AreEqual(7U, BitScanner.Mask(7));
Assert.AreEqual(0x7FFFFFFFU, BitScanner.Mask(0x7FFFFFFF));
Assert.AreEqual(0xFFFFFFFFU, BitScanner.Mask(0x80000000));
Assert.AreEqual(0xFFFFFFFFU, BitScanner.Mask(0x80000001));
Assert.AreEqual(0xFFFFFFFFU, BitScanner.Mask(0xFFFFFFFF));
Assert.AreEqual(0U, BitScanner.Mask(0));
}
private static void Test(uint value)
{
Assert.AreEqual(1UL << (CalcReverse(value) + 1), (ulong)BitScanner.Mask(value) + 1);
}
/// <summary>
/// The CopyAndBindStaleTables
/// </summary>
/// <param name="type">The <see cref="DescriptorHeapType"/></param>
/// <param name="descriptorSize">The <see cref="uint"/></param>
/// <param name="destHandleStart">The <see cref="DescriptorHandle"/></param>
/// <param name="setFunction">The <see cref="CommandListSetFunc"/></param>
public void CopyAndBindStaleTables(DescriptorHeapType type, uint descriptorSize, DescriptorHandle destHandleStart, CommandListSetFunc setFunction)
{
uint staleParamCount = 0;
var tableSize = new int[MaxNumDescriptorTables];
var rootIndices = new int[MaxNumDescriptorTables];
var needSpace = 0;
int rootIndex;
var staleParams = StaleRootParamsBitMap;
while (BitScanner.BitScanForward(staleParams, out rootIndex))
{
rootIndices[staleParamCount] = rootIndex;
staleParams ^= (uint)(1 << (int)rootIndex);
Debug.Assert(BitScanner.BitScanReverse(RootDescriptorTable[rootIndex].AssignedHandleBitMap, out var maxSetHandle), "Root entry marked as stale but has no stale descriptors");
needSpace += maxSetHandle + 1;
tableSize[staleParamCount] = maxSetHandle + 1;
staleParamCount++;
}
Debug.Assert(staleParamCount <= MaxNumDescriptorTables, "We're only equipped to handle so many descriptor tables");
StaleRootParamsBitMap = 0;
const uint maxdescriptorPerCopy = 16;
var numDestDescriptorRanges = 0;
var destDescriptorRangeStarts = new CpuDescriptorHandle[maxdescriptorPerCopy];
var destDescriptorRangeSizes = new int[maxdescriptorPerCopy];
var numSrcDescriptorRanges = 0;
var srcDescriptorRangeStarts = new CpuDescriptorHandle[maxdescriptorPerCopy];
var srcDescriptorRangeSizes = new int[maxdescriptorPerCopy];
for (uint idx = 0; idx < staleParamCount; idx++)
{
rootIndex = rootIndices[idx];
setFunction?.Invoke((int)rootIndex, destHandleStart.GPUHandle);
var rootDescTable = RootDescriptorTable[rootIndex];
var srcHandles = rootDescTable.TableStart;
UInt64 setHandles = rootDescTable.AssignedHandleBitMap;
var curDest = destHandleStart.CPUHandle;
destHandleStart += (int)(tableSize[idx] * descriptorSize);
while (BitScanner.BitScanForward64(setHandles, out var skipCount))
{
setHandles >>= skipCount;
srcHandles += skipCount;
curDest.Ptr += skipCount * descriptorSize;
BitScanner.BitScanForward64(~setHandles, out var descriptorCount);
setHandles >>= descriptorCount;
if (numSrcDescriptorRanges + descriptorCount > maxdescriptorPerCopy)
{
Globals.Device.CopyDescriptors(numDestDescriptorRanges, destDescriptorRangeStarts, destDescriptorRangeSizes, numSrcDescriptorRanges, srcDescriptorRangeStarts, srcDescriptorRangeSizes, type);
numSrcDescriptorRanges = 0;
numDestDescriptorRanges = 0;
}
destDescriptorRangeStarts[numDestDescriptorRanges] = curDest;
destDescriptorRangeSizes[numDestDescriptorRanges] = descriptorCount;
numDestDescriptorRanges++;
for (int jdx = 0; jdx < descriptorCount; jdx++)
{
srcDescriptorRangeStarts[numSrcDescriptorRanges] = Marshal.PtrToStructure <CpuDescriptorHandle>(rootDescTable.TableStart + jdx * Marshal.SizeOf <CpuDescriptorHandle>());
srcDescriptorRangeSizes[numSrcDescriptorRanges] = 1;
numSrcDescriptorRanges++;
}
srcHandles += descriptorCount;
curDest.Ptr += descriptorCount;
}
}
Globals.Device.CopyDescriptors(numDestDescriptorRanges, destDescriptorRangeStarts, destDescriptorRangeSizes, numSrcDescriptorRanges, srcDescriptorRangeStarts, srcDescriptorRangeSizes, type);
}
private void RunCodingPass(BitScanner singleBitScanner, BitScanner quadBitScanner = null)
{
