如何在 16 位 MASM Assembly x86 中创建睡眠函数？

发布于 2024-08-13 22:26:46 字数 892 浏览 3 评论 0原文

我正在尝试在 16 位 MASM Assembly x86 中创建一个睡眠/延迟程序，该程序每 500 毫秒在屏幕上打印一个字符。根据我所做的研究，似乎有三种方法可以实现这一目标 - 我想使用使用 CPU 时钟滴答的方法。

请注意，我在 Mac OS X Snow Leopard 上通过 VMWare Fusion 运行 Windows XP - 我不确定这是否会影响任何内容。

有人可以指出我正确的方向，或者提供一段我可以调整的工作代码吗？谢谢你！

我找到的代码应该每秒在屏幕上打印“A”，但不起作用（无论如何我想使用毫秒）。

TOP:
MOV AH,2C
INT 21
MOV BH,DH  ; DH has current second
GETSEC:      ; Loops until the current second is not equal to the last, in BH
MOV AH,2C
INT 21
CMP BH,DH  ; Here is the comparison to exit the loop and print 'A'
JNE PRINTA
JMP GETSEC
PRINTA:
MOV AH,02
MOV DL,41
INT 21
JMP TOP

编辑：按照 GJ 的建议，这是一个工作程序。只需调用它

DELAY PROC
 TIMER:
 MOV     AH, 00H
 INT     1AH
 CMP     DX,WAIT_TIME
 JB      TIMER
 ADD     DX,3         ;1-18, where smaller is faster and 18 is close to 1 second
 MOV     WAIT_TIME,DX
 RET
DELAY ENDP

原文

I am trying to create a sleep/delay procedure in 16bit MASM Assembly x86 that will, say, print a character on the screen every 500ms.
From the research I have done, it seems that there are three methods to achieve this - I would like to use the one that uses CPU clock ticks.

Please note I am running Windows XP through VMWare Fusion on Mac OS X Snow Leopard - I am not sure if that affects anything.

Could someone please point me in the right direction, or provide a working piece of code I can tweak? Thank you!

The code I have found is supposed to print 'A' on the screen every second, but does not work (I'd like to use milliseconds anyways).

TOP:
MOV AH,2C
INT 21
MOV BH,DH  ; DH has current second
GETSEC:      ; Loops until the current second is not equal to the last, in BH
MOV AH,2C
INT 21
CMP BH,DH  ; Here is the comparison to exit the loop and print 'A'
JNE PRINTA
JMP GETSEC
PRINTA:
MOV AH,02
MOV DL,41
INT 21
JMP TOP

EDIT: Following GJ's advice, here's a working procedure. Just call it

DELAY PROC
 TIMER:
 MOV     AH, 00H
 INT     1AH
 CMP     DX,WAIT_TIME
 JB      TIMER
 ADD     DX,3         ;1-18, where smaller is faster and 18 is close to 1 second
 MOV     WAIT_TIME,DX
 RET
DELAY ENDP

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

奈何桥上唱咆哮 2024-08-20 22:26:46

这无法在纯 MASM 中完成。所有设置固定延迟的旧技巧都假设您完全控制机器并且是 CPU 上运行的唯一线程，因此，如果您等待 5 亿个周期，则恰好是 500,000,000/f 秒数将过去（对于频率为 f 的 CPU）；对于 1GHz 处理器来说，这将是 500 毫秒。

因为您运行在现代操作系统上，所以您与许多其他线程（其中包括内核，无论您做什么，都不能获得高于内核的优先级！）共享 CPU，因此仅等待 5 亿个周期你的线程将意味着现实世界中已经经过了超过 5 亿个周期。这个问题不能仅通过用户空间代码来解决；你将需要内核的配合。

解决此问题的正确方法是查找哪个 Win32 API 函数会将线程挂起指定的毫秒数，然后调用该函数。您应该能够直接从汇编中执行此操作，可能需要为链接器添加其他参数。或者，可能有一个 NT 内核系统调用来执行此功能（我对 NT 系统调用的经验很少，并且老实说不知道 NT 系统调用表是什么样子，但睡眠功能是我可能会做的事情）期待看到）。如果系统调用可用，那么从程序集发出直接系统调用可能是完成您想要的操作的最快方法；它也是最不便携的（但是，你正在编写汇编！）。

编辑：查看NT内核系统调用表，似乎没有任何与睡眠或获取日期和时间相关的调用（如您的原始代码使用的那样），但有几个系统调用用于设置和查询计时器。在等待计时器达到所需延迟时旋转是一种有效但不优雅的解决方案。

回复收藏 0 原文

蓝礼 2024-08-20 22:26:46

使用 INT 15h，功能 86h：

调用方式：
啊=86小时
CX:DX = 间隔（以我们为单位）

回复收藏 0 原文

九局 2024-08-20 22:26:46

实际上，您可以使用 ROM BIOS 中断 1Ah 功能 00h，“读取当前时钟计数”。或者您可以读取地址 $40:$6C 处的双字，但必须确保原子读取。它由 MS-DOS 以大约 18.2 Hz 的频率递增。

有关更多信息，请阅读：DOS 时钟

回复收藏 0 原文

勿忘初心 2024-08-20 22:26:46

好吧，那么。旧式的、非恒定的、耗电的延迟循环会导致其他线程运行速度变慢，看起来像：

       delay equ 5000

top:   mov ax, delay
loopa: mov bx, delay
loopb: dec bx
       jnc loopb
       dec ax
       jnc loopa

       mov ah,2
       mov dl,'A'
       int 21
       jmp top

延迟是常数的二次方。但如果你使用这个延迟循环，世界某个地方一只无辜的小猫就会死去。

Well, then. An old style, non constant, power consuming delay loop which will make other threads running slow down would look like:

       delay equ 5000

top:   mov ax, delay
loopa: mov bx, delay
loopb: dec bx
       jnc loopb
       dec ax
       jnc loopa

       mov ah,2
       mov dl,'A'
       int 21
       jmp top

The delay is quadratic to the constant. But if you use this delay loop, somewhere in the world a young innocent kitten will die.

回复收藏 0 原文

禾厶谷欠 2024-08-20 22:26:46

我没有测试这段代码，但概念必须有效......
保存/恢复寄存器是可选的！
仔细检查代码！

DelayProcedure:
    push  es                      //Save es and load new es
    mov   ax, 0040h
    mov   es, ax
//Pseudo atomic read of 32 bit DOS time tick variable
PseudoAtomicRead1:
    mov   ax, es:[006ch]
    mov   dx, es:[006eh]
    cmp   ax, es:[006ch]
    jne   PseudoAtomicRead1
//Add time delay to dx,ax where smaller is faster and 18 is close to 1 second
    add   ax, 3
    adc   dx, 0
//1800AFh is last DOS time tick value so check day overflow
    mov   cx, ax
    mov   bx, dx
//Do 32 bit subtract/compare
    sub   cx, 00AFh
    sbb   dx, 0018h
    jbe   DayOverflow
//Pseudo atomic read of 32 bit DOS time tick variable
PseudoAtomicRead2:
    mov   cx, es:[006ch]
    mov   bx, es:[006eh]
    cmp   cx, es:[006ch]
    jne   PseudoAtomicRead2
NotZero:
//At last do 32 bit compare
    sub   cx, ax
    sbb   bx, dx
    jae   Exit
//Check again day overflow because task scheduler can overjumps last time ticks
    inc   bx                //If no Day Overflow then bx = 0FFh
    jz    PseudoAtomicRead2
    jmp   Exit
DayOverflow:
//Pseudo atomic read of 32 bit DOS time tick variable
PseudoAtomicRead3:
    mov   ax, es:[006ch]
    mov   dx, es:[006eh]
    cmp   dx, es:[006ch]
    jne   PseudoAtomicRead3
//At last do 32 bit compare
    sub   ax, cx
    sbb   dx, bx
    jb    PseudoAtomicRead3
Exit:
    pop   es                      //Restore es
    ret

I didn't test this code but concept must work...
Save/restore es register is optional!
Check code carefully!

DelayProcedure:
    push  es                      //Save es and load new es
    mov   ax, 0040h
    mov   es, ax
//Pseudo atomic read of 32 bit DOS time tick variable
PseudoAtomicRead1:
    mov   ax, es:[006ch]
    mov   dx, es:[006eh]
    cmp   ax, es:[006ch]
    jne   PseudoAtomicRead1
//Add time delay to dx,ax where smaller is faster and 18 is close to 1 second
    add   ax, 3
    adc   dx, 0
//1800AFh is last DOS time tick value so check day overflow
    mov   cx, ax
    mov   bx, dx
//Do 32 bit subtract/compare
    sub   cx, 00AFh
    sbb   dx, 0018h
    jbe   DayOverflow
//Pseudo atomic read of 32 bit DOS time tick variable
PseudoAtomicRead2:
    mov   cx, es:[006ch]
    mov   bx, es:[006eh]
    cmp   cx, es:[006ch]
    jne   PseudoAtomicRead2
NotZero:
//At last do 32 bit compare
    sub   cx, ax
    sbb   bx, dx
    jae   Exit
//Check again day overflow because task scheduler can overjumps last time ticks
    inc   bx                //If no Day Overflow then bx = 0FFh
    jz    PseudoAtomicRead2
    jmp   Exit
DayOverflow:
//Pseudo atomic read of 32 bit DOS time tick variable
PseudoAtomicRead3:
    mov   ax, es:[006ch]
    mov   dx, es:[006eh]
    cmp   dx, es:[006ch]
    jne   PseudoAtomicRead3
//At last do 32 bit compare
    sub   ax, cx
    sbb   dx, bx
    jb    PseudoAtomicRead3
Exit:
    pop   es                      //Restore es
    ret

回复收藏 0 原文

赠意 2024-08-20 22:26:46

这是一个相当简单的示例，如果需要较长且不高精度的延迟，则该示例应该可以工作。

要使用该延迟，请以 AX 为单位以 125 毫秒为增量指定延迟。

;----------------------------------------------------------------------------;
; Simple delay based on PIT timer ticks
;----------------------------------------------------------------------------;
; Input: AX = delay_time in 1/8th of a second (~125ms) increments
;----------------------------------------------------------------------------;
DELAY_TIMER PROC
    STI                             ; ensure interrupts are on
    PUSH    CX                      ; call-preserve CX and DS (if needed)
    PUSH    DS
    MOV     CX, 40H                 ; set DS to BIOS Data Area
    MOV     DS, CX
    MOV     CX, 583                 ; delay_factor = 1/8 * 18.2 * 256
    MUL     CX                      ; AH (ticks) = delay_time * delay_factor
    XOR     CX, CX                  ; CX = 0
    MOV     CL, AH                  ; CX = # of ticks to wait
    MOV     AH, BYTE PTR DS:[6CH]   ; get starting tick counter
TICK_DELAY:
    HLT                             ; wait for any interrupt
    MOV     AL, BYTE PTR DS:[6CH]   ; get current tick counter
    CMP     AL, AH                  ; still the same?
    JZ      TICK_DELAY              ; loop if the same
    MOV     AH, AL                  ; otherwise, save new tick value to AH
    LOOP    TICK_DELAY              ; loop until # of ticks (CX) has elapsed
    POP     DS
    POP     CX
    RET
DELAY_TIMER ENDP

下面是一个“睡眠”1/2 秒的示例：

MOV     AX, 4                       ; delay for 1/2 seconds (4 * 1/8 seconds)
CALL    IO_DELAY_TIMER

这有点“非阻塞”，因为它会在滴答之间停止 CPU。在单用户 DOS 上运行的真实硬件上，这当然不是问题，但在 VM/Windows 环境中，它可能会使其成为更好的邻居。

Here's a fairly simple example that should work if a long, not highly precise delay is needed.

To use, specify the delay in AX in 125ms increments.

;----------------------------------------------------------------------------;
; Simple delay based on PIT timer ticks
;----------------------------------------------------------------------------;
; Input: AX = delay_time in 1/8th of a second (~125ms) increments
;----------------------------------------------------------------------------;
DELAY_TIMER PROC
    STI                             ; ensure interrupts are on
    PUSH    CX                      ; call-preserve CX and DS (if needed)
    PUSH    DS
    MOV     CX, 40H                 ; set DS to BIOS Data Area
    MOV     DS, CX
    MOV     CX, 583                 ; delay_factor = 1/8 * 18.2 * 256
    MUL     CX                      ; AH (ticks) = delay_time * delay_factor
    XOR     CX, CX                  ; CX = 0
    MOV     CL, AH                  ; CX = # of ticks to wait
    MOV     AH, BYTE PTR DS:[6CH]   ; get starting tick counter
TICK_DELAY:
    HLT                             ; wait for any interrupt
    MOV     AL, BYTE PTR DS:[6CH]   ; get current tick counter
    CMP     AL, AH                  ; still the same?
    JZ      TICK_DELAY              ; loop if the same
    MOV     AH, AL                  ; otherwise, save new tick value to AH
    LOOP    TICK_DELAY              ; loop until # of ticks (CX) has elapsed
    POP     DS
    POP     CX
    RET
DELAY_TIMER ENDP

Here is an example to "sleep" for 1/2 second:

MOV     AX, 4                       ; delay for 1/2 seconds (4 * 1/8 seconds)
CALL    IO_DELAY_TIMER

This is somewhat "non-blocking" as it will halt the CPU between ticks. It would of course be a non-issue on real hardware running on single-user DOS, but in a VM/Windows environment it might make it a better neighbor.

回复收藏 0 原文