1524 lines
36 KiB
C++
1524 lines
36 KiB
C++
|
|
/*++
|
|
|
|
Copyright (c) 1994 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
disp.c
|
|
|
|
Abstract:
|
|
|
|
Template for simple windows program
|
|
|
|
Author:
|
|
|
|
Mark Enstrom (marke)
|
|
|
|
Environment:
|
|
|
|
C
|
|
|
|
Revision History:
|
|
|
|
08-26-92 Initial version
|
|
|
|
|
|
|
|
--*/
|
|
|
|
#include "precomp.h"
|
|
#include "disp.h"
|
|
#include <wchar.h>
|
|
#include "resource.h"
|
|
|
|
HWND hWndMain;
|
|
HINSTANCE hInstMain;
|
|
ULONG InitialTest = 0;
|
|
PFN_DISP pfnLast = NULL;
|
|
BOOL bThreadActive = FALSE;
|
|
HANDLE gThreadHandle = 0;
|
|
DWORD dwThreadID = 0;
|
|
BOOL gfPentium = FALSE;
|
|
BOOL gfUseCycleCount = FALSE;
|
|
CRITICAL_SECTION ThreadCritSect;
|
|
SYSTEM_INFO SystemInfo;
|
|
_int64 PerformanceFreq = 1;
|
|
OSVERSIONINFO Win32VersionInformation;
|
|
PTIMER_RESULT gpTimerResult;
|
|
HBITMAP hbmCars;
|
|
HBRUSH hbrFillCars;
|
|
HFONT hTestFont;
|
|
TEST_CALL_DATA TestCallData;
|
|
XFORM rotationXform = {1.0, 0.0, 0.0, 1.0, 0.0, 0.0};
|
|
|
|
#define DISP_SUBITEM(fmt, v) \
|
|
sprintf(szT, fmt, v); \
|
|
ListView_SetItemText(hwndList, lvl.iItem, ++lvl.iSubItem, szT);
|
|
|
|
|
|
/******************************Public*Routine******************************\
|
|
* GetDCAndTransform
|
|
* Calls GetDC and sets the world transform to the current rotation.
|
|
*
|
|
* Arguments:
|
|
* hwnd
|
|
*
|
|
*
|
|
* Return Value:
|
|
* hdc
|
|
*
|
|
*
|
|
* History:
|
|
*
|
|
* 2-Jul-1997 -by- Ori Gershony [orig]
|
|
*
|
|
\**************************************************************************/
|
|
HDC
|
|
GetDCAndTransform(
|
|
HWND hwnd
|
|
)
|
|
{
|
|
HDC hdc;
|
|
|
|
hdc = GetDC(hwnd);
|
|
SetGraphicsMode(hdc, GM_ADVANCED);
|
|
SetWorldTransform(hdc, &rotationXform);
|
|
return hdc;
|
|
}
|
|
|
|
|
|
/******************************Public*Routine******************************\
|
|
* FillTransformedRect
|
|
* Same as FillRect except that it obeys the current world transform. This
|
|
* is achieved by calling Rectangle instead of FillRect.
|
|
*
|
|
* Arguments:
|
|
* hdc
|
|
* lprc
|
|
* hbr
|
|
*
|
|
* Return Value:
|
|
* Success or failure
|
|
*
|
|
*
|
|
* History:
|
|
*
|
|
* 2-Jul-1997 -by- Ori Gershony [orig]
|
|
*
|
|
\**************************************************************************/
|
|
BOOL
|
|
FillTransformedRect(
|
|
HDC hdc,
|
|
CONST RECT *lprc,
|
|
HBRUSH hbr
|
|
)
|
|
{
|
|
HBRUSH oldHbr;
|
|
BOOL retValue;
|
|
|
|
oldHbr = (HBRUSH) SelectObject(hdc, hbr);
|
|
retValue = Rectangle(hdc, lprc->left, lprc->top, lprc->right, lprc->bottom);
|
|
SelectObject(hdc, oldHbr);
|
|
|
|
return retValue;
|
|
}
|
|
|
|
|
|
|
|
/******************************Public*Routine******************************\
|
|
*
|
|
*
|
|
* Arguments:
|
|
*
|
|
*
|
|
*
|
|
* Return Value:
|
|
*
|
|
*
|
|
*
|
|
* History:
|
|
*
|
|
* 26-Apr-1996 -by- Mark Enstrom [marke]
|
|
*
|
|
\**************************************************************************/
|
|
|
|
int PASCAL
|
|
WinMain(
|
|
HINSTANCE hInst,
|
|
HINSTANCE hPrev,
|
|
LPSTR szCmdLine,
|
|
int cmdShow
|
|
)
|
|
{
|
|
MSG msg;
|
|
WNDCLASS wc;
|
|
HWND hWndDesktop;
|
|
RECT WindowRect;
|
|
|
|
hInstMain = hInst;
|
|
|
|
//
|
|
// read command line params to determine initial test
|
|
//
|
|
// [-t x]
|
|
//
|
|
|
|
InitCommonControls();
|
|
|
|
pfnLast = gTestEntry[0].pfn;
|
|
|
|
if (szCmdLine)
|
|
{
|
|
PUCHAR p = (PUCHAR)szCmdLine;
|
|
|
|
while (*p != '\0')
|
|
{
|
|
if (*p == '-')
|
|
{
|
|
p++;
|
|
|
|
if ((*p == 't') || (*p == 'T'))
|
|
{
|
|
ULONG iret,test;
|
|
|
|
p++;
|
|
iret = sscanf((const char *)p," %i",&test);
|
|
|
|
if ((iret == 1) && (test < gNumTests))
|
|
{
|
|
pfnLast = gTestEntry[test].pfn;
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
p++;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// determine processor type for timer measurements
|
|
//
|
|
|
|
#ifdef _X86_
|
|
|
|
GetSystemInfo(&SystemInfo);
|
|
|
|
if (gfUseCycleCount&&(PROCESSOR_INTEL_PENTIUM==SystemInfo.dwProcessorType))
|
|
{
|
|
gfPentium = TRUE;
|
|
}
|
|
|
|
#endif
|
|
|
|
//
|
|
// Calculate Timer Frequency For Current Machine and
|
|
// Convert to MicroSeconds (Actual time will be presented in units of 100ns)
|
|
//
|
|
|
|
BOOL Status = QueryPerformanceFrequency((LARGE_INTEGER *)&PerformanceFreq);
|
|
|
|
if(Status)
|
|
{
|
|
PerformanceFreq /= 1000000;
|
|
}
|
|
else
|
|
{
|
|
PerformanceFreq = 1;
|
|
}
|
|
|
|
//
|
|
// Create (if no prev instance) and Register the class
|
|
//
|
|
|
|
if (!hPrev)
|
|
{
|
|
wc.hCursor = LoadCursor((HINSTANCE)NULL, IDC_ARROW);
|
|
wc.hIcon = (HICON)NULL;
|
|
wc.lpszMenuName = MAKEINTRESOURCE(IDR_PAL_MENU);
|
|
wc.lpszClassName = "palClass";
|
|
wc.hbrBackground = (HBRUSH)GetStockObject(LTGRAY_BRUSH);
|
|
wc.hInstance = hInst;
|
|
wc.style = 0;
|
|
wc.lpfnWndProc = WndProc;
|
|
wc.cbWndExtra = 0;
|
|
wc.cbClsExtra = 0;
|
|
|
|
|
|
if (!RegisterClass(&wc)) {
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
//
|
|
// determine screen width
|
|
//
|
|
|
|
hWndDesktop = GetDesktopWindow();
|
|
GetWindowRect(hWndDesktop,&WindowRect);
|
|
|
|
//
|
|
// Create and show the main window
|
|
//
|
|
|
|
hWndMain = CreateWindow ("palClass", // class name
|
|
"DC Test", // caption
|
|
WS_OVERLAPPEDWINDOW, // style bits
|
|
0, // horizontal position.
|
|
0, // vertical position.
|
|
WindowRect.right, // width.
|
|
WindowRect.bottom - 64,// height.
|
|
(HWND)NULL, // parent window
|
|
(HMENU)NULL, // use class menu
|
|
(HINSTANCE)hInst, // instance handle
|
|
(LPSTR)NULL // no params to pass on
|
|
);
|
|
|
|
if (hWndMain == NULL) {
|
|
return(FALSE);
|
|
}
|
|
|
|
//
|
|
// Show the window
|
|
//
|
|
|
|
ShowWindow(hWndMain,cmdShow);
|
|
UpdateWindow(hWndMain);
|
|
SetFocus(hWndMain);
|
|
|
|
//
|
|
// init thread data
|
|
//
|
|
|
|
InitializeCriticalSection(&ThreadCritSect);
|
|
|
|
bThreadActive = FALSE;
|
|
gThreadHandle = NULL;
|
|
dwThreadID = 0;
|
|
|
|
//
|
|
// Main message loop
|
|
//
|
|
|
|
while (GetMessage(&msg,(HWND)NULL,0,0))
|
|
{
|
|
TranslateMessage(&msg);
|
|
DispatchMessage(&msg);
|
|
}
|
|
|
|
return msg.wParam;
|
|
}
|
|
|
|
|
|
/**************************************************************************\
|
|
* DisplayTime
|
|
*
|
|
*
|
|
* Arguments:
|
|
*
|
|
*
|
|
*
|
|
* Return Value:
|
|
*
|
|
*
|
|
*
|
|
* History:
|
|
*
|
|
* 4/1/1997 Mark Enstrom [marke]
|
|
*
|
|
\**************************************************************************/
|
|
|
|
VOID
|
|
vDisplayTime(
|
|
HDC hdc,
|
|
PTIMER_RESULT ptimer
|
|
)
|
|
{
|
|
//
|
|
// display memory bandwidth
|
|
//
|
|
|
|
CHAR tmsg[256];
|
|
double fImageSize = (double)ptimer->ImageSize;
|
|
|
|
wsprintf(tmsg,"Time = %8li",ptimer->TestTime);
|
|
TextOut(hdc,10,10,tmsg,strlen(tmsg));
|
|
|
|
if (ptimer->ImageSize != 0)
|
|
{
|
|
double fTimePerPixel = (ptimer->TestTime * 1000) / fImageSize;
|
|
double fbw = (4.0 * 1000000000.0)/fTimePerPixel;
|
|
|
|
ptimer->TimerPerPixel = (LONG)fTimePerPixel;
|
|
|
|
if (ptimer->TimerPerPixel < 20)
|
|
{
|
|
ptimer->Bandwidth = 0;
|
|
}
|
|
else
|
|
{
|
|
ptimer->Bandwidth = (LONG)fbw;
|
|
}
|
|
|
|
wsprintf(tmsg,"Time per pixel = %li ns, bw = %li bytes/s",ptimer->TimerPerPixel,ptimer->Bandwidth);
|
|
TextOut(hdc,10,40,tmsg,strlen(tmsg));
|
|
}
|
|
}
|
|
|
|
|
|
/**************************************************************************\
|
|
* RunAllTimerTests
|
|
*
|
|
* This routine is called on a separate thread to run all timer tests
|
|
*
|
|
* Arguments:
|
|
*
|
|
* hwnd
|
|
*
|
|
* Return Value:
|
|
*
|
|
*
|
|
*
|
|
* History:
|
|
*
|
|
* 2/28/1997 Mark Enstrom [marke]
|
|
*
|
|
\**************************************************************************/
|
|
|
|
VOID
|
|
RunAllTimerTests(HWND hwnd)
|
|
{
|
|
ULONG iTest;
|
|
PFN_DISP pfnTimer = NULL;
|
|
HDC hdc = GetDC(hwnd);
|
|
|
|
ShowCursor(FALSE);
|
|
|
|
for (iTest = 0;iTest < gNumTimers; iTest++)
|
|
{
|
|
ULONGLONG ululTime;
|
|
|
|
if (gTimerEntry[iTest].Auto == 1)
|
|
{
|
|
SetWindowText(hwnd,(CHAR *)gTimerEntry[iTest].Api);
|
|
pfnTimer = gTimerEntry[iTest].pfn;
|
|
PatBlt(hdc,0,0,2000,2000,BLACKNESS);
|
|
TestCallData.Param = gTimerEntry[iTest].Param;
|
|
TestCallData.pTimerResult = &gpTimerResult[iTest];
|
|
(*pfnTimer)(&TestCallData);
|
|
vDisplayTime(hdc,&gpTimerResult[iTest]);
|
|
}
|
|
}
|
|
|
|
ShowCursor(TRUE);
|
|
|
|
DialogBox(hInstMain, (LPSTR)IDD_RESULTS, hwnd, (DLGPROC)ResultsDlgProc);
|
|
ReleaseDC(hwnd,hdc);
|
|
}
|
|
|
|
|
|
/**************************************************************************\
|
|
* RunAlls
|
|
*
|
|
* This routine called on separate thread to run through each functionality
|
|
* test
|
|
*
|
|
* Arguments:
|
|
*
|
|
* hwnd
|
|
*
|
|
* Return Value:
|
|
*
|
|
*
|
|
*
|
|
* History:
|
|
*
|
|
* 2/28/1997 Mark Enstrom [marke]
|
|
*
|
|
\**************************************************************************/
|
|
|
|
VOID
|
|
RunAllFunctionalityTests(HWND hwnd)
|
|
{
|
|
PFN_DISP pfnDisp;
|
|
ULONG iTest;
|
|
HDC hdc = GetDC(hwnd);
|
|
|
|
for (iTest = 0;iTest < gNumTests; iTest++)
|
|
{
|
|
if (gTestEntry[iTest].Auto == 1)
|
|
{
|
|
pfnDisp = gTestEntry[iTest].pfn;
|
|
TestCallData.Param = gTestEntry[iTest].Param;
|
|
SetWindowText(hwnd,(CHAR *)gTestEntry[iTest].Api);
|
|
PatBlt(hdc,0,0,2000,2000,BLACKNESS);
|
|
(*pfnDisp)(&TestCallData);
|
|
}
|
|
}
|
|
|
|
ReleaseDC(hwnd,hdc);
|
|
}
|
|
|
|
/**************************************************************************\
|
|
* RunAllAlphaTests
|
|
*
|
|
* This routine called on separate thread to run through each functionality
|
|
* test
|
|
*
|
|
* Arguments:
|
|
*
|
|
* hwnd
|
|
*
|
|
* Return Value:
|
|
*
|
|
*
|
|
*
|
|
* History:
|
|
*
|
|
* 2/28/1997 Mark Enstrom [marke]
|
|
*
|
|
\**************************************************************************/
|
|
|
|
VOID
|
|
RunAllAlphaTests(HWND hwnd)
|
|
{
|
|
PFN_DISP pfnDisp;
|
|
ULONG iTest;
|
|
HDC hdc = GetDC(hwnd);
|
|
|
|
for (iTest = 0;iTest < gNumAlphaTests; iTest++)
|
|
{
|
|
if (gTestAlphaEntry[iTest].Auto == 1)
|
|
{
|
|
pfnDisp = gTestAlphaEntry[iTest].pfn;
|
|
TestCallData.Param = gTestAlphaEntry[iTest].Param;
|
|
SetWindowText(hwnd,(CHAR *)gTestAlphaEntry[iTest].Api);
|
|
PatBlt(hdc,0,0,2000,2000,BLACKNESS);
|
|
(*pfnDisp)(&TestCallData);
|
|
Sleep(500);
|
|
}
|
|
}
|
|
|
|
ReleaseDC(hwnd,hdc);
|
|
}
|
|
|
|
/**************************************************************************\
|
|
* RunAllTranTests
|
|
*
|
|
* This routine called on separate thread to run through each functionality
|
|
* test
|
|
*
|
|
* Arguments:
|
|
*
|
|
* hwnd
|
|
*
|
|
* Return Value:
|
|
*
|
|
*
|
|
*
|
|
* History:
|
|
*
|
|
* 2/28/1997 Mark Enstrom [marke]
|
|
*
|
|
\**************************************************************************/
|
|
|
|
VOID
|
|
RunAllTranTests(HWND hwnd)
|
|
{
|
|
PFN_DISP pfnDisp;
|
|
ULONG iTest;
|
|
HDC hdc = GetDC(hwnd);
|
|
|
|
for (iTest = 0;iTest < gNumTranTests; iTest++)
|
|
{
|
|
if (gTestTranEntry[iTest].Auto == 1)
|
|
{
|
|
pfnDisp = gTestTranEntry[iTest].pfn;
|
|
TestCallData.Param = gTestTranEntry[iTest].Param;
|
|
SetWindowText(hwnd,(CHAR *)gTestTranEntry[iTest].Api);
|
|
PatBlt(hdc,0,0,2000,2000,BLACKNESS);
|
|
(*pfnDisp)(&TestCallData);
|
|
}
|
|
}
|
|
|
|
ReleaseDC(hwnd,hdc);
|
|
}
|
|
|
|
/**************************************************************************\
|
|
* RunStress
|
|
*
|
|
* run all tests forever
|
|
*
|
|
* Arguments:
|
|
*
|
|
* hwnd
|
|
*
|
|
* Return Value:
|
|
*
|
|
*
|
|
*
|
|
* History:
|
|
*
|
|
* 2/28/1997 Mark Enstrom [marke]
|
|
*
|
|
\**************************************************************************/
|
|
|
|
VOID
|
|
RunStress(HWND hwnd)
|
|
{
|
|
PFN_DISP pfnDisp;
|
|
PFN_DISP pfnTimer = NULL;
|
|
ULONG iTest;
|
|
HDC hdc = GetDC(hwnd);
|
|
|
|
ULONG StressSleep = 100;
|
|
|
|
|
|
while (TRUE)
|
|
{
|
|
for (iTest = 0;iTest < gNumTests; iTest++)
|
|
{
|
|
if (gTestEntry[iTest].Auto == 1)
|
|
{
|
|
pfnDisp = gTestEntry[iTest].pfn;
|
|
TestCallData.Param = gTestEntry[iTest].Param;
|
|
SetWindowText(hwnd,(CHAR *)gTestEntry[iTest].Api);
|
|
PatBlt(hdc,0,0,2000,2000,BLACKNESS);
|
|
(*pfnDisp)(&TestCallData);
|
|
Sleep(StressSleep);
|
|
}
|
|
}
|
|
|
|
for (iTest = 0;iTest < gNumAlphaTests; iTest++)
|
|
{
|
|
if (gTestAlphaEntry[iTest].Auto == 1)
|
|
{
|
|
pfnDisp = gTestAlphaEntry[iTest].pfn;
|
|
TestCallData.Param = gTestAlphaEntry[iTest].Param;
|
|
SetWindowText(hwnd,(CHAR *)gTestAlphaEntry[iTest].Api);
|
|
PatBlt(hdc,0,0,2000,2000,BLACKNESS);
|
|
(*pfnDisp)(&TestCallData);
|
|
Sleep(StressSleep);
|
|
}
|
|
}
|
|
|
|
for (iTest = 0;iTest < gNumTranTests; iTest++)
|
|
{
|
|
if (gTestTranEntry[iTest].Auto == 1)
|
|
{
|
|
pfnDisp = gTestTranEntry[iTest].pfn;
|
|
TestCallData.Param = gTestTranEntry[iTest].Param;
|
|
PatBlt(hdc,0,0,2000,2000,BLACKNESS);
|
|
SetWindowText(hwnd,(CHAR *)gTestTranEntry[iTest].Api);
|
|
(*pfnDisp)(&TestCallData);
|
|
Sleep(StressSleep);
|
|
}
|
|
}
|
|
|
|
for (iTest = 0;iTest < gNumTimers; iTest++)
|
|
{
|
|
ULONGLONG ululTime;
|
|
|
|
if (gTimerEntry[iTest].Auto == 1)
|
|
{
|
|
pfnTimer = gTimerEntry[iTest].pfn;
|
|
SetWindowText(hwnd,(CHAR *)gTimerEntry[iTest].Api);
|
|
PatBlt(hdc,0,0,2000,2000,BLACKNESS);
|
|
TestCallData.Param = gTimerEntry[iTest].Param;
|
|
TestCallData.pTimerResult = &gpTimerResult[iTest];
|
|
(*pfnTimer)(&TestCallData);
|
|
vDisplayTime(hdc,&gpTimerResult[iTest]);
|
|
Sleep(StressSleep);
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
ReleaseDC(hwnd,hdc);
|
|
}
|
|
|
|
#define ABS(X) (((X) < 0 ) ? -(X) : (X))
|
|
|
|
|
|
LONG
|
|
CreateSubMenu(
|
|
HMENU hAdd,
|
|
PTEST_ENTRY pTestEntry,
|
|
LONG Level,
|
|
LONG ix,
|
|
LONG Start_ID
|
|
)
|
|
{
|
|
CHAR tmsg[256];
|
|
|
|
//
|
|
// validate
|
|
//
|
|
|
|
if (ABS(pTestEntry[ix].Level) != Level)
|
|
{
|
|
wsprintf(tmsg,"Level: %li, ix: %i: %s",Level,ix,pTestEntry[ix].Api);
|
|
MessageBox(NULL,"CreateSubMenu Error",tmsg,MB_OK);
|
|
return(0);
|
|
}
|
|
|
|
//
|
|
// create sub menu
|
|
//
|
|
|
|
HMENU hCreate = CreateMenu();
|
|
wsprintf(tmsg,"T%i: %s",ix,pTestEntry[ix].Api);
|
|
AppendMenu(hAdd, MF_POPUP,(UINT)hCreate,(const char *)tmsg);
|
|
|
|
ix++;
|
|
|
|
do
|
|
{
|
|
if (pTestEntry[ix].Level == Level)
|
|
{
|
|
wsprintf(tmsg,"T%i: %s",ix,pTestEntry[ix].Api);
|
|
AppendMenu(hCreate, MF_STRING | MF_ENABLED, Start_ID + ix,(const char *)tmsg);
|
|
ix++;
|
|
}
|
|
else if (ABS(pTestEntry[ix].Level) > Level)
|
|
{
|
|
ix = CreateSubMenu(hCreate,pTestEntry,ABS(pTestEntry[ix].Level),ix,Start_ID);
|
|
}
|
|
else
|
|
{
|
|
return(ix);
|
|
}
|
|
}
|
|
while (TRUE);
|
|
}
|
|
|
|
|
|
|
|
/**************************************************************************\
|
|
* ExpandMenu
|
|
*
|
|
*
|
|
* Arguments:
|
|
*
|
|
*
|
|
*
|
|
* Return Value:
|
|
*
|
|
*
|
|
*
|
|
* History:
|
|
*
|
|
* 5/29/1997 Mark Enstrom [marke]
|
|
*
|
|
\**************************************************************************/
|
|
|
|
VOID
|
|
ExpandMenu(
|
|
HMENU hAdd,
|
|
PTEST_ENTRY pTestEntry,
|
|
ULONG Start_ID
|
|
)
|
|
{
|
|
CHAR tmsg[256];
|
|
LONG ix = 0;
|
|
|
|
while(pTestEntry[ix].Level != 0)
|
|
{
|
|
LONG CurLevel = pTestEntry[ix].Level;
|
|
|
|
if (ABS(CurLevel) > 1)
|
|
{
|
|
ix = CreateSubMenu(hAdd,pTestEntry,ABS(CurLevel),ix,Start_ID);
|
|
|
|
if (ix == 0)
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
else if (CurLevel == 1)
|
|
{
|
|
wsprintf(tmsg,"T%i: %s",ix,pTestEntry[ix].Api);
|
|
AppendMenu(hAdd, MF_STRING | MF_ENABLED, Start_ID + ix,(const char *)tmsg);
|
|
ix++;
|
|
}
|
|
else
|
|
{
|
|
wsprintf(tmsg,"Level = %lu, API = %s",CurLevel,pTestEntry[ix].Api);
|
|
MessageBox(NULL,"Error in menu creation at line",tmsg,MB_OK);
|
|
ix++;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**************************************************************************\
|
|
* WinMain
|
|
*
|
|
*
|
|
* Arguments:
|
|
*
|
|
*
|
|
*
|
|
* Return Value:
|
|
*
|
|
*
|
|
*
|
|
* History:
|
|
*
|
|
* 2/28/1997 Mark Enstrom [marke]
|
|
*
|
|
\**************************************************************************/
|
|
|
|
|
|
LONG FAR
|
|
PASCAL WndProc(
|
|
HWND hwnd,
|
|
unsigned msg,
|
|
UINT wParam,
|
|
LONG lParam)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Process messages.
|
|
|
|
Arguments:
|
|
|
|
hwnd - window hande
|
|
msg - type of message
|
|
wParam - additional information
|
|
lParam - additional information
|
|
|
|
Return Value:
|
|
|
|
status of operation
|
|
|
|
|
|
Revision History:
|
|
|
|
02-17-91 Initial code
|
|
|
|
--*/
|
|
|
|
{
|
|
TestCallData.hwnd = hwnd;
|
|
static HFONT hFont;
|
|
|
|
//
|
|
// message loop
|
|
//
|
|
|
|
switch (msg) {
|
|
|
|
case WM_CREATE:
|
|
{
|
|
HDC hdc = GetDC(hwnd);
|
|
|
|
hFont = (HFONT) GetStockObject(SYSTEM_FIXED_FONT);
|
|
|
|
HMENU hAdd = GetSubMenu(GetMenu(hwnd),1);
|
|
ExpandMenu(hAdd,gTestEntry,ID_TEST_START);
|
|
|
|
hAdd = GetSubMenu(GetMenu(hwnd),2);
|
|
ExpandMenu(hAdd,gTestAlphaEntry,ID_ALPHA_START);
|
|
|
|
|
|
hAdd = GetSubMenu(GetMenu(hwnd),3);
|
|
ExpandMenu(hAdd,gTestTranEntry,ID_TRAN_START);
|
|
|
|
hAdd = GetSubMenu(GetMenu(hwnd),4);
|
|
ExpandMenu(hAdd,gTimerEntry,ID_TIMER_START);
|
|
|
|
gpTimerResult = (PTIMER_RESULT)LocalAlloc(0,gNumTimers * sizeof(TIMER_RESULT));
|
|
memset(gpTimerResult,0,gNumTimers * sizeof(TIMER_RESULT));
|
|
|
|
//
|
|
// global fill brush
|
|
//
|
|
|
|
hbmCars = LoadBitmap(hInstMain,MAKEINTRESOURCE(CAR_BITMAP));
|
|
LOGBRUSH lgBrush;
|
|
|
|
lgBrush.lbStyle = BS_PATTERN;
|
|
lgBrush.lbColor = 0;
|
|
lgBrush.lbHatch = (LONG)hbmCars;
|
|
|
|
hbrFillCars = CreateBrushIndirect(&lgBrush);
|
|
|
|
//
|
|
// global font
|
|
//
|
|
|
|
LOGFONT lf = {
|
|
12, // h
|
|
8, // w
|
|
0, // Esc
|
|
0, // Ori
|
|
0, // Weight
|
|
0, // itallic
|
|
0, // underline
|
|
0, // strile
|
|
OEM_CHARSET,
|
|
OUT_DEFAULT_PRECIS,
|
|
CLIP_DEFAULT_PRECIS,
|
|
DEFAULT_QUALITY,
|
|
FIXED_PITCH,
|
|
"Terminal"
|
|
};
|
|
|
|
HFONT hTestFont = CreateFontIndirect(&lf);
|
|
|
|
ReleaseDC(hwnd,hdc);
|
|
}
|
|
break;
|
|
|
|
case WM_COMMAND:
|
|
{
|
|
switch (LOWORD(wParam)){
|
|
|
|
case IDM_EXIT:
|
|
|
|
if (gThreadHandle != NULL)
|
|
{
|
|
TerminateThread(gThreadHandle,0);
|
|
}
|
|
|
|
SendMessage(hwnd,WM_CLOSE,0,0L);
|
|
break;
|
|
|
|
case IDM_REDRAW:
|
|
//
|
|
// kill old thread if active
|
|
//
|
|
|
|
if (gThreadHandle != NULL)
|
|
{
|
|
TerminateThread(gThreadHandle,0);
|
|
}
|
|
|
|
gThreadHandle = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)pfnLast,&TestCallData,0,&dwThreadID);
|
|
|
|
break;
|
|
|
|
case IDM_SHOW:
|
|
DialogBox(hInstMain, (LPSTR)IDD_RESULTS, hwnd, (DLGPROC)ResultsDlgProc);
|
|
break;
|
|
|
|
|
|
case IDM_ALL_TIMERS:
|
|
|
|
//
|
|
// kill old thread if active
|
|
//
|
|
|
|
if (gThreadHandle != NULL)
|
|
{
|
|
TerminateThread(gThreadHandle,0);
|
|
}
|
|
|
|
gThreadHandle = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)RunAllTimerTests,hwnd,0,&dwThreadID);
|
|
|
|
break;
|
|
|
|
case IDM_STRESS:
|
|
|
|
//
|
|
// kill old thread if active
|
|
//
|
|
|
|
if (gThreadHandle != NULL)
|
|
{
|
|
TerminateThread(gThreadHandle,0);
|
|
}
|
|
|
|
gThreadHandle = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)RunStress,hwnd,0,&dwThreadID);
|
|
|
|
break;
|
|
|
|
case IDM_RUN:
|
|
|
|
//
|
|
// kill old thread if active
|
|
//
|
|
|
|
if (gThreadHandle != NULL)
|
|
{
|
|
TerminateThread(gThreadHandle,0);
|
|
}
|
|
|
|
gThreadHandle = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)RunAllFunctionalityTests,hwnd,0,&dwThreadID);
|
|
|
|
break;
|
|
|
|
case IDM_RUN_ALPHA:
|
|
|
|
//
|
|
// kill old thread if active
|
|
//
|
|
|
|
if (gThreadHandle != NULL)
|
|
{
|
|
TerminateThread(gThreadHandle,0);
|
|
}
|
|
|
|
gThreadHandle = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)RunAllAlphaTests,hwnd,0,&dwThreadID);
|
|
|
|
break;
|
|
|
|
|
|
case IDM_RUN_TRAN:
|
|
|
|
//
|
|
// kill old thread if active
|
|
//
|
|
|
|
if (gThreadHandle != NULL)
|
|
{
|
|
TerminateThread(gThreadHandle,0);
|
|
}
|
|
|
|
gThreadHandle = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)RunAllTranTests,hwnd,0,&dwThreadID);
|
|
|
|
break;
|
|
|
|
case IDM_ROTATE0:
|
|
case IDM_ROTATE10:
|
|
case IDM_ROTATE20:
|
|
case IDM_ROTATE30:
|
|
case IDM_ROTATE40:
|
|
case IDM_ROTATE50:
|
|
case IDM_ROTATE60:
|
|
case IDM_ROTATE70:
|
|
case IDM_ROTATE80:
|
|
case IDM_ROTATE90:
|
|
{
|
|
double rotationAngle = (LOWORD(wParam) - IDM_ROTATE0) * 10;
|
|
rotationAngle *= 2 * 3.1415 / 360; // Radians
|
|
|
|
rotationXform.eM11 = (float) cos(rotationAngle);
|
|
rotationXform.eM12 = (float) sin(rotationAngle);
|
|
rotationXform.eM21 = (float) -sin(rotationAngle);
|
|
rotationXform.eM22 = (float) cos(rotationAngle);
|
|
|
|
rotationXform.eDx = 0;
|
|
rotationXform.eDy = 0;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
//
|
|
// Tests
|
|
//
|
|
|
|
default:
|
|
{
|
|
ULONG Test = LOWORD(wParam) - ID_TEST_START;
|
|
ULONG TestAlpha = LOWORD(wParam) - ID_ALPHA_START;
|
|
ULONG TestTran = LOWORD(wParam) - ID_TRAN_START;
|
|
ULONG TestTimer = LOWORD(wParam) - ID_TIMER_START;
|
|
ULONG Index;
|
|
RECT CliRect;
|
|
|
|
//
|
|
// display tests
|
|
//
|
|
|
|
if (Test < gNumTests)
|
|
{
|
|
pfnLast = gTestEntry[Test].pfn;
|
|
|
|
SetWindowText(hwnd,(CHAR *)gTestEntry[Test].Api);
|
|
|
|
TestCallData.Param = gTestEntry[Test].Param;
|
|
|
|
//
|
|
// kill old thread if active
|
|
//
|
|
|
|
if (gThreadHandle != NULL)
|
|
{
|
|
TerminateThread(gThreadHandle,0);
|
|
}
|
|
|
|
gThreadHandle = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)pfnLast,&TestCallData,0,&dwThreadID);
|
|
}
|
|
else if (TestAlpha < gNumAlphaTests)
|
|
{
|
|
pfnLast = gTestAlphaEntry[TestAlpha].pfn;
|
|
SetWindowText(hwnd,(CHAR *)gTestAlphaEntry[TestAlpha].Api);
|
|
TestCallData.Param = gTestAlphaEntry[TestAlpha].Param;
|
|
|
|
//
|
|
// kill old thread if active
|
|
//
|
|
|
|
if (gThreadHandle != NULL)
|
|
{
|
|
TerminateThread(gThreadHandle,0);
|
|
}
|
|
|
|
gThreadHandle = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)pfnLast,&TestCallData,0,&dwThreadID);
|
|
}
|
|
else if (TestTran < gNumTranTests)
|
|
{
|
|
pfnLast = gTestTranEntry[TestTran].pfn;
|
|
TestCallData.Param = gTestTranEntry[TestTran].Param;
|
|
SetWindowText(hwnd,(CHAR *)gTestTranEntry[TestTran].Api);
|
|
|
|
//
|
|
// kill old thread if active
|
|
//
|
|
|
|
if (gThreadHandle != NULL)
|
|
{
|
|
TerminateThread(gThreadHandle,0);
|
|
}
|
|
|
|
gThreadHandle = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)pfnLast,&TestCallData,0,&dwThreadID);
|
|
}
|
|
else if (TestTimer < gNumTimers)
|
|
{
|
|
//
|
|
// timer tests, run on main thread
|
|
// kill old thread if active
|
|
//
|
|
|
|
if (gThreadHandle != NULL)
|
|
{
|
|
TerminateThread(gThreadHandle,0);
|
|
}
|
|
|
|
HDC hdc = GetDC(hwnd);
|
|
CHAR szBuffer[255];
|
|
|
|
PFN_DISP pfnTimer = NULL;
|
|
|
|
pfnTimer = gTimerEntry[TestTimer].pfn;
|
|
TestCallData.Param = gTimerEntry[TestTimer].Param;
|
|
TestCallData.pTimerResult = &gpTimerResult[TestTimer];
|
|
SetWindowText(hwnd,(CHAR *)gTimerEntry[TestTimer].Api);
|
|
|
|
(*pfnTimer)(&TestCallData);
|
|
|
|
vDisplayTime(hdc,&gpTimerResult[TestTimer]);
|
|
|
|
ReleaseDC(hwnd,hdc);
|
|
}
|
|
|
|
}
|
|
break;
|
|
|
|
}
|
|
}
|
|
break;
|
|
|
|
case WM_SIZE:
|
|
|
|
if (gThreadHandle != NULL)
|
|
{
|
|
TerminateThread(gThreadHandle,0);
|
|
}
|
|
|
|
InvalidateRect(hwnd,NULL,TRUE);
|
|
break;
|
|
|
|
case WM_PAINT:
|
|
{
|
|
PAINTSTRUCT ps;
|
|
HDC hdc = BeginPaint(hwnd,&ps);
|
|
|
|
//(*pfnLast)(hwnd);
|
|
|
|
EndPaint(hwnd,&ps);
|
|
|
|
}
|
|
break;
|
|
|
|
case WM_DESTROY:
|
|
PostQuitMessage(0);
|
|
break;
|
|
|
|
default:
|
|
|
|
//
|
|
// Passes message on if unproccessed
|
|
//
|
|
|
|
return (DefWindowProc(hwnd, msg, wParam, lParam));
|
|
}
|
|
|
|
return ((LONG)NULL);
|
|
|
|
}
|
|
|
|
/**************************************************************************\
|
|
* ResultsDlgProc
|
|
*
|
|
* Show results of time run
|
|
*
|
|
* Arguments:
|
|
*
|
|
*
|
|
*
|
|
* Return Value:
|
|
*
|
|
*
|
|
*
|
|
* History:
|
|
*
|
|
* 1/27/1997 Mark Enstrom [marke]
|
|
*
|
|
\**************************************************************************/
|
|
|
|
|
|
BOOL
|
|
APIENTRY
|
|
ResultsDlgProc(
|
|
HWND hwnd,
|
|
UINT msg,
|
|
UINT wParam,
|
|
LONG lParam)
|
|
{
|
|
ULONG ix;
|
|
char szT[180];
|
|
BOOL fResults;
|
|
int aiT[2];
|
|
|
|
switch (msg) {
|
|
case WM_INITDIALOG:
|
|
aiT[0] = 100;
|
|
aiT[1] = 190;
|
|
fResults = FALSE;
|
|
|
|
{
|
|
LV_COLUMN lvc;
|
|
LV_ITEM lvl;
|
|
UINT width;
|
|
RECT rc;
|
|
HWND hwndList = GetDlgItem(hwnd, IDC_RESULTSLIST);
|
|
int i;
|
|
|
|
static LPCSTR title[] =
|
|
{
|
|
"Function",
|
|
"Time(1us)",
|
|
"Iterations"
|
|
};
|
|
|
|
//
|
|
// check if using pentium counters
|
|
//
|
|
|
|
#ifdef _X86_
|
|
if (gfPentium)
|
|
{
|
|
title[1] = "Cycle Counts";
|
|
}
|
|
#endif
|
|
|
|
if (hwndList == NULL)
|
|
{
|
|
break;
|
|
}
|
|
|
|
GetClientRect(hwndList, &rc);
|
|
|
|
//
|
|
// only first column has doubled width. Save space menu
|
|
//
|
|
|
|
width = ((rc.right - rc.left) / (sizeof title / sizeof *title + 1)) - 32;
|
|
|
|
lvc.cx = width * 2;
|
|
lvc.mask = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM;
|
|
lvc.fmt = LVCFMT_LEFT;
|
|
lvc.iSubItem = 0;
|
|
|
|
for (i = 0; i < sizeof title / sizeof *title; ++i)
|
|
{
|
|
int iRet;
|
|
lvc.pszText = (LPSTR)title[i];
|
|
lvc.cchTextMax = strlen((LPSTR)title[i]);
|
|
iRet = ListView_InsertColumn(hwndList, i, &lvc);
|
|
|
|
if (iRet == -1)
|
|
{
|
|
MessageBox(hwnd, "ListView_InsertColumn failed","disp",MB_OK);
|
|
}
|
|
|
|
//
|
|
// normal width, right aligned
|
|
//
|
|
|
|
lvc.cx = width;
|
|
lvc.fmt = LVCFMT_RIGHT;
|
|
}
|
|
|
|
lvl.iItem = 0;
|
|
lvl.mask = LVIF_TEXT;
|
|
|
|
for (ix = 0; ix < gNumTimers; ix++)
|
|
{
|
|
if (gpTimerResult[ix].TestTime == 0)
|
|
{
|
|
// no measuement, skip
|
|
continue;
|
|
}
|
|
|
|
lvl.iSubItem = 0;
|
|
lvl.pszText = (CHAR *)gTimerEntry[ix].Api;
|
|
|
|
ListView_InsertItem(hwndList, &lvl);
|
|
|
|
DISP_SUBITEM("%ld",gpTimerResult[ix].TestTime);
|
|
DISP_SUBITEM("%ld",gTimerEntry[ix].Param);
|
|
|
|
++lvl.iItem;
|
|
fResults = TRUE;
|
|
}
|
|
|
|
if (!fResults)
|
|
{
|
|
MessageBox(hwnd, "No results have been generated yet or Test may have failed!",
|
|
"UsrBench", MB_OK | MB_ICONEXCLAMATION);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case WM_COMMAND:
|
|
switch (LOWORD(wParam))
|
|
{
|
|
case IDOK:
|
|
case IDCANCEL:
|
|
EndDialog(hwnd, 0);
|
|
break;
|
|
|
|
case IDM_SAVERESULTS:
|
|
SaveResults();
|
|
break;
|
|
|
|
default:
|
|
return FALSE;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Save results to file
|
|
|
|
Arguments
|
|
|
|
none
|
|
|
|
Return Value
|
|
|
|
none
|
|
|
|
--*/
|
|
|
|
VOID
|
|
SaveResults()
|
|
{
|
|
static OPENFILENAME ofn;
|
|
static char szFilename[256];
|
|
static char szDirname[256];
|
|
char CurDir[256];
|
|
char szT[80];
|
|
int i, hfile;
|
|
FILE *fpOut;
|
|
|
|
ULONG ulScreenFormat = ulDetermineScreenFormat(NULL);
|
|
|
|
GetCurrentDirectory(256,CurDir);
|
|
|
|
memset(&ofn,0,sizeof(OPENFILENAME));
|
|
|
|
ofn.lStructSize = sizeof(ofn);
|
|
ofn.hwndOwner = hWndMain;
|
|
ofn.hInstance = hInstMain;
|
|
|
|
ofn.lpstrFilter = "Text (*.txt)\0*.txt\0All Files\0*.*\0\0";
|
|
ofn.lpstrCustomFilter = NULL;
|
|
ofn.nMaxCustFilter = 0;
|
|
ofn.nFilterIndex = 0;
|
|
ofn.lpstrFileTitle = NULL;
|
|
ofn.nMaxFileTitle = 0;
|
|
|
|
//ofn.lpstrInitialDir = szDirname;
|
|
//lstrcpy(szDirname,"D:\\nt\\private\\ntos\\w32\\ntgdi\\test\\imgtest");
|
|
|
|
ofn.lpstrInitialDir = CurDir;
|
|
|
|
ofn.Flags = 0;
|
|
ofn.lpstrDefExt = "txt";
|
|
ofn.lCustData = 0;
|
|
ofn.lpfnHook = NULL;
|
|
ofn.lpTemplateName = NULL;
|
|
|
|
lstrcpy(szFilename,"Disp_");
|
|
lstrcat(szFilename,pScreenDef[ulScreenFormat]);
|
|
|
|
ofn.lpstrFile = szFilename;
|
|
ofn.nMaxFile = sizeof(szFilename);
|
|
ofn.lpstrTitle = "Save As";
|
|
|
|
if (!GetSaveFileName(&ofn))
|
|
{
|
|
return;
|
|
}
|
|
|
|
fpOut = fopen(szFilename, "w+");
|
|
|
|
if(NULL != fpOut)
|
|
{
|
|
WriteBatchResults(fpOut,ulScreenFormat);
|
|
fclose(fpOut);
|
|
}
|
|
else
|
|
{
|
|
MessageBox(hWndMain,"Cannot Open File to Save Results", "Output File Creation Error",MB_ICONSTOP|MB_OK);
|
|
}
|
|
}
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
WriteBatchResults - Save Batch results to file
|
|
|
|
Arguments
|
|
|
|
FILE *fpOutFile
|
|
int TestType
|
|
|
|
Return Value
|
|
|
|
none
|
|
|
|
--*/
|
|
|
|
|
|
VOID
|
|
WriteBatchResults(
|
|
FILE *fpOut,
|
|
ULONG ulScreenFormat
|
|
)
|
|
{
|
|
char szT[180];
|
|
MEMORYSTATUS MemoryStatus;
|
|
char ComputerName[MAX_COMPUTERNAME_LENGTH + 1];
|
|
ULONG SizBuf = MAX_COMPUTERNAME_LENGTH + 1;
|
|
int i,j;
|
|
ULONG ix;
|
|
char *pszOSName;
|
|
ULONG ixStart = 0;
|
|
ULONG ixEnd = gNumTimers;
|
|
|
|
//
|
|
// Write out the build information and current date.
|
|
//
|
|
|
|
Win32VersionInformation.dwOSVersionInfoSize = sizeof(Win32VersionInformation);
|
|
|
|
if (GetVersionEx(&Win32VersionInformation))
|
|
{
|
|
switch (Win32VersionInformation.dwPlatformId)
|
|
{
|
|
case VER_PLATFORM_WIN32s:
|
|
pszOSName = "WIN32S";
|
|
break;
|
|
case VER_PLATFORM_WIN32_WINDOWS:
|
|
pszOSName = "Windows 95";
|
|
break;
|
|
case VER_PLATFORM_WIN32_NT:
|
|
pszOSName = "Windows NT";
|
|
break;
|
|
default:
|
|
pszOSName = "Windows ???";
|
|
break;
|
|
}
|
|
|
|
GetComputerName(ComputerName, &SizBuf);
|
|
|
|
wsprintf(szT, "\n\n/////////////// ");
|
|
|
|
fwrite(szT, sizeof(char), lstrlen(szT), fpOut);
|
|
|
|
wsprintf(szT, "%s Version %d.%d Build %d ", pszOSName,
|
|
Win32VersionInformation.dwMajorVersion,
|
|
Win32VersionInformation.dwMinorVersion,
|
|
Win32VersionInformation.dwBuildNumber);
|
|
fwrite(szT, sizeof(char), lstrlen(szT), fpOut);
|
|
|
|
MemoryStatus.dwLength = sizeof(MEMORYSTATUS);
|
|
GlobalMemoryStatus(&MemoryStatus);
|
|
|
|
wsprintf(szT, "Physical Memory = %dKB ////////////////\n", MemoryStatus.dwTotalPhys/1024);
|
|
fwrite(szT, sizeof(char), lstrlen(szT), fpOut);
|
|
|
|
wsprintf(szT,"\nComputer Name = %s", ComputerName);
|
|
fwrite(szT, sizeof(char), lstrlen(szT), fpOut);
|
|
|
|
//
|
|
// determine and output screen type
|
|
//
|
|
|
|
ULONG ulScreenFormat = ulDetermineScreenFormat(NULL);
|
|
|
|
wsprintf(szT,"\nScreen Format = %s\n", pScreenDef[ulScreenFormat]);
|
|
fwrite(szT, sizeof(char), lstrlen(szT), fpOut);
|
|
|
|
}
|
|
|
|
#if 0
|
|
#ifdef _X86_
|
|
//
|
|
// Print the Names of the event monitored
|
|
// Needs to detect CPU for Pentium or up later
|
|
// a-ifkao
|
|
//
|
|
if(gfCPUEventMonitor) {
|
|
wsprintf(szT, "\nThe CPU Events monitored are <%s> and <%s>",PerfName[0], PerfName[1]);
|
|
fwrite(szT, sizeof(char), lstrlen(szT), fpOut);
|
|
}
|
|
#endif
|
|
#endif
|
|
|
|
wsprintf(szT,"\n\n\n");
|
|
fwrite(szT, sizeof(char), lstrlen(szT), fpOut);
|
|
wsprintf(szT,"Function Name Iterations Time PixelTime bw ImageSize\n");
|
|
fwrite(szT, sizeof(char), lstrlen(szT), fpOut);
|
|
wsprintf(szT,"\n");
|
|
fwrite(szT, sizeof(char), lstrlen(szT), fpOut);
|
|
|
|
ULONG uix;
|
|
|
|
for (uix=0;uix<gNumTimers;uix++)
|
|
{
|
|
wsprintf(szT,"%s%8li %8li %8li %10li %8li\n",
|
|
gTimerEntry[uix].Api,
|
|
gTimerEntry[uix].Param,
|
|
gpTimerResult[uix].TestTime,
|
|
gpTimerResult[uix].TimerPerPixel,
|
|
gpTimerResult[uix].Bandwidth,
|
|
gpTimerResult[uix].ImageSize
|
|
);
|
|
fwrite(szT, sizeof(char), lstrlen(szT), fpOut);
|
|
}
|
|
}
|