中国DOS联盟

What is the exact input frequency of the 8253 timer chip on a PC?

Many books say that the output frequency of timer #0 of the 8253 on a PC is 18.2 times per second (triggering once every 55ms), but all say this is only an approximate value, and the exact value has a long string of decimals. Computers should rely on integer operations, and those decimal values should just be the result of converting to real time. So I wanted to know the exact frequency, so I looked up a lot of materials, and it turned out that there were some differences:
1. The exact value (counter #0) as said in many books:
　　F: 18.2064819336 times per second
　　T: once every 54.925ms.
2. Terrv Dettmann's "DOS Programmer's Reference":
　　H: The system clock is called about 18.2 times per second (65536 times per hour).
　　D: The 00h function of int 1Ah: This interrupt obtains the system clock counter, which starts from zero and counts 18.2065 times per second. The total number of counts in a full day (from midnight) is 1573040 counts, and the elapsed time is 86399.9129 seconds.
3. Mazid's "Assembly Language, Design and Interface Technology": The 8284 chip is connected to a 14.31818MHz crystal oscillator source. The Clr pin output is the main frequency of the CPU, memory (system bus) in 8088, divided by 3, 4.772776MHz. PClk is connected to the 8253/54 timer, divided by 6, 2.386383MHz. There is a 72LS175 D flip-flop between the 8284 and the 8253, so the frequency is divided by 2 again, 1.1931817MHz.
4. Some interface technology books say that the frequency period of the crystal oscillator source is 70ns, matching the memory speed.
5. On many computers, the return value of QueryPerformanceFrequency (Win32 API) is 3579545. 3579545 * 4 = 14318180, which matches 3.

Constant Analysis
~~~~~~~~

　　Now analyze these constants:

The first type, according to the frequency (18.2064819336 times per second)

Crystal oscillator source frequency: 18.2064819336Hz * 65536 * 12 = 14,318,160.0000049152Hz
Period: 1s / 14,318,160.0000049152Hz = 0.000000069841376266200176256402804053989s = 69.841376266200176256402804053989ns

8253 input frequency: 18.2064819336Hz * 65536 = 1,193,180.0000004096Hz
Period: 1s / 1,193,180.0000004096Hz = 0.00000083809651519440211507683364864787s = 838.09651519440211507683364864787ns

Timer #0 output frequency: 18.2064819336Hz
Period: 1s / 18.2064819336Hz = 0.054925493219780337013675369997787s = 54.925493219780337013675369997787ms

Timer #0 triggers 65536 times: (1s / 18.2064819336Hz) * 65536 = 65536s / 18.2064819336Hz = 3599.597123651524166528229048175s
Timer #0 triggers 1573040 times: (1s / 18.2064819336Hz) * 1573040 = 1573040s / 18.2064819336Hz = 86399.997854443261335991904021318s


The first type, according to the period (once every 54.925ms)

Crystal oscillator source frequency: (1s / 54.925ms) * 65536 * 12 = (65536 * 12)s / 0.054925s = 14,318,288.575329995448338643604916Hz
Period: 54.925ms / (65536 * 12) = 0.000000069840749104817708333333333333333s = 69.840749104817708333333333333333ns

8253 input frequency: (1s / 54.925ms) * 65536 = 65536s / 0.054925s = 1,193,190.7146108329540282203004096Hz
Period: 54.925ms / 65536 = 0.0000008380889892578125s = 838.0889892578125ns

Timer #0 output frequency: 1s / 54.925ms = 18.206645425580336822940373236231Hz
Period: 54.925ms

Timer #0 triggers 65536 times: 54.925ms * 65536 = 3599.5648s
Timer #0 triggers 1573040 times: 54.925ms * 1573040 = 86399.222s


The second type, according to the hour (65536 times per hour)

Crystal oscillator source frequency: 1s / (3600s / 65536 / 65536 / 12) = (65536 * 65536 * 12)s / 3600s = 14,316,557.653333333333333333333333Hz
Period: 3600s / 65536 / 65536 / 12 = 3600s / (65536 * 65536 * 12) = 0.000000069849193096160888671875s = 69.849193096160888671875ns

8253 input frequency: 1s / (3600s / 65536 / 65536) = (65536*65536)s / 3600s = 1,193,046.4711111111111111111111111Hz
Period: 3600s / 65536 / 65536 = 3600s / (65536 * 65536) = 0.0000008381903171539306640625s = 838.1903171539306640625ns

Timer #0 output frequency: 1s / (3600s / 65536) = 65536s / 3600s = 18.204444444444444444444444444444Hz
Period: 3600s / 65536 = 0.054931640625s = 54.931640625ms

Timer #0 triggers 65536 times: 3600s
Timer #0 triggers 1573040 times: (3600s / 65536) * 1573040 = (3600s * 1573040) / 65536 = 86409.66796875s


The second type, according to the day (clock counts 1573040 times, elapsed time is 86399.9129 seconds)

Crystal oscillator source frequency: 1s / (86399.9129s / 1573040 / 65536 / 12) = (1573040 * 65536 * 12)s / 86399.9129s = 14,318,174.078622248240715529702808Hz
Period: 86399.9129s / 1573040 / 65536 / 12 = 86399.9129s / (1573040 * 65536 * 12) = 0.000000069841307593336928084579328349353s = 69.841307593336928084579328349353ns

8253 input frequency: 1s / (86399.9129s / 1573040 / 65536) = (1573040 * 65536)s / 86399.9129s = 1,193,181.1732185206867262941419007Hz
Period: 86399.9129s / 1573040 / 65536 = 86399.9129s / (1573040 * 65536) = 0.00000083809569112004313701495194019224s = 838.09569112004313701495194019224ns

Timer #0 output frequency: 1s / (86399.9129s / 1573040) = 1573040s / 86399.9129s = 18.206499835487681377049165983592Hz
Period: 86399.9129s / 1573040 = 0.054925439213243147027411890352439s = 54.925439213243147027411890352439ms

Timer #0 triggers 65536 times: (86399.9129s / 1573040) * 65536Hz = (86399.9129s * 65536) / 1573040 = 3599.5935842791028835884656461374s
Timer #0 triggers 1573040 times: 86399.9129s


The third type (8284 chip connected to a 14.31818MHz crystal oscillator source)

Crystal oscillator source frequency: 14.31818MHz = 14,318,180Hz
Period: 1s / 14,318,180Hz = 0.000000069841278710003645714748662190306s = 69.841278710003645714748662190306ns

8253 input frequency: 14,318,180Hz / 12 = 1,193,181.6666666666666666666666667Hz
Period: 1s / (14,318,180Hz / 12) = 12s / 14,318,180Hz = 0.00000083809534452004374857698394628368s = 838.09534452004374857698394628368ns

Timer #0 output frequency: 14,318,180Hz / 12 / 65536 = 14,318,180Hz / (12 * 65536) = 18.206507364908854166666666666667Hz
Period: 1s / (14,318,180Hz / 12 / 65536) = (12 * 65536)s / 14,318,180Hz = 0.054925416498465587106741219903647s = 54.925416498465587106741219903647ms

Timer #0 triggers 65536 times: (1s / (14,318,180Hz / 12 / 65536)) * 65536 = (12 * 65536 * 65536)s / 14,318,180Hz = 3599.5920956434407166273925876054s
Timer #0 triggers 1573040 times: (1s / (14,318,180Hz / 12 / 65536)) * 1573040 = (12 * 65536 * 1573040)s / 14,318,180Hz = 86399.877168746307142388208557233s


The fourth type (the frequency period of the crystal oscillator source is 70ns, matching the memory speed)

Crystal oscillator source frequency: 1s / 0.00000007s = 14,285,714.285714285714285714285714Hz
Period: 70ns = 0.00000007s

8253 input frequency: 1s / (0.00000007s * 12) = 1,190,476.1904761904761904761904762Hz
Period: 0.00000007s * 12 = 0.00000084s = 840ns

Timer #0 output frequency: 1s / (0.00000007s * 12 * 65536) = 18.165225074404761904761904761905Hz
Period: 0.00000007s * 12 * 65536 = 0.05505024s = 55.05024ms

Timer #0 triggers 65536 times: (0.00000007s * 12 * 65536) * 65536 = 3607.77252864s
Timer #0 triggers 1573040 times: (0.00000007s * 12 * 65536) * 1573040 = 86596.2295296s


Total Table
~~~~

　　Crystal oscillator source frequency (Hz):
1F: 14,318,160.0000049152
1T: 14,318,288.575329995448338643604916
2H: 14,316,557.653333333333333333333333
2D: 14,318,174.078622248240715529702808
3 : 14,318,180
4 : 14,285,714.285714285714285714285714

　　Crystal oscillator source period (ns):
1F: 69.841376266200176256402804053989
1T: 69.840749104817708333333333333333
2H: 69.849193096160888671875
2D: 69.841307593336928084579328349353
3 : 69.841278710003645714748662190306
4 : 70

　　8253 input frequency (Hz):
1F: 1,193,180.0000004096
1T: 1,193,190.7146108329540282203004096
2H: 1,193,046.4711111111111111111111111
2D: 1,193,181.1732185206867262941419007
3 : 1,193,181.6666666666666666666666667
4 : 1,190,476.1904761904761904761904762

　　8253 input period (ns):
1F: 838.09651519440211507683364864787
1T: 838.0889892578125
2H: 838.1903171539306640625
2D: 838.09569112004313701495194019224
3 : 838.09534452004374857698394628368
4 : 840

　　Timer #0 output frequency (Hz):
1F: 18.2064819336
1T: 18.206645425580336822940373236231
2H: 18.204444444444444444444444444444
2D: 18.206499835487681377049165983592
3 : 18.206507364908854166666666666667
4 : 18.165225074404761904761904761905

　　Timer #0 output period (ms):
1F: 54.925493219780337013675369997787
1T: 54.925
2H: 54.931640625
2D: 54.925439213243147027411890352439
3 : 54.925416498465587106741219903647
4 : 55.05024

　　Timer #0 triggers 65536 times (s):
1F: 3599.597123651524166528229048175
1T: 3599.5648
2H: 3600
2D: 3599.5935842791028835884656461374
3 : 3599.5920956434407166273925876054
4 : 3607.77252864

　　Timer #0 triggers 1573040 times (s):
1F: 86399.997854443261335991904021318
1T: 86399.222
2H: 86409.66796875
2D: 86399.9129
3 : 86399.877168746307142388208557233
4 : 86596.2295296



Conclusion
~~~~

　　Personally, I think the statement in "Assembly Language, Design and Interface Technology" is the most credible, with a crystal oscillator source frequency of 14,318,180Hz, because it matches many numbers.



PS: I have always had this question, but I never studied it. Until a few days ago, I saw an article by Fengyun "Not Very Accurate Clock" (http://blog.codingnow.com/2006/05/iaeeoeo.html) and then realized the seriousness of this problem, which caught my attention.

Last edited by zyl910 on 2006-6-3 at 12:44 ]

;

; *** Listing 3-1 ***

;

; The precision Zen timer (PZTIMER.ASM)

;

; Uses the 8253 timer to time the performance of code that takes

; less than about 54 milliseconds to execute, with a resolution

; of better than 10 microseconds.

;

; By Michael Abrash 

;

; Externally callable routines:

;

;  ZTimerOn: Starts the Zen timer, with interrupts disabled.

;

;  ZTimerOff: Stops the Zen timer, saves the timer count,

;	times the overhead code, and restores interrupts to the

;	state they were in when ZTimerOn was called.

;

;  ZTimerReport: Prints the net time that passed between starting

;	and stopping the timer.

;

; Note: If longer than about 54 ms passes between ZTimerOn and

;	ZTimerOff calls, the timer turns over and the count is

;	inaccurate. When this happens, an error message is displayed

;	instead of a count. The long-period Zen timer should be used

;	in such cases.

;

; Note: Interrupts *MUST* be left off between calls to ZTimerOn

;	and ZTimerOff for accurate timing and for detection of

;	timer overflow.

;

; Note: These routines can introduce slight inaccuracies into the

;	system clock count for each code section timed even if

;	timer 0 doesn't overflow. If timer 0 does overflow, the

;	system clock can become slow by virtually any amount of

;	time, since the system clock can't advance while the

;	precison timer is timing. Consequently, it's a good idea

;	to reboot at the end of each timing session. (The

;	battery-backed clock, if any, is not affected by the Zen

;	timer.)

;

; All registers, and all flags except the interrupt flag, are

; preserved by all routines. Interrupts are enabled and then disabled

; by ZTimerOn, and are restored by ZTimerOff to the state they were

; in when ZTimerOn was called.

;



Code	segment word public 'CODE'

	assume	cs:Code, ds:nothing

	public	ZTimerOn, ZTimerOff, ZTimerReport



;

; Base address of the 8253 timer chip.

;

BASE_8253		equ	40h

;

; The address of the timer 0 count registers in the 8253.

;

TIMER_0_8253		equ	BASE_8253 + 0

;

; The address of the mode register in the 8253.

;

MODE_8253		equ	BASE_8253 + 3

;

; The address of Operation Command Word 3 in the 8259 Programmable

; Interrupt Controller (PIC) (write only, and writable only when

; bit 4 of the byte written to this address is 0 and bit 3 is 1).

;

OCW3			equ	20h

;

; The address of the Interrupt Request register in the 8259 PIC

; (read only, and readable only when bit 1 of OCW3 = 1 and bit 0

; of OCW3 = 0).

;

IRR			equ	20h

;

; Macro to emulate a POPF instruction in order to fix the bug in some

; 80286 chips which allows interrupts to occur during a POPF even when

; interrupts remain disabled.

;

MPOPF macro 

	local	p1, p2

	jmp short p2

p1:	iret			;jump to pushed address & pop flags

p2:	push	cs		;construct far return address to

	call	p1		; the next instruction

	endm



;

; Macro to delay briefly to ensure that enough time has elapsed

; between successive I/O accesses so that the device being accessed

; can respond to both accesses even on a very fast PC.

;

DELAY	macro

	jmp	$+2

	jmp	$+2

	jmp	$+2

	endm



OriginalFlags		db	?	;storage for upper byte of

					; FLAGS register when

					; ZTimerOn called

TimedCount		dw	?	;timer 0 count when the timer

					; is stopped

ReferenceCount		dw	?	;number of counts required to

					; execute timer overhead code

OverflowFlag		db	?	;used to indicate whether the

					; timer overflowed during the

					; timing interval

;

; String printed to report results.

;

OutputStr	label	byte

		db	0dh, 0ah, 'Timed count: ', 5 dup (?)

ASCIICountEnd	label	byte

		db	' microseconds', 0dh, 0ah

		db	'$'

;

; String printed to report timer overflow.

;

OverflowStr	label	byte

	db	0dh, 0ah

	db	'****************************************************'

	db	0dh, 0ah

	db	'* The timer overflowed, so the interval timed was  *'

	db	0dh, 0ah

	db	'* too long for the precision timer to measure.     *'

	db	0dh, 0ah

	db	'* Please perform the timing test again with the    *'

	db	0dh, 0ah

	db	'* long-period timer.                               *'

	db	0dh, 0ah

	db	'****************************************************'

	db	0dh, 0ah

	db	'$'



;********************************************************************

;* Routine called to start timing.				    *

;********************************************************************



ZTimerOn	proc	near



;

; Save the context of the program being timed.

;

	push	ax

	pushf

	pop	ax			;get flags so we can keep

					; interrupts off when leaving

					; this routine

	mov	cs:,ah	;remember the state of the

					; Interrupt flag

	and	ah,0fdh 		;set pushed interrupt flag

					; to 0

	push	ax

;

; Turn on interrupts, so the timer interrupt can occur if it's

; pending.

;

	sti

;

; Set timer 0 of the 8253 to mode 2 (divide-by-N), to cause

; linear counting rather than count-by-two counting. Also

; leaves the 8253 waiting for the initial timer 0 count to

; be loaded.

;

	mov	al,00110100b		;mode 2

	out	MODE_8253,al

;

; Set the timer count to 0, so we know we won't get another

; timer interrupt right away.

; Note: this introduces an inaccuracy of up to 54 ms in the system

; clock count each time it is executed.

;

	DELAY

	sub	al,al

	out	TIMER_0_8253,al		;lsb

	DELAY

	out	TIMER_0_8253,al		;msb

;

; Wait before clearing interrupts to allow the interrupt generated

; when switching from mode 3 to mode 2 to be recognized. The delay

; must be at least 210 ns long to allow time for that interrupt to

; occur. Here, 10 jumps are used for the delay to ensure that the

; delay time will be more than long enough even on a very fast PC.

;

	rept 10

	jmp	$+2

	endm

;

; Disable interrupts to get an accurate count.

;

	cli

;

; Set the timer count to 0 again to start the timing interval.

;

	mov	al,00110100b		;set up to load initial

	out	MODE_8253,al		; timer count

	DELAY

	sub	al,al

	out	TIMER_0_8253,al		;load count lsb

	DELAY

	out	TIMER_0_8253,al		;load count msb

;

; Restore the context and return.

;

	MPOPF				;keeps interrupts off

	pop	ax

	ret



ZTimerOn	endp



;********************************************************************

;* Routine called to stop timing and get count.			    *

;********************************************************************



ZTimerOff proc	near



;

; Save the context of the program being timed.

;

	push	ax

	push	cx

	pushf

;

; Latch the count.

;

	mov	al,00000000b		;latch timer 0

	out	MODE_8253,al

;

; See if the timer has overflowed by checking the 8259 for a pending

; timer interrupt.

;

	mov	al,00001010b		;OCW3, set up to read

	out	OCW3,al			; Interrupt Request register

	DELAY

	in	al,IRR			;read Interrupt Request

					; register

	and	al,1			;set AL to 1 if IRQ0 (the

					; timer interrupt) is pending

	mov	cs:,al	;store the timer overflow

					; status

;

; Allow interrupts to happen again.

;

	sti

;

; Read out the count we latched earlier.

;

	in	al,TIMER_0_8253		;least significant byte

	DELAY

	mov	ah,al

	in	al,TIMER_0_8253		;most significant byte

	xchg	ah,al

	neg	ax			;convert from countdown

					; remaining to elapsed

					; count

	mov	cs:,ax

; Time a zero-length code fragment, to get a reference for how

; much overhead this routine has. Time it 16 times and average it,

; for accuracy, rounding the result.

;

	mov	cs:,0

	mov	cx,16

	cli				;interrupts off to allow a

					; precise reference count

RefLoop:

	call	ReferenceZTimerOn

	call	ReferenceZTimerOff

	loop	RefLoop

	sti

	add	cs:,8	;total + (0.5 * 16)

	mov	cl,4

	shr	cs:,cl	;(total) / 16 + 0.5

;

; Restore original interrupt state.

;

	pop	ax			;retrieve flags when called

	mov	ch,cs:	;get back the original upper

					; byte of the FLAGS register

	and	ch,not 0fdh		;only care about original

					; interrupt flag...

	and	ah,0fdh			;...keep all other flags in

					; their current condition

	or	ah,ch			;make flags word with original

					; interrupt flag

	push	ax			;prepare flags to be popped

;

; Restore the context of the program being timed and return to it.

;

	MPOPF				;restore the flags with the

					; original interrupt state

	pop	cx

	pop	ax

	ret



ZTimerOff endp



;

; Called by ZTimerOff to start timer for overhead measurements.

;



ReferenceZTimerOn	proc	near

;

; Save the context of the program being timed.

;

	push	ax

	pushf		;interrupts are already off

;

; Set timer 0 of the 8253 to mode 2 (divide-by-N), to cause

; linear counting rather than count-by-two counting.

;

	mov	al,00110100b	;set up to load

	out	MODE_8253,al	; initial timer count

	DELAY

;

; Set the timer count to 0.

;

	sub	al,al

	out	TIMER_0_8253,al	;load count lsb

	DELAY

	out	TIMER_0_8253,al	;load count msb

;

; Restore the context of the program being timed and return to it.

;

	MPOPF

	pop	ax

	ret



ReferenceZTimerOn	endp



;

; Called by ZTimerOff to stop timer and add result to ReferenceCount

; for overhead measurements.

;



ReferenceZTimerOff proc	near

;

; Save the context of the program being timed.

;

	push	ax

	push	cx

	pushf

;

; Latch the count and read it.

;

	mov	al,00000000b		;latch timer 0

	out	MODE_8253,al

	DELAY

	in	al,TIMER_0_8253		;lsb

	DELAY

	mov	ah,al

	in	al,TIMER_0_8253		;msb

	xchg	ah,al

	neg	ax			;convert from countdown

					; remaining to amount

					; counted down

	add	cs:,ax

;

; Restore the context of the program being timed and return to it.

;

	MPOPF

	pop	cx

	pop	ax

	ret



ReferenceZTimerOff endp



;********************************************************************

;* Routine called to report timing results.			    *

;********************************************************************



ZTimerReport	proc	near



	pushf

	push	ax

	push	bx

	push	cx

	push	dx

	push	si

	push	ds

;

	push	cs	;DOS functions require that DS point

	pop	ds	; to text to be displayed on the screen

	assume	ds:Code

;

; Check for timer 0 overflow.

;

	cmp	,0

	jz	PrintGoodCount

	mov	dx,offset OverflowStr

	mov	ah,9

	int	21h

	jmp	short EndZTimerReport

;

; Convert net count to decimal ASCII in microseconds.

;

PrintGoodCount:

	mov	ax,

	sub	ax,

	mov	si,offset ASCIICountEnd - 1

;

; Convert count to microseconds by multiplying by .8381.

;

	mov	dx,8381

	mul	dx

	mov	bx,10000

	div	bx		;* .8381 = * 8381 / 10000

;

; Convert time in microseconds to 5 decimal ASCII digits.

;

	mov	bx,10

	mov	cx,5

CTSLoop:

	sub	dx,dx

	div	bx

	add	dl,'0'

	mov	,dl

	dec	si

	loop	CTSLoop

;

; Print the results.

;

	mov	ah,9

	mov	dx,offset OutputStr

	int	21h

;

EndZTimerReport:

	pop	ds

	pop	si

	pop	dx

	pop	cx

	pop	bx

	pop	ax

	MPOPF

	ret



ZTimerReport	endp



Code	ends

	end

Just now I flipped through "Graphics Programmer's Guide (Michael Abrash's Graphics Programming Black Book Special Editior)" again, and found that the code uses an (input frequency period) of 0.8381ms (ZTimerReport function):

;

; *** Listing 3-1 ***

;

; Precision Zen timer (PZTIMER.ASM)

;

; Uses the 8253 timer to time code that takes less than about 54 milliseconds to execute, with a resolution better than 10 microseconds.

;

; By Michael Abrash 

;

; Externally callable routines:

;

;  ZTimerOn: Starts the Zen timer, with interrupts disabled.

;

;  ZTimerOff: Stops the Zen timer, saves the timer count, times the overhead code, and restores interrupts to the state they were in when ZTimerOn was called.

;

;  ZTimerReport: Prints the net time that passed between starting and stopping the timer.

;

; Note: If more than about 54 ms passes between ZTimerOn and ZTimerOff calls, the timer overflows and the count is inaccurate. In this case, an error message is displayed instead of a count. In such cases, the long - period Zen timer should be used.

;

; Note: For accurate timing and detection of timer overflow, interrupts must remain off between calls to ZTimerOn and ZTimerOff.

;

; Note: Even if timer 0 does not overflow, these routines may introduce slight inaccuracies into the system clock count for each timed code section. If timer 0 overflows, the system clock can slow down by almost any amount because the system clock cannot advance while the precision timer is timing. Therefore, it is a good idea to reboot at the end of each timing session. (The battery - backed clock, if any, is not affected by the Zen timer.)

;

All registers and all flags except the interrupt flag are preserved by all routines. ZTimerOn enables and then disables interrupts, and ZTimerOff restores interrupts to the state they were in when ZTimerOn was called.





Code segment word public 'CODE'

	assume cs:Code, ds:nothing

	public ZTimerOn, ZTimerOff, ZTimerReport



;

; Base address of 8253 timer chip.

;

BASE_8253		equ	40h

;

; Address of timer 0 count register in 8253.

;

TIMER_0_8253		equ	BASE_8253 + 0

;

; Address of mode register in 8253.

;

MODE_8253		equ	BASE_8253 + 3

;

; Address of Operation Command Word 3 in 8259 Programmable Interrupt Controller (PIC) (write - only, and writable only when bit 4 of the byte written to this address is 0 and bit 3 is 1).

;

OCW3			equ	20h

;

; Address of Interrupt Request register in 8259 PIC (read - only, and readable only when bit 1 of OCW3 = 1 and bit 0 of OCW3 = 0).

;

IRR			equ	20h

;

; Macro to simulate POPF instruction to fix the bug in some 80286 chips that allows interrupts to occur during POPF even when interrupts are still disabled.

;

MPOPF macro 

	local	p1, p2

	jmp short p2

p1:	iret			;jump to pushed address & pop flags

p2:	push	cs		;construct far return address to

	call	p1		; the next instruction

	endm



;

; Macro to briefly delay to ensure that enough time has elapsed between successive I/O accesses so that the accessed device can respond to both accesses even on a very fast PC.

;

DELAY	macro

	jmp	$+2

	jmp	$+2

	jmp	$+2

	endm



OriginalFlags		db	?	;storage for upper byte of

					; FLAGS register when

					; ZTimerOn called

TimedCount		dw	?	;timer 0 count when the timer

					; is stopped

ReferenceCount		dw	?	;number of counts required to

					; execute timer overhead code

OverflowFlag		db	?	;used to indicate whether the

					; timer overflowed during the

					; timing interval

;

; String printed to report results.

;

OutputStr	label	byte

		db	0dh, 0ah, 'Timed count: ', 5 dup (?)

ASCIICountEnd	label	byte

		db	' microseconds', 0dh, 0ah

		db	'$'

;

; String printed to report timer overflow.

;

OverflowStr	label	byte

	db	0dh, 0ah

	db	'****************************************************'

	db	0dh, 0ah

	db	'* The timer overflowed, so the interval timed was  *'

	db	0dh, 0ah

	db	'* too long for the precision timer to measure.     *'

	db	0dh, 0ah

	db	'* Please perform the timing test again with the    *'

	db	0dh, 0ah

	db	'* long - period timer.                               *'

	db	0dh, 0ah

	db	'****************************************************'

	db	0dh, 0ah

	db	'$'



;********************************************************************

;* Routine called to start timing.				    *

;********************************************************************



ZTimerOn	proc	near



;

; Save the context of the program being timed.

;

	push	ax

	pushf

	pop	ax			;get flags so we can keep

					; interrupts off when leaving

					; this routine

	mov	cs:,ah	;remember the state of the

					; Interrupt flag

	and	ah,0fdh 		;set pushed interrupt flag

					; to 0

	push	ax

;

; Turn on interrupts, so the timer interrupt can occur if it's

; pending.

;

	sti

;

; Set timer 0 of 8253 to mode 2 (divide - by - N), to cause

; linear counting rather than count - by - two counting. Also

; leaves the 8253 waiting for the initial timer 0 count to

; be loaded.

;

	mov	al,00110100b		;mode 2

	out	MODE_8253,al

;

; Set the timer count to 0, so we know we won't get another

; timer interrupt right away.

; Note: this introduces an inaccuracy of up to 54 ms in the system

; clock count each time it is executed.

;

	DELAY

	sub	al,al

	out	TIMER_0_8253,al		;lsb

	DELAY

	out	TIMER_0_8253,al		;msb

;

; Wait before clearing interrupts to allow the interrupt generated

; when switching from mode 3 to mode 2 to be recognized. The delay

; must be at least 210 ns long to allow time for that interrupt to

; occur. Here, 10 jumps are used for the delay to ensure that the

; delay time will be more than long enough even on a very fast PC.

;

	rept 10

	jmp	$+2

	endm

;

; Disable interrupts to get an accurate count.

;

	cli

;

; Set the timer count to 0 again to start the timing interval.

;

	mov	al,00110100b		;set up to load initial

	out	MODE_8253,al		; timer count

	DELAY

	sub	al,al

	out	TIMER_0_8253,al		;load count lsb

	DELAY

	out	TIMER_0_8253,al		;load count msb

;

; Restore the context and return.

;

	MPOPF				;keeps interrupts off

	pop	ax

	ret



ZTimerOn	endp



;********************************************************************

;* Routine called to stop timing and get count.			    *

;********************************************************************



ZTimerOff proc	near



;

; Save the context of the program being timed.

;

	push	ax

	push	cx

	pushf

;

; Latch the count.

;

	mov	al,00000000b		;latch timer 0

	out	MODE_8253,al

;

; See if the timer has overflowed by checking the 8259 for a pending

; timer interrupt.

;

	mov	al,00001010b		;OCW3, set up to read

	out	OCW3,al			; Interrupt Request register

	DELAY

	in	al,IRR			;read Interrupt Request

					; register

	and	al,1			;set AL to 1 if IRQ0 (the

					; timer interrupt) is pending

	mov	cs:,al	;store the timer overflow

					; status

;

; Allow interrupts to happen again.

;

	sti

;

; Read out the count we latched earlier.

;

	in	al,TIMER_0_8253		;least significant byte

	DELAY

	mov	ah,al

	in	al,TIMER_0_8253		;most significant byte

	xchg	ah,al

	neg	ax			;convert from countdown

					; remaining to elapsed

					; count

	mov	cs:,ax

; Time a zero - length code fragment, to get a reference for how

; much overhead this routine has. Time it 16 times and average it,

; for accuracy, rounding the result.

;

	mov	cs:,0

	mov	cx,16

	cli				;interrupts off to allow a

					; precise reference count

RefLoop:

	call	ReferenceZTimerOn

	call	ReferenceZTimerOff

	loop	RefLoop

	sti

	add	cs:,8	;total + (0.5 * 16)

	mov	cl,4

	shr	cs:,cl	;(total) / 16 + 0.5

;

; Restore original interrupt state.

;

	pop	ax			;retrieve flags when called

	mov	ch,cs:	;get back the original upper

					; byte of the FLAGS register

	and	ch,not 0fdh		;only care about original

					; interrupt flag...

	and	ah,0fdh			;...keep all other flags in

					; their current condition

	or	ah,ch			;make flags word with original

					; interrupt flag

	push	ax			;prepare flags to be popped

;

; Restore the context of the program being timed and return to it.

;

	MPOPF				;restore the flags with the

					; original interrupt state

	pop	cx

	pop	ax

	ret



ZTimerOff endp



;

; Called by ZTimerOff to start timer for overhead measurements.

;



ReferenceZTimerOn	proc	near

;

; Save the context of the program being timed.

;

	push	ax

	pushf		;interrupts are already off

;

; Set timer 0 of 8253 to mode 2 (divide - by - N), to cause

; linear counting rather than count - by - two counting.

;

	mov	al,00110100b	;set up to load

	out	MODE_8253,al	; initial timer count

	DELAY

;

; Set the timer count to 0.

;

	sub	al,al

	out	TIMER_0_8253,al	;load count lsb

	DELAY

	out	TIMER_0_8253,al	;load count msb

;

; Restore the context of the program being timed and return to it.

;

	MPOPF

	pop	ax

	ret



ReferenceZTimerOn	endp



;

; Called by ZTimerOff to stop timer and add result to ReferenceCount

; for overhead measurements.

;



ReferenceZTimerOff proc	near

;

; Save the context of the program being timed.

;

	push	ax

	push	cx

	pushf

;

; Latch the count and read it.

;

	mov	al,00000000b		;latch timer 0

	out	MODE_8253,al

	DELAY

	in	al,TIMER_0_8253		;lsb

	DELAY

	mov	ah,al

	in	al,TIMER_0_8253		;msb

	xchg	ah,al

	neg	ax			;convert from countdown

					; remaining to amount

					; counted down

	add	cs:,ax

;

; Restore the context of the program being timed and return to it.

;

	MPOPF

	pop	cx

	pop	ax

	ret



ReferenceZTimerOff endp



;********************************************************************

;* Routine called to report timing results.			    *

;********************************************************************



ZTimerReport	proc	near



	pushf

	push	ax

	push	bx

	push	cx

	push	dx

	push	si

	push	ds

;

	push	cs	;DOS functions require that DS point

	pop	ds	; to text to be displayed on the screen

	assume	ds:Code

;

; Check for timer 0 overflow.

;

	cmp	,0

	jz	PrintGoodCount

	mov	dx,offset OverflowStr

	mov	ah,9

	int	21h

	jmp	short EndZTimerReport

;

; Convert net count to decimal ASCII in microseconds.

;

PrintGoodCount:

	mov	ax,

	sub	ax,

	mov	si,offset ASCIICountEnd - 1

;

; Convert count to microseconds by multiplying by .8381.

;

	mov	dx,8381

	mul	dx

	mov	bx,10000

	div	bx		;* .8381 = * 8381 / 10000

;

; Convert time in microseconds to 5 decimal ASCII digits.

;

	mov	bx,10

	mov	cx,5

CTSLoop:

	sub	dx,dx

	div	bx

	add	dl,'0'

	mov	,dl

	dec	si

	loop	CTSLoop

;

; Print the results.

;

	mov	ah,9

	mov	dx,offset OutputStr

	int	21h

;

EndZTimerReport:

	pop	ds

	pop	si

	pop	dx

	pop	cx

	pop	bx

	pop	ax

	MPOPF

	ret



ZTimerReport	endp



Code	ends

	end

The following is the description of 8253 in the "Graphics Programmer's Guide", which is consistent with "Assembly Language, Design and Interface Technology":

The 8253 actually contains three timers, as shown in Figure 3.1. All three timers are driven by the system board's 14.31818 MHz crystal, divided by 12 to produce a 1.19318 MHz clock for the timers, so the timers count once every 838.1 ns. Each of the three timers counts down in a programmable way, generating a signal on its output pin when it counts down to 0. Each timer can be stopped at any time via a 0 level on its gate input; when a timer's gate input is 1, that timer counts continuously. In general, the 8253's timers are inherently very flexible timing devices; unfortunately, much of that flexibility depends on how the timers are connected to external circuits, and in the PC, the timers are connected for specific purposes.

In normal use, I just take it as 18 times, and I haven't required such precision. It can be set to a higher frequency (UCOS/II seems to have changed it), but it seems to affect performance.

In actual applications, precise timing never uses the system-provided 8253. Generally, timing from expansion cards is used, and this 18.2 seconds of the system is not of much concern.

But I want to achieve millisecond-level timing under DOS!
It's for making animation and game programs
There's no hope of others installing expansion cards

My purpose is: to write functions similar to the Win32 API - QueryPerformanceFrequency, QueryPerformanceCounter - to achieve high-precision timing

Cai cai's question:
What are TSC and ACPI?
How to use them to time?
ACPI seems to be that advanced power management, does it also have a timing function? Oh, it's really hard to find hardware interface information now

http://blog.codingnow.com/2006/05/iaeeoeo.html

Also, QueryPerformanceCounter in Windows is not available. According to the MSDN documentation, it is guessed that it may be implemented using TSC. In the multi-core and variable frequency era, it is almost impossible to get accurate time with TSC.

On freebsd, the priority of using TSC to get time is the lowest. Now generally use ACPI to get the clock. No corresponding means are found in Windows.

TSC is a newly added 64-bit register in Pentium and above processors. This counter increments by one automatically at each CPU base clock (the base clock refers to the stage of the pipeline). TSC can be read using the RDTSC instruction.

The QueryPerformanceCounter in the Win32 API indeed should use TSC. First, its precision is very high. Second, MSDN says that this API uses some hardware-related features, and it may not be supported on some CPUs.

The main design intention of TSC is profiling. In most cases, it is not suitable to use it for timing, mainly because the overhead is relatively high.

In most cases, the 8253 itself can work at a precision of the nanosecond level at most. This precision should be sufficient for most applications, but any operating system including Windows usually cannot keep its own working granularity at this frequency, which would make the maintenance overhead of the operating system itself too large.

Plus, when Windows handles interrupts, in order to further reduce the overhead, it specially uses the DPC mechanism. So the Timer granularity of NT-series Windows client products is generally between 10ms and 15ms, and the granularity of server products is generally between 15ms and 30ms.

Through the Windows Native API (not the Win32 API): NtSetTimerResolution, the working granularity of the system can be changed. However, this change will affect all processes in the current system, and improper settings may increase the management burden of the system.

What is even more frustrating is that there are signs that this setting may also affect the working state of the system kernel, such as thread scheduling, blocked event and asynchronous IO state query, etc. Adjusting this value also correspondingly increases the frequency of these tasks, leading to further performance degradation of the system.

ACPI？

Brother zyl910 is referring to the Advanced Programmable Interrupt Controller (APIC) Timer?
As for the commonly said ACPI Timer, it is the periodic timing interrupt triggered by the RTC in an ACPI-compliant system.

There is a special article on various hardware Timers and timing issues introduced by Microsoft's Hardware Development Center:
http://www.microsoft.com/whdc/system/CEC/mm-timer.mspx

昏

Original TSC refers to RDTSC. I didn't pay attention to its abbreviation usually.


Thanks a lot, brother asbai. Now it's really hard to find hardware interface programming materials. It's quite troublesome to write a more accurate timing function under DOS.

Originally posted by zyl910 at 2006-6-10 12:
Dizzy
It turns out that TSC refers to RDTSC
I didn't pay attention to its abbreviation at ordinary times


Thank you very much, Brother asbai
Now, hardware interface programming materials are really hard to find
It's so troublesome to write a more accurate timing function under DOS

Brother zyl910, you're too polite. Now, hardware materials are really hard to find. Intel and AMD released x86 developer manuals are both authoritative and detailed (especially AMD), which should be the preferred source. There is also a website: http://www.powernet.co.za/info/index.htm, although the speed is a bit slow, the materials are quite complete.

I only know so much. Brothers, do you have any good places, take them out and share them. :D