windows-xp/Source/XPSP1/NT/com/oleutest/perform/procswap/procswap.cxx

//+------------------------------------------------------------------------
//
//  Microsoft Windows
//  Copyright (C) Microsoft Corporation, 1993.
//
//  File:	procswap.cxx
//
//  Contents:	Program for measuring task switching performance
//		between two windows programs. The program creates
//		CTaskSwitch objects...
//
//		Each Object can wait on one of three things...
//		    1. GetMessage
//		    2. MsgWaitForMultipleObjects
//		    3. WaitForSingleObject (event)
//
//		and when awoken, will signal another Object in one
//		of three ways...
//		    1. PostMessage
//		    2. SendMessage
//		    3. SetEvent
//
//		These cases can be combined in any manner to obtain
//		a maxtrix of possible scenarios.
//
//		The CTaskSwitch objects can be in the same process on
//		different threads, or in different processes.
//
//  Classes:	CEvent	      -	event handling class
//		CTaskSwitch   -	main task switch class
//
//
//  Functions:	WinMain       - entry point of process
//		ThreadEntry   - entry point of spawned threads
//		ThreadWndProc -	processes windows messages
//
//
//  History:	08-Feb-94   Rickhi	Created
//
//--------------------------------------------------------------------------

#include <benchmrk.hxx>
#include <tchar.h>


//  execution parameter structure

typedef struct tagSExecParms
{
    int 	oloop;		//  outer loop count
    int 	iloop;		//  inner loop count
    HWND	hWndOther;	//  HWND of other process
    HANDLE	hEventOther;	//  Event Handle of other process
    WNDPROC	pfnWndProc;	//  ptr to WndProc function
    TCHAR	szFile[20];	//  output file name
    TCHAR	szWaitEvent[20];   // event name to wait on
    TCHAR	szSignalEvent[20]; // event name to signal
} SExecParms;


typedef enum tagWAITTYPES
{
    WAIT_EVENT		    = 1,
    WAIT_MSGWAITFORMULTIPLE = 2,
    WAIT_GETMESSAGE	    = 3,
    WAIT_SYNCHRONOUS	    = 4
} WAITTYPES;

typedef enum tagSIGNALTYPES
{
    SIGNAL_EVENT	    = 1,
    SIGNAL_POSTMESSAGE	    = 2,
    SIGNAL_SENDMESSAGE	    = 3,
    SIGNAL_SYNCHRONOUS	    = 4
} SIGNALTYPES;

//  input names corresponding to the wait types
LPSTR aszWait[] = {"", "event", "msgwait", "getmsg", "sync", NULL};

//  input names corresponding to the signal types
LPSTR aszSignal[] = {"", "event", "postmsg", "sendmsg", "sync", NULL};



//  Name of window class for dispatching messages.

#define MY_WINDOW_CLASS TEXT("ProcSwapWindowClass")

#define MAX_OLOOP   100


//  globals

DWORD		g_fFullInfo = 0;	    //	write full info or not
HINSTANCE	g_hInst     = NULL;	    //	misc windows junk.
ATOM		g_MyClass   = 0;
UINT		g_MyMessage = WM_USER;


//  function prototype
LRESULT	ThreadWndProc(HWND hWnd, UINT msg, WPARAM wparam, LPARAM lparam);
DWORD	ThreadEntry(void *param);


//--------------------------------------------------------------------------
//
//  Class:	CEvent
//
//  Purpose:	class for blocking & starting threads.
//
//--------------------------------------------------------------------------

class	CEvent
{
public:
	    CEvent(LPTSTR szName, HRESULT &hr) { Init(szName, hr); }
	    CEvent(void) {m_hdl = NULL; }

	    ~CEvent()	 { CloseHandle(m_hdl); }

    void    Signal(void) { SetEvent(m_hdl); }
    void    Reset(void)  { ; }		      // ResetEvent(m_hdl); }
    void    BlockS(void) { WaitForSingleObject(m_hdl, 60000); }
    void    BlockM(void) { WaitForMultipleObjects(1, &m_hdl, FALSE, 60000); }
    HANDLE *GetHdl(void) { return &m_hdl; };

    void    Init(LPTSTR szName, HRESULT &hr);

private:

    HANDLE  m_hdl;
};


void CEvent::Init(LPTSTR szName, HRESULT &hr)
{
    hr = S_OK;

    //	first try opening the event
    m_hdl = OpenEvent(EVENT_ALL_ACCESS,
		      FALSE,
		      szName);

    if (m_hdl == NULL)
    {
	//  doesnt exist yet so create it.
	m_hdl = CreateEvent(NULL,	    // security
			    FALSE,	    // auto reset
			    FALSE,	    // initially not signalled
			    szName);

	if (m_hdl == NULL)
	{
	    _tprintf (TEXT("Error Creating CEvent (%s)\n"), szName);
	    hr = GetLastError();
	}
	else
	{
	    _tprintf (TEXT("Created CEvent (%s)\n"), szName);
	}
    }
    else
    {
        _tprintf (TEXT("Opened CEvent (%s)\n"), szName);
    }
}



//--------------------------------------------------------------------------
//
//  Class:	CTaskSwitch
//
//  Purpose:	class for timing task switches.
//
//--------------------------------------------------------------------------

class	CTaskSwitch
{
public:
		CTaskSwitch(LPSTR lpszCmdLine, HRESULT &hr);
		~CTaskSwitch(void);

    int		MainProcessLoop(void);
    LRESULT	ThreadWndProc(HWND hWnd, UINT msg, WPARAM wparam, LPARAM lparam);
    HRESULT	SpawnOtherSide(void);

private:

    //	initialization / cleanup methods

    HRESULT	ParseCmdLine(LPSTR lpszCmdLine, SExecParms &execp);
    HRESULT	WindowInitialize(WNDPROC pfnWndProc, HWND &hWnd);
    void	WindowUninitialize(HWND hWnd);
    void	CreateOtherParms(void);
    void	WriteExecParms(void);
    void	WriteResults(void);
    void	Help(void);
    DWORD	GetWaitType(LPSTR pszCmd);
    DWORD	GetSignalType(LPSTR pszCmd);
    DWORD	CreateProc(void);

    //	processing methods

    HRESULT	SendOrWaitFirstSignal(void);
    void	ProcessMsgWaitForMultiple(DWORD dwRet);
    void	ProcessIncommingEvent(void);
    void	UpdateLoopCounters(void);
    void	SignalOtherSide(void);

    //	data

    BOOL		g_fDone;	    //	when to exit the loop
    BOOL		g_fKicker;	    //	we kick the other guy
    BOOL		g_fThreadSwitch;    //	thread or process switching?
    BOOL		g_fWaitMultiple;    //	wait single or multiple

    ULONG		g_oloop;	    //	outer loop counter
    ULONG		g_iloop;	    //	inner loop counter

    DWORD		g_WaitType;	    //	what to wait on
    DWORD		g_SignalType;	    //	what to signal

    //	used only for parameter parseing
    DWORD		g_WaitType1;	    //	what to wait on
    DWORD		g_SignalType1;	    //	what to signal
    DWORD		g_WaitType2;	    //	what to wait on
    DWORD		g_SignalType2;	    //	what to signal


    HWND		g_hWndOther;	    //	hWnd of other side
    HWND		g_hWndMe;	    //	my hWnd

    CEvent		g_WaitEvent;	    //	event to wait on
    CEvent		g_SignalEvent;	    //	event to signal

    ULONG		g_time[MAX_OLOOP];  //	place to store the timings.
    CStopWatch		g_timer;	    //	global timer proc 1

    SExecParms		g_execp;	    //	execution parameters
    CTestOutput       * g_output;	    //	output log

    HRESULT		g_hr;		    //	result code

    CHAR		g_szOtherParms[MAX_PATH]; // parm string for other guy
};




//  task switch objects - must be global for ThreadWndProc

CTaskSwitch	*g_pTaskSwitch1 = NULL;
CTaskSwitch	*g_pTaskSwitch2 = NULL;


//--------------------------------------------------------------------------
//
//  WinMain - main entry point of program.  May just call ThreadEntry, or
//	      may spawn another thread in the case of thread switching.
//
//
//--------------------------------------------------------------------------

int WinMain(HINSTANCE hinst, HINSTANCE hPrev, LPSTR lpszCmdLine, int CmdShow)
{
    HRESULT hr;

    //	create the first task switch object for this process
    g_pTaskSwitch1 = new CTaskSwitch(lpszCmdLine, hr);

    if (hr == S_OK)
    {
	//  spawn a new thread or a new process to do task switching with.
	hr = g_pTaskSwitch1->SpawnOtherSide();

	if (hr == S_OK)
	{
	    //	enter the main processing loop
	    g_pTaskSwitch1->MainProcessLoop();
	}
    }

    //	print the results
    delete g_pTaskSwitch1;
    return 1;
}



//--------------------------------------------------------------------------
//
//  ThreadEntry - main entry point for a thread spawned by CreateThread
//	    in the case of task switching between threads.
//
//	    Creates an instance of the CTaskSwitch class and invokes it
//	    main function.
//
//--------------------------------------------------------------------------

DWORD ThreadEntry(void *param)
{
    LPSTR lpszCmdLine = (LPSTR) param;

    HRESULT hr;

    //	create the second task switch object for this process
    g_pTaskSwitch2 = new CTaskSwitch(lpszCmdLine, hr);

    if (hr == S_OK)
    {
	//  enter the main processing loop
	g_pTaskSwitch2->MainProcessLoop();
    }

    //	print the results
    delete g_pTaskSwitch2;
    return hr;
}




//--------------------------------------------------------------------------
//
//  Dipatch to the correct CTaskSwitch object if the message is our
//  special message.
//
//--------------------------------------------------------------------------

LRESULT ThreadWndProc(HWND hWnd, UINT msg, WPARAM wparam, LPARAM lparam)
{
    if (msg == g_MyMessage)
    {
	//  its my special message, go handle it.
	//  here i have to select which object to dispatch to for the
	//  multithreaded case. i base that decision on lparam.

	if (lparam == 0)
	{
	    //	use the first task switch object
	    return g_pTaskSwitch1->ThreadWndProc(hWnd, msg, wparam, lparam);
	}
	else
	{
	    //	use the second task switch object
	    return g_pTaskSwitch2->ThreadWndProc(hWnd, msg, wparam, lparam);
	}
    }
    else
    {
	// let the default window procedure have the message.
	return DefWindowProc(hWnd, msg, wparam, lparam);
    }
}




//--------------------------------------------------------------------------
//
//  Constructor : parse the command line, create the events, create the
//		  window, and open a log file.
//
//--------------------------------------------------------------------------

CTaskSwitch::CTaskSwitch(LPSTR lpszCmdLine, HRESULT &hr) :
    g_fDone(FALSE),
    g_fKicker(FALSE),
    g_fThreadSwitch(FALSE),
    g_fWaitMultiple(FALSE),
    g_oloop(10),
    g_iloop(100),
    g_WaitType(WAIT_EVENT),
    g_SignalType(SIGNAL_EVENT),
    g_hWndMe(NULL),
    g_hWndOther(NULL),
    g_output(NULL),
    g_hr(S_OK)
{
    //	parse command line and write the parms to log file.
    g_hr = ParseCmdLine(lpszCmdLine, g_execp);

    if (g_hr == S_OK)
    {
	//  Create a log file & write execution parameters
	g_output = new CTestOutput(g_execp.szFile);
	WriteExecParms();

	//  create the window for this thread
	g_hr = WindowInitialize(g_execp.pfnWndProc, g_hWndMe);
	if (g_hr == S_OK)
	{
	    //	Create the Wait event.
	    g_WaitEvent.Init(g_execp.szWaitEvent, g_hr);
	    if (g_hr == S_OK)
	    {
		//  Create the Signal event.
		g_SignalEvent.Init(g_execp.szSignalEvent, g_hr);

		if (g_hr == S_OK)
		{
		    //	create paramters to send to other side.
		    CreateOtherParms();
		}
	    }
	}
    }

    //	return the results
    hr = g_hr;
}


//--------------------------------------------------------------------------
//
//  Desructor
//
//--------------------------------------------------------------------------

CTaskSwitch::~CTaskSwitch(void)
{
    //	write the results
    WriteResults();

    //	cleanup window registration
    WindowUninitialize(g_hWndMe);

    //	close the log file
    delete g_output;
}


//--------------------------------------------------------------------------
//
//  Spawns either another process or another thread to perform the task
//  switching with.
//
//--------------------------------------------------------------------------

HRESULT CTaskSwitch::SpawnOtherSide(void)
{
    if (g_fKicker)
    {
	//  i'm already the second entry, dont spawn anything.
	//  sleep for a bit to make sure both sides are ready
	//  when i kick things off.

	Sleep(1000);
	return S_OK;
    }


    if (g_fThreadSwitch)
    {
	//  spawn a thread

	HANDLE	hdl;
	DWORD  dwId;
	hdl = CreateThread(NULL,	    //	default security
			   0,		    //	default stack size
			   ThreadEntry,     //	entry point
			   g_szOtherParms,  //	command line parms
			   0,		    //	flags
			   &dwId);	    //	threadid

	if (hdl)
	{
	    //	dont need the handle
	    CloseHandle(hdl);
	}
	else
	{
	    //	what went wrong?
	    return GetLastError();
	}
    }
    else
    {
	//  spawn a process
	DWORD dwRet = CreateProc();
	if (dwRet != S_OK)
	{
	    return dwRet;
	}
    }

    return S_OK;
}



//--------------------------------------------------------------------------
//
//  MainProcessLoop - does the main wait & process the event
//
//--------------------------------------------------------------------------

int CTaskSwitch::MainProcessLoop(void)
{
    MSG     msg;
    DWORD   dwRet;


    //	Send, or wait on, the first signal.
    SendOrWaitFirstSignal();


    //	Reset the timer and enter the main loop.
    g_timer.Reset();


    //	wait loop - based on the type of event we should receive, we
    //	wait here until such an event occurs. Then we send a signal
    //	to the other side based on what it expects from us.

    while (!g_fDone)
    {
	switch (g_WaitType)
	{

	case WAIT_MSGWAITFORMULTIPLE:

	    //	wait here for a message or an event to be signalled
	    dwRet = MsgWaitForMultipleObjects(1,
					    g_WaitEvent.GetHdl(),
					    FALSE,
					    600000,
					    QS_ALLINPUT);

	    //	Dispatch to ThreadWndProc if a message, or
	    //	to ProcessEvent if an event was signalled
	    ProcessMsgWaitForMultiple(dwRet);
	    break;


	case WAIT_GETMESSAGE:

	    //	wait for a windows message
	    if (GetMessage(&msg, NULL, 0, 0))
	    {
		//  dispatches to my ThreadWndProc
		DispatchMessage(&msg);
	    }
	    break;


	case WAIT_EVENT:

	    //	wait for the event to be signalled
	    if (g_fWaitMultiple)
		g_WaitEvent.BlockM();
	    else
		g_WaitEvent.BlockS();

	    //	process the event
	    ProcessIncommingEvent();
	    break;


	case WAIT_SYNCHRONOUS:

	    //	we have a synchronous singal to the other side, so there is
	    //	nothing to wait on, we will just go make another synchronous
	    //	call. this is valid only if the g_SignalType is
	    //	SIGNAL_SENDMESSAGE.

	    ProcessIncommingEvent();
	    break;


	default:

	    //	unknown event
	    break;
	}

    }	// while

    return msg.wParam;	 // Return value from PostQuitMessage
}



//--------------------------------------------------------------------------
//
//  processes a wakeup from MsgWaitForMultiple. Determines if the event was
//  a message arrival (in which case it Peeks it and Dispatches it, or if it
//  was an event signalled, in which case it calls the event handler.
//
//--------------------------------------------------------------------------

void CTaskSwitch::ProcessMsgWaitForMultiple(DWORD dwRet)
{
	MSG msg;

	if (dwRet == WAIT_OBJECT_0)
	{
	    // our event got signalled, update the counters
	    ProcessIncommingEvent();
	}

	else if (dwRet == WAIT_OBJECT_0 + 1)
	{
	    //	some windows message was received. dispatch it.

	    if (PeekMessage(&msg, g_hWndMe, 0, 0, PM_REMOVE))
	    {
		DispatchMessage(&msg);
	    }
	}
	else
	{
	    //	our event timed out or our event was abandoned or
	    //	an error occurred.

	    g_fDone = TRUE;
	}
}



//--------------------------------------------------------------------------
//
//  processes an incomming event. Just updates the counters and
//  signals the other side.
//
//--------------------------------------------------------------------------

void CTaskSwitch::ProcessIncommingEvent(void)
{
    //	update the loop counters
    UpdateLoopCounters();

    //	Signal the other side
    SignalOtherSide();
}



//--------------------------------------------------------------------------
//
//  process the incomming message
//
//--------------------------------------------------------------------------

LRESULT CTaskSwitch::ThreadWndProc(HWND hWnd, UINT msg, WPARAM wparam, LPARAM lparam)
{
    //	save the callers hWnd
    g_hWndOther = (HWND) wparam;

    //	process as usual
    ProcessIncommingEvent();

    return 0;
}



//--------------------------------------------------------------------------
//
//  updates the global loop counters, reseting the time when the inner
//  loop counter expires, and setting the fDone when the outer and inner
//  loop counters expire.
//
//--------------------------------------------------------------------------

void CTaskSwitch::UpdateLoopCounters(void)
{
    if (g_iloop == 0)
    {
	//  get time for latest outer loop
	g_time[g_oloop] = g_timer.Read();

	if (g_oloop == 0)
	{
	    //	that was the last outerloop, we're done.
	    g_fDone = TRUE;
	}
	else
	{
	    //	update the counters
	    g_iloop = g_execp.iloop;
	    --g_oloop;

	    //	restart the timer
	    g_timer.Reset();
	}
    }
    else
    {
	//  just update the inner loop count
	--g_iloop;
    }
}



//--------------------------------------------------------------------------
//
//  signals the other process or thread according to the SendType (either
//  signals an event or posts a message).
//
//--------------------------------------------------------------------------

void CTaskSwitch::SignalOtherSide(void)
{
    switch (g_SignalType)
    {

    case SIGNAL_EVENT:

	//  signal the other sides event
	g_SignalEvent.Signal();
	break;


    case SIGNAL_POSTMESSAGE:

	//  post a message to the other sides window handle.
	//  lparam tells ThreadWndProc which object to dispatch to, either
	//  g_pTaskSwitch1 or g_pTaskSwitch2.  We only go to 2 if we are
	//  doing thread switches AND the poster is not the kicker.

	PostMessage(g_hWndOther,
		    g_MyMessage,
		    (WPARAM)g_hWndMe,
		    (g_fThreadSwitch && !g_fKicker));
	break;


    case SIGNAL_SENDMESSAGE:

	//  send a message to the other side. this is a synchronous
	//  event. see comment in PostMessage above regarding lparam.

	SendMessage(g_hWndOther,
		    g_MyMessage,
		    (WPARAM)g_hWndMe,
		    (g_fThreadSwitch && !g_fKicker));
	break;


    case SIGNAL_SYNCHRONOUS:

	//  the event we received is a synchronous event. there is no need
	//  to do anything to wake the other side.

	break;


    default:

	//  unknown signal type
	break;
    }
}


//--------------------------------------------------------------------------
//
//  signals the other process or thread that it can begin the test. this
//  avoids timings skewed due to process startup latency.
//
//--------------------------------------------------------------------------

HRESULT CTaskSwitch::SendOrWaitFirstSignal(void)
{
    if (g_fKicker)
    {
	//  send a signal to drop the otherside into its wait loop, and
	//  then call SignalOtherSide to start the cycle, kicking the
	//  other side out of his first wait.

	printf ("Initial Signal to Other Side\n");
	g_SignalEvent.Signal();
	SignalOtherSide();
    }
    else
    {
	printf ("Waiting for Signal From Other Side\n");
	g_WaitEvent.BlockS();
    }

    return S_OK;
}



//--------------------------------------------------------------------------
//
//  initializes the window with the specified window proc.
//
//--------------------------------------------------------------------------

HRESULT CTaskSwitch::WindowInitialize(WNDPROC pfnWndProc, HWND &hWnd)
{

	if (!g_MyMessage)
	{
	    //	Register my message type
	    g_MyMessage = RegisterWindowMessage(
			  TEXT("Component Object Model Remote Request Arrival") );
	}

	if (!g_MyClass)
	{
	    // Register my window class.
	    WNDCLASS wcls;

	    wcls.style	       = 0;
	    wcls.lpfnWndProc   = pfnWndProc;
	    wcls.cbClsExtra    = 0;
	    wcls.cbWndExtra    = 0;
	    wcls.hInstance     = g_hInst;
	    wcls.hIcon	       = NULL;
	    wcls.hCursor       = NULL;
	    wcls.hbrBackground = (HBRUSH) COLOR_BACKGROUND + 1;
	    wcls.lpszMenuName  = NULL;
	    wcls.lpszClassName = MY_WINDOW_CLASS;

	    g_MyClass = RegisterClass( &wcls );
	}


	if (g_MyClass)
	{
	    // Create a hidden window.
	    hWnd  = CreateWindowEx( 0,
				    (LPCTSTR) g_MyClass,
				    TEXT("Task Switcher"),
                                    WS_DISABLED,
                                    CW_USEDEFAULT,
                                    CW_USEDEFAULT,
                                    CW_USEDEFAULT,
                                    CW_USEDEFAULT,
                                    NULL,
                                    NULL,
				    g_hInst,
				    NULL );


	    if (hWnd)
	    {
		printf ("Created Window with hWnd %x\n", hWnd);
		return S_OK;
	    }
	}

	return E_OUTOFMEMORY;
}


//--------------------------------------------------------------------------
//
//  destroys the window and unregisters the class.
//
//--------------------------------------------------------------------------

void CTaskSwitch::WindowUninitialize(HWND hWnd)
{
    if (hWnd != NULL)
    {
	DestroyWindow(hWnd);
    }

    if (g_MyClass != 0)
    {
	UnregisterClass(MY_WINDOW_CLASS, g_hInst);
    }
}



//--------------------------------------------------------------------------
//
//  parses the command line and returns the execution parameters
//
//--------------------------------------------------------------------------

HRESULT CTaskSwitch::ParseCmdLine(LPSTR lpszCmdLine, SExecParms &execp)
{
    BOOL fFile	       = FALSE;

    //	set the default values for execution parameters.

    execp.oloop        = 10;
    execp.iloop        = 100;
    execp.hWndOther    = NULL;
    execp.pfnWndProc   = ::ThreadWndProc;



    //	check the input parameters

    LPSTR pszCmd = lpszCmdLine;
    LPSTR pszCmdNext = NULL;

    while (pszCmd)
    {
	pszCmdNext = strchr(pszCmd, ' ');
	if (pszCmdNext)
	{
	    *pszCmdNext = '\0';
	    pszCmdNext++;
	}

	//  check for outer loop count
	if (!_strnicmp(pszCmd, "/o:", 3))
	{
	    execp.oloop = atoi (pszCmd+3);
	    if (execp.oloop > MAX_OLOOP)
		execp.oloop = MAX_OLOOP;
	}

	//  check for inner loop count
	else if (!_strnicmp(pszCmd, "/i:", 3))
	{
	    execp.iloop = atoi (pszCmd+3);
	    if (execp.iloop < 1)
		execp.iloop = 1;
	}

	//  check for window handle
	else if (!_strnicmp(pszCmd, "/hwnd:", 6))
	{
	    execp.hWndOther = (HWND) atoi (pszCmd+6);
	}

	//  check for waiter or Kicker
	else if (!_strnicmp(pszCmd, "/k", 2))
	{
	    g_fKicker = TRUE;
	}

	//  check for thread or process switch
	else if (!_strnicmp(pszCmd, "/p", 2))
	{
	    g_fThreadSwitch = FALSE;
	}

	//  check for thread or process switch
	else if (!_strnicmp(pszCmd, "/t", 2))
	{
	    g_fThreadSwitch = TRUE;
	}

	//  check for wait single or multiple
	else if (!_strnicmp(pszCmd, "/m", 2))
	{
	    g_fWaitMultiple = TRUE;
	}

	//  check for wait event name
	else if (!_strnicmp(pszCmd, "/e1:", 4))
	{
#ifdef UNICODE
	    mbstowcs(execp.szWaitEvent, pszCmd+4, strlen(pszCmd+4)+1);
#else
	    strcpy(execp.szWaitEvent, pszCmd+4);
#endif
	}

	//  check for signal event name
	else if (!_strnicmp(pszCmd, "/e2:", 4))
	{
#ifdef UNICODE
	    mbstowcs(execp.szSignalEvent, pszCmd+4, strlen(pszCmd+4)+1);
#else
	    strcpy(execp.szSignalEvent, pszCmd+4);
#endif
	}

	//  check for output file name
	else if (!_strnicmp(pszCmd, "/f:", 3))
	{
	    fFile = TRUE;
#ifdef UNICODE
	    mbstowcs(execp.szFile, pszCmd+3, strlen(pszCmd+3)+1);
#else
	    strcpy(execp.szFile, pszCmd+3);
#endif
	}

	//  check for wait type
	else if (!_strnicmp(pszCmd, "/w1:", 4))
	{
	    g_WaitType1 = GetWaitType(pszCmd+4);
	}
	else if (!_strnicmp(pszCmd, "/w2:", 4))
	{
	    g_WaitType2 = GetWaitType(pszCmd+4);
	}

	//  check for signal type
	else if (!_strnicmp(pszCmd, "/s1:", 4))
	{
	    g_SignalType1 = GetSignalType(pszCmd+4);
	}
	else if (!_strnicmp(pszCmd, "/s2:", 4))
	{
	    g_SignalType2 = GetSignalType(pszCmd+4);
	}

	//  check for help request
	else if ((!_strnicmp(pszCmd, "/?", 2)) || (!_strnicmp(pszCmd, "/h", 2)))
	{
	    Help();
	    return -1;
	}

	pszCmd = pszCmdNext;
    }


    g_iloop = execp.iloop;
    g_oloop = execp.iloop;
    g_hWndOther = execp.hWndOther;


    if (g_fKicker)
    {
	g_WaitType = g_WaitType2;
	g_SignalType = g_SignalType2;
	if (!fFile)
	    _tcscpy(execp.szFile, TEXT("kicker"));
    }
    else
    {
	g_WaitType = g_WaitType1;
	g_SignalType = g_SignalType1;
	if (!fFile)
	    _tcscpy(execp.szFile, TEXT("waiter"));

    }

    return S_OK;
}



DWORD	CTaskSwitch::GetWaitType(LPSTR pszCmd)
{
    ULONG   i=0;

    while (aszWait[++i])	// slot 0 is not used
    {
	if (!_stricmp(pszCmd, aszWait[i]))
	    return i;
    }

    Help();
    return 0;
}


DWORD	CTaskSwitch::GetSignalType(LPSTR pszCmd)
{
    ULONG   i=0;

    while (aszSignal[++i])	// slot 0 is not used
    {
	if (!_stricmp(pszCmd, aszSignal[i]))
	    return i;
    }

    Help();
    return 0;
}



//--------------------------------------------------------------------------
//
//  creates the command line parameters for the other guy
//
//--------------------------------------------------------------------------

void  CTaskSwitch::CreateOtherParms(void)
{




    //	write the formatted parms to the parm string

    sprintf(g_szOtherParms, "/k %s %s /i:%d /o:%d /hWnd:%ld "
        "/e1:%hs /e2:%hs /w1:%s /s1:%s /w2:%s /s2:%s",
	    (g_fThreadSwitch) ? "/t" : "/p",
	    (g_fWaitMultiple) ? "/m" : " ",
	    g_execp.iloop,		// same loop counts as me
	    g_execp.oloop,
	    g_hWndMe,			// posts to my window
	    g_execp.szSignalEvent,		// it waits on my signal event
	    g_execp.szWaitEvent,		// it signals my wait event
	    aszWait[g_WaitType1],	// signal what i wait on
	    aszSignal[g_SignalType1],	// wait on what i signal
	    aszWait[g_WaitType2],	// signal what i wait on
	    aszSignal[g_SignalType2]);	// wait on what i signal

}



//--------------------------------------------------------------------------
//
//  writes the execution parameters to a log file.
//
//--------------------------------------------------------------------------

void CTaskSwitch::WriteExecParms()
{
    //	write the run parameters to the output file

    g_output->WriteString(TEXT("Using Parametes:\n"));
    g_output->WriteResult(TEXT("\tInner Loop Count = "), g_execp.iloop);
    g_output->WriteResult(TEXT("\tOuter Loop Count = "), g_execp.oloop);
    g_output->WriteString(TEXT("\n\n"));

    //	flush to avoid disk io during the test
    g_output->Flush();
}


//--------------------------------------------------------------------------
//
//  writes the results to a log file.
//
//--------------------------------------------------------------------------

void CTaskSwitch::WriteResults(void)
{
    if (g_hr == S_OK)
    {
	//  compute the averages

	ULONG tTotal = 0;

	//  skip the first & last value as they are sometimes skewed
	for (int i=0; i<g_execp.oloop; i++)
	{
	    tTotal += g_time[i];
	}

	//  compute average for 1 call/response
	tTotal /= (g_execp.oloop * g_execp.iloop);


	//	display the results

	g_output->WriteResults(TEXT("Times "), g_execp.oloop, g_time);
	g_output->WriteResult(TEXT("\nAverage "), tTotal);
    }
}


//--------------------------------------------------------------------------
//
//  writes the help info to the screen
//
//--------------------------------------------------------------------------

void CTaskSwitch::Help()
{
    printf ("msgtask\n");
    printf ("\t/o:<nnn>             - outer loop count def 10\n");
    printf ("\t/i:<nnn>             - inner loop count def 100\n");
    printf ("\t/f:<name>            - name of output file. def [kick | wait]\n");
    printf ("\t/w1:<event|getmsg|msgwait> - what to wait on\n");
    printf ("\t/s1:<event|postmsg>   - what to signal\n");
    printf ("\t/w2:<event|getmsg|msgwait> - what to wait on\n");
    printf ("\t/s2:<event|postmsg>   - what to signal\n");
    printf ("\t/e1:<name>           - name of wait event\n");
    printf ("\t/e2:<name>           - name of signal event\n");
    printf ("\t/k                   - kicker (as opposed to waiter)\n");
    printf ("\t/t                   - use thread switching\n");
    printf ("\t/p                   - use process switching\n");
    printf ("\t/m                   - use WaitMultiple vs WaitSingle\n");
    printf ("\t/hWnd:<nnnn>         - window handle of other side\n");

    printf ("\n");
    printf ("timings are given for the inner loop count calls\n");

    return;
}


//--------------------------------------------------------------------------
//
//  creates a process
//
//--------------------------------------------------------------------------

DWORD CTaskSwitch::CreateProc(void)
{
    //	create the command line

    TCHAR szCmdLine[256];

    _stprintf(szCmdLine, TEXT("ntsd procswap %hs"), g_szOtherParms);



    //	build the win32 startup info structure

    STARTUPINFO startupinfo;
    startupinfo.cb	    = sizeof(STARTUPINFO);
    startupinfo.lpReserved  = NULL;
    startupinfo.lpDesktop   = NULL;
    startupinfo.lpTitle     = TEXT("Task Switcher");
    startupinfo.dwX	    = 40;
    startupinfo.dwY	    = 40;
    startupinfo.dwXSize     = 80;
    startupinfo.dwYSize     = 40;
    startupinfo.dwFlags     = 0;
    startupinfo.wShowWindow = SW_SHOWNORMAL;
    startupinfo.cbReserved2 = 0;
    startupinfo.lpReserved2 = NULL;

    PROCESS_INFORMATION	ProcInfo;


    BOOL fRslt = CreateProcess(NULL,	    //	app name
			 szCmdLine,	    //	command line
			 NULL,		    //	lpsaProcess
			 NULL,		    //	lpsaThread
			 FALSE,		    //	inherit handles
			 CREATE_NEW_CONSOLE,//	creation flags
			 NULL,		    //	lpEnvironment
			 NULL,		    //	curr Dir
			 &startupinfo,	    //	Startup Info
			 &ProcInfo);	    //	process info

    if (fRslt)
    {
	//  we dont need the handles
	CloseHandle(ProcInfo.hProcess);
	CloseHandle(ProcInfo.hThread);
	printf ("Created Process (%ws) pid=%x\n", szCmdLine, ProcInfo.dwProcessId);
	return S_OK;
    }
    else
    {
	//  what went wrong?
	DWORD dwRet = GetLastError();
	printf ("CreateProcess (%ws) failed %x\n", szCmdLine, dwRet);
	return dwRet;
    }
}