Compare text

Find the difference between two text files

Real-time diff

Unified diff

Collapse lines

Highlight change

Syntax highlighting

Tools

balmgr.c MS and ReactOS

Created 5 years agoDiff never expires

174 removals

189 lines

98 additions

114 lines

NTOS Kernel

REACT OS

VOID

KiScanReadyQueues (

NTAPI

IN PKDPC Dpc,

KiScanReadyQueues(IN PKDPC Dpc,

IN PVOID DeferredContext,

IN PVOID SystemArgument1,

IN PVOID SystemArgument2

IN PVOID SystemArgument2)

)

/*++

Routine Description:

This function scans a section of the ready queues and attempts to

boost the priority of threads that run at variable priority levels.

N.B. This function is executed as a DPC from the periodic timer that

drives the balance set manager.

Arguments:

Dpc - Supplies a pointer to a DPC object - not used.

DeferredContext - Supplies the DPC context - not used.

SystemArgument1 - Supplies the first system argument - note used.

SystemArgument2 - Supplies the second system argument - note used.

Return Value:

None.

--*/

{

PULONG ScanLast = DeferredContext;

ULONG Count = 0;

ULONG ScanIndex = *ScanLast;

PLIST_ENTRY Entry;

ULONG Count = 10, Number = 16;

ULONG Index;

PKPRCB Prcb = KiProcessorBlock[ScanIndex];

PLIST_ENTRY ListHead;

ULONG Index = Prcb->QueueIndex;

ULONG Number = 0;

ULONG WaitLimit = KeTickCount.LowPart - 300;

ULONG Summary;

KIRQL OldIrql;

PKPRCB Prcb;

PLIST_ENTRY ListHead, NextEntry;

ULONG ScanIndex;

PULONG ScanLast;

ULONG Summary;

PKTHREAD Thread;

ULONG WaitLimit;

UNREFERENCED_PARAMETER(SystemArgument1);

/* Lock the dispatcher and PRCB */

UNREFERENCED_PARAMETER(SystemArgument2);

OldIrql = KiAcquireDispatcherLock();

// Get the address of the queue index variable.

// N.B. If a fault occurs accessing queue index value, then the exception

// handler is either executed or a bugcheck occurs.

ScanLast = (PULONG)DeferredContext;

#if defined(_AMD64_)

try {

ScanIndex = *ScanLast;

} except(KiKernelDpcFilter(Dpc, GetExceptionInformation())) {

return;

}

#else

UNREFERENCED_PARAMETER(Dpc);

ScanIndex = *ScanLast;

#endif

// Lock the dispatcher database, acquire the PRCB lock, and check if

// there are any ready threads queued at the scanable priority levels.

Count = THREAD_READY_COUNT;

Number = THREAD_SCAN_COUNT;

Prcb = KiProcessorBlock[ScanIndex];

Index = Prcb->QueueIndex;

WaitLimit = KiQueryLowTickCount() - READY_WITHOUT_RUNNING;

KiLockDispatcherDatabase(&OldIrql);

KiAcquirePrcbLock(Prcb);

/* Check if there's any thread that need help */

Summary = Prcb->ReadySummary & ((1 << THREAD_BOOST_PRIORITY) - 2);

if (Summary != 0) {

if (Summary)

do {

{

/* Start scan loop */

{

/* Normalize the index */

if (Index > (THREAD_BOOST_PRIORITY - 1)) Index = 1;

/* Loop for ready threads */

// If the current ready queue index is beyond the end of the range

if (Summary & PRIORITY_MASK(Index))

// of priorities that are scanned, then wrap back to the beginning

{

// priority.

/* Sanity check */

ASSERT(!IsListEmpty(&Prcb->DispatcherReadyListHead[Index]));

if (Index > THREAD_SCAN_PRIORITY) {

Index = 1;

}

/* Update summary and select list */

// If there are any ready threads queued at the current priority

// level, then attempt to boost the thread priority.

if (Summary & PRIORITY_MASK(Index)) {

ASSERT(IsListEmpty(&Prcb->DispatcherReadyListHead[Index]) == FALSE);

Summary ^= PRIORITY_MASK(Index);

ListHead = &Prcb->DispatcherReadyListHead[Index];

Entry = ListHead->Flink;

NextEntry = ListHead->Flink;

do {

{

/* Select a thread */

// If the thread has been waiting for an extended period,

Thread = CONTAINING_RECORD(NextEntry,

// then boost the priority of the selected.

KTHREAD,

WaitListEntry);

ASSERT(Thread->Priority == Index);

Thread = CONTAINING_RECORD(Entry, KTHREAD, WaitListEntry);

ASSERT(Thread->Priority == (KPRIORITY)Index);

if (WaitLimit >= Thread->WaitTime) {

// Remove the thread from the respective ready queue.

Entry = Entry->Blink;

ASSERT((Prcb->ReadySummary & PRIORITY_MASK(Index)) != 0);

if (RemoveEntryList(Entry->Flink) != FALSE) {

/* Check if the thread has been waiting too long */

if (WaitLimit >= Thread->WaitTime)

{

/* Remove the thread from the queue */

NextEntry = NextEntry->Blink;

ASSERT((Prcb->ReadySummary & PRIORITY_MASK(Index)));

if (RemoveEntryList(NextEntry->Flink))

{

/* The list is empty now */

Prcb->ReadySummary ^= PRIORITY_MASK(Index);

}

/* Verify priority decrement and set the new one */

// Compute the priority decrement value, set the new

// thread priority, set the thread quantum to a value

// appropriate for lock ownership, and insert the

// thread in the ready list.

ASSERT((Thread->PriorityDecrement >= 0) &&

(Thread->PriorityDecrement <= Thread->Priority));

(Thread->PriorityDecrement <=

Thread->Priority));

Thread->PriorityDecrement +=

Thread->PriorityDecrement += (THREAD_BOOST_PRIORITY -

(THREAD_BOOST_PRIORITY - Thread->Priority);

Thread->Priority);

ASSERT((Thread->PriorityDecrement >= 0) &&

(Thread->PriorityDecrement <= THREAD_BOOST_PRIORITY));

(Thread->PriorityDecrement <=

THREAD_BOOST_PRIORITY));

/* Update priority and insert into ready list */

Thread->Priority = THREAD_BOOST_PRIORITY;

Thread->Quantum = LOCK_OWNERSHIP_QUANTUM;

Thread->Quantum = WAIT_QUANTUM_DECREMENT * 4;

KiInsertDeferredReadyList(Thread);

Count -= 1;

Count --;

}

Entry = Entry->Flink;

/* Go to the next entry */

Number -= 1;

NextEntry = NextEntry->Flink;

} while ((Entry != ListHead) && (Number != 0) && (Count != 0));

Number--;

} while((NextEntry != ListHead) && (Number) && (Count));

}

Index += 1;

/* Increase index */

} while ((Summary != 0) && (Number != 0) && (Count != 0));

Index++;

} while ((Summary) && (Number) && (Count));

}

/* Release the locks and dispatcher */

// Release the PRCB lock, unlock the dispatcher database, and save the

// last ready queue index for the next scan.

KiReleasePrcbLock(Prcb);

KiUnlockDispatcherDatabase(OldIrql);

KiReleaseDispatcherLock(OldIrql);

if ((Count != 0) && (Number != 0)) {

/* Update the queue index for next time */

if ((Count) && (Number))

{

/* Reset the queue at index 1 */

Prcb->QueueIndex = 1;

}

} else {

else

{

/* Set the index we're in now */

Prcb->QueueIndex = Index;

}

/* Increment the CPU number for next time and normalize to CPU count */

// Increment the processor number.

ScanIndex++;

if (ScanIndex == KeNumberProcessors) ScanIndex = 0;

ScanIndex += 1;

if (ScanIndex == (ULONG)KeNumberProcessors) {

ScanIndex = 0;

}

/* Return the index */

*ScanLast = ScanIndex;

return;

}

Saved diffs

Original text

Open file

NTOS Kernel

VOID
KiScanReadyQueues (
    IN PKDPC Dpc,
    IN PVOID DeferredContext,
    IN PVOID SystemArgument1,
    IN PVOID SystemArgument2
    )

/*++
Routine Description:
    This function scans a section of the ready queues and attempts to
    boost the priority of threads that run at variable priority levels.
    N.B. This function is executed as a DPC from the periodic timer that
         drives the balance set manager.
Arguments:
    Dpc - Supplies a pointer to a DPC object - not used.
    DeferredContext - Supplies the DPC context - not used.
    SystemArgument1 - Supplies the first system argument - note used.
    SystemArgument2 - Supplies the second system argument - note used.
Return Value:
    None.
--*/

{

    ULONG Count = 0;
    PLIST_ENTRY Entry;
    ULONG Index;
    PLIST_ENTRY ListHead;
    ULONG Number = 0;
    KIRQL OldIrql;
    PKPRCB Prcb;
    ULONG ScanIndex;
    PULONG ScanLast;
    ULONG Summary;
    PKTHREAD Thread;
    ULONG WaitLimit;

    UNREFERENCED_PARAMETER(SystemArgument1);
    UNREFERENCED_PARAMETER(SystemArgument2);

    //
    // Get the address of the queue index variable.
    //
    // N.B. If a fault occurs accessing queue index value, then the exception
    //      handler is either executed or a bugcheck occurs.
    //

    ScanLast = (PULONG)DeferredContext;

#if defined(_AMD64_)

    try {
        ScanIndex = *ScanLast;

    } except(KiKernelDpcFilter(Dpc, GetExceptionInformation())) {
        return;
    }

#else

    UNREFERENCED_PARAMETER(Dpc);

    ScanIndex = *ScanLast;

#endif

    //
    // Lock the dispatcher database, acquire the PRCB lock, and check if
    // there are any ready threads queued at the scanable priority levels.
    //

    Count = THREAD_READY_COUNT;
    Number = THREAD_SCAN_COUNT;
    Prcb = KiProcessorBlock[ScanIndex];
    Index = Prcb->QueueIndex;
    WaitLimit = KiQueryLowTickCount() - READY_WITHOUT_RUNNING;
    KiLockDispatcherDatabase(&OldIrql);
    KiAcquirePrcbLock(Prcb);
    Summary = Prcb->ReadySummary & ((1 << THREAD_BOOST_PRIORITY) - 2);
    if (Summary != 0) {
        do {

            //
            // If the current ready queue index is beyond the end of the range
            // of priorities that are scanned, then wrap back to the beginning
            // priority.
            //

            if (Index > THREAD_SCAN_PRIORITY) {
                Index = 1;
            }

            //
            // If there are any ready threads queued at the current priority
            // level, then attempt to boost the thread priority.
            //

            if (Summary & PRIORITY_MASK(Index)) {

                ASSERT(IsListEmpty(&Prcb->DispatcherReadyListHead[Index]) == FALSE);

                Summary ^= PRIORITY_MASK(Index);
                ListHead = &Prcb->DispatcherReadyListHead[Index];
                Entry = ListHead->Flink;
                do {

                    //
                    // If the thread has been waiting for an extended period,
                    // then boost the priority of the selected.
                    //

                    Thread = CONTAINING_RECORD(Entry, KTHREAD, WaitListEntry);

                    ASSERT(Thread->Priority == (KPRIORITY)Index);

                    if (WaitLimit >= Thread->WaitTime) {

                        //
                        // Remove the thread from the respective ready queue.
                        //

                        Entry = Entry->Blink;

                        ASSERT((Prcb->ReadySummary & PRIORITY_MASK(Index)) != 0);

                        if (RemoveEntryList(Entry->Flink) != FALSE) {
                            Prcb->ReadySummary ^= PRIORITY_MASK(Index);
                        }

                        //
                        // Compute the priority decrement value, set the new
                        // thread priority, set the thread quantum to a value
                        //  appropriate for lock ownership, and insert the
                        // thread in the ready list.
                        //

                        ASSERT((Thread->PriorityDecrement >= 0) &&
                               (Thread->PriorityDecrement <= Thread->Priority));

                        Thread->PriorityDecrement +=
                                    (THREAD_BOOST_PRIORITY - Thread->Priority);

                        ASSERT((Thread->PriorityDecrement >= 0) &&
                               (Thread->PriorityDecrement <= THREAD_BOOST_PRIORITY));

                        Thread->Priority = THREAD_BOOST_PRIORITY;
                        Thread->Quantum = LOCK_OWNERSHIP_QUANTUM;
                        KiInsertDeferredReadyList(Thread);
                        Count -= 1;
                    }

                    Entry = Entry->Flink;
                    Number -= 1;
                } while ((Entry != ListHead) && (Number != 0) && (Count != 0));
            }

            Index += 1;
        } while ((Summary != 0) && (Number != 0) && (Count != 0));
    }

    //
    // Release the PRCB lock, unlock the dispatcher database, and save the
    // last ready queue index for the next scan.
    //

    KiReleasePrcbLock(Prcb);
    KiUnlockDispatcherDatabase(OldIrql);
    if ((Count != 0) && (Number != 0)) {
        Prcb->QueueIndex = 1;

    } else {
        Prcb->QueueIndex = Index;
    }

    //
    // Increment the processor number.
    //

    ScanIndex += 1;
    if (ScanIndex == (ULONG)KeNumberProcessors) {
        ScanIndex = 0;
    }

    *ScanLast = ScanIndex;
    return;
}

Changed text

Open file

REACT OS

VOID
NTAPI
KiScanReadyQueues(IN PKDPC Dpc,
                  IN PVOID DeferredContext,
                  IN PVOID SystemArgument1,
                  IN PVOID SystemArgument2)
{
    PULONG ScanLast = DeferredContext;
    ULONG ScanIndex = *ScanLast;
    ULONG Count = 10, Number = 16;
    PKPRCB Prcb = KiProcessorBlock[ScanIndex];
    ULONG Index = Prcb->QueueIndex;
    ULONG WaitLimit = KeTickCount.LowPart - 300;
    ULONG Summary;
    KIRQL OldIrql;
    PLIST_ENTRY ListHead, NextEntry;
    PKTHREAD Thread;

    /* Lock the dispatcher and PRCB */
    OldIrql = KiAcquireDispatcherLock();
    KiAcquirePrcbLock(Prcb);
    /* Check if there's any thread that need help */
    Summary = Prcb->ReadySummary & ((1 << THREAD_BOOST_PRIORITY) - 2);
    if (Summary)
    {
        /* Start scan loop */
        do
        {
            /* Normalize the index */
            if (Index > (THREAD_BOOST_PRIORITY - 1)) Index = 1;

            /* Loop for ready threads */
            if (Summary & PRIORITY_MASK(Index))
            {
                /* Sanity check */
                ASSERT(!IsListEmpty(&Prcb->DispatcherReadyListHead[Index]));

                /* Update summary and select list */
                Summary ^= PRIORITY_MASK(Index);
                ListHead = &Prcb->DispatcherReadyListHead[Index];
                NextEntry = ListHead->Flink;
                do
                {
                    /* Select a thread */
                    Thread = CONTAINING_RECORD(NextEntry,
                                               KTHREAD,
                                               WaitListEntry);
                    ASSERT(Thread->Priority == Index);

                    /* Check if the thread has been waiting too long */
                    if (WaitLimit >= Thread->WaitTime)
                    {
                        /* Remove the thread from the queue */
                        NextEntry = NextEntry->Blink;
                        ASSERT((Prcb->ReadySummary & PRIORITY_MASK(Index)));
                        if (RemoveEntryList(NextEntry->Flink))
                        {
                            /* The list is empty now */
                            Prcb->ReadySummary ^= PRIORITY_MASK(Index);
                        }

                        /* Verify priority decrement and set the new one */
                        ASSERT((Thread->PriorityDecrement >= 0) &&
                               (Thread->PriorityDecrement <=
                                Thread->Priority));
                        Thread->PriorityDecrement += (THREAD_BOOST_PRIORITY -
                                                      Thread->Priority);
                        ASSERT((Thread->PriorityDecrement >= 0) &&
                               (Thread->PriorityDecrement <=
                                THREAD_BOOST_PRIORITY));

                        /* Update priority and insert into ready list */
                        Thread->Priority = THREAD_BOOST_PRIORITY;
                        Thread->Quantum = WAIT_QUANTUM_DECREMENT * 4;
                        KiInsertDeferredReadyList(Thread);
                        Count --;
                    }

                    /* Go to the next entry */
                    NextEntry = NextEntry->Flink;
                    Number--;
                } while((NextEntry != ListHead) && (Number) && (Count));
            }

            /* Increase index */
            Index++;
        } while ((Summary) && (Number) && (Count));
    }

    /* Release the locks and dispatcher */
    KiReleasePrcbLock(Prcb);
    KiReleaseDispatcherLock(OldIrql);

    /* Update the queue index for next time */
    if ((Count) && (Number))
    {
        /* Reset the queue at index 1 */
        Prcb->QueueIndex = 1;
    }
    else
    {
        /* Set the index we're in now */
        Prcb->QueueIndex = Index;
    }

    /* Increment the CPU number for next time and normalize to CPU count */
    ScanIndex++;
    if (ScanIndex == KeNumberProcessors) ScanIndex = 0;

    /* Return the index */
    *ScanLast = ScanIndex;
}