windows-nt/Source/XPSP1/NT/base/ntos/ex/alpha/hifreqlk.s

292 lines
7.7 KiB
ArmAsm
Raw Normal View History

2020-09-26 03:20:57 -05:00
// TITLE("High Frequency Spin Locks")
//++
//
// Copyright (c) 1993 Microsoft Corporation
// Copyright (c) 1993 Digital Equipment Corporation
//
// Module Name:
//
// hifreqlk.s
//
// Abstract:
//
// This module contains storage for high frequency spin locks. Each
// is allocated to a separate cache line.
//
// Author:
//
// David N. Cutler (davec) 25-Jun-1993
// Joe Notarangelo 29-Nov-1993
//
// Environment:
//
// Kernel mode.
//
// Revision History:
//
//--
#include "ksalpha.h"
//
// Define alignment for mp and up spinlocks.
//
#if defined(NT_UP)
#define ALIGN
#else
#define ALIGN .align 6
#endif
//
// Define spinlock size for mp and up systems.
//
#if defined(_AXP64_)
#define SPIN_LOCK .quad 0
#else
#define SPIN_LOCK .long 0
#endif
.sdata
ALIGN
SPIN_LOCK
.globl AfdWorkQueueSpinLock
ALIGN
AfdWorkQueueSpinLock: // AFD work queue lock
SPIN_LOCK //
.globl CcBcbSpinLock
ALIGN
CcBcbSpinLock: // cache manager BCB lock
SPIN_LOCK //
.globl CcMasterSpinLock
ALIGN
CcMasterSpinLock: // cache manager master lock
SPIN_LOCK //
.globl CcVacbSpinLock
ALIGN
CcVacbSpinLock: // cache manager VACB lock
SPIN_LOCK //
.globl CcWorkQueueSpinLock
ALIGN
CcWorkQueueSpinLock: // cache manager work queue lock
SPIN_LOCK //
.globl ExpResourceSpinLock
ALIGN
ExpResourceSpinLock: // resource package lock
SPIN_LOCK //
.globl IopCancelSpinLock
ALIGN
IopCancelSpinLock: // I/O cancel lock
SPIN_LOCK //
.globl IopCompletionLock
ALIGN
IopCompletionLock: // I/O completion lock
SPIN_LOCK //
.globl IopDatabaseLock
ALIGN
IopDatabaseLock: // I/O database lock
SPIN_LOCK //
.globl IopVpbSpinLock
ALIGN
IopVpbSpinLock: // I/O VPB lock
SPIN_LOCK //
.globl IoStatisticsLock
ALIGN
IoStatisticsLock: // I/O statistics lock
SPIN_LOCK //
.globl KiContextSwapLock
ALIGN
KiContextSwapLock: // context swap lock
SPIN_LOCK //
.globl KiMasterSequence
KiMasterSequence: // master sequence number
.quad 1 //
.globl KiMasterAsn
KiMasterAsn: // master ASN number
.long 0 //
.globl KiMaximumAsn
KiMaximumAsn: //
.long 0 //
.globl KiTbiaFlushRequest //
KiTbiaFlushRequest: // TB invalidate all mask
.long 0xFFFFFFFF //
.globl KiDispatcherLock
ALIGN
KiDispatcherLock: // dispatcher database lock
SPIN_LOCK //
.globl KiSynchIrql
KiSynchIrql: // synchronization IRQL
.long SYNCH_LEVEL //
.globl MmPfnLock
ALIGN
MmPfnLock: // page frame database lock
SPIN_LOCK //
.globl MmChargeCommitmentLock
ALIGN
MmChargeCommitmentLock: // charge commitment lock
SPIN_LOCK //
.globl NonPagedPoolLock
ALIGN
NonPagedPoolLock: // nonpage pool allocation lock
SPIN_LOCK //
.globl NtfsStructLock
ALIGN
NtfsStructLock: // NTFS structure lock lock
SPIN_LOCK //
//
// IopLookasideIrpFloat - This is the number of IRPs that are currently
// in progress that were allocated from a lookaside list.
//
.globl IopLookasideIrpFloat
ALIGN
IopLookasideIrpFloat: //
.long 0 //
//
// IopLookasideIrpLimit - This is the maximum number of IRPs that can be
// in progress that were allocated from a lookaside list.
//
.globl IopLookasideIrpLimit
IopLookasideIrpLimit: //
.long 0 //
//
// KeTickCount - This is the number of clock ticks that have occurred since
// the system was booted. This count is used to compute a millisecond
// tick counter.
//
.align 6
.globl KeTickCount
KeTickCount: //
.quad 0 //
//
// KeMaximumIncrement - This is the maximum time between clock interrupts
// in 100ns units that is supported by the host HAL.
//
.globl KeMaximumIncrement
KeMaximumIncrement: //
.long 0 //
//
// KeTimeAdjustment - This is the actual number of 100ns units that are to
// be added to the system time at each interval timer interupt. This
// value is copied from KeTimeIncrement at system start up and can be
// later modified via the set system information service.
// timer table entries.
//
.globl KeTimeAdjustment
KeTimeAdjustment: //
.long 0 //
//
// KiTickOffset - This is the number of 100ns units remaining before a tick
// is added to the tick count and the system time is updated.
//
.globl KiTickOffset
KiTickOffset: //
.long 0 //
//
// KiMaximumDpcQueueDepth - This is used to control how many DPCs can be
// queued before a DPC of medium importance will trigger a dispatch
// interrupt.
//
.globl KiMaximumDpcQueueDepth
KiMaximumDpcQueueDepth: //
.long 4 //
//
// KiMinimumDpcRate - This is the rate of DPC requests per clock tick that
// must be exceeded before DPC batching of medium importance DPCs
// will occur.
//
.globl KiMinimumDpcRate
KiMinimumDpcRate: //
.long 3 //
//
// KiAdjustDpcThreshold - This is the threshold used by the clock interrupt
// routine to control the rate at which the processor's DPC queue depth
// is dynamically adjusted.
//
.globl KiAdjustDpcThreshold
KiAdjustDpcThreshold: //
.long 20 //
//
// KiIdealDpcRate - This is used to control the aggressiveness of the DPC
// rate adjusting algorithm when decrementing the queue depth. As long
// as the DPC rate for the last tick is greater than this rate, the
// DPC queue depth will not be decremented.
//
.globl KiIdealDpcRate
KiIdealDpcRate: //
.long 20 //
//
// KiMbTimeStamp - This is the memory barrier time stamp value that is
// incremented each time a global memory barrier is executed on an
// MP system.
//
#if !defined(NT_UP)
ALIGN
.globl KiMbTimeStamp
KiMbTimeStamp: //
.long 0 //
#endif
//
// KiTbFlushTimeStamp - This is the TB flush entire time stamp counter.
//
ALIGN
.globl KiTbFlushTimeStamp
KiTbFlushTimeStamp: //
.long 0 //