Discussion :

[ShaiLeTroll]

Bonjour,

Je faisais une recherche ici sur NexusMM et j'ai pas trouvé mieux que mon sujet Mesurer un temps d'éxécution - Incertitude qui n'était qu'un problème d'option d'alimentation, un Desktop configuré en mode économie d'énergie ...

Quelqu'un a-t-il utilisé NexusMM ?
Pas NexusDB qui est le produit parent mais juste son Memory Manager.
J'ai trouvé des articles de plus de dix ans, c'est pas bien folichon, surtout que depuis le 64Bits, les multi-coeur, HT, l'OS ... cela a un peu évolué.
On trouve des projets de comparaison mais tout ça étant très expérimental (comme celui de ScaleMM), difficile de l'appliquer à ses propres utilisations.

Je reprends mon programme de Tests divers (SQL Server, Manipulation de Chaine, ... en attendant de mettre un DUnit pour assurer les non-regressions des Refactoring) et un outil de Diagnostic interne (CPU, Mémoire, Thread) initialement prévu pour vérifier si nos clients nous fournissent une machine digne de ce nom pour faire un serveur.
Je voudrais fusionner tout ça, l'automatiser, le scénariser par fichier de configuration pour le laisser tourner la nuit, voire même si j'en ai la possibilité sur des serveurs similaires à la PROD.

Avec le confinement, j'ai en plus deux machines, mon Portable et le Distant pour comparer.

Pour le moment

Default* MM vs Nexus MM
10-20% plus rapide pour Delphi sauf les gros blocs où Nexus est bien 80% plus rapide.
Je vais varier mes tests, GetMem, New, Create, String vs WideString, SetLength ... mais aussi allocation directe sur l'OS.
Car j'ai observé parfois des gains de 40% en revenant sur le MM de D10
J'ai l'impression que l'on a plus besoin de petits et moyens blocs dans ce que j'ai pu observé que de gros blocs, alors ce n'est pas en faveur de NexusMM
Par contre, je bosse sur les mesures des Threads, que ce soit en simultané, les sections critiques et tout ça, j'avoue, c'est très empirique, je fais ça un peu au pif (si certains ont des conseils)

* Default MM ou autrement nommé FastMM "Version RTL"
Je chercherais si il existe encore FastMM4 dans sa version complète (et pas la version minimale de Delphi)
Exemple de fonctionnalité perdue : les fuites mémoire en fichier c'est mieux pour récupérer le log dans un Service au lieu du ShowMessage qui plante à 32Ko de message
Car oui, provoquer volontairement une fuite mémoire permet aussi d'observer le comportement que l'on souhaite éviter et donc le reconnaitre lorsqu'il est involontaire.

Evidemment, un NexusMM à jour sera aussi confronté.
J'ai connu ou juste survolé en 2003, 2007, 2010 sur D3 à D7 comme bucketMem de Robert Houdart puis en XE2 plus récemment SapMM et j'ai souvenir d'autres bricolages plus ou moins efficaces.
Tout ça à titre personnel par curiosité pour améliorer mes programmes, c'est bien la première fois que l'on me demande ce travail et où je vise une qualité professionnelle, mon nouveau responsable est soucieux de l'efficience du code, de sa simplicité et de son utilité.

Déjà, je sais que l'on ne peut pas généraliser un MM, à l'époque de D7, j'ai écrit des fonctions sur l'ancien MM de Borland qui lui était adapté et donc plus rapide que sur FastMM, mais dont le code était affreusement compliqué.
Je teste le comportement du MM aussi dans une DLL, voir si cela a un impact, voir si l'on peut donc modulariser et profiter dans certains cas des qualités de l'un ou l'autre.

Si certains d'entre vous ont déjà mené ce travail vraiment sérieusement, je suis à l'écoute d'idée et de scénario de mesure.

Merci

[ShaiLeTroll]

Que pensez vous de ce passage de 32Bits à 64Bits ?
Avez-vous des résultats cohérents ?
Personnellement sur un i7 2,6 et un i7 3,6 : c'est OK,
utilisant ces deux PC pour les comparaisons, je constate à quel point la vitesse du CPU influence mes tests, on est presque exactement au même ratio Temps vs Fréquence.

Pour les curieux cf IsProcessorFeaturePresent PF_RDTSC_INSTRUCTION_AVAILABLE, RDTSC qui est un peu vieux truc, QueryPerfomanceCounter faisant un travail similaire

32Bits (Delphi 3 )

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
 
function GetCPUSpeed: Double;
const
  DelayTime = 500;
var
  TimerHi, TimerLo: DWORD;
  PriorityClass, Priority: Integer;
begin
  PriorityClass := GetPriorityClass(GetCurrentProcess);
  Priority      := GetThreadPriority(GetCurrentThread);
 
  SetPriorityClass(GetCurrentProcess, REALTIME_PRIORITY_CLASS);
  SetThreadPriority(GetCurrentThread, THREAD_PRIORITY_TIME_CRITICAL);
 
  Sleep(10);
  asm
    dw 310Fh
    mov TimerLo, eax
    mov TimerHi, edx
  end;
  Sleep(DelayTime);
  asm
    dw 310Fh
    sub eax, TimerLo
    sbb edx, TimerHi 
    mov TimerLo, eax
    mov TimerHi, edx
  end;
 
  SetThreadPriority(GetCurrentThread, Priority);
  SetPriorityClass(GetCurrentProcess, PriorityClass);
 
  Result := TimerLo / (1000 * DelayTime);
end;
 
...
MemoMemoire.Lines.Add(Format('~ %.1f MHz', [GetCPUSpeed()]));
...

64Bits (Delphi 23 / 10.0, j'ai changé d'unité du Mhz au Ghz)

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
 
//------------------------------------------------------------------------------
procedure TTestPerformanceExtensionPlugInEvaluationMMCPU.ExecuteSpeedMetrics(AEventSink: TTestPerformanceExtensionPlugInEventSink);
 
  // Tout simplement le code de https://fr.wikipedia.org/wiki/RDTSC adapté au 64 Bits
  function RDTSC(): Comp;
  var
    CompRec: record case Byte of
               1: (Whole: Comp);
               2: (Lo, Hi: Longint);
             end;
  asm
    rdtsc // dw 310Fh, l'ASM Delphi connait le mnémonique désormais
    mov [CompRec.Lo], eax // On Intel 64 architecture, the high-order 32 bits of RAX and RDX are cleared, on pourrait tricher et ne récupérer que EAX mais il y a un risque infinitésimal de tomber au moment du "32bits overflow" 
    mov [CompRec.Hi], edx
    mov rax, [CompRec.Comp] // ou mov rax, [rbp+$08]
  end;
 
  function GetCPUSpeed(): Double;
  const
    DelayTime = 500;
  var
    TickStart, TickEnd: Comp;
    PriorityClass, Priority: Integer;
  begin
    PriorityClass := GetPriorityClass(GetCurrentProcess);
    Priority      := GetThreadPriority(GetCurrentThread);
 
    SetPriorityClass(GetCurrentProcess, REALTIME_PRIORITY_CLASS);
    SetThreadPriority(GetCurrentThread, THREAD_PRIORITY_TIME_CRITICAL);
 
    Sleep(10);
    TickStart := RDTSC();
    Sleep(DelayTime);
    TickEnd := RDTSC();
 
    SetThreadPriority(GetCurrentThread, Priority);
    SetPriorityClass(GetCurrentProcess, PriorityClass);
 
    Result := (TickEnd - TickStart) / (1000000 * DelayTime);
  end;
 
begin
  AEventSink.Comment(Format('~ %.2f GHz', [GetCPUSpeed()]));
end;