private static void ShowRunningStatus(BENCHMARK_TRANSFER_PARAM transferParam)
{
BENCHMARK_TRANSFER_PARAM temp = transferParam;
double bpsOverall;
double bpsLastTransfer;
// LOCK the display critical section
lock (DisplayCriticalSection)
{
// UNLOCK the display critical section
if ((temp.StartTick == 0) || (temp.StartTick >= temp.LastTick))
{
CONMSG("Synchronizing {0}..\n", Math.Abs(transferParam.Packets));
}
else
{
GetAverageBytesSec(temp, out bpsOverall);
GetCurrentBytesSec(temp, out bpsLastTransfer);
transferParam.LastStartTick = 0;
CONMSG("Avg. Bytes/s: {0:F2} Transfers: {1} Bytes/s: {2:F2}\n",
bpsOverall,
temp.Packets,
bpsLastTransfer);
}
}
}
private static void GetCurrentBytesSec(BENCHMARK_TRANSFER_PARAM transferParam, out double bps)
{
double ticksSec;
if ((transferParam.StartTick == 0) ||
(transferParam.LastStartTick == 0) ||
(transferParam.LastTick <= transferParam.LastStartTick) ||
transferParam.LastTransferred == 0)
{
bps = 0;
}
else
{
ticksSec = (transferParam.LastTick - transferParam.LastStartTick)/10000000.0;
bps = transferParam.LastTransferred/ticksSec;
}
}
private static void ResetRunningStatus(BENCHMARK_TRANSFER_PARAM transferParam)
{
if (ReferenceEquals(transferParam, null)) return;
transferParam.StartTick = 0;
transferParam.TotalTransferred = 0;
transferParam.Packets = -2;
transferParam.LastTick = 0;
transferParam.RunningTimeoutCount = 0;
}
private static byte ENDPOINT_TYPE(BENCHMARK_TRANSFER_PARAM TransferParam)
{
return (byte) (TransferParam.Ep.EndpointInfo.Descriptor.Attributes & 3);
}
private static void FreeTransferParam(ref BENCHMARK_TRANSFER_PARAM testTransferRef)
{
if (ReferenceEquals(testTransferRef, null)) return;
if (testTransferRef.ThreadHandle != null)
{
testTransferRef.ThreadHandle = null;
}
testTransferRef = null;
}
private static void WaitForTestTransfer(BENCHMARK_TRANSFER_PARAM transferParam)
{
while (!ReferenceEquals(transferParam, null))
{
if (!transferParam.IsRunning)
{
if (!transferParam.ThreadHandle.IsAlive)
{
CONMSG("stopped Ep{0:X2}h thread.\n",
transferParam.Ep.EndpointInfo.Descriptor.EndpointID);
break;
}
}
Thread.Sleep(100);
CONMSG("waiting for Ep{0:X2}h thread..\n", transferParam.Ep.EndpointInfo.Descriptor.EndpointID);
}
}
private static BENCHMARK_TRANSFER_PARAM CreateTransferParam(BENCHMARK_TEST_PARAM test, int endpointID)
{
BENCHMARK_TRANSFER_PARAM transferParam;
UsbInterfaceInfo testInterface;
UsbInterfaceInfo firstInterface;
int i;
transferParam = new BENCHMARK_TRANSFER_PARAM();
transferParam.Test = test;
transferParam.Buffer = new byte[transferParam.Test.BufferCount][];
for (i = 0; i < transferParam.Test.BufferCount; i++)
transferParam.Buffer[i] = new byte[transferParam.Test.BufferSize];
if (ReferenceEquals((testInterface = usb_find_interface(test.Device.Configs[0], test.Intf, out firstInterface)), null))
{
CONERR("failed locating interface {0:X2}h!\n", test.Intf);
FreeTransferParam(ref transferParam);
goto Done;
}
for (i = 0; i < testInterface.EndpointInfoList.Count; i++)
{
if ((endpointID & 0x80) == 0x80)
{
// Use first endpoint that matches the direction
if ((testInterface.EndpointInfoList[i].Descriptor.EndpointID & 0x80) == 0x80)
{
transferParam.Ep = test.Device.OpenEndpointReader(
(ReadEndpointID) testInterface.EndpointInfoList[i].Descriptor.EndpointID,
0,
(EndpointType) (testInterface.EndpointInfoList[i].Descriptor.Attributes & 0x3));
break;
}
}
else
{
if ((testInterface.EndpointInfoList[i].Descriptor.EndpointID & 0x80) == 0x00)
{
transferParam.Ep = test.Device.OpenEndpointWriter(
(WriteEndpointID) testInterface.EndpointInfoList[i].Descriptor.EndpointID,
(EndpointType) (testInterface.EndpointInfoList[i].Descriptor.Attributes & 0x3));
break;
}
}
}
if (ReferenceEquals(transferParam.Ep, null))
{
CONERR("failed locating EP{0:X2}h!\n", endpointID);
FreeTransferParam(ref transferParam);
goto Done;
}
if ((transferParam.Test.BufferSize%transferParam.Ep.EndpointInfo.Descriptor.MaxPacketSize) > 0)
{
CONERR("buffer size {0} is not an interval of EP{1:X2}h maximum packet size of {2}!\n",
transferParam.Test.BufferSize,
transferParam.Ep.EndpointInfo.Descriptor.EndpointID,
transferParam.Ep.EndpointInfo.Descriptor.MaxPacketSize);
FreeTransferParam(ref transferParam);
goto Done;
}
if (test.IsoPacketSize != 0)
transferParam.IsoPacketSize = test.IsoPacketSize;
else
transferParam.IsoPacketSize = transferParam.Ep.EndpointInfo.Descriptor.MaxPacketSize;
if (ENDPOINT_TYPE(transferParam) == (byte) EndpointType.Isochronous)
transferParam.Test.TransferMode = BENCHMARK_TRANSFER_MODE.TRANSFER_MODE_ASYNC;
ResetRunningStatus(transferParam);
transferParam.ThreadHandle = new Thread(TransferThreadProc);
// If verify mode is on, this is a loop test, and this is a write endpoint, fill
// the buffers with the same test data sent by a benchmark device when running
// a read only test.
if (transferParam.Test.Verify &&
transferParam.Test.TestType == BENCHMARK_DEVICE_TEST_TYPE.TestTypeLoop &&
(transferParam.Ep.EndpointInfo.Descriptor.EndpointID & 0x80) == 0)
{
// Data Format:
// [0][KeyByte] 2 3 4 5 ..to.. wMaxPacketSize (if data byte rolls it is incremented to 1)
// Increment KeyByte and repeat
//
byte indexC = 0;
int bufferIndex = 0;
int transferIndex = 0;
UInt16 dataIndex;
int packetIndex;
int packetCount = ((transferParam.Test.BufferCount*transferParam.Test.BufferSize)/transferParam.Ep.EndpointInfo.Descriptor.MaxPacketSize);
for (packetIndex = 0; packetIndex < packetCount; packetIndex++)
{
indexC = 2;
for (dataIndex = 0; dataIndex < transferParam.Ep.EndpointInfo.Descriptor.MaxPacketSize; dataIndex++)
{
if (dataIndex == 0) // Start
transferParam.Buffer[transferIndex][bufferIndex] = 0;
else if (dataIndex == 1) // Key
transferParam.Buffer[transferIndex][bufferIndex] = (byte) (packetIndex & 0xFF);
else // Data
transferParam.Buffer[transferIndex][bufferIndex] = indexC++;
// if wMaxPacketSize is > 255, indexC resets to 1.
if (indexC == 0) indexC = 1;
bufferIndex++;
if (transferParam.Test.BufferSize == bufferIndex)
{
bufferIndex = 0;
transferIndex++;
}
}
}
}
Done:
if (ReferenceEquals(transferParam, null))
CONERR0("failed creating transfer param!\n");
return transferParam;
}
private static int VerifyData(BENCHMARK_TRANSFER_PARAM transferParam, byte[] data, int dataLength)
{
int verifyDataSize = transferParam.Test.VerifyBufferSize;
byte[] verifyData = transferParam.Test.VerifyBuffer;
byte keyC = 0;
bool seedKey = true;
int dataLeft = dataLength;
int dataIndex = 0;
int packetIndex = 0;
int verifyIndex = 0;
while (dataLeft > 1)
{
verifyDataSize = dataLeft > transferParam.Test.VerifyBufferSize ? transferParam.Test.VerifyBufferSize : dataLeft;
if (seedKey)
keyC = data[dataIndex + 1];
else
{
if (data[dataIndex + 1] == 0)
keyC = 0;
else
{
keyC++;
}
}
seedKey = false;
// Index 0 is always 0.
// The key is always at index 1
verifyData[1] = keyC;
if (memcmp(data, dataIndex, verifyData, verifyDataSize) != 0)
{
// Packet verification failed.
// Reset the key byte on the next packet.
seedKey = true;
CONVDAT("data mismatch packet-index={0} data-index={1}\n", packetIndex, dataIndex);
if (transferParam.Test.VerifyDetails)
{
for (verifyIndex = 0; verifyIndex < verifyDataSize; verifyIndex++)
{
if (verifyData[verifyIndex] == data[dataIndex + verifyIndex])
continue;
CONVDAT("packet-offset={0} expected {1:X2}h got {2:X2}h\n",
verifyIndex,
verifyData[verifyIndex],
data[dataIndex + verifyIndex]);
}
}
}
// Move to the next packet.
packetIndex++;
dataLeft -= verifyDataSize;
dataIndex += verifyDataSize;
}
return 0;
}
// Critical section for running status.
private static string TRANSFER_DISPLAY(BENCHMARK_TRANSFER_PARAM TransferParam, string ReadingString, string WritingString)
{
return ((TransferParam.Ep.EndpointInfo.Descriptor.EndpointID & 0x80) == 0x80 ? ReadingString : WritingString);
}
private static ErrorCode TransferSync(BENCHMARK_TRANSFER_PARAM transferParam, out int transferred)
{
return transferParam.Ep.Transfer(transferParam.Buffer[0],
0,
transferParam.Test.BufferSize,
transferParam.Test.Timeout,
out transferred);
}
private static ErrorCode TransferAsync(BENCHMARK_TRANSFER_PARAM transferParam, out BENCHMARK_TRANSFER_HANDLE handleRef, out int transferred)
{
BENCHMARK_TRANSFER_HANDLE handle;
handleRef = null;
ErrorCode ret = ErrorCode.Success;
transferred = 0;
// Submit transfers until the maximum number of outstanding transfer(s) is reached.
while (transferParam.OutstandingTransferCount < transferParam.Test.BufferCount)
{
if (ReferenceEquals(transferParam.TransferHandles[transferParam.TransferHandleNextIndex],null))
{
transferParam.TransferHandles[transferParam.TransferHandleNextIndex]=new BENCHMARK_TRANSFER_HANDLE();
}
// Get the next available benchmark transfer handle.
handleRef = handle = transferParam.TransferHandles[transferParam.TransferHandleNextIndex];
// If a libusb-win32 transfer context hasn't been setup for this benchmark transfer
// handle, do it now.
//
if (ReferenceEquals(handle.Context, null))
{
// Data buffer(s) are located at the end of the transfer param.
handle.Data = transferParam.Buffer[transferParam.TransferHandleNextIndex];
handle.DataMaxLength = transferParam.Test.BufferSize;
handle.Context = transferParam.Ep.NewAsyncTransfer();
handle.Context.Fill(handle.Data,
0,
handle.DataMaxLength,
transferParam.Test.Timeout,
transferParam.IsoPacketSize > 0 ? transferParam.IsoPacketSize : transferParam.Ep.EndpointInfo.Descriptor.MaxPacketSize);
}
// Submit this transfer now.
handle.Context.Reset();
ret = handle.Context.Submit();
if (ret != ErrorCode.Success) goto Done;
// Mark this handle has InUse.
handle.InUse = true;
// When transfers ir successfully submitted, OutstandingTransferCount goes up; when
// they are completed it goes down.
//
transferParam.OutstandingTransferCount++;
// Move TransferHandleNextIndex to the next available transfer.
INC_ROLL(ref transferParam.TransferHandleNextIndex, transferParam.Test.BufferCount);
}
// If the number of outstanding transfers has reached the limit, wait for the
// oldest outstanding transfer to complete.
//
if (transferParam.OutstandingTransferCount == transferParam.Test.BufferCount)
{
// TransferHandleWaitIndex is the index of the oldest outstanding transfer.
handleRef = handle = transferParam.TransferHandles[transferParam.TransferHandleWaitIndex];
ret = handle.Context.Wait(out transferred, false);
if (ret != ErrorCode.Success)
goto Done;
// Mark this handle has no longer InUse.
handle.InUse = false;
// When transfers ir successfully submitted, OutstandingTransferCount goes up; when
// they are completed it goes down.
//
transferParam.OutstandingTransferCount--;
// Move TransferHandleWaitIndex to the oldest outstanding transfer.
INC_ROLL(ref transferParam.TransferHandleWaitIndex, transferParam.Test.BufferCount);
}
Done:
return ret;
}
private static void ShowTransferInfo(BENCHMARK_TRANSFER_PARAM transferParam)
{
double bpsAverage;
double bpsCurrent;
double elapsedSeconds;
if (ReferenceEquals(transferParam, null)) return;
CONMSG("{0} {1} (Ep{2:X2}h) max packet size: {3}\n",
EndpointTypeDisplayString[ENDPOINT_TYPE(transferParam)],
TRANSFER_DISPLAY(transferParam, "Read", "Write"),
transferParam.Ep.EndpointInfo.Descriptor.EndpointID,
transferParam.Ep.EndpointInfo.Descriptor.MaxPacketSize);
if (transferParam.StartTick != 0)
{
GetAverageBytesSec(transferParam, out bpsAverage);
GetCurrentBytesSec(transferParam, out bpsCurrent);
CONMSG("\tTotal Bytes : {0}\n", transferParam.TotalTransferred);
CONMSG("\tTotal Transfers : {0}\n", transferParam.Packets);
if (transferParam.ShortTransferCount > 0)
{
CONMSG("\tShort Transfers : {0}\n", transferParam.ShortTransferCount);
}
if (transferParam.TotalTimeoutCount > 0)
{
CONMSG("\tTimeout Errors : {0}\n", transferParam.TotalTimeoutCount);
}
if (transferParam.TotalErrorCount > 0)
{
CONMSG("\tOther Errors : {0}\n", transferParam.TotalErrorCount);
}
CONMSG("\tAvg. Bytes/sec : {0:F2}\n", bpsAverage);
if (transferParam.StartTick != 0 && transferParam.StartTick < transferParam.LastTick)
{
elapsedSeconds = (transferParam.LastTick - transferParam.StartTick) / 10000000.0;
CONMSG("\tElapsed Time : {0:F2} seconds\n", elapsedSeconds);
}
CONMSG0("\n");
}
}
