Delay Probleme auf 1 GHz Rechner

[neolithos]

Ich habe versucht eine Delay-Funktion für eine schnellen Prozessor zu kreiren, doch habe ich Probleme mit der Routine "Calibrate_Delay", die scheinbar einen "sich verzählt" :?

Ich habe versucht die Routine DelayOneMs zu "strecken", da sonst ein 16 Bit Wert nicht ausreicht!

Code:

   ;***************************************
   ;   Delay-Funktionen
   ;***************************************

Delay:
   ;
   ;  Warte cx Millisekunden
   ;
    jcxz Delay_2      ; falls cx = 0 -> abbruch
Delay_1:
   call DelayOneMs
   loop Delay_1      ; Warte cx millisekunden
Delay_2:
   ret

DelayOneMs:               
   ;
   ; Warte für die Zeit einer Millisekunde
   ;
                     ; call = 19 TZ
   push cx               ; = 11 TZ

   mov cx, [wDelayOneMs]   ; = 8 TZ
DelayOneMs_1:
   push cx               ; = 11 TZ
   mov cx, 0FFFFh         ; = 8 TZ
DelayOneMs_2:
   nop                  ; = cx * 65536 * 3 TZ
   loop DelayOneMs_2      ; = cx * 65536 * 17 + 5 TZ
   pop cx               ; = cx * 5 TZ
   loop DelayOneMs_1      ; = cx * 17 + 5 TZ

   pop cx               ; = 8 TZ
   ret                  ; = 16 TZ
   ; TZ == 86 + cx * 65536 * 20

Calibrate_Delay:
   ;
   ; Initialisiert eine Millisekunde
   ;
   push ax
   push cx
   push dx
   push es   

   mov ax, 40h
   mov es, ax            ; es - Segment für BIOS-Datenbereich
   mov di, 6Ch            ; es:di zeigt auf Low-Wort des BIOS-Timer-Count

   mov [wDelayOneMs], WORD 1 ; Init
   mov ax, [es:di]         ; ax = Low-Wort des BIOS-Timer-Count
     
Calibrate_Delay_1:         ; Synchronisation mit System-Timer
   cmp ax, [es:di]         ; Hat sich der Wert geändert?
   je Calibrate_Delay_1   ; alter = neuer -> warte
   
   mov ax, [es:di]         ; Setze hin
     
   xor dx, dx
Calibrate_Delay_2:         ; Nun kann wDelayOneMS berechnet werden
   call DelayOneMs         ; Warte ein bißchen 200000 TZ
   inc dx               ; Inkrementier Schläfenzähler
   cmp ax,[es:di]         ; Hat sich der Wert geändert?
   je Calibrate_Delay_2
   
   ; in DX steht wert für 55ms
   mov ax, dx
   xor dx, dx
   mov bx, 55
   div bx
   
   mov [wDelayOneMs], ax   ; setze den Schleifenzähler
   
   pop es
   pop dx
   pop cx
   pop ax
   
   ret

wDelayOneMs:
   dw 0

Dieser Ausschnitt gehört zu einem Versuch von mir an meiner FH.
Dieses Programm lauft nur unter dem Basic Input Output System.
Es können demnach nur BIOS-Interrupts verwendet werden.

[negaH]

Hm, ich weiß nicht so recht. Obige Methode mag unter Realmode OS wie DOS noch funktionieren, aber unter PM Systemen eben nicht mehr. Zudem ist 1 Millisekunde auf heutigen Rechnern enorm viel Zeit. Zb. eine 2GHz CPU erledigt in 1 Millisekunde ca. 2.091.008 Instruktionen, das ist schon fast ein komplettes Program !! Deine Methode würde ja in einem Realtime Thread/Process laufen, und somit enorm viel Rechenzeit verschwenden.

Viel besser ist es dann anders vorzugehen. Man nimmt einen Realtime Thread/Process, ließt per QueryPerformanceCounter() den High Resolution Timer aus. Dieser hat eine Auflösung von QueryPerformanceFrequency() = min. 1,7 MHz. D.h. man kommt unter 1ms Auflösung. Nun wird der letzte Zeitpunkt in dem der Thread aufgerufen wurde zwischengespeichert. Beim erneuten Aufruf wird überprüft ob 1 ms vergangen ist. Falls ja führt der Thead seine Aktion aus und speichert den nächsten Zeitwert zwischen.

Denoch wird man niemals unter PM Systemen auf Anwendungsebene einen exakten Timer hinbekommen. Dies geht nur auf Treiberebene unter Verwendung von Interrupt gesteuerten Zeitgebern. Auch dann ist es noch fraglich ob die abzuarbeitene Routine tatsächlich zeitsynchron laufen kann. Denn diese Routine ist dann immer noch dem Tasksheduller vom OS abhängig. Es spielt hier keine Rolle ob man Windows oder Linux oder Unix betrachtet. KEINES dieser Betriebssysteme ist technisch gesehen in der Lage echte Echtzeit zu ermöglichen. Auch wenn man von Linux/Unix desöfteren anderes hören mag, es gibt keine Echtzeit Betriebsysteme, denn Echtzeit würde bedeuten das der Rechner unendlich schnell getaktet sein müsste, eben in Echtzeit. Selbst der Mensch denkt nur im Millisekunden Bereich schnell.

Gruß Hagen

[neolithos]

Vielleicht habe ich es nicht deutlich gesagt

aber

das Programm läuft nur unter dem BIOS, kein Windows, kein DOS und auch sonst kein "höherwertiges" Betriebssystem!

[negaH]

Hm, muß ich wohl überlesen haben, wer arbeitet heute noch nur mit dem BIOS.

Ich kenne eigentlich kein BIOS das den Protected Mode startet, obwohl die neueren BIOS'e alle den PM unterstützen.

D.h. obiger Code sollte dann auch funktionieren. Allerdings ist mir nicht ganz klar wie du dann ohne OS überhaupt arbeiten kannst ?? Was für eine Rechnerarchitektur liegt denn vor ??

Gruß Hagen

[neolithos]

Das ist ein Versuch im Fach Rechnerarchitektur an meiner Hochschule!

Dabei habe ich ergründet wie ein PC - Bootet. Als beweiß für meine Thesen habe ich dieses Programm entworfen. Was direkt nach dem BIOS geladen wird! Quasi als Betriebssystem!

Das ganze hat NIX mit Protected Mode zu tun! Es ist noch guter alter 16 Bit-Code. Das Program selbst hat eine einfache Menüsteuerung und kann via Serieller Schnittstelle Daten an einen anderen PC übertragen.

Das ganze Programm hat meinen RA-Prof. so beeindruckt das ich es so umgeschalten musste, das noch andere Studenten es für weiter Untersuchungen an der Hardware anpassen können.

Eve. CMOS-, PCI-Auslesen (das geht mich aber nix mehr an, dafür haben wir einen anderen Speziallisten) und via Serielle-Schnittstelle übertragen.

Bei der Anpassung wollte ich die Delay-Funktion von den Fixen Werten, die ich vorgegeben hatte, wegbringen, leider ist mir das bis heute noch nicht gelungen!

Wie kann ich nun so eine Funktion realisieren?
Bzw. diese Funktionsfähig gestalten?

[negaH]

Naja, dann ist die pragmatische Lösung doch einfach.

Du hast eine Delay Procedure die 65.534 Millisekunden warten kann, also ca. 65 Sekunden. Ich würde nun eine zweite Delay Funktion basteln die im Sekunden Bereich warten kann. Diese ruft intern die Millisekunden Delay Procedure auf mit einem Wert von 1000 ms. Dies wäre der pragmatische Weg.
Eine andere Lösunf sähe so aus das deine Funktion von 16 Bit auf 32 Bit umgebaut werden müsste. Im Register ECX also 32 Bit benutzt.

Delphi-Quellcode:

   
Delay_1: 
   dec  ecx
   jl   Delay_2                 // ecx < 0 ?? then return
   push offset Delay_1          // return address of DelayOneMs to Delay_1
   jmp  DelayOneMs              // instead of Delay_2 if call where used
Delay_2: 
   ret

Gruß Hagen