Docstoc

Win32 Programming

Document Sample
Win32 Programming Powered By Docstoc
					Win32 Programming
Lesson 10: Thread Scheduling and Priorities
Where are we?
   We’ve got thread basics worked out…
   But it’s very helpful to understand how the
    OS deals with thread scheduling
   This lesson, we’ll work on scheduling threads
    – understanding how each one gets executed
    on the machine
Thread Context
   Remember the kernel keeps a copy of the
    thread context which contains important
    runtime information
       Such as?
   Every 20ms or so, Windows looks at the
    thread contexts on the machine and decided
    which to allow to run
       This is known as a context switch – see a tool like
        Spy++
Context Switch (cntd)
   After about 20ms, the Operating System saves
    the processor’s internal state to thread’s
    context and looks for the next thread to
    execute
   This cycle continues until the system shuts
    down
   Only “schedulable” threads can be run
Example: Notepad
   When Notepad is just sitting about as a
    Window with nothing to do, it is not marked
    schedulable
   When the OS sees that the Windows has been
    moved or typed in, the thread is marked as
    schedulable
       NB: This is not the same as actually running the
        thread – that still depends on the OS scheduler
Ensuring you get run
   Often, want to make sure that there is no
    latency between a particular action (maybe
    data arriving on a port) and response
   How?
   Sorry, can’t be done easily. Windows is not a
    Real-time operating system
Suspending and Resuming Threads
   DWORD ResumeThread(HANDLE hThread)
   DWORD SuspendThread(HANDLE hThread)
   NB: A thread can be suspended multiple
    times. If a thread is suspended more than
    once, it must be resumed more than once
    before it becomes schedulable
   Danger, Will Robinson!
       Randomly suspending a thread can cause
        deadlocks. Don’t do this unless you know exactly
        what the thread is doing!
Example: Suspending a Process
   Why is the idea of suspending a process
    meaningless?
   What do we mean when we do this?
   Let’s look at an example from VS2008
Sleeping
   A thread can tell the OS that it wants to go to sleep
    (that is, be unscheduled for a certain amount of time)
   VOID Sleep(DWORD dwMilliseconds)
       Calling Sleep automatically gives up the rest of this time
        slice
       The time to sleep is approximate – remember, Windows is
        not a real-time OS
       You can call Sleep with the parameter INFINITE. This is
        not useful.
       You can call Sleep with the parameter 0 to give up the
        remainder of this timeslice
Switching to another Thread
   Imagine you have a low-priority thread
    locking a resource…
   Can use BOOL SwitchToThread()
       See if another thread is CPU starved and waiting
       Returns FALSE if no other thread can run
       Similar to Sleep except lower-priority threads
        also execute
Aside: ThreadExecution Times
   Naively, most simply take the time at the start of a
    code block and the end, and subtract
       No guarantee there weren’t thread switches in there!
   Instead, can use
       BOOL GetThreadTimes(
         HANDLE hThread,
         PFILETIME pftCreationTime,
         PFILETIME pftExitTime,
         PFILETIME pftKernelTime,
         PFILETIME pftUserTime);
Thread Context Revisited
   There is actually a structure for the thread context
    documented by Microsoft… ooh!
   Declared in winnt.h (see here for details)
   So, if we wanted to we could stop a running thread
    and modify its context… well, let’s look at the
    example in the book…
Thread Priorities
   Each thread can execute at a different priority
   Priorities are assigned from 0 (lowest) to 31
    (highest)
   When the scheduler assigns a thread it always
    passes control to a priority 31 thread if there
    are any available to run
   And so on, down the priorities…
Caveat Emptor
   Microsoft does not fully document the
    behavior of the scheduler
   Microsoft tells you the scheduler is subject to
    change
   Microsoft provides an abstraction layer – you
    can’t talk to the scheduler directly
Windows Priorities
   Six process levels
       Real-time: respond immediately to time-critical messages.
        This priority is higher than task manager – it you use it,
        you can hang the machine! BE CAREFUL!
       High: threads which must respond. This is how task
        manager runs
       Above normal: between high and normal
       Normal: No special scheduling needs
       Below normal: between normal and idle
       Idle: Only run when the system is basically idle
And then threads
   You can set the relative thread priorities too…
   This sets the overall priority
   So, this all sounds good, but how do you do
    it?
Programming Priorities
   Parameter to CreateProcess
   REALTIME_PRIORITY_CLASS,
    HIGH_PRIORITY_CLASS,
    ABOVE_NORMAL_PRIORITY_CLASS,
    NORMAL_PRIORITY_CLASS,
    BELOW_NORMAL_PRIORITY_CLASS,
    IDLE_PRIORITY_CLASS
DIY
   A process can also call BOOL
    SetPriorityClass(HANDLE hProcess, DWORD
    fwdPriority)
   Example: SetPriorityClass(GetCurrentProcess(),
    IDLE_PRIORITY_CLASS)
   Also DWORD GetPriorityClass(HANDLE
    hProcess)
   Similarly SetThreadPriority(HANDLE hThread, int
    nPriority)
Tweaking the Scheduler
   Can optimize the foreground or background
    processes
Affinities
   Can control which processor a thread executes
    on, on a multi-processor machine
       Why does this matter?
Assignment
   Threading is a very useful technique
   Write a network server which listens on Port 31337
   The server should handle multiple clients, creating a new
    thread for each client
   The server simply echoes back what you type (but waits for a
    newline)
   A session is closed when the string “close” is typed to the
    server
   The console should provide a simple output which details the
    number of threads in use when asked
   Also, the console should remain responsive to a “shutdown”
    request

				
DOCUMENT INFO
Shared By:
Categories:
Tags:
Stats:
views:12
posted:8/27/2012
language:English
pages:21