Win32 Programming

Win32 Programming Lesson 12: Kernel-mode Thread Sync (aka: Why I love Gentoo)

Where are we? • Yay! We can communicate between threads • But, we’ve only talked about doing this in User-mode until now • Sometimes, you need to go kernel-mode • Why should we avoid this?

Limitations • Interlocked functions never put the thread in a WAIT state • Critical Sections only work within a particular process – don’t work between processes • But… kernel-objects take a lot of effort… and I do mean a lot

Signaled/Non-signaled Objects • Can use almost any kernel object as a method of thread synchronization • Each object can be in a signaled or non-signaled state • State change is controlled by what type of object it is • Can put a thread in a wait state and wait for a signaling event

Signaling • Powerful, as you can make sure you don’t execute until a particular event happens • Thread puts itself into the WAIT state and won’t be scheduled until the object is signaled

Wait Functions • Voluntarily go into a WAIT state until OBJECT is signaled • WaitForSingleObject( HANDLE hObject, DWORD dwMilliseconds); • Can use INFINITE • E.g. WaitForSingleObject(hProcess, INFINITE) • Waits forever until a process exits

Example • DWORD dw = WaitForSingleObject(hProcess, 5000); switch (dw) { case WAIT_OBJECT_0: // The process terminated. break; case WAIT_TIMEOUT: // The process did not terminate within 5000 milliseconds. break; case WAIT_FAILED: // Bad call to function (invalid handle?) break; }

Multiple Objects… • DWORD WaitForMultipleObjects( DWORD dwCount, CONST HANDLE* phObjects, BOOL fWaitAll, DWORD dwMilliseconds); • phObject points to an array of Objects • Wait until one gets signaled or wait for all

Oops • WaitForMultipleObjects works atomically • So, if two threads are waiting on the same objects what happens?

Event Kernel Objects • Most basic of objects • Two kinds: manual (reset all waiting threads) and auto (reset only one waiting thread) • HANDLE CreateEvent( PSECURITY_ATTRIBUTES psa, BOOL fManualReset, BOOL fInitialState, PCTSTR pszName);

Example • Look at the Event example in the book… • Then let’s look at the next one…

Waitable Timer Kernel Objects • Used when you want to pause for a period of time (or regular intervals) • Easy to create: • HANDLE CreateWaitableTimer( PSECURITY_ATTRIBUTES psa, BOOL fManualReset, PCTSTR pszName);

Setting the Timer… • BOOL SetWaitableTimer( HANDLE hTimer, const LARGE_INTEGER *pDueTime, LONG lPeriod, PTIMERAPCROUTINE pfnCompletionRoutine, PVOID pvArgToCompletionRoutine, BOOL fResume);

Semaphore Kernel Objects • Used for Resource counting • Contains • Maximum resource count • Current resource count • Consider • Server which can only handle 5 connections • Need to keep track of how many connections are open

Creating a Semaphore • Fairly simple: • HANDLE CreateSemaphore( PSECURITY_ATTRIBUTE psa, LONG lInitialCount, LONG lMaximumCount, PCTSTR pszName); • Examples are a little tricky – look this up in the book…

MutEx • Lets a thread have mutually-exclusive access to a particular resource • HANDLE CreateMutex( PSECURITY_ATTRIBUTES psa, BOOL fInitialOwner, PCTSTR pszName); • BOOL ReleaseMutex(HANDLE hMutex);

MutEx v. Critical Section

Other Thread Sync Functions • DWORD WaitForInputIdle( HANDLE hProcess, DWORD dwMilliseconds); • Suspend yourself until hProcess has no input to deal with • Can be used (sneakily) to feed messages into another process… *hehe*

SignalObjectAndWait • Signal a kernel object and wait on another kernel object • DWORD SignalObjectAndWait( HANDLE hObjectToSignal, HANDLE hObjectToWaitOn, DWORD dwMilliseconds, BOOL fAlertable);

Assignment • Create a simple console application which calculates the prime factors of a given 32-bit unsigned int • You should prompt for input from the console window and the command line • However… you may use a maximum of 3 threads in your program, so you can be working out the answers in parallel • Output for 8 should be 2\n2\n2\n • And the entry/answer thread must always remain responsive • Output must be printed VERTICALLY… if there’s more than 10 lines, you should pause and wait for keyboard input • At no point when both threads are waiting to output should you be using CPU time – everything should be in the WAIT state 

Win32 Programming