int _CRTAPI1 Zatexit (void (_CRTAPI1 * Arg1)(void))
{
int RetVal;
SHORT sTimerHandle;
ULONG ulElapsedTime;
if (fInitDone == FALSE) {
ApfInitDll();
}
TimerOpen(&sTimerHandle, MICROSECONDS);
TimerInit(sTimerHandle);
//
// Call the api
//
RetVal = atexit(Arg1);
//
// Get the elapsed time
//
ulElapsedTime = TimerRead(sTimerHandle);
ApfRecordInfo(I_atexit, ulElapsedTime);
TimerClose(sTimerHandle);
return(RetVal);
}
void test_calls_wptr_chans (Workspace p, Channel *in0, Channel *in1, Channel *out)
{
int data, timeo;
Channel local;
ChanInit (p, &local);
ChanOut (p, out, &data, sizeof (data));
ChanIn (p, in0, &data, sizeof (data));
Alt (p);
AltEnableChannel (p, 1, in0);
AltEnableChannel (p, 1, in1);
AltWait (p);
AltDisableChannel (p, 1, in0);
AltDisableChannel (p, 1, in1);
AltEnd (p);
timeo = TimerRead (p);
TAlt (p);
AltEnableTimeout (p, 1, timeo);
TAltWait (p);
AltDisableTimeout (p, 1, timeo);
AltEnd (p);
ProcAlt (p, in0, in1, NULL);
ProcPriAlt (p, in0, in1, NULL);
ProcPriAltSkip (p, in0, in1, NULL);
TestChan (p, &local);
}
int _CRTAPI1 Z_execl (const char* Arg1,const char* Arg2, DWORD64ARGS)
{
int RetVal;
SHORT sTimerHandle;
ULONG ulElapsedTime;
if (fInitDone == FALSE) {
ApfInitDll();
}
TimerOpen(&sTimerHandle, MICROSECONDS);
TimerInit(sTimerHandle);
//
// Call the api
//
RetVal = _execl(Arg1,Arg2, ARGS64);
//
// Get the elapsed time
//
ulElapsedTime = TimerRead(sTimerHandle);
ApfRecordInfo(I__execl, ulElapsedTime - ApfData[I_CALIBRATE].ulFirstTime);
TimerClose(sTimerHandle);
return(RetVal);
}
void _CRTAPI1 Zqsort (void * Arg1, size_t Arg2, size_t Arg3,
int (_CRTAPI1 * Arg4)(const void *, const void *))
{
SHORT sTimerHandle;
ULONG ulElapsedTime;
if (fInitDone == FALSE) {
ApfInitDll();
}
TimerOpen(&sTimerHandle, MICROSECONDS);
TimerInit(sTimerHandle);
//
// Call the api
//
qsort(Arg1,Arg2,Arg3,Arg4);
//
// Get the elapsed time
//
ulElapsedTime = TimerRead(sTimerHandle);
ApfRecordInfo(I_qsort, ulElapsedTime);
TimerClose(sTimerHandle);
return;
}
void* _CRTAPI1 Z_lsearch (const void * Arg1, void * Arg2,unsigned int * Arg3, unsigned int Arg4,
int (_CRTAPI1 * Arg5)(const void *, const void *))
{
void* RetVal;
SHORT sTimerHandle;
ULONG ulElapsedTime;
if (fInitDone == FALSE) {
ApfInitDll();
}
TimerOpen(&sTimerHandle, MICROSECONDS);
TimerInit(sTimerHandle);
//
// Call the api
//
RetVal = _lsearch(Arg1,Arg2,Arg3,Arg4,Arg5);
//
// Get the elapsed time
//
ulElapsedTime = TimerRead(sTimerHandle);
ApfRecordInfo(I__lsearch, ulElapsedTime);
TimerClose(sTimerHandle);
return(RetVal);
}
void FAR PASCAL FileSyncProfInitDll ()
{
DWORD ulInitElapsedTime, ThreadId;
SHORT sTimerHandle;
int i;
// Initialize the File I/O Profiler data
InitFileProf ();
// Initialize the Syncronization Profiler data
InitSyncProf ();
// Create the two threads and events to catch the Dump and Clear data events
// that are signalled by the apf32dmp program
hDumpEvent = CreateEvent ( (LPSECURITY_ATTRIBUTES) NULL, TRUE, FALSE,
L"FileProfDumpEvent" );
hWaitingForDumpThread = CreateThread ( (LPSECURITY_ATTRIBUTES) NULL, 0,
(LPTHREAD_START_ROUTINE) CatchDump, (LPVOID) NULL, (DWORD) 0,
(LPDWORD) &ThreadId );
hClearEvent = CreateEvent ( (LPSECURITY_ATTRIBUTES) NULL, TRUE, FALSE,
L"FileProfClearEvent" );
hWaitingForClearThread = CreateThread ( (LPSECURITY_ATTRIBUTES) NULL, 0,
(LPTHREAD_START_ROUTINE) CatchClear, (LPVOID) NULL, (DWORD) 0,
(LPDWORD) &ThreadId );
//
// Do timer calibration, if not already done.
//
//
// Calibrate time overhead from register save and restore:
// we get the minimum time here, to avoid extra time from
// interrupts etc.
// the tedious approach has two benefits
// - duplicate generated code as accurately as possible
// - pick up timer overhead, that isn't handled correctly
// in timer
// NOTE: The global variable ulTimerOverhead contains the
// timer overhead.
ulTimerOverhead = MAX_LONG;
TimerOpen(&sTimerHandle, MICROSECONDS);
for (i = 0; i < NUM_ITRATIONS; i++) {
TimerInit(sTimerHandle);
ulInitElapsedTime = TimerRead(sTimerHandle);
if ( ( ulInitElapsedTime < ulTimerOverhead ) &&
( ulInitElapsedTime > MIN_ACCEPTABLEOVERHEAD ) )
ulTimerOverhead = ulInitElapsedTime;
}
TimerClose(sTimerHandle);
}
int TestMod11A(PDOT11_MOD_ARGS pArgs)
{
BB11A_TX_VECTOR TxVector;
BB11ATxContextInit(&TxVector, pArgs->SampleRate);
if (!Dot11ARate_KbpsValid(pArgs->nBitRate))
{
printf("Data rate %d kbps is not supported by 802.11a mode\n", pArgs->nBitRate);
return -1;
}
TxVector.ti_uiDataRate = Dot11ADataRate_Kbps2Code(pArgs->nBitRate);
if (PreparePacket(pArgs->pcInFileName, &Mdl, &Packet, DataBuffer, SymbolBuffer, SYMBOLBUF_SIZE) < 0)
return -1;
TIMINGINFO ti;
double dTimeSum = 0.0;
// Cache warm-up for first 2 rounds
for (int i = 0; i < 2; i++)
{
BB11ATxFrameMod(&TxVector, &Packet);
}
// Measure modulation speed for many rounds
TimerStart(&ti);
for (int i = 0; i < RUN_TIMES; i++)
{
BB11ATxFrameMod(&TxVector, &Packet);
}
TimerStop(&ti);
dTimeSum = TimerRead(&ti) * 1000;
printf("Signal data rate: %d kbps\n", Dot11ADataRate_Code2Kbps(TxVector.ti_uiDataRate));
printf("Signal packet size: %d\n", Packet.PacketSize);
printf("Signal encoded size: %d\n", Packet.Reserved3);
printf("Time cost average: %.3f us \n", dTimeSum / RUN_TIMES);
FILE* pOut = NULL;
#pragma warning (push)
#pragma warning (disable:4996)
pOut = fopen(pArgs->pcOutFileName, "w+b");
#pragma warning (pop)
if (!pOut)
{
printf("Cannot create output file.\n");
return -1;
}
fwrite(Packet.pReserved, Packet.Reserved3, 1, pOut);
fclose(pOut);
return 0;
}
void test_calls_wptr_time (Workspace p)
{
int timeo, to2;
timeo = TimerRead (p);
to2 = timeo + 42;
TimerWait (p, to2);
if (Time_AFTER (to2, timeo)) {
/* boo */
StopP (p);
}
}
void printStatus(void) {
uint32_t currentTemp, currentTime;
uint16_t setpoint;
char s[10];
currentTime=TimerRead();
currentTemp=getHighResTemperature();
setpoint=getPIDSetpoint();
uart_puts_P("#:");
uart_put_longint(currentTime/1000);
DS18X20_format_from_maxres(currentTemp, s, 10 );
uart_puts_P(" T:");
uart_puts( s );
uart_puts_P(" S:");
uart_put_float( setpoint );
uart_puts_P(" D:");
uart_put_longint( get_duty_cycle() );
uart_puts_P( NEWLINESTR );
}
void ApfInitDll ()
{
NTSTATUS Status;
DWORD ulInitElapsedTime;
SHORT sInitTimerHandle;
DWORD ARGS64;
#ifdef CALIBDBG
SHORT sTimerHandle;
ULONG ulElapsedTime;
#endif
#ifdef ERRORDBG
DWORD Error;
#endif
int i;
STRING DataSemName;
UNICODE_STRING DataSemUnicodeName;
OBJECT_ATTRIBUTES DataSemAttributes;
// Create public share security descriptor for all the named objects
//
Status = RtlCreateSecurityDescriptor (
&SecDescriptor,
SECURITY_DESCRIPTOR_REVISION1
);
#ifdef ERRORDBG
if (!NT_SUCCESS(Status)) {
KdPrint (("WAP: RtlCreateSecurityDescriptor falied - 0x%lx\n", Status));
}
#endif
Status = RtlSetDaclSecurityDescriptor (
&SecDescriptor, // SecurityDescriptor
TRUE, // DaclPresent
NULL, // Dacl
FALSE // DaclDefaulted
);
#ifdef ERRORDBG
if (!NT_SUCCESS(Status)) {
KdPrint (("WAP: RtlSetDaclSecurityDescriptor falied - 0x%lx\n", Status));
}
#endif
// Create sections for data and api arrays
//
if ( NT_SUCCESS(ApfCreateDataSection(&ApfControl)) ) {
// Leave room for control flag
//
ApfData = (PAPFDATA)(ApfControl+1);
// Initialization for semaphore creation
//
RtlInitString(&DataSemName, DATA_SEM_NAME);
Status = RtlAnsiStringToUnicodeString(
&DataSemUnicodeName,
&DataSemName,
TRUE);
if (NT_SUCCESS(Status)) {
InitializeObjectAttributes(
&DataSemAttributes,
&DataSemUnicodeName,
OBJ_OPENIF | OBJ_CASE_INSENSITIVE,
NULL,
&SecDescriptor);
}
// Create semaphores
//
Status = NtCreateSemaphore(
&hDataSem,
SEMAPHORE_QUERY_STATE |
SEMAPHORE_MODIFY_STATE |
SYNCHRONIZE,
&DataSemAttributes,
1L,
1L);
#ifdef ERRORDBG
if (!NT_SUCCESS(Status)) {
KdPrint (("WAP: Data semaphore creation falied %lx\n",
Status));
}
#endif
// Get semaphores
//
Status = NtWaitForSingleObject(hDataSem,FALSE,NULL);
#ifdef ERRORDBG
if (!NT_SUCCESS(Status)) {
KdPrint (("WAP: Could not wait for Dsemaphore in ApfInitDll, %lx\n",
Status));
}
#endif
//
// Do timer calibration if not already done.
//
if (!ApfControl->fCalibrate) {
ApfControl->fCalibrate = TRUE;
//
// Calibrate time overheads:
// we get the minimum time here, to avoid extra time from
// interrupts etc.
// the tedious approach has two benefits
// - duplicate generated code as accurately as possible
// - pick up timer overhead, that isn't handled correctly
// in timer
// NOTE: ApfData[I_CALIBRATE].ulMinTime contains the
// timer overhead, while ApfData[I_CALIBRATE].cCalls
// contains the number of processess accessing this
// DLL.
//
ApfData[I_CALIBRATE].cCalls = 0L;
ApfData[I_CALIBRATE].cTimingErrors = 0L;
ApfData[I_CALIBRATE].ulTotalTime = 0L;
ApfData[I_CALIBRATE].ulFirstTime = MAX_LONG;
ApfData[I_CALIBRATE].ulMaxTime = MAX_LONG;
ApfData[I_CALIBRATE].ulMinTime = MAX_LONG;
ApfClearData();
TimerOpen(&sInitTimerHandle, MICROSECONDS);
#ifdef CALIBDBG
// Release semaphore
//
Status = NtReleaseSemaphore(hDataSem,1,NULL);
#ifdef ERRORDBG
if (!NT_SUCCESS(Status)) {
KdPrint (("WAP: DSemaphore Not Released in ApfInitDll!! %lx\n",
Status));
}
#endif
//
// Overhead for all the API wrapper code
// Stored in ApfData[I_CALIBRATE].ulMaxTime
// Used for debugging - for WOW profiling overhead.
//
for (i=0; i<NUM_ITRATIONS; i++) {
TimerInit(sInitTimerHandle);
if (fInitDone == FALSE) {
}
TimerOpen(&sTimerHandle, MICROSECONDS);
TimerInit(sTimerHandle);
//
// Get the elapsed time
//
ulElapsedTime = TimerRead(sTimerHandle);
ApfRecordInfo(1, ulElapsedTime);
TimerClose(sTimerHandle);
ulInitElapsedTime = TimerRead(sInitTimerHandle);
if ((ulInitElapsedTime < ApfData[I_CALIBRATE].ulMaxTime) &&
(ulInitElapsedTime > MIN_ACCEPTABLEOVERHEAD)) {
ApfData[I_CALIBRATE].ulMaxTime = ulInitElapsedTime;
}
}
// Get semaphores
//
Status = NtWaitForSingleObject(hDataSem,FALSE,NULL);
#ifdef ERRORDBG
if (!NT_SUCCESS(Status)) {
KdPrint (("WAP: Could not wait for Dsemaphore in ApfInitDll, %lx\n",
Status));
}
#endif
#endif
//
// Excess overhead for TimerInit() followed by TimerREad() calls
// Stored in ApfData[I_CALIBRATE].ulMinTime
// Used by all APIs
//
for (i=0; i<NUM_ITRATIONS; i++) {
TimerInit(sInitTimerHandle);
ulInitElapsedTime = TimerRead(sInitTimerHandle);
if ((ulInitElapsedTime < ApfData[I_CALIBRATE].ulMinTime) &&
(ulInitElapsedTime > MIN_ACCEPTABLEOVERHEAD)) {
ApfData[I_CALIBRATE].ulMinTime = ulInitElapsedTime;
}
}
//
// Oerhead for calling cdecl APIs with 64 DWORD arguments
// Stored in ApfData[I_CALIBRATE].ulFirstTime
// Used by all variable argument cdecl APIs such as wsprintf()
//
for (i=0; i<NUM_ITRATIONS; i++) {
TimerInit(sInitTimerHandle);
CalibCdeclApi (ARGS64);
ulInitElapsedTime = TimerRead(sInitTimerHandle);
if ((ulInitElapsedTime < ApfData[I_CALIBRATE].ulFirstTime) &&
(ulInitElapsedTime > MIN_ACCEPTABLEOVERHEAD)) {
ApfData[I_CALIBRATE].ulFirstTime = ulInitElapsedTime;
}
}
ApfData[I_CALIBRATE].ulFirstTime -= ApfData[I_CALIBRATE].ulMinTime;
TimerClose(sInitTimerHandle);
}
// Increment the number of active processes on this DLL
//
ApfData[I_CALIBRATE].cCalls++;
// Load the module being profiled
//
hModule=GetModuleHandle(MODULE_NAME);
#ifdef ERRORDBG
if (hModule==NULL) {
Error=GetLastError();
KdPrint (("WAP: Module Handle is null - %lx\n",Error));
}
#endif
// Release semaphore
//
Status = NtReleaseSemaphore(hDataSem,1,NULL);
#ifdef ERRORDBG
if (!NT_SUCCESS(Status)) {
KdPrint (("WAP: DSemaphore Not Released in ApfInitDll!! %lx\n",
Status));
}
#endif
fInitDone = TRUE;
}
#ifdef ERRORDBG
else {
KdPrint (("WAP: Couldn't create DATA section in ApfInitDll\n"));
}
#endif
} /* ApfInitDll () */
void initCommandLine(void) {
uart_puts_P( NEWLINESTR "C8H10N4O2 startup." NEWLINESTR );
cmdline_looptime = TimerRead();
menuEnabled=0;
}
