Tu souhaiterais:
Pouvoir évaluer le vitesse d'un processeur au MHz près ?
Savoir le nombre de microsecondes entre deux instants et donc laquel de tes 2 possibilités de code est la plus rapide ?
Pouvoir utiliser un Sleep précis à la microseconde ?
Executer un bout de code précisement 100000 fois par secondes quel que soit le processeur, et même si la vitesse de ce code peut varier d'une fois sur l'autre ?
Et que si le processeur soit incapable de le faire, tu sois au courant ?
Bah tu rêves pas: voilà une solution, et ultra simple d'emplois !
Ce source ne t'apprendras sûrement rien sur VB6, rien sur rien aussi: Il est juste là pour te fournir des routines de gestion du temps bien au dela des capacité de VB6.
Bon, la précision a la microseconde n'est pas toujours assurée: Il peut bien sûr arriver que Windows change de Trhead.
Mais on ne vas quand même pas empecher Windows de s'occuper de lui et des autres !
Si tu n'aimes pas lire, tu peux directement aller voire le code (Bien sûr, il y en plus dans le zip que ce que je donne ci-dessous).
Si tu veux plus d'infos:
Si tu as déjà essayer le contrôle Timer, tu sais que ses performances sont très loins de la milliseconde.
De même, l'API Sleep, bien que plus précise reste très peu performante dés que l'on s'approche des milisecondes.
Mes routines utilisent donc deux autres méthodes, infiniment plus précises:
1 Un compteur fourni par l'API Windows, dont la fréquence est indépendante de celle du processeur.
Ce compteur 64 bits est accessible via QueryPerformanceCounter et QueryPerformanceFrequency pour sa fréquence.
2 Le registre TSC, qui s'incrémente à chaque front d'horloge du processeur.
Mais la fréquence de certains processeurs (au moins les centrino) est variable.
En conséquence je n'utilise pas le registre TSC pour les routines de timer et les intervalles de temps.
On peut faire la plupart de mes routines en VB6, seulement, à ma connaissance VB6 ne prend pas en charge les entiers 64 bits.
Les dlls sont donc en Delphi7 qui prend en charge les entiers 64 bits, ainsi que l'assemblage en ligne, ce qui permet d'utiliser l'instruction assembleur RDTSC.
Le seul problème qu'il me reste est que je ne parviens toujours pas à bloquer au sens propre un trhead avec précision.
Conséquement, je les fais boucler sur un sleep(0) qui demande à Windows de s'occuper des autres trhead.
Mon timer et mon sleep ne libereront les ressources seulement pour des fréquence strictement inférieures à 200 Hz, et si le processeur est suffisement rapide.
En guise de libération, j'utilise Sleep(1) ou supérieur, c'est pour ça que je peux pas libérer à des fréquences supérieures.
Source / Exemple :
Public Declare Function GetCpuSpeed Lib "EX_Time.dll" Alias "EXtmr_GetCpuSpeed" (nBuffer As Long, ByVal lpEX As String) As Long
Public Declare Function GetCpuMaxSpeed Lib "EX_Time.dll" Alias "EXtmr_GetCpuMaxSpeed" (nBuffer As Long, ByVal lpEX As String) As Long
Public Declare Function Sleep Lib "EX_Time.dll" Alias "EXtmr_Sleep" (ByVal lpEX As String, Optional ByVal nTime As Long = 0) As Long
Public Declare Function InitDelta Lib "EX_Time.dll" Alias "EXtmr_InitDelta" (ByVal lpEX As String) As Long
Public Declare Function GetDelta Lib "EX_Time.dll" Alias "EXtmr_GetDelta" (nBuffer As Long, ByVal lpEX As String) As Long
Public Declare Function InitTimer Lib "EX_Time.dll" Alias "EXtmr_InitTimer" (ByVal lpEX As String, Optional ByVal nInterval As Long = 0) As Long
Public Declare Function Timer Lib "EX_Time.dll" Alias "EXtmr_Timer" (nBuffer As Long, ByVal lpEX As String) As Long
Public Declare Function InitDeltaClock Lib "EX_Time.dll" Alias "EXtmr_InitDeltaClock" (ByVal lpEX As String) As Long
Public Declare Function GetDeltaClock Lib "EX_Time.dll" Alias "EXtmr_GetDeltaClock" (nBuffer As Long, ByVal lpEX As String) As Long
Conclusion :
La fonction de calcul de la vitesse maximale du processeur est tirée d'un livre de Pierre Maurette.
GetCpuSpeed:
Renvoie la fréquence actuelle du processeur, en MHz.
Le calcul est rapide et la CPU ne monte pas à 100%.
On peut ainsi connaitre la fréquence actuelle d'un centrino (Elle varie beaucoup).
Sur un processeur à fréquence fixe, c'est cette fréquence qui est renvoyée.
GetCpuMaxSpeed:
Renvoie la fréquence (maximale) du processeur, en MHz.
Le calcul n'est pas instantané, et la CPU monte forcément à 100% de ses capacités.
Sleep:
Même fonction que sleep, mais en qui prend un argument en microsecondes.
Pour des intervalles supérieures à 5000 microsecondes la libération des ressources est réel.
Au dessous, la CPU mont à 100% sur un sleep(O), ce qui permet aux autres appplication de consommer pas mal de ressources.
InitDelta:
Initialise l'origine des temps.
GetDelta:
Renvoie le temps écoulé depuis l'origine des temps, en microsecondes.
Il est indispensable que l'origine des temps soit redéfinie toutes les demi-heures.
En effet: 2^32/2 microsecondes= 35 minutes.
InitTimer:
Initialise le timer.
Timer:
Il permet d'executer du code à une certaine fréquence.
Placé la fin du code à executé, elle calcul un temps envoyer au Sleep pour que le code dure toujours le même temps.
Elle renvoie le temps d'attente envoyé au sleep, négatif si le timer est en retard.
InitDeltaClock:
Initialise l'origine des fronts.
GetDeltaClock:
Renvoie le nombre de fronts de l'horloge du processeur ayant eu lieu depuis l'origine des fronts.
Renvoie 0 si il y a eu plus de 2^32/2 fronts (Sur un 3GHz, cela prend moins de 0,716 secondes).
Vous n'êtes pas encore membre ?
inscrivez-vous, c'est gratuit et ça prend moins d'une minute !
Les membres obtiennent plus de réponses que les utilisateurs anonymes.
Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.
Le fait d'être membre vous permet d'avoir des options supplémentaires.