#include <fxinterruptthreadpoolum.hpp>

Inheritance diagram for FxInterruptThreadpool:

Collaboration diagram for FxInterruptThreadpool:

[legend]

Public Member Functions
	FxInterruptThreadpool (PFX_DRIVER_GLOBALS FxDriverGlobals)

	~FxInterruptThreadpool ()

PTP_CALLBACK_ENVIRON	GetCallbackEnvironment (VOID)

PTP_WAIT	CreateThreadpoolWait (__in PTP_WAIT_CALLBACK pfnwa, __inout_opt PVOID Context)

HRESULT	UpdateThreadPoolThreadLimits (_In_ ULONG InterruptCount)

Static Public Member Functions
static HRESULT	_CreateAndInit (_In_ PFX_DRIVER_GLOBALS DriverGlobals, _Out_ FxInterruptThreadpool **ppThreadpool)

Private Member Functions
HRESULT	Initialize ()

Private Member Functions inherited from FxGlobalsStump
	FxGlobalsStump (__in PFX_DRIVER_GLOBALS FxDriverGlobals)

PFX_DRIVER_GLOBALS	GetDriverGlobals (VOID)

Private Member Functions inherited from FxStump
PVOID	operator new (__in size_t Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals)

PVOID	operator new (__in size_t Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals, __in POOL_TYPE PoolType)

VOID	operator delete (__in PVOID pointer)

PVOID	operator new[] (__in size_t Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals)

VOID	operator delete[] (__in PVOID pointer)

	FxStump (VOID)

Private Attributes
PTP_POOL	m_Pool

TP_CALLBACK_ENVIRON	m_CallbackEnvironment

ULONG	m_MinimumThreadCount

Detailed Description

Definition at line 31 of file fxinterruptthreadpoolum.hpp.

Constructor & Destructor Documentation

◆ FxInterruptThreadpool()

FxInterruptThreadpool::FxInterruptThreadpool ( PFX_DRIVER_GLOBALS FxDriverGlobals )

Definition at line 36 of file fxinterruptthreadpoolum.cpp.

      :
    FxGlobalsStump(FxDriverGlobals),
    m_Pool(NULL),
    m_MinimumThreadCount(MINIMUM_THREAD_COUNT_DEFAULT)
{
    InitializeThreadpoolEnvironment(&m_CallbackEnvironment);
}

◆ ~FxInterruptThreadpool()

FxInterruptThreadpool::~FxInterruptThreadpool ( )

Definition at line 46 of file fxinterruptthreadpoolum.cpp.

{
    //
    // close pool
    //
    if (m_Pool != NULL) {
        CloseThreadpool(m_Pool);
        m_Pool = NULL;
    }
 
    DestroyThreadpoolEnvironment(&m_CallbackEnvironment);
}

Member Function Documentation

◆ _CreateAndInit()

HRESULT FxInterruptThreadpool::_CreateAndInit	(	_In_ PFX_DRIVER_GLOBALS	DriverGlobals,
		_Out_ FxInterruptThreadpool **	ppThreadpool
	)

static

Definition at line 60 of file fxinterruptthreadpoolum.cpp.

{
    HRESULT hr;
    FxInterruptThreadpool* pool = NULL;
 
    FX_VERIFY_WITH_NAME(INTERNAL, CHECK_NOT_NULL(ppThreadpool),
        DriverGlobals->Public.DriverName);
 
    *ppThreadpool = NULL;
 
    pool = new (DriverGlobals) FxInterruptThreadpool(DriverGlobals);
    if (pool == NULL)
    {
        hr = ERROR_NOT_ENOUGH_MEMORY;
        DoTraceLevelMessage(DriverGlobals,
                    TRACE_LEVEL_ERROR, TRACINGPNP,
                    "FxInterruptThreadpool creation failed, "
                    "%!hresult!", hr);
        return hr;
    }
 
    hr = pool->Initialize();
 
    if (SUCCEEDED(hr))
    {
        *ppThreadpool = pool;
    }
    else {
        delete pool;
    }
 
    return hr;
}

◆ CreateThreadpoolWait()

PTP_WAIT FxInterruptThreadpool::CreateThreadpoolWait	(	__in PTP_WAIT_CALLBACK	pfnwa,
		__inout_opt PVOID	Context
	)

inline

Definition at line 80 of file fxinterruptthreadpoolum.hpp.

    {
        return ::CreateThreadpoolWait(pfnwa, Context, &m_CallbackEnvironment);
    }

◆ GetCallbackEnvironment()

PTP_CALLBACK_ENVIRON FxInterruptThreadpool::GetCallbackEnvironment ( VOID )

inline

Definition at line 72 of file fxinterruptthreadpoolum.hpp.

    {
        return &m_CallbackEnvironment;
    }

◆ Initialize()

HRESULT FxInterruptThreadpool::Initialize ( )

private

Definition at line 98 of file fxinterruptthreadpoolum.cpp.

{
    HRESULT hr = S_OK;
    DWORD error;
    BOOL bRet;
 
    //
    // Create a thread pool using win32 APIs
    //
    m_Pool = CreateThreadpool(NULL);
    if (m_Pool == NULL)
    {
        error = GetLastError();
        hr = HRESULT_FROM_WIN32(error);
        DoTraceLevelMessage(GetDriverGlobals(),
                    TRACE_LEVEL_ERROR, TRACINGPNP,
                    "Threadpool creation failed, %!winerr!", error);
        return hr;
    }
 
    //
    // Set maximum thread count to equal the total number of interrupts.
    // Set minimum thread count (persistent threads) to equal the lower of
    // number of interrupt and number of processors.
    //
    // We want minimum number of persistent threads to be at least equal to the
    // number of interrupt objects so that there is no delay in servicing the
    // interrupt if there are processors available (the delay can come due to
    // thread pool delay in allocating and initializing a new thread). However,
    // there is not much benefit in having more persistent threads than
    // processors, as threads would have to wait for processor to become
    // available anyways. Therefore, we chose to have the number of persistent
    // equal to the Min(number of interrupts, number of processors).
    //
    // In the current design, if there are more interrupts than
    // processors, as soon as one thread finishes servicing the interrupt, both
    // the thread and processor will be available to service the next queued
    // interrupt. Note that thread pool will queue all the waits and will
    // satisfy them in a FIFO manner.
    //
    // Since we don't know the number of interrupts in the beginning, we will
    // start with one and update it when we know the actual number of interrupts
    // after processing driver's OnPrepareHardware callback.
    //
    // Note on interrupt servicing:
    // When fx connects the interrupt, it queues an event-based wait block
    // to thread pool for each interrupt, so that the interrupt can get serviced
    // using one of the thread pool threads when the auto-reset event shared
    // with reflector is set by reflector in the DpcForIsr routine queued by Isr.
    // While the interrupt is being serviced by one of the threads, no wait block
    // is queued to thread pool for that interrupt, so arrival of same interrupt
    // signals the event in DpcForIsr but doesn't cause new threads to pick up
    // the servicing. Note that other interrupts still have their wait blocks
    // queued so they will be serviced as they arrive.
    //
    // When previous servicing is over (i.e. the ISR callback has been
    // invoked and it has returned), Fx queues another wait block to thread pool
    // for that interrupt. If the event is already signalled, it would result in
    // the same thread (or another) picking up servicing immediately.
    //
    // This means the interrupt ISR routine can never run concurrently
    // for same interrupt. Therefore, there is no need to have more than one
    // thread for each interrupt.
    //
    SetThreadpoolThreadMaximum(m_Pool, 1);
 
    //
    // Create one persistent thread since atleast one interrupt is the most
    // likely scenario. We will update this number to have either the same
    // number of threads as there are interrupts, or the number of
    // processors on the machine.
    //
    bRet = SetThreadpoolThreadMinimum(m_Pool, m_MinimumThreadCount);
    if (bRet == FALSE) {
        error = GetLastError();
        hr = HRESULT_FROM_WIN32(error);
        DoTraceLevelMessage(GetDriverGlobals(),
                    TRACE_LEVEL_ERROR, TRACINGPNP,
                    "%!FUNC!: Failed to set minimum threads (%d) in threadpool,"
                    " %!winerr!", m_MinimumThreadCount, error);
        goto cleanup;
    }
 
    //
    // Associate thread pool with callback environment.
    //
    SetThreadpoolCallbackPool(&m_CallbackEnvironment, m_Pool);
 
cleanup:
 
    if (FAILED(hr)) {
        CloseThreadpool(m_Pool);
        m_Pool = NULL;
    }
 
    return hr;
}

◆ UpdateThreadPoolThreadLimits()

HRESULT FxInterruptThreadpool::UpdateThreadPoolThreadLimits ( _In_ ULONG InterruptCount )

Definition at line 198 of file fxinterruptthreadpoolum.cpp.

{
    BOOL bRet;
    HRESULT hr = S_OK;
    SYSTEM_INFO sysInfo;
    ULONG minThreadCount = 0;
    ULONG procs;
    DWORD error;
 
    FX_VERIFY(INTERNAL, CHECK_NOT_NULL(m_Pool));
 
    //
    // if there are more than one interrupts then we need to update minimum
    // thread count.
    //
    if (m_MinimumThreadCount >= InterruptCount) {
        //
        // nothing to do
        //
        return S_OK;
    }
 
    //
    // We want to have number of minimum persistent threads
    // = Min(number of interrupts, number of processors).
    // See comments in Initialize routine for details.
    //
    GetSystemInfo(&sysInfo);
    procs = sysInfo.dwNumberOfProcessors;
 
    minThreadCount = min(InterruptCount, procs);
 
    if (m_MinimumThreadCount < minThreadCount) {
        //
        // Set threadpool min
        //
        bRet = SetThreadpoolThreadMinimum(m_Pool, minThreadCount);
        if (bRet == FALSE) {
            error = GetLastError();
            hr = HRESULT_FROM_WIN32(error);
            DoTraceLevelMessage(GetDriverGlobals(),
                        TRACE_LEVEL_ERROR, TRACINGPNP,
                        "Failed to set minimum threads in threadpool,"
                        " TP_POOL 0x%p to %d %!winerr!", m_Pool, minThreadCount,
                        error);
            return hr;
        }
 
        m_MinimumThreadCount = minThreadCount;
    }
 
    //
    // set thread pool max to max number of interrupts
    //
    SetThreadpoolThreadMaximum(m_Pool, InterruptCount);
 
    DoTraceLevelMessage(GetDriverGlobals(),
                TRACE_LEVEL_ERROR, TRACINGPNP,
                "Threads in thread pool TP_POOL 0x%p updated"
                " to Max %d Min %d threads", m_Pool,
                InterruptCount, minThreadCount);
 
    return hr;
}