begin process at 2012 05 27 18:37:56
  Trouver un code source :
 
dans
 
Accueil > 

Code

 > 

Système

 > MEMORYTEST

MEMORYTEST


 Information sur la source

Note :
5 / 10 - par 1 personne
5,00 / 10

  • 1

  • 2

  • 3

  • 4

  • 5

  • 6

  • 7

  • 8

  • 9

  • 10
Catégorie :Système Niveau :Débutant Date de création :17/10/2004 Date de mise à jour :21/05/2005 18:38:15 Vu :3 224

Auteur : RaphAstronome

Ecrire un message privé
Site perso
Commentaire sur cette source (25)
Ajouter un commentaire et/ou une note

 Description

MemoryTest : teste la mémoire vive

Teste las performances en écriture de la mémoire vive pour les types de variables char, short et long. Je fut assez surpris d'avoir des résultats si différants selon le type de variable.
Le test dure généralement moins d'une minute, il semble y avoir une marge d'erreur de 5% environ.
Ce programme a été programmé avec Dev-c++ pour Windows mais je pense qu'il est facile a porter vers d'autres compilateurs/systèmes d'exploitation.

Source

  • /*********************************************************
  • Nom : MemoryTest
  • Description : Teste la mémoire vive RAM
  • Licence : GPL
  • Auteur : Raphaël MELIOR (RaphAstronome)
  • Date : 12 oct. 2004
  • *********************************************************/
  • #include <iostream>
  • #include <stdlib.h>
  • #define DWORD unsigned long
  • #include <Windows.h>
  • using namespace std;
  • int main(int argc, char *argv[])
  • {
  • // Variables de fonctionnement
  • int ready=0, centmega=100*1024*1024;
  • DWORD temps_debut, temps_execution;
  • // Variables d'essais
  • long* variabletestlong;
  • short* variabletestshort;
  • char* variabletestchar;
  • // Un petit message
  • cout << "Test de la vitesse de la memoire ram (100 Mo)." << endl;
  • cout << "Vous DEVEZ avoir au minimum 256 Mo pour executer ce test sinon ca swapera." << endl;
  • cout << "Code sous licence GNU.";
  • cout << endl;
  • cout << "Lancer le test ? 1:oui 2:non" << endl;
  • cin >> ready;
  • if (ready == 1) {
  • // Test de variable de type long
  • variabletestlong = new long[centmega/4]; // Initialise le tableau
  • temps_debut = GetTickCount(); // Note le moment du départ
  • cout << "Test long ";
  • for (int i=1; i<=15; i++) { // On fait 15 passes
  • cout << ".";
  • for (int j=0; j<centmega/4; j++) variabletestlong[j] = j; // On met des tas de trucs en mémoire
  • }
  • temps_execution = GetTickCount() - temps_debut; // On calcule de temps passé
  • cout << " " << (temps_execution/1000.0f) << "s, "; // On l'affiche
  • cout << (15.0f/(temps_execution/100000.0f)) << "Mo/s" << endl;// On calcule la vitesse
  • delete variabletestlong; // On n'oublie pas de supprimer la var ;D
  • // Test de variable de type short
  • variabletestshort = new short[centmega/2]; // Initialise le tableau
  • temps_debut = GetTickCount(); // Note le moment du départ
  • cout << "Test short ";
  • for (int i=1; i<=15; i++) { // On fait 15 passes
  • cout << ".";
  • for (int j=0; j<centmega/2; j++) variabletestshort[j] = j; // On met des tas de trucs en mémoire
  • }
  • temps_execution = GetTickCount() - temps_debut; // On calcule de temps passé
  • cout << " " << (temps_execution/1000.0f) << "s, "; // On l'affiche
  • cout << (15.0f/(temps_execution/100000.0f)) << "Mo/s" << endl;// On calcule la vitesse
  • delete variabletestshort; // On n'oublie pas de supprimer la var ;D
  • // Test de variable de type char
  • variabletestchar = new char[centmega]; // Initialise le tableau
  • temps_debut = GetTickCount(); // Note le moment du départ
  • cout << "Test char ";
  • for (int i=1; i<=15; i++) { // On fait 15 passes
  • cout << ".";
  • for (int j=0; j<centmega; j++) variabletestchar[j] = j; // On met des tas de trucs en mémoire
  • }
  • temps_execution = GetTickCount() - temps_debut; // On calcule de temps passé
  • cout << " " << (temps_execution/1000.0f) << "s, "; // On l'affiche
  • cout << (15.0f/(temps_execution/100000.0f)) << "Mo/s" << endl;// On calcule la vitesse
  • delete variabletestchar; // On n'oublie pas de supprimer la var ;D
  • system("PAUSE");
  • }
  • return 0;
  • }
/*********************************************************
 Nom : MemoryTest
 Description : Teste la mémoire vive RAM
 Licence : GPL
 Auteur : Raphaël MELIOR (RaphAstronome)
 Date : 12 oct. 2004
*********************************************************/

#include <iostream>
#include <stdlib.h>
#define DWORD unsigned long
#include <Windows.h>

using namespace std;

int main(int argc, char *argv[])
{
  // Variables de fonctionnement
  int ready=0, centmega=100*1024*1024;
  DWORD temps_debut, temps_execution;
  
  // Variables d'essais
  long*  variabletestlong;
  short* variabletestshort;
  char*  variabletestchar;
  
  // Un petit message
  cout << "Test de la vitesse de la memoire ram (100 Mo)." << endl;
  cout << "Vous DEVEZ avoir au minimum 256 Mo pour executer ce test sinon ca swapera." << endl;
  cout << "Code sous licence GNU.";
  cout << endl;
  cout << "Lancer le test ?  1:oui  2:non" << endl;
  cin  >> ready;
  if (ready == 1) {
       
    // Test de variable de type long
    variabletestlong = new long[centmega/4];    									// Initialise le tableau
    temps_debut = GetTickCount();																	// Note le moment du départ
    cout << "Test long  ";												
    for (int i=1; i<=15; i++) {																		// On fait 15 passes
      cout << ".";
      for (int j=0; j<centmega/4; j++) variabletestlong[j] = j;		// On met des tas de trucs en mémoire
    }
    temps_execution = GetTickCount() - temps_debut;    						// On calcule de temps passé
    cout << " " << (temps_execution/1000.0f) << "s, ";						// On l'affiche
    cout << (15.0f/(temps_execution/100000.0f)) << "Mo/s" << endl;// On calcule la vitesse
    delete variabletestlong;																			// On n'oublie pas de supprimer la var ;D

    // Test de variable de type short
    variabletestshort = new short[centmega/2];   									// Initialise le tableau
    temps_debut = GetTickCount();																	// Note le moment du départ
    cout << "Test short ";												
    for (int i=1; i<=15; i++) {																		// On fait 15 passes
      cout << ".";
      for (int j=0; j<centmega/2; j++) variabletestshort[j] = j;	// On met des tas de trucs en mémoire
    }
    temps_execution = GetTickCount() - temps_debut;    						// On calcule de temps passé
    cout << " " << (temps_execution/1000.0f) << "s, ";						// On l'affiche
    cout << (15.0f/(temps_execution/100000.0f)) << "Mo/s" << endl;// On calcule la vitesse
    delete variabletestshort;																			// On n'oublie pas de supprimer la var ;D

    // Test de variable de type char
    variabletestchar = new char[centmega];    	  								// Initialise le tableau
    temps_debut = GetTickCount();																	// Note le moment du départ
    cout << "Test char  ";												
    for (int i=1; i<=15; i++) {																		// On fait 15 passes
      cout << ".";
      for (int j=0; j<centmega; j++) variabletestchar[j] = j;	  	// On met des tas de trucs en mémoire
    }
    temps_execution = GetTickCount() - temps_debut;    						// On calcule de temps passé
    cout << " " << (temps_execution/1000.0f) << "s, ";						// On l'affiche
    cout << (15.0f/(temps_execution/100000.0f)) << "Mo/s" << endl;// On calcule la vitesse
    delete variabletestchar;																			// On n'oublie pas de supprimer la var ;D

    system("PAUSE");
  }  
  return 0;
}

 Conclusion

Veuillez donner les résultats de vos tests, pour moi :
Long : 149.775Mo/s
Short : 98.4123Mo/s
Char : 63.4679Mo/s
Sur un Athlon 1GHz, 256 Mo de RAM @ 133 MHz sur carte-mere ASUS A7V-133


 Historique

21 mai 2005 18:38:15 :
Ajout des lignes #define DWORD unsigned long #include <Windows.h>

 Sources du même auteur

LES CHAÎNES EN C++
TABLEAUX DYNAMIQUES À UNE OU DEUX DIMENSIONS
AFFICHER L'HEURE SANS CTIME (DEV C++)

 Sources de la même categorie

Source avec Zip Source avec une capture INFORMATION PROCESSEUR (CPUID) par Devils_Tiger
Source avec Zip Source avec une capture LECTURE TEMPÉRATURE PROCESSEUR par Devils_Tiger
Source avec Zip Source avec une capture LECTURE FRÉQUENCE PROCESSEUR par Devils_Tiger
Source avec Zip Source avec une capture UNE LISTE HÉTÉROGÈNE DOUBLEMENT CHAINÉE par pgl10
Source avec Zip Source avec une capture POUR AFFICHER LES CARACTÈRES ACCENTUÉS SOUS WINDOWS EN MODE ... par pgl10

Commentaires et avis

Commentaire de wxccxw le 18/10/2004 16:30:29

g borland C++ builder et voila ce quil me dit quand je LINK


bcc32 -g100 -j25 -O2 -k- -vi -tWC -c -IC:\CBuilderX\include -oC:\CBuilderX\samples\welcome\windows\Release_Build\main.obj   HelloWorld\main.cpp
Borland C++ 5.6.4 pour Win32 Copyright (c) 1993, 2002 Borland
helloworld\main.cpp:
"main.cpp" : E2451 Symbole 'DWORD' non défini dans la fonction main(int,char * *) en ligne 10
"main.cpp" : E2379 ; manquant dans l'instruction dans la fonction main(int,char * *) en ligne 10
"main.cpp" : E2451 Symbole 'temps_debut' non défini dans la fonction main(int,char * *) en ligne 28
"main.cpp" : E2268 Appel à une fonction non définie 'GetTickCount' dans la fonction main(int,char * *) en ligne 28
"main.cpp" : E2451 Symbole 'temps_execution' non défini dans la fonction main(int,char * *) en ligne 34
"main.cpp" : W8057 Le paramètre 'argc' n'est jamais utilisé dans la fonction main(int,char * *) en ligne 68
"main.cpp" : W8057 Le paramètre 'argv' n'est jamais utilisé dans la fonction main(int,char * *) en ligne 68
*** 5 erreurs dans la compilation ***
BCC32 a quitté avec le code d'erreur : 1
La construction a été annulée à cause d'erreurs

Commentaire de Kirua le 18/10/2004 18:00:12

ça ne teste pas la vitesse de lecture écriture de la RAM, ça teste l'efficacité de l'assignation des plages mémoires par l'OS. C'est assez différent. Ce qui prend du temps ici (notament), c'est de trouver une plage continue pour stocler ton tableau, ce qui n'est pas une mince affaire.

Commentaire de RaphAstronome le 18/10/2004 19:02:43

wxccxw essaye de mettre :
#define DWORD double
#include <Windows.h>

Kirua dans un premier temps le prog initialise 100 Mo de variable, chez moi c'est instantané.
Apres cela une boucle scanne 15 fois toutes les valeurs de ce tableau et c'est le temps qu'il met a scanner qui est compté pas le temps qu'il met a assigner la variable.

Commentaire de Kirua le 18/10/2004 19:23:21

oups, excuse moi, au temps pour moi.

Commentaire de plus_plus_fab le 18/10/2004 20:08:35

"au temps pour moi."  bonne orthographe, c'est rarissime !

Sinon, ça aurait été plus commode de faire une fonction template prenant en parametre le type avec lequel tu fais le test ...
En fait, ça teste un peu tout ce code :
fréquence, taille, qualité de la RAM
frequence CPU,
fréquence, taille du cache L2,
performance du compilateur pour optimiser le parcours des très gros tableaux,
etc ...

Commentaire de djl le 19/10/2004 11:54:45

pareil le test n'est pas assez ciblé, et les cout fausses toutes les mesures

en passant, 100 mo c'est 100 * 1000 * 1000

1 mo = 1000 * 1000
1 Mbits = 1024 * 1024

vous allez etres surpris mais ca fais partie de la norme depuis 1997 deja et peu de personnes la respectent

Commentaire de Kirua le 19/10/2004 16:52:54

?? un Mbit c'est 1024*1024 bits, et donc 1024*1024 / 8 octets.

Un Moctet (Mo) c'est 1024*1024 octet.


enfin, c'est la certitude avec laquelle je vis depuis tjs. Tu peux trouver une preuve du contraire? Je tomberais de haut O_o.

Commentaire de djl le 19/10/2004 17:42:55

c'est la (sainte) norme definie par l'IEC

autant 1 kbits = 2^10 bits, autant c'est completement arbitraire de dire la meme chose d'un octet

mais heureusement on perd pas complement la correspondance, suffit d'utiliser le terme kibi qui signifie kilo binaire

1 kibi octet = 2^10 octets

de meme avec mebi, gibi, ...

Commentaire de plus_plus_fab le 19/10/2004 17:46:08

simplement :
1 ko = 1000 octets (systeme métrique)
1 Ko  = 2^10  octets = 1024 octets
Ko != ko

idem pour Mo, mo etc ...

djl > quelle norme standardise ça ?

Commentaire de Kirua le 19/10/2004 17:47:11

et en anglais, ça fonctionne encore?

1 Mb (megabyte), ça reste 1024² bytes//octets ?

parce que si oui, je vois pas ce que l'IEC (c'est quelle nationalité) vient raconter...

enfin, c'est bien d'être au courant déjà.

Commentaire de plus_plus_fab le 19/10/2004 17:49:29

par contre pour les bits,
1 Mbit = 1 000 000 bits

Commentaire de djl le 19/10/2004 17:55:54

c'est un organisme us mais le standard est adopté, de meme notre iso c90 n'est autre que l'ansi c89

http://physics.nist.gov./cuu/Units/binary.html


plus_plus_fab >

1 Mbits = 2^20 bits

Commentaire de djl le 19/10/2004 18:00:56

plus_plus_fab > désolé j'avais pas vu ton message,

pour le k et le K, c'est plutot Ki et K (voir lien)

Commentaire de plus_plus_fab le 19/10/2004 18:46:25

je suis un peu perplexe devant ton lien ...

Je pense qu'en france, c'est inusité en pratique (meme si c'est standardisé)
pour les petites lettres, on est d'accord que ça correspond au système métrique traditionnel ? (kilo, mega, giga noté respectivement k, m, g)

Dans la pratique, dès qu'on parle d'une mémoire, on utilise K pour Kilo, ... ,
et on "approxime" par une puissance de 2.
Ceci car une  memoire contient toujours un nombre de bits égal à une puissance de 2.

Dans la pratique toujours, quand on parle du débit d'une connexion internet par exemple :
56 kbit/s = 56 Kbit/s = 56 000 bits par seconde.

Mais apparemment, tout ceci ne respecte aucune normes, c'est donc condamner un jour à disparaitre ... heureusement parce que c'est le fouilli !

Commentaire de Kirua le 19/10/2004 18:51:31

les mutliples du SI sont des majuscules (Kg, Km... mais mg, cm...)

Commentaire de plus_plus_fab le 19/10/2004 18:53:47

encore un pb, apparemment, on met souvent des majuscules pour les unités > 1000 (donc à partir de méga : M), il faut donc voir à quoi correspond le chiffre en gros !

allez, j'adopte la norme USI :-)

Commentaire de djl le 19/10/2004 19:00:08

oui, de toutes facons faut pas croire que les standards sont la pour nous embrouiller, c'est justements pour eviter ce gros bordel :)

Commentaire de juki_webmaster le 21/10/2004 20:53:20

Salut,
J'ai compiler sous devcpp en ajoutant les deux lignes dite par Rafhastronome, et je me sort avec 31 erreurs de type :
522 c:\dev-c_~1\include\winbase.h
bit-field `double _DCB::fTXContinueOnXoff' with non-integral type
Quelqu'un peut-il me donner un peu plus d'info, ou me conseiller un meilleur compilateur de type freeware / trial
merci

Commentaire de RaphAstronome le 22/10/2004 16:31:31

Les deux lignes a ajouter c'est pour borland C++ builder, avec Dev-C++ ça marche directement. J'ai fait cette source avec Dev-C++.

Commentaire de dominion le 26/10/2004 00:31:34

J'ai le même problème que juki_webmaster.
#define DWORD double ok ça marche, mais #include <Windows.h> me donne des erreurs Kmétriques (avec la majuscule ;-)) et sans cet include j'ai "GetTickCount undeclared (first use this function)"

À mon avis tu ne respecte pas la STL...

Commentaire de dominion le 26/10/2004 00:32:56

Trouvé une solution qui marche pour moi : #include <Windows.h> sans le #define DWORD double et là ça compile

Commentaire de BruNews le 26/10/2004 01:14:44 administrateur CS

#define DWORD double !!!
c'etait vraiment abuse, DWORD voulant dire 32 bits.

Commentaire de RaphAstronome le 26/10/2004 11:47:42

oups ...
#define DWORD unsigned long

je devais être fatigué le jour ou j'ai écrit ça !

Commentaire de Kirua le 26/10/2004 16:37:54

GetTickCount ne fait pas partie de la STL, c'est une méthode Win32, et DWORD est un type bien à l'API Win32.

Commentaire de dominion le 26/10/2004 18:07:37

C'est ce que je dis : vive la portabilité ;-)

 Ajouter un commentaire




Nos sponsors


Sondage...

Comparez les prix

CalendriCode

Mai 2012
LMMJVSD
 123456
78910111213
14151617181920
21222324252627
28293031   

Consulter la suite du CalendriCode

A découvrir



 
Développement réalisé par Nicolas SOREL (Nix) avec l'aide de : Cyril DURAND et Emmanuel (EBArtSoft), Merci à Vincent pour ses précieux conseils.
CodeS-SourceS.com© Toute reproduction même partielle est interdite sauf accord écrit du Webmaster
CodeS-SourceS.com© est une marque déposée tous droits réservés

Google Coop CodeS-SourceS Google Coop CodeS-SourceS
Temps d'éxécution de la page : 0,593 sec (3)

Nous contacter | Annoncer sur CodeS-SourceS | Mentions légales