/*************************************************************************************************************************************/
/* */
/* V E R I F I C A T I O N D E L A M E M O I R E P H Y S I Q U E : */
/* */
/* */
/* Author of '$xcg/CheckMem$vv$K' : */
/* */
/* Jean-Francois COLONNA (LACTAMME, 20031111102432). */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* I N T E R F A C E ' listG ' : */
/* */
/* */
/* :Debut_listG: */
/* :Fin_listG: */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D I R E C T I V E S S P E C I F I Q U E S D E C O M P I L A T I O N : */
/* */
/*************************************************************************************************************************************/
@define PRAGMA_CL_____PAS_DE_LIBRAIRIES_DYNAMIQUES
/* Introduit le 20061114154342 (car tres utile dans '$xE'...). */
@define PRAGMA_CL_____PAS_DE_FICHIER_____PARAM
/* Introduit le 20170416093259 a cause de l'argument 'taille_de_la_memoire_en_octets' */
/* qui est local a chaque MACHINE ('v $xcg/CheckMem$vv$K MemorySizeMB')... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* F I C H I E R S D ' I N C L U D E S : */
/* */
/*************************************************************************************************************************************/
#include INCLUDES_MINI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* P A R A M E T R E S : */
/* */
/*************************************************************************************************************************************/
#define TESTER_DE_FACON_INCREMENTALE \
VRAI
#define TESTER_AVEC_DES_PATTERNS \
VRAI
/* Choix des modes de test. Les tests incrementaux ont ete introduits le 20051210104215... */
#if (SYSTEME_32_64_BITS==SYSTEME_32_BITS)
/* Test introduit le 20111114183228, en particulier, a cause de '$LACT19'... */
# define PATTERN_1 \
0x00000000
# define PATTERN_2 \
0xffffffff
# define PATTERN_3 \
0x55555555
# define PATTERN_4 \
0xaaaaaaaa
/* "Patterns" utiles a priori. */
#Aif (SYSTEME_32_64_BITS==SYSTEME_32_BITS)
#Eif (SYSTEME_32_64_BITS==SYSTEME_32_BITS)
#if (SYSTEME_32_64_BITS==SYSTEME_64_BITS)
/* Test introduit le 20111114183228, en particulier, a cause de '$LACT19'... */
# define PATTERN_1 \
0x0000000000000000
# define PATTERN_2 \
0xffffffffffffffff
# define PATTERN_3 \
0x5555555555555555
# define PATTERN_4 \
0xaaaaaaaaaaaaaaaa
/* "Patterns" utiles a priori. */
#Aif (SYSTEME_32_64_BITS==SYSTEME_64_BITS)
#Eif (SYSTEME_32_64_BITS==SYSTEME_64_BITS)
#define NOMBRE_D_ITERATIONS \
UN \
/* Nombre d'iterations du test. */
#define TAILLE_DE_LA_MEMOIRE_EN_OCTETS \
AINT(PRENDRE_UN_POURCENTAGE(MEG2(sHOTE_____TAILLE_DE_LA_MEMOIRE_EN_MEGA_OCTETS) \
,sHOTE_____TAILLE_DE_LA_MEMOIRE_DE_REFERENCE_EN_MEGA_OCTETS \
) \
) \
/* Taille de la memoire a tester en octets. */ \
/* */ \
/* Le 20061023155856 'POURCENTAGE(...)' fut remplace par 'PRENDRE_UN_POURCENTAGE(...)'. */ \
/* */ \
/* Le 20090319083808, 'MemorySizeMB' fut recuperee via la variable '$MemorySizeMB' de facon */ \
/* a pouvoir changer cette valeur dynamiquement... */ \
/* */ \
/* Le 20120131165034, 'QUATRE_VINGT' fut remplace par l'acces a '$PCtMemorySizeMB', puis */ \
/* par '$PCMemorySizeMB' le 20120201091847... */ \
/* */ \
/* Le 20120131180305, le 'FLOT(...)' de 'FLOT(Gval("MemorySizeMB"))' a ete supprime... */ \
/* */ \
/* Le 20120201104921, 'VALEUR_PAR_DEFAUT_DE_PCMemorySizeMB' a ete introduit... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* M A C R O S U T I L E S : */
/* */
/*************************************************************************************************************************************/
#define TAILLE_DE_LA_MEMOIRE_EN_Int \
DIVI(taille_testable_de_la_memoire_en_octets,NOCMO) \
/* Nombre de 'Int' testes... */
#define ACCES_MEMOIRE(index) \
IdTb1(memoire \
,INDX(index,PREMIERE_ITERATION_D_UN_Repe) \
,TAILLE_DE_LA_MEMOIRE_EN_Int \
) \
/* Acces a la memoire... */
#define TEST_D_UNE_PATTERN(pattern) \
Bblock \
DEFV(Logical,INIT(tout_s_est_bien_passe,VRAI)); \
/* A priori, tout va bien... */ \
\
Repe(TAILLE_DE_LA_MEMOIRE_EN_Int) \
Bblock \
EGAL(ACCES_MEMOIRE(compteur_des_repetitions_du_Repe),pattern); \
/* Ecriture de la "pattern" dans toute la memoire... */ \
Eblock \
ERep \
\
Repe(TAILLE_DE_LA_MEMOIRE_EN_Int) \
Bblock \
Test(IFNE(ACCES_MEMOIRE(compteur_des_repetitions_du_Repe),pattern)) \
/* Lecture de la "pattern" dans toute la memoire et verification... */ \
Bblock \
EGAL(tout_s_est_bien_passe,FAUX); \
/* Il y a eu au moins un probleme... */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
ERep \
\
Test(EST_FAUX(tout_s_est_bien_passe)) \
Bblock \
PRINT_ERREUR("la memoire semble en mauvais etat"); \
CAL1(Prer1("pattern courante=%0x\n",pattern)); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Test d'une pattern donnee. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* V E R I F I C A T I O N D E L A M E M O I R E P H Y S I Q U E : */
/* */
/*************************************************************************************************************************************/
BCommande(nombre_d_arguments,arguments)
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
DEFV(Logical,INIT(tester_de_facon_incrementale,TESTER_DE_FACON_INCREMENTALE));
DEFV(Logical,INIT(tester_avec_des_patterns,TESTER_AVEC_DES_PATTERNS));
/* Choix des modes de test. Les tests incrementaux ont ete introduits le 20051210104215... */
DEFV(Positive,INIT(pattern_1,PATTERN_1));
DEFV(Positive,INIT(pattern_2,PATTERN_2));
DEFV(Positive,INIT(pattern_3,PATTERN_3));
DEFV(Positive,INIT(pattern_4,PATTERN_4));
/* "Patterns" utiles a priori. */
DEFV(Positive,INIT(nombre_d_iterations,NOMBRE_D_ITERATIONS));
/* Nombre d'iterations du test. */
DEFV(Float,INIT(taille_de_la_memoire_en_octets,TAILLE_DE_LA_MEMOIRE_EN_OCTETS));
DEFV(Int,INIT(taille_testable_de_la_memoire_en_octets,UNDEF));
/* Taille de la memoire a tester en octets. */
/* */
/* Le 20090319083808, 'taille_de_la_memoire_en_octets' est passe de 'Positive' a 'Float' */
/* a cause de la nouvelle definition de '$CMAP28' ('v $Fmachines 20090316110150' qui possede */
/* 8 Go de memoire...). */
/* */
/* Le 20090320171006, 'taille_testable_de_la_memoire_en_octets' est passe de 'Positive' */
/* a 'Int' afin de permettre le 'ABSO(...)' ci-apres... */
/*..............................................................................................................................*/
GET_ARGUMENTS_(nombre_d_arguments
,BLOC(GET_ARGUMENT_L("incremental=""increment=",tester_de_facon_incrementale);
GET_ARGUMENT_L("patterns=""pattern=",tester_avec_des_patterns);
GET_ARGUMENT_X("pattern1=""p1=",pattern_1);
GET_ARGUMENT_X("pattern2=""p2=",pattern_2);
GET_ARGUMENT_X("pattern3=""p3=",pattern_3);
GET_ARGUMENT_X("pattern4=""p4=",pattern_4);
/* Le 20070909122035, les 'GET_ARGUMENT_X(...)'s ont remplace des 'GET_ARGUMENT_I(...)'s. */
GET_ARGUMENT_I("nombre=""n=""iterations=",nombre_d_iterations);
PROCESS_ARGUMENT_F("taille=""t=",taille_de_la_memoire_en_octets
,BLOC(VIDE;)
,BLOC(Bblock
Test(N_EST_PAS_ENTIER(taille_de_la_memoire_en_octets))
Bblock
PRINT_ATTENTION("la taille de la memoire doit etre un nombre entier");
CAL1(Prer1("(au lieu de %f c'est ",taille_de_la_memoire_en_octets));
EGAL(taille_de_la_memoire_en_octets,AINT(taille_de_la_memoire_en_octets));
CAL1(Prer1("%d qui sera utilise)\n",INTE(taille_de_la_memoire_en_octets)));
Eblock
ATes
Bblock
Eblock
ETes
Eblock
)
);
/* Le 20120131181218 'PROCESS_ARGUMENT_F(...)' a remplace 'GET_ARGUMENT_F(...)' afin de */
/* permettre de valider 'taille_de_la_memoire_en_octets'... */
)
);
EGAL(taille_testable_de_la_memoire_en_octets,ABSO(INTE(taille_de_la_memoire_en_octets)));
Test(IZLE(taille_testable_de_la_memoire_en_octets))
Bblock
EGAL(taille_testable_de_la_memoire_en_octets,INFINI);
/* Le forcage de l'INFINI a ete introduit le 20090320175955 a cause du nombre -2147483648 */
/* qui est son propre inverse : */
/* */
/* -(-2147483648) = -2147483648 */
/* */
/* car, en effet, il vaut '0x80000000' dont le complement a 2 est aussi '0x80000000'... */
Eblock
ATes
Bblock
Eblock
ETes
Test(IFNE(FLOT(taille_testable_de_la_memoire_en_octets),taille_de_la_memoire_en_octets))
/* Test introduit le 20090319083808... */
Bblock
PRINT_ERREUR("la taille de la memoire declaree est trop grande, seule une partie sera testee");
CAL1(Prer2("(taille de la memoire en octets = %f (%f))\n"
,taille_de_la_memoire_en_octets
,FLOT(taille_testable_de_la_memoire_en_octets)
)
);
CAL1(Prer1("(taille de la memoire testee = %d)\n",taille_testable_de_la_memoire_en_octets));
Eblock
ATes
Bblock
Eblock
ETes
EGAL(taille_testable_de_la_memoire_en_octets,MULD(taille_testable_de_la_memoire_en_octets,NOCMO));
begin_nouveau_block
Bblock
DEFV(Int,DdTb1(POINTERi
,memoire
,TAILLE_DE_LA_MEMOIRE_EN_Int
,iMalo(taille_testable_de_la_memoire_en_octets)
)
);
/* Allocation du vecteur destine a la memoire a tester. */
Repe(nombre_d_iterations)
Bblock
Test(IL_FAUT(tester_de_facon_incrementale))
Bblock
TEST_D_UNE_PATTERN(NEUT(compteur_des_repetitions_du_Repe));
TEST_D_UNE_PATTERN(SOUS(TAILLE_DE_LA_MEMOIRE_EN_Int,compteur_des_repetitions_du_Repe));
/* Les tests de nature incrementale furent introduits le 20051210104215. Il s'agit donc */
/* alors de tester avec une valeur variable et non pas une "pattern" fixee a la meme valeur */
/* pour tous les mots de la memoire... */
Eblock
ATes
Bblock
Eblock
ETes
Test(IL_FAUT(tester_avec_des_patterns))
Bblock
TEST_D_UNE_PATTERN(pattern_1);
TEST_D_UNE_PATTERN(pattern_2);
TEST_D_UNE_PATTERN(pattern_3);
TEST_D_UNE_PATTERN(pattern_4);
/* Test des differentes "patterns". On notera le 20031112140306 le probleme de '$LACT15' */
/* pour une seule iteration (iterations=1) : */
/* */
/* taille=904000000 : 7.350u 2.110s 0:10.60 89.2% 0+0k 0+0io 268pf+0w */
/* taille=905000000 : le programme n'a toujours pas rendu la main au */
/* bout d'une heure... */
/* */
/* la taille de la memoire physique etant de 878000000. On notera que le phenomene decrit */
/* precedemment se produit aussi si la zone 'memoire' est allouee de facon statique a */
/* l'aide d'un tableau 'memoire[taille]' ('v $xtc/CheckMem$vv$c'), de meme qu'en utilisant */
/* un autre langage de programmation ('v $xtf/trashing.01$f'). Enfin, ce probleme se */
/* rencontre sur toutes les MACHINEs de type 'SYSTEME_APC_Linux'... */
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ERep
FdTb1(memoire,TAILLE_DE_LA_MEMOIRE_EN_Int,Int,ADRESSE_PLUS_DEFINIE);
/* Liberation du vecteur contenant la memoire a tester. */
/* */
/* Le 'ADRESSE_PLUS_DEFINIE' a ete introduit le 20050221170714... */
Eblock
end_nouveau_block
RETU_Commande;
Eblock
ECommande