Presentation is loading. Please wait.

Presentation is loading. Please wait.

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

Similar presentations

Presentation on theme: "Win32 Programming Lesson 12: Kernel-mode Thread Sync (aka: Why I love Gentoo)"— Presentation transcript:

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

2 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?

3 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

4 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

5 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

6 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

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

8 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

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

10 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);

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

12 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);

13 Setting the Timer…  BOOL SetWaitableTimer( HANDLE hTimer, const LARGE_INTEGER *pDueTime, LONG lPeriod, PTIMERAPCROUTINE pfnCompletionRo utine, PVOID pvArgToCompletionRoutine, BOOL fResume );

14 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

15 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…

16 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);

17 MutEx v. Critical Section

18 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*

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

20 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

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

Similar presentations

Ads by Google