windows-xp/Source/XPSP1/NT/printscan/print/spooler/spllib/threadm.cxx

/*++

Copyright (c) 1994  Microsoft Corporation
All rights reserved

Module Name:

    ThreadM.c

Abstract:

    Generic thread manager for spooler.

Author:

    Albert Ting (AlbertT) 13-Feb-1994

Environment:

    User Mode -Win32

Revision History:

    Albert Ting (AlbertT) 28-May-1994       C++ized

--*/

#include "spllibp.hxx"
#pragma hdrstop

pfCreateThread gpfSafeCreateThread;

/********************************************************************

    Public interfaces.

********************************************************************/

TThreadM::
TThreadM(
    UINT uMaxThreads,
    UINT uIdleLife,
    MCritSec* pCritSec OPTIONAL
    ) :

    _uMaxThreads(uMaxThreads), _uIdleLife(uIdleLife), _uActiveThreads(0),
    _uRunNowThreads(0), _iIdleThreads(0)

/*++

Routine Description:

    Construct a Thread Manager object.

Arguments:

    uMaxThreads - Upper limit of threads that will be created.

    uIdleLife - Maximum life once a thread goes idle (in ms).

    pCritSec - Use this crit sec for synchronization (if not specified,
        a private one will be created).

Return Value:

Notes:

    _hTrigger is our validity variable.  When this value is NULL,
    instantiation failed.  If it's non-NULL, the entire object is valid.

--*/

{
    _hTrigger = CreateEvent( NULL,
                             FALSE,
                             FALSE,
                             NULL );

    if( !_hTrigger ){
        return;
    }

    //
    // If no critical section, create our own.
    //
    if (!pCritSec) {

        _pCritSec = new MCritSec();

        if( !VALID_PTR( _pCritSec )){

            //
            // _hTrigger is our valid variable.  If we fail to create
            // the critical section, prepare to return failure.
            //
            CloseHandle( _hTrigger );
            _hTrigger = NULL;

            return;
        }
        _State |= kPrivateCritSec;

    } else {
        _pCritSec = pCritSec;
    }
}

VOID
TThreadM::
vDelete(
    VOID
    )

/*++

Routine Description:

    Indicates that the object is pending deletion.  Any object that
    inherits from vDelete should _not_ call the destructor directly,
    since there may be pending jobs.  Instead, they should call
    TThreadM::vDelete().

Arguments:

Return Value:

--*/

{
    BOOL bDestroy = FALSE;

    {
        TCritSecLock CSL( *_pCritSec );

        //
        // Mark as wanting to be destroyed.
        //
        _State |= kDestroyReq;

        if( !_iIdleThreads && !_uActiveThreads ){
            bDestroy = TRUE;
        }
    }

    if( bDestroy ){

        //
        // Delete the object.  Note that absolutely no object fields
        // can be accessed after this, since the object is returned
        // to free store.
        //
        delete this;
    }
}

BOOL
TThreadM::
bJobAdded(
    BOOL bRunNow
    )

/*++

Routine Description:

    Notify the thread manager that a new job has been added.  This job
    will be processed fifo.

Arguments:

    bRunNow - Ignore the thread limits and run the job now.

Return Value:

    TRUE - Job successfully added.
    FALSE - Job could not be added.

--*/

{
    DWORD dwThreadId;
    HANDLE hThread;
    BOOL rc = TRUE;

    TCritSecLock CSL( *_pCritSec );

    if( _State.bBit( kDestroyReq )){

        DBGMSG( DBG_THREADM | DBG_ERROR,
                ( "ThreadM.bJobAdded: add failed since DESTROY requested.\n" ));

        SetLastError( ERROR_INVALID_PARAMETER );
        rc = FALSE;

    } else {

        //
        // We either: give it to an idle thread, create a new thread,
        // or leave it in the queue.
        //
        if( _iIdleThreads > 0 ){

            //
            // There are some idle threads--trigger the event and it
            // will be picked up.
            //
            --_iIdleThreads;

            DBGMSG( DBG_THREADM,
                    ( "ThreadM.bJobAdded: Trigger: --iIdle %d, uActive %d\n",
                      _iIdleThreads, _uActiveThreads ));

            //
            // If we set the event, then the worker thread that receives
            // this event should _not_ decrement _iIdleThreads, since
            // we already did this.
            //
            SetEvent( _hTrigger );

        } else if( _uActiveThreads < _uMaxThreads || bRunNow ){

            //
            // No idle threads, but we can create a new one since we
            // haven't reached the limit, or the bRunNow flag is set.
            //

            hThread = gpfSafeCreateThread( NULL,
                                           0,
                                           xdwThreadProc,
                                           this,
                                           0,
                                           &dwThreadId );
            if( hThread ){

                CloseHandle( hThread );

                //
                // We have successfully created a thread; up the
                // count.
                //
                ++_uActiveThreads;

                //
                // We have less active threads than the max; create a new one.
                //
                DBGMSG( DBG_THREADM,
                        ( "ThreadM.bJobAdded: ct: iIdle %d, ++uActive %d\n",
                          _iIdleThreads,
                          _uActiveThreads ));

            } else {

                rc = FALSE;

                DBGMSG( DBG_THREADM | DBG_WARN,
                        ( "ThreadM.bJobAdded: unable to ct %d\n",
                          GetLastError( )));
            }
        } else {

            //
            // No idle threads, and we are already at the max so we
            // can't create new threads.  Dec iIdleThreads anyway
            // (may go negative, but that's ok).
            //
            // iIdleThreads represents the number of threads that
            // are currently not processing jobs.  If the number is
            // negative, this indicates that even if a thread suddenly
            // completes a job and would go idle, there is a queued
            // job that would immediately grab it, so the thread really
            // didn't go into an idle state.
            //
            // The negative number indicates the number of outstanding
            // jobs that are queued (e.g., -5 indicate 5 jobs queued).
            //
            // There is always an increment of iIdleThreads when a
            // job is compeleted.
            //
            --_iIdleThreads;

            //
            // No threads idle, and at max threads.
            //
            DBGMSG( DBG_THREADM,
                    ( "ThreadM.bJobAdded: wait: --iIdle %d, uActive %d\n",
                      _iIdleThreads,
                      _uActiveThreads ));
        }

        //
        // If we succeeded and bRunNow is set, this indicates that
        // we were able to start a special thread, so we need to adjust
        // the maximum number of threads.  When a this special thread
        // job completes, we will decrement it.
        //
        if( bRunNow && rc ){

            ++_uMaxThreads;
            ++_uRunNowThreads;
        }
    }
    return rc;
}

/********************************************************************

    Private routines.

********************************************************************/

TThreadM::
~TThreadM(
    VOID
    )

/*++

Routine Description:

    Destroy the thread manager object.  This is private; to request
    that the thread manager quit, call vDelete().

Arguments:

Return Value:

--*/

{
    SPLASSERT( _State.bBit( kDestroyReq ));

    if( _State.bBit( kPrivateCritSec )){
        SPLASSERT( _pCritSec->bOutside( ));
        delete _pCritSec;
    }

    if( _hTrigger )
        CloseHandle( _hTrigger );

    vThreadMDeleteComplete();
}

VOID
TThreadM::
vThreadMDeleteComplete(
    VOID
    )

/*++

Routine Description:

    Stub routine for objects that don't need deletion
    complete notification.

Arguments:

Return Value:

--*/

{
}

DWORD
TThreadM::
xdwThreadProc(
    LPVOID pVoid
    )

/*++

Routine Description:

    Worker thread routine that calls the client to process the jobs.

Arguments:

    pVoid - pTMStateVar

Return Value:

    Ignored.

--*/

{
    TThreadM* pThreadM = (TThreadM*)pVoid;
    return pThreadM->dwThreadProc();
}

DWORD
TThreadM::
dwThreadProc(
    VOID
    )
{
    BOOL bDestroy = FALSE;

    {
        TCritSecLock CSL( *_pCritSec );

        DBGMSG( DBG_THREADM,
                ( "ThreadM.dwThreadProc: ct: iIdle %d, uActive %d\n",
                  _iIdleThreads,
                  _uActiveThreads));

        PJOB pJob = pThreadMJobNext();

        while( TRUE ){

            for( ; pJob; pJob=pThreadMJobNext( )){

                //
                // If bRunNow count is non-zero, this indicates that we just
                // picked up a RunNow job.  As soon as it completes, we
                // can decrement the count.
                //
                BOOL bRunNowCompleted = _uRunNowThreads > 0;

                {
                    TCritSecUnlock CSU( *_pCritSec );

                    //
                    // Call back to client to process the job.
                    //
                    DBGMSG( DBG_THREADM,
                            ( "ThreadM.dwThreadProc: %x processing\n",
                              (ULONG_PTR)pJob ));

                    //
                    // Call through virtual function to process the
                    // user's job.
                    //
                    vThreadMJobProcess( pJob );

                    DBGMSG( DBG_THREADM,
                            ( "ThreadM.dwThreadProc: %x processing done\n",
                              (ULONG_PTR)pJob ));
                }

                //
                // If a RunNow job has been completed, then decrement both
                // counts.  uMaxThreads was increased by one when the job was
                // accepted, so now it must be lowered.
                //
                if( bRunNowCompleted ){

                    --_uMaxThreads;
                    --_uRunNowThreads;
                }

                ++_iIdleThreads;

                DBGMSG( DBG_THREADM,
                        ( "ThreadM.dwThreadProc: ++iIdle %d, uActive %d\n",
                           _iIdleThreads,
                           _uActiveThreads ));
            }

            DBGMSG( DBG_THREADM,
                    ( "ThreadM.dwThreadProc: Sleep: iIdle %d, uActive %d\n",
                                    _iIdleThreads,
                                    _uActiveThreads ));

            {
                TCritSecUnlock CSU( *_pCritSec );

                //
                // Done, now relax and go idle for a bit.  We don't
                // care whether we timeout or get triggered; in either
                // case we check for another job.
                //
                WaitForSingleObject( _hTrigger, _uIdleLife );
            }

            //
            // We must check here instead of relying on the return value
            // of WaitForSingleObject since someone may see iIdleThreads!=0
            // and set the trigger, but we timeout before it gets set.
            //
            pJob = pThreadMJobNext();

            if( pJob ){

                DBGMSG( DBG_THREADM,
                        ( "ThreadM.dwThreadProc: Woke and found job: iIdle %d, uActive %d\n",
                          _iIdleThreads,
                          _uActiveThreads ));
            } else {

                //
                // No jobs found; break.  Be sure to reset the hTrigger, since
                // there are no waiting jobs, and the main thread might
                // have set it in the following case:
                //
                // MainThread:           WorkerThread:
                //                       Sleeping
                //                       Awoke, not yet in CS.
                // GotJob
                // SetEvent
                // --iIdleThreads
                //                       Enter CS, found job, process it.
                //
                // In this case, the event is set, but there is no thread
                // to pick it up.
                //
                ResetEvent( _hTrigger );
                break;
            }
        }

        //
        // Decrement ActiveThreads.  This was incremented when the thread
        // was successfully created, and should be decremented when the thread
        // is about to exit.
        //
        --_uActiveThreads;

        //
        // The thread enters an idle state right before it goes to sleep.
        //
        // When a job is added, the idle count is decremented by the main
        // thread, so the worker thread doesn't decrement it (avoids sync
        // problems).  If the worker thread timed out and there were no jobs,
        // then we need to decrement the matching initial increment here.
        //
        --_iIdleThreads;

        if( _State.bBit( kDestroyReq ) &&
            !_uActiveThreads           &&
            !_iIdleThreads ){

            //
            // Destroy requested.
            //
            bDestroy = TRUE;
        }

        DBGMSG( DBG_THREADM,
                ( "ThreadM.dwThreadProc: dt: --iIdle %d, --uActive %d\n",
                  _iIdleThreads,
                  _uActiveThreads));
    }

    if( bDestroy ){
        delete this;
    }

    return 0;
}