텍스트 비교

두 텍스트 파일의 차이점을 찾아보세요

실시간 편집

공백 변경 숨기기

변경 없는 행 숨기기

줄바꿈 비활성화

레이아웃

비교 단위

텍스트 스타일

구문 강조

Diffchecker Desktop 가장 안전하게 Diffchecker를 사용하는 방법. 데스크톱 앱을 사용하면 비교 데이터가 외부로 전송되지 않습니다!데스크톱 앱 받기

balmgr.c MS and ReactOS

생성일 7년 전비교 결과 만료 없음

165 삭제

행
총
삭제

글자
총
삭제

이 기능을 계속 사용하려면 업그레이드해 주세요 Diffchecker Pro 요금제 보기

189 행

95 추가

행
총
추가

글자
총
추가

이 기능을 계속 사용하려면 업그레이드해 주세요 Diffchecker Pro 요금제 보기

114 행

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;

KIRQL OldIrql;

PKPRCB Prcb;

ULONG ScanIndex;

PULONG ScanLast;

ULONG Summary;

KIRQL OldIrql;

PLIST_ENTRY ListHead, NextEntry;

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;

/* Lock the dispatcher and PRCB */

Number = THREAD_SCAN_COUNT;

OldIrql = KiAcquireDispatcherLock();

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

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

{

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

/* Normalize the index */

// priority.

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

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

/* 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];

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;

}

저장된 비교 결과

원본

파일 열기

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

수정본

파일 열기

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