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"); } }