Je réalise un émulateur de Z80.
Mon problème est de ralentir la vitesse d'execution (d'ou le titre) car
sur mon
Duron 800, le Z80 fait du ...20 MHz, et le temps de traitement n'est pas
en relation avec le nombre de cycle de l'instruction réelle.
Entre chaque execution d'une instruction émulée, j'envisage une
synchronisation
avec un timer calé à la fréquence désirée.
Comment coder cela en C (Visual C, pas C++) sous W2000 ?
D'autres suggestions de solutions ?
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Emmanuel Delahaye
In 'fr.comp.lang.c', pthfndr wrote:
Je réalise un émulateur de Z80. Mon problème est de ralentir la vitesse d'execution (d'ou le titre) car sur mon Duron 800, le Z80 fait du ...20 MHz, et le temps de traitement n'est pas en relation avec le nombre de cycle de l'instruction réelle. Entre chaque execution d'une instruction émulée, j'envisage une synchronisation avec un timer calé à la fréquence désirée. Comment coder cela en C (Visual C, pas C++) sous W2000 ? D'autres suggestions de solutions ?
Il est quasiment impossible de simuler une horloge à 20 MHz sans artifice matériel extérieur. A moins que le Timer Multi Média de Windows sache faire ça: news:fr.comp.os.ms-windows.programmation
-- -ed- [remove YOURBRA before answering me] The C-language FAQ: http://www.eskimo.com/~scs/C-faq/top.html <blank line> FAQ de f.c.l.c : http://www.isty-info.uvsq.fr/~rumeau/fclc/
In 'fr.comp.lang.c', pthfndr <pthfndr@wanadoo.fr> wrote:
Je réalise un émulateur de Z80.
Mon problème est de ralentir la vitesse d'execution (d'ou le titre) car
sur mon
Duron 800, le Z80 fait du ...20 MHz, et le temps de traitement n'est pas
en relation avec le nombre de cycle de l'instruction réelle.
Entre chaque execution d'une instruction émulée, j'envisage une
synchronisation
avec un timer calé à la fréquence désirée.
Comment coder cela en C (Visual C, pas C++) sous W2000 ?
D'autres suggestions de solutions ?
Il est quasiment impossible de simuler une horloge à 20 MHz sans artifice
matériel extérieur. A moins que le Timer Multi Média de Windows sache faire
ça: news:fr.comp.os.ms-windows.programmation
--
-ed- emdelYOURBRA@noos.fr [remove YOURBRA before answering me]
The C-language FAQ: http://www.eskimo.com/~scs/C-faq/top.html
<blank line>
FAQ de f.c.l.c : http://www.isty-info.uvsq.fr/~rumeau/fclc/
Je réalise un émulateur de Z80. Mon problème est de ralentir la vitesse d'execution (d'ou le titre) car sur mon Duron 800, le Z80 fait du ...20 MHz, et le temps de traitement n'est pas en relation avec le nombre de cycle de l'instruction réelle. Entre chaque execution d'une instruction émulée, j'envisage une synchronisation avec un timer calé à la fréquence désirée. Comment coder cela en C (Visual C, pas C++) sous W2000 ? D'autres suggestions de solutions ?
Il est quasiment impossible de simuler une horloge à 20 MHz sans artifice matériel extérieur. A moins que le Timer Multi Média de Windows sache faire ça: news:fr.comp.os.ms-windows.programmation
-- -ed- [remove YOURBRA before answering me] The C-language FAQ: http://www.eskimo.com/~scs/C-faq/top.html <blank line> FAQ de f.c.l.c : http://www.isty-info.uvsq.fr/~rumeau/fclc/
pthfndr
In 'fr.comp.lang.c', pthfndr wrote:
Je réalise un émulateur de Z80. Mon problème est de ralentir la vitesse d'execution (d'ou le titre) car sur mon Duron 800, le Z80 fait du ...20 MHz, et le temps de traitement n'est pas en relation avec le nombre de cycle de l'instruction réelle. Entre chaque execution d'une instruction émulée, j'envisage une synchronisation avec un timer calé à la fréquence désirée. Comment coder cela en C (Visual C, pas C++) sous W2000 ? D'autres suggestions de solutions ?
Il est quasiment impossible de simuler une horloge à 20 MHz sans artifice matériel extérieur. A moins que le Timer Multi Média de Windows sache faire ça: news:fr.comp.os.ms-windows.programmation
-- -ed- [remove YOURBRA before answering me] The C-language FAQ: http://www.eskimo.com/~scs/C-faq/top.html <blank line> FAQ de f.c.l.c : http://www.isty-info.uvsq.fr/~rumeau/fclc/
Je me suis mal exprimé :
Je veux émuler un Z80 à 5 MHz. Chaque cycle d'horloge vaut donc 1/5*10**6 seconde soit 0.2 microseconde. Si je fais "émuler" mon émulateur sans controle , la vitesse équivaut à un processeur tournant à 20 MHZ ( je cherche l'exactitude en temps, à disons 10 % près). La question est donc de stopper l'émulateur (par un wait ?) le temps d'un cycle d'horloge (0.2 us) mais en y retranchant la durée qu'a déjà consommé l'émulation de l'instruction. Peut-on générer sous windows des durées si courtes (2/10 de us) ? Je vois cela comme ça :
Mais on doit pouvoir, au lieu du while{;} faire un wait() ou suspend() et redémarrer le process par un timer, non ?
Merci pour vos conseils et expertises en matière d'émulations et de temps réel.
Pthfndr.
In 'fr.comp.lang.c', pthfndr <pthfndr@wanadoo.fr> wrote:
Je réalise un émulateur de Z80.
Mon problème est de ralentir la vitesse d'execution (d'ou le titre) car
sur mon
Duron 800, le Z80 fait du ...20 MHz, et le temps de traitement n'est pas
en relation avec le nombre de cycle de l'instruction réelle.
Entre chaque execution d'une instruction émulée, j'envisage une
synchronisation
avec un timer calé à la fréquence désirée.
Comment coder cela en C (Visual C, pas C++) sous W2000 ?
D'autres suggestions de solutions ?
Il est quasiment impossible de simuler une horloge à 20 MHz sans artifice
matériel extérieur. A moins que le Timer Multi Média de Windows sache faire
ça: news:fr.comp.os.ms-windows.programmation
--
-ed- emdelYOURBRA@noos.fr [remove YOURBRA before answering me]
The C-language FAQ: http://www.eskimo.com/~scs/C-faq/top.html
<blank line>
FAQ de f.c.l.c : http://www.isty-info.uvsq.fr/~rumeau/fclc/
Je me suis mal exprimé :
Je veux émuler un Z80 à 5 MHz.
Chaque cycle d'horloge vaut donc 1/5*10**6 seconde soit 0.2
microseconde.
Si je fais "émuler" mon émulateur sans controle , la vitesse équivaut à
un processeur
tournant à 20 MHZ ( je cherche l'exactitude en temps, à disons 10 %
près).
La question est donc de stopper l'émulateur (par un wait ?) le temps
d'un cycle d'horloge
(0.2 us) mais en y retranchant la durée qu'a déjà consommé l'émulation
de l'instruction.
Peut-on générer sous windows des durées si courtes (2/10 de us) ?
Je vois cela comme ça :
Je réalise un émulateur de Z80. Mon problème est de ralentir la vitesse d'execution (d'ou le titre) car sur mon Duron 800, le Z80 fait du ...20 MHz, et le temps de traitement n'est pas en relation avec le nombre de cycle de l'instruction réelle. Entre chaque execution d'une instruction émulée, j'envisage une synchronisation avec un timer calé à la fréquence désirée. Comment coder cela en C (Visual C, pas C++) sous W2000 ? D'autres suggestions de solutions ?
Il est quasiment impossible de simuler une horloge à 20 MHz sans artifice matériel extérieur. A moins que le Timer Multi Média de Windows sache faire ça: news:fr.comp.os.ms-windows.programmation
-- -ed- [remove YOURBRA before answering me] The C-language FAQ: http://www.eskimo.com/~scs/C-faq/top.html <blank line> FAQ de f.c.l.c : http://www.isty-info.uvsq.fr/~rumeau/fclc/
Je me suis mal exprimé :
Je veux émuler un Z80 à 5 MHz. Chaque cycle d'horloge vaut donc 1/5*10**6 seconde soit 0.2 microseconde. Si je fais "émuler" mon émulateur sans controle , la vitesse équivaut à un processeur tournant à 20 MHZ ( je cherche l'exactitude en temps, à disons 10 % près). La question est donc de stopper l'émulateur (par un wait ?) le temps d'un cycle d'horloge (0.2 us) mais en y retranchant la durée qu'a déjà consommé l'émulation de l'instruction. Peut-on générer sous windows des durées si courtes (2/10 de us) ? Je vois cela comme ça :
En C standard, tu dois pouvoir émuler des trucs en 1 Hz, et encore...
Ivan Vecerina
"pthfndr" wrote in message news: | Je réalise un émulateur de Z80. | Mon problème est de ralentir la vitesse d'execution (d'ou le titre) car | sur mon | Duron 800, le Z80 fait du ...20 MHz, et le temps de traitement n'est pas | en relation avec le nombre de cycle de l'instruction réelle. | Entre chaque execution d'une instruction émulée, j'envisage une | synchronisation | avec un timer calé à la fréquence désirée. | Comment coder cela en C (Visual C, pas C++) sous W2000 ? | D'autres suggestions de solutions ?
Le C standard ne fournit pas un support tres valable pour une synchronisation precise -- Windows lui-même non plus, d'ailleurs. (il faut pas se faire trop d'illusion, avec le scheduleur de windows, il est deja bien difficile d'exécuter une tache ponctuellement toutes les 1 ou 2 ms).
Il n'est pas pratique de synchroniser chaque instruction. Cependant, tu pourrais faire tourner ton emulateur par lots de pex. 100'000 cycles, puis faire une pose de synchronisation (pour attendre la fin d'une période de 20ms). Ceci pourrait etre suffisant (sauf lors du controle direct d'un convertisseur DA en sortie -- genre son ou ecran -- mais une emulation specifique de ce HW pourrait prendre cela en compte).
En C standard, voir le header <ctime.h> Sous Win32, voir timeGetTime et QueryPerformanceTimer. Peut-etre meme utiliser qqch comme des evenements WM_TIMER...
Bonne route... Ivan -- http://www.post1.com/~ivec <> Ivan Vecerina
"pthfndr" <pthfndr@wanadoo.fr> wrote in message
news:3F56284C.AF7E3046@wanadoo.fr...
| Je réalise un émulateur de Z80.
| Mon problème est de ralentir la vitesse d'execution (d'ou le titre) car
| sur mon
| Duron 800, le Z80 fait du ...20 MHz, et le temps de traitement n'est pas
| en relation avec le nombre de cycle de l'instruction réelle.
| Entre chaque execution d'une instruction émulée, j'envisage une
| synchronisation
| avec un timer calé à la fréquence désirée.
| Comment coder cela en C (Visual C, pas C++) sous W2000 ?
| D'autres suggestions de solutions ?
Le C standard ne fournit pas un support tres valable pour une
synchronisation precise -- Windows lui-même non plus, d'ailleurs.
(il faut pas se faire trop d'illusion, avec le scheduleur de
windows, il est deja bien difficile d'exécuter une tache
ponctuellement toutes les 1 ou 2 ms).
Il n'est pas pratique de synchroniser chaque instruction. Cependant,
tu pourrais faire tourner ton emulateur par lots de pex. 100'000 cycles,
puis faire une pose de synchronisation (pour attendre la fin d'une
période de 20ms).
Ceci pourrait etre suffisant (sauf lors du controle direct d'un
convertisseur DA en sortie -- genre son ou ecran -- mais une emulation
specifique de ce HW pourrait prendre cela en compte).
En C standard, voir le header <ctime.h>
Sous Win32, voir timeGetTime et QueryPerformanceTimer.
Peut-etre meme utiliser qqch comme des evenements WM_TIMER...
Bonne route...
Ivan
--
http://www.post1.com/~ivec <> Ivan Vecerina
"pthfndr" wrote in message news: | Je réalise un émulateur de Z80. | Mon problème est de ralentir la vitesse d'execution (d'ou le titre) car | sur mon | Duron 800, le Z80 fait du ...20 MHz, et le temps de traitement n'est pas | en relation avec le nombre de cycle de l'instruction réelle. | Entre chaque execution d'une instruction émulée, j'envisage une | synchronisation | avec un timer calé à la fréquence désirée. | Comment coder cela en C (Visual C, pas C++) sous W2000 ? | D'autres suggestions de solutions ?
Le C standard ne fournit pas un support tres valable pour une synchronisation precise -- Windows lui-même non plus, d'ailleurs. (il faut pas se faire trop d'illusion, avec le scheduleur de windows, il est deja bien difficile d'exécuter une tache ponctuellement toutes les 1 ou 2 ms).
Il n'est pas pratique de synchroniser chaque instruction. Cependant, tu pourrais faire tourner ton emulateur par lots de pex. 100'000 cycles, puis faire une pose de synchronisation (pour attendre la fin d'une période de 20ms). Ceci pourrait etre suffisant (sauf lors du controle direct d'un convertisseur DA en sortie -- genre son ou ecran -- mais une emulation specifique de ce HW pourrait prendre cela en compte).
En C standard, voir le header <ctime.h> Sous Win32, voir timeGetTime et QueryPerformanceTimer. Peut-etre meme utiliser qqch comme des evenements WM_TIMER...
Bonne route... Ivan -- http://www.post1.com/~ivec <> Ivan Vecerina
pthfndr
pthfndr écrit:
Je me suis mal exprimé :
Tu as aussi posté dans le mauvais groupe.
Je veux émuler un Z80 à 5 MHz.
En C standard, tu dois pouvoir émuler des trucs en 1 Hz, et encore...
Bonsoir,
Pourquoi en "C standard" on ne peut émuler qu'à 1 Hz, et encore ?
Quel rapport entre un langage de programmation et une limitation temporelle ou
intrinsèque ?
Merci de m'éclairer.
Cordialement.
pthfndr <pthfndr@wanadoo.fr> écrit:
Je me suis mal exprimé :
Tu as aussi posté dans le mauvais groupe.
Je veux émuler un Z80 à 5 MHz.
En C standard, tu dois pouvoir émuler des trucs en 1 Hz, et encore...
Bonsoir,
Pourquoi en "C standard" on ne peut émuler qu'à 1 Hz, et encore ?
Quel rapport entre un langage de programmation et une limitation
temporelle ou
En C standard, tu dois pouvoir émuler des trucs en 1 Hz, et encore...
Bonsoir,
Pourquoi en "C standard" on ne peut émuler qu'à 1 Hz, et encore ?
Quel rapport entre un langage de programmation et une limitation temporelle ou
intrinsèque ?
Merci de m'éclairer.
Cordialement.
pthfndr
"pthfndr" wrote in message news: | Je réalise un émulateur de Z80. | Mon problème est de ralentir la vitesse d'execution (d'ou le titre) car | sur mon | Duron 800, le Z80 fait du ...20 MHz, et le temps de traitement n'est pas | en relation avec le nombre de cycle de l'instruction réelle. | Entre chaque execution d'une instruction émulée, j'envisage une | synchronisation | avec un timer calé à la fréquence désirée. | Comment coder cela en C (Visual C, pas C++) sous W2000 ? | D'autres suggestions de solutions ?
Le C standard ne fournit pas un support tres valable pour une synchronisation precise -- Windows lui-même non plus, d'ailleurs. (il faut pas se faire trop d'illusion, avec le scheduleur de windows, il est deja bien difficile d'exécuter une tache ponctuellement toutes les 1 ou 2 ms).
Il n'est pas pratique de synchroniser chaque instruction. Cependant, tu pourrais faire tourner ton emulateur par lots de pex. 100'000 cycles, puis faire une pose de synchronisation (pour attendre la fin d'une période de 20ms). Ceci pourrait etre suffisant (sauf lors du controle direct d'un convertisseur DA en sortie -- genre son ou ecran -- mais une emulation specifique de ce HW pourrait prendre cela en compte).
En C standard, voir le header <ctime.h> Sous Win32, voir timeGetTime et QueryPerformanceTimer. Peut-etre meme utiliser qqch comme des evenements WM_TIMER...
Bonne route... Ivan -- http://www.post1.com/~ivec <> Ivan Vecerina
Merci pour la piste du QueryPerformanceTimer. qui semble être confirmée par ailleurs.
Bon vent... Pthfndr.
"pthfndr" <pthfndr@wanadoo.fr> wrote in message
news:3F56284C.AF7E3046@wanadoo.fr...
| Je réalise un émulateur de Z80.
| Mon problème est de ralentir la vitesse d'execution (d'ou le titre) car
| sur mon
| Duron 800, le Z80 fait du ...20 MHz, et le temps de traitement n'est pas
| en relation avec le nombre de cycle de l'instruction réelle.
| Entre chaque execution d'une instruction émulée, j'envisage une
| synchronisation
| avec un timer calé à la fréquence désirée.
| Comment coder cela en C (Visual C, pas C++) sous W2000 ?
| D'autres suggestions de solutions ?
Le C standard ne fournit pas un support tres valable pour une
synchronisation precise -- Windows lui-même non plus, d'ailleurs.
(il faut pas se faire trop d'illusion, avec le scheduleur de
windows, il est deja bien difficile d'exécuter une tache
ponctuellement toutes les 1 ou 2 ms).
Il n'est pas pratique de synchroniser chaque instruction. Cependant,
tu pourrais faire tourner ton emulateur par lots de pex. 100'000 cycles,
puis faire une pose de synchronisation (pour attendre la fin d'une
période de 20ms).
Ceci pourrait etre suffisant (sauf lors du controle direct d'un
convertisseur DA en sortie -- genre son ou ecran -- mais une emulation
specifique de ce HW pourrait prendre cela en compte).
En C standard, voir le header <ctime.h>
Sous Win32, voir timeGetTime et QueryPerformanceTimer.
Peut-etre meme utiliser qqch comme des evenements WM_TIMER...
Bonne route...
Ivan
--
http://www.post1.com/~ivec <> Ivan Vecerina
Merci pour la piste du QueryPerformanceTimer. qui semble être confirmée
par ailleurs.
"pthfndr" wrote in message news: | Je réalise un émulateur de Z80. | Mon problème est de ralentir la vitesse d'execution (d'ou le titre) car | sur mon | Duron 800, le Z80 fait du ...20 MHz, et le temps de traitement n'est pas | en relation avec le nombre de cycle de l'instruction réelle. | Entre chaque execution d'une instruction émulée, j'envisage une | synchronisation | avec un timer calé à la fréquence désirée. | Comment coder cela en C (Visual C, pas C++) sous W2000 ? | D'autres suggestions de solutions ?
Le C standard ne fournit pas un support tres valable pour une synchronisation precise -- Windows lui-même non plus, d'ailleurs. (il faut pas se faire trop d'illusion, avec le scheduleur de windows, il est deja bien difficile d'exécuter une tache ponctuellement toutes les 1 ou 2 ms).
Il n'est pas pratique de synchroniser chaque instruction. Cependant, tu pourrais faire tourner ton emulateur par lots de pex. 100'000 cycles, puis faire une pose de synchronisation (pour attendre la fin d'une période de 20ms). Ceci pourrait etre suffisant (sauf lors du controle direct d'un convertisseur DA en sortie -- genre son ou ecran -- mais une emulation specifique de ce HW pourrait prendre cela en compte).
En C standard, voir le header <ctime.h> Sous Win32, voir timeGetTime et QueryPerformanceTimer. Peut-etre meme utiliser qqch comme des evenements WM_TIMER...
Bonne route... Ivan -- http://www.post1.com/~ivec <> Ivan Vecerina
Merci pour la piste du QueryPerformanceTimer. qui semble être confirmée par ailleurs.
Bon vent... Pthfndr.
Emmanuel Delahaye
In 'fr.comp.lang.c', pthfndr wrote:
Pourquoi en "C standard" on ne peut émuler qu'à 1 Hz, et encore ?
Le langage C dispose d'une bibliothèque standard qui permet de gerer le temps (en lecture seule) à la seconde près.
Quel rapport entre un langage de programmation et une limitation temporelle ou
intrinsèque ?
Merci de m'éclairer.
Il ne dispose ni de mécanisme d'interruption, ni de programmation de timer, ni de lecture du temps en-dessous d'une seconde. Pour tout ça, il faut des extensions non standard à discuter sur les forums adéquates.
Voilà pourquoi "Quel rapport entre un langage de programmation et une limitation temporelle ou intrinsèque ?"
-- -ed- [remove YOURBRA before answering me] The C-language FAQ: http://www.eskimo.com/~scs/C-faq/top.html <blank line> FAQ de f.c.l.c : http://www.isty-info.uvsq.fr/~rumeau/fclc/
In 'fr.comp.lang.c', pthfndr <pthfndr@wanadoo.fr> wrote:
Pourquoi en "C standard" on ne peut émuler qu'à 1 Hz, et encore ?
Le langage C dispose d'une bibliothèque standard qui permet de gerer le temps
(en lecture seule) à la seconde près.
Quel rapport entre un langage de programmation et une limitation
temporelle ou
intrinsèque ?
Merci de m'éclairer.
Il ne dispose ni de mécanisme d'interruption, ni de programmation de timer,
ni de lecture du temps en-dessous d'une seconde. Pour tout ça, il faut des
extensions non standard à discuter sur les forums adéquates.
Voilà pourquoi "Quel rapport entre un langage de programmation et une
limitation temporelle ou intrinsèque ?"
--
-ed- emdelYOURBRA@noos.fr [remove YOURBRA before answering me]
The C-language FAQ: http://www.eskimo.com/~scs/C-faq/top.html
<blank line>
FAQ de f.c.l.c : http://www.isty-info.uvsq.fr/~rumeau/fclc/
Pourquoi en "C standard" on ne peut émuler qu'à 1 Hz, et encore ?
Le langage C dispose d'une bibliothèque standard qui permet de gerer le temps (en lecture seule) à la seconde près.
Quel rapport entre un langage de programmation et une limitation temporelle ou
intrinsèque ?
Merci de m'éclairer.
Il ne dispose ni de mécanisme d'interruption, ni de programmation de timer, ni de lecture du temps en-dessous d'une seconde. Pour tout ça, il faut des extensions non standard à discuter sur les forums adéquates.
Voilà pourquoi "Quel rapport entre un langage de programmation et une limitation temporelle ou intrinsèque ?"
-- -ed- [remove YOURBRA before answering me] The C-language FAQ: http://www.eskimo.com/~scs/C-faq/top.html <blank line> FAQ de f.c.l.c : http://www.isty-info.uvsq.fr/~rumeau/fclc/
Jean-Marc
"pthfndr" a écrit:
Je réalise un émulateur de Z80. Mon problème est de ralentir la vitesse d'execution (d'ou le titre) car sur mon Duron 800, le Z80 fait du ...20 MHz, et le temps de traitement n'est pas en relation avec le nombre de cycle de l'instruction réelle. Entre chaque execution d'une instruction émulée, j'envisage une synchronisation avec un timer calé à la fréquence désirée. Comment coder cela en C (Visual C, pas C++) sous W2000 ? D'autres suggestions de solutions ?
Voilà un lien vers les sources (744Ko) d'un émulateur d'Atari ST du nom de WinSTone. Comme chacun sait, il émule le MC68000 à 8Mhz ainsi que pas mal de chispets périphériques (MFP, YM8149 ?, 6502, etc...). L'émulateur fonctionne sous windows. Tu trouveras peut-être une piste dans les sources.
Bon courage...
Page de description: http://atari.lautre.net/atari/emul/winston.htm#1
Je réalise un émulateur de Z80.
Mon problème est de ralentir la vitesse d'execution
(d'ou le titre) car sur mon Duron 800, le Z80 fait
du ...20 MHz, et le temps de traitement n'est pas
en relation avec le nombre de cycle de l'instruction réelle.
Entre chaque execution d'une instruction émulée, j'envisage une
synchronisation avec un timer calé à la fréquence désirée.
Comment coder cela en C (Visual C, pas C++) sous W2000 ?
D'autres suggestions de solutions ?
Voilà un lien vers les sources (744Ko) d'un émulateur
d'Atari ST du nom de WinSTone. Comme chacun sait, il émule
le MC68000 à 8Mhz ainsi que pas mal de chispets périphériques
(MFP, YM8149 ?, 6502, etc...). L'émulateur fonctionne sous
windows. Tu trouveras peut-être une piste dans les sources.
Bon courage...
Page de description:
http://atari.lautre.net/atari/emul/winston.htm#1
Je réalise un émulateur de Z80. Mon problème est de ralentir la vitesse d'execution (d'ou le titre) car sur mon Duron 800, le Z80 fait du ...20 MHz, et le temps de traitement n'est pas en relation avec le nombre de cycle de l'instruction réelle. Entre chaque execution d'une instruction émulée, j'envisage une synchronisation avec un timer calé à la fréquence désirée. Comment coder cela en C (Visual C, pas C++) sous W2000 ? D'autres suggestions de solutions ?
Voilà un lien vers les sources (744Ko) d'un émulateur d'Atari ST du nom de WinSTone. Comme chacun sait, il émule le MC68000 à 8Mhz ainsi que pas mal de chispets périphériques (MFP, YM8149 ?, 6502, etc...). L'émulateur fonctionne sous windows. Tu trouveras peut-être une piste dans les sources.
Bon courage...
Page de description: http://atari.lautre.net/atari/emul/winston.htm#1
