Particularité de la function Sleep

**DarkVader** · 09/03/2009, 14h13

Bonjour,
Il semble que les fonctions Sleep et SleepEx ne soient pas linéaires !!!
Cela n'est pas très important dans le cas d'un appel unique en utilisant un délai long
mais peu poser problème lors d'appels répétifs avec un délai court pour peu le temps cumulé doit correspondre à une valeur recherchée.

Afin d'identifier d'éventuelles différences en fonctions de la machine utilisée
(ce dont je doute, il est plus probable que ce soit une particularité liée au développement des fonctions)
il serait intéressant d'exécuter le code ci-dessous sur différentes machines puis coller dans ce thread les résultats en indiquant l'os utilisée.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
Option Explicit
 
    Private Type LARGE_INTEGER
        LowPart As Long
        HighPart As Long
    End Type
    Private Declare Function QueryPerformanceCounter Lib "kernel32" (lpPerformanceCount As LARGE_INTEGER) As Long
    Private Declare Function QueryPerformanceFrequency Lib "kernel32" (lpFrequency As LARGE_INTEGER) As Long
    Private Declare Sub CopyMemory Lib "kernel32.dll" Alias "RtlMoveMemory" (Destination As Any, Source As Any, ByVal Length As Long)
 
 
    Private Declare Sub Sleep Lib "kernel32" (ByVal dwMilliseconds As Long)
    Private Declare Function SleepEx Lib "kernel32" (ByVal dwMilliseconds As Long, ByVal bAlertable As Long) As Long
 
 
 
    Private Sub Command1_Click()
        Dim x As Long, y As Long, ret As String, t As Currency
        Dim frequency As Currency, liStart As LARGE_INTEGER, liStop As LARGE_INTEGER, cStart As Currency, cStop As Currency
 
        Const k0 As Long = 0
        Const k1 As Long = 250
 
 
Me.ProgressBar1.Min = k0
Me.ProgressBar1.Max = k1
 
        frequency = GetFrequency()
        If frequency <> 0 Then
            For x = k0 To k1
                QueryPerformanceCounter liStart
                    SleepEx x, False
                QueryPerformanceCounter liStop
                cStart = LargeInteger2Currency(liStart)
                cStop = LargeInteger2Currency(liStop)
                t = (cStop - cStart) / frequency
 
                ret = ret & IIf(ret <> "", vbCrLf, "") & x & vbTab & t
Me.ProgressBar1.Value = x
            Next
        End If
 
            Clipboard.Clear
            Clipboard.SetText vbtab & frequency & vbCrLf & ret
 
        MsgBox "Test End"
        Unload Me
    End Sub
 
                Private Function GetFrequency() As Currency
                    Dim liFrequency As LARGE_INTEGER
 
                    If QueryPerformanceFrequency(liFrequency) <> 0 Then GetFrequency = LargeInteger2Currency(liFrequency)
                End Function
                Private Function LargeInteger2Currency(liInput As LARGE_INTEGER) As Currency
                    CopyMemory LargeInteger2Currency, liInput, LenB(liInput)
                    LargeInteger2Currency = LargeInteger2Currency * 10000
                End Function

Le code est à exécuter depuis une feuille contenant un bouton de commande et un progressbar.
Il demande autant de temps d'exécution (environ 30") en runtime ou compilé.

Le résultat se trouvant dans le presse papier, il suffit d'effectuer un ctrl V pour le coller et indiquer l'OS utilisé.
Merci de votre concours.

**littledoudou** · 09/03/2009, 14h34

bonjour DarkVader,

PC: Athlon X2 4000+ 2.1GHz - 960Mo RAM
OS: Microsoft Windows XP Pro v2002 SP3
Kernel32: 5.1.2600.5512

cdlt,

**DarkVader** · 09/03/2009, 14h43

Merci,
Je développerais plus tard les résultats.

**jbrasselet** · 09/03/2009, 14h53

OS : Microsoft Windows XP SP3
P8400 2,26GHz 1,95 Go de RAM
Version kernel 32 : 5.1.2600.5512

Résultat en PJ

**Delbeke** · 09/03/2009, 14h55

XP pro version 2002 SP3
pentium 4, 3 Ghz, 860 Mo Ram

**DarkVader** · 09/03/2009, 15h48

Chacun peut-il préciser sa version de kernel32 ?

**jbrasselet** · 09/03/2009, 16h00

Mis à jour dans mon message précédent

**DarkVader** · 09/03/2009, 16h06

Merci,
J'ai cru un instant que le défaut était lié au processeur AMD mais comme Delbeke a également un Pentium, je sèche.
Tu es le seul d'entre nous pour l'instant pour lequel Sleep est linéaire

**DarkVader** · 09/03/2009, 16h48

Afin de mieux comprendre mon soucis, sur 4 tests,
3 retournent une fonction non linéaires
contrairement au test effectué par jbrasselet pour lequel Sleep est linéaire !!!

Autres intervenants, bienvenus.

**jbrasselet** · 09/03/2009, 17h09

Faut toujours que je me démarque

Blague mis à part, une des grosses différences est la RAM. Cela pourrait jouer?

**DarkVader** · 09/03/2009, 17h18

Non,
j'ai un Phenom II quad core avec 2 go de ram et je ne suis pas du bon coté de la force lol.

A mon avis,c'est
soit la version de kernel,
soit les instructions spécifiques du cpu (Delbeke ayant également un Pentium, j'en doute)
soit éventuellement la version (SP installé) de VB (ce dont je doute également puisque j'ai installé le SP6 et à moins d'un retour vers le futur ...)

**Delbeke** · 09/03/2009, 17h22

version de mon kernel32.dll
5.1.2600.5512 (xpsp.080413-2111)

**DarkVader** · 09/03/2009, 17h35

Comme jbrasselet, (ça aide 8) )

Sans t'offenser Delbeke, tu es sur du CPU utilisé (des fois que tu travailles sur plusieurs machines en même temps) ?

PS : En plus, cela m'arrangerait bien. lol

**Delbeke** · 09/03/2009, 17h42

Non, moi je suis pas sûr, j'ai demandé a windows de me le dire
Panneau config /Système, première page

**DarkVader** · 09/03/2009, 17h47

C'eusse pu t'être de tête 8)
Éventuellement, mais ne rêvons pas, une différence de version de NTDLL ?

**ucfoutu** · 09/03/2009, 20h30

Bonsoir,
et avant toute autre chose : l'affirmation de mon amitié envers chacun (cette affirmation/réaffirmation est nécessaire car je sais que je vais en faire hurler plus d'un...)

Ce genre de quête de linéarité est vain car entâché à plusieurs niveaux.

Il ressemble assez à celui d'une quête de démonstration de linéarité en ce qui concerne l'accélération dûe à la gravité terrestre.

Cette démonstration sera toujours possible dans le vide absolu mais jamais, en raison du nombre de "tares" diverses, si le vide n'est pas absolu.

Les tares ?
Elles sont nombreuses et sacrément présentes :
- temps de calcul de chaque fonction, chaque procédure
- fréquence de l'affichage
- temps requis par la progressbar

Comment parler de linéarité dans de telles conditions ("impures") ? il faudrait pouvoir isoler ces tares et les déduire des temps mesurés, dans le meilleur des cas.
Mais voilà ! une autre tare, plus insidieuse, celle-là, est également présente : l'état du processeur à un instant t et celui de la mémoire...

Voilà ...

Hurlez et maudissez-moi maintenant autant que vous voudrez. Défoulez_vous sans vergogne. Vous n'entâcherez pas mon amitié pour autant.

**DarkVader** · 09/03/2009, 21h51

Bonsoir UC
Si tu n'avais pas seulement survolé le sujet, tu aurais découvert que la fonction Sleep
évolue la plupart du temps non pas comme «fonction linéaire»
mais par paliers suivant les modes «15, 16, 15, 16, 16, 15, 16, 16, 15, 16, 15, 16, 16, 15, 16, 16 ...» ticks !!!
ce qui pour une fonction dont le pas devrait être le tick est des plus curieux.
En pratique, il découle que sleep 1 ou sleep 15 est la même chose, sleep 16 ou 31 etc.

Coté précision des données linéaires fournies pas jbrasselet, à part 2 valeurs,
celles-ci reproduisent la modélisation pour les valeurs>10 avec une précision moyenne de 0.33%, soit un coeff de corrélation très proche de 1.
D'autre part, je te signale que la charge due au code annexe peut être considéré comme nulle
sur des machines de dernières générations comme celles de Delbeke ou la mienne :
la précision des résultats de jbrasselet dont la machine reproduit environ 1000 fois moins de cycles à la seconde en est la preuve.

Coté pratique, mon problème était de reproduire une séquence d'affichage identique quelquesoit la machine ;
je me suis donc adapté en réévaluant le temps restant à chaque passe.
J'aurais toutefois apprécié de comprendre ce qui différenciait l'environnement de jbrasselet du notre.

PS: Un test de ta part aurait été le bienvenu.

**ucfoutu** · 09/03/2009, 22h10

Re, DarkVader,

Mais j'ai testé, et observé l'absence de linéarité (à laquelle je m'attendais avant même de tester, d'ailleurs...)

J'ai même testé en inhibant l'affichage, puis en supprimant carrément la progressbar (réduction des "tares"') : avec un résultat moins mauvais mais toujours non linéaire (je ne peux supprimer les calculs et le temps des fonctions et instructions !)

"peuvent être considérées comme nulles" est bien vite dit (tu l'as mesuré comment ? en absolu ou en relatif ?

)!

Alors ...

Voyons un peu ceci, qui, toutefois, ne prend pas en compte (peut pas simuler la chose) les variations d'état du processeur et de la mémoire entre 2 instants t :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
ma_tare = 3
mon_attente = 2
For i = 1 To 10
  List1.AddItem (i * mon_attente) + ma_tare
Next
MsgBox "on voit bien que le dernier article n'est pas égal au décuple du 1er (becauise la tare)"

Pour ton information : j'ai testé des dizaines de fois et envoyé (par acquit de conscience) vers plusieurs fichiers txt, que j'ai ensuite comparés :
Observation : à deux moments différents, les résultats ne sont pas les mêmes (pour les mêmes valeurs de x, pourtant).
Le plus surprenant, je te le concède, est de constater ici et là des "régressions" du genre :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

mais elles peuvent s'expliquer par la "tare insidieuse" résultat d'états différents du processeur et de la mémoire.

EDIT :
J'essaie simplement de te dire que tu te trouves face à une équation qui serait du genre :
Y = ax + tare_fixe + tare_aléatoire

Elle ne sera pas linéaire ... en raison de tare_aléatoire
Si tare_aléatoire était nulle (ou même fixe), on arriverait à une linéarité, mais à celle de
Y = ax + b
et non à celle de
y = ax

Re-EDIT :
Tiens...
Voyons donc de manière simple et claire ce que tu as choisi de considérer "comme "nul"
250 fois une division et une incrémentation de chaîne.
Je fais de surcroît la chose 10 fois (en envoyant vers une listbox les résultats... pour constater qu'ils ne sont bien évidemment pas toujours les mêmes ... (la tare aléatoire) ...)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
For essai = 1 To 10
 Dim debut As Long
 debut = Timer
 For i = 1 To 500
  aie = 10 / 100
  ret = ret & IIf(ret <> "", vbCrLf, "") & x & vbTab & t
 Next
 List1.AddItem Timer - debut
Next

voilà ...
ce n'est ni "considérable comme nul", ni même fixe ...

Edit (j'avais mis 250, mais viens de modifier à 500 pour ne pas que tu te méprennes sur le choix de ce chiffre...)

**ucfoutu** · 09/03/2009, 22h51

Bonsoir, progelect,

Voilà où s'est, chez toi, manifestée la "tare aléatoire" :

228 0,2283
229 0,4331
230 0,23
231 0,2313

Mais tu as dans l'ensemble un résultat meilleur que sur ma bécane.

**DarkVader** · 09/03/2009, 23h15

Envoyé par ucfoutu

Re, DarkVader,

Mais j'ai testé, et observé l'absence de linéarité (à laquelle je m'attendais avant même de tester, d'ailleurs...) .../..

Trop fort, tu es de Marseille ?

Bonsoir,

Envoyé par ProgElecT

Salut à tous
Oui en effet, de plus je viens de faire plusieurs séries, pas une d'identique, avec des écarts trés importants.
Sur ce bonsoir, je suivrais la suite demain.

Amuses-toi à comparer la série de la liste dont tu fournis le lien et celle de jbrasselet.

Il semble de plus en plus probable qu'il s'agit d'un jeu de composant hardware :
horloge carte mère ?

Particularité de la function Sleep

VB 6 et antérieur

Discussions similaires

Partager

Partager