Bonsoir à tous,

J'ai alloué dynamiquement un tableau de 1 Mo avec la fonction calloc, et j'aimerai utiliser son espace mémoire pour travailler dessus de façon à ne pas avoir de segment fault 11. J'ai pu récupérer l'adresse de la première case du tableau. Savez-vous comment pourrais-je allouer d'autres tableaux en utilisant un offset de l'adresse de la première case de mon tableau précédemment crée ?

Merci d'avance,

Bonjour,

ta question est tout sauf claire. Tu veux allouer un espace dans un espace déjà alloué ?

Pourquoi calloc ? as-tu besoin de mettre les valeurs à 0 ?

Tu veux créer un tableau multidimensionnel ?

PicoDev a écrit:

Bonjour,

ta question est tout sauf claire. Tu veux allouer un espace dans un espace déjà alloué ?

voila c'est exacte, de façon à ne pas avoir de segmaut fault 11

Pourquoi calloc ? as-tu besoin de mettre les valeurs à 0 ?

oui j'ai besoin d'avoir tout à 0

Tu veux créer un tableau multidimensionnel ?

je veux juste utiliser les adresses allouées pour mon tableau pour ma structure et mes autres variables 

merci de de ta réponse 

Salut,

je veux juste utiliser les adresses allouées pour mon tableau pour ma structure et mes autres variables

Dans ce cas, alloue de la place pour ta structure et tes autres variables, n’alloue pas un tableau pour allouer de la place pour eux.

yo@n97one a écrit:

Salut,

je veux juste utiliser les adresses allouées pour mon tableau pour ma structure et mes autres variables

Dans ce cas, alloue de la place pour ta structure et tes autres variables, n’alloue pas un tableau pour allouer de la place pour eux.

Guillou972 a écrit:

yo@n97one a écrit:

Salut,

je veux juste utiliser les adresses allouées pour mon tableau pour ma structure et mes autres variables

Dans ce cas, alloue de la place pour ta structure et tes autres variables, n’alloue pas un tableau pour allouer de la place pour eux.

C'est ce que j'avais fait au début mais j'ai un problème d'allocation mémoire, alors que j'ai tout bien fait ! Je ne comprends pas ...

Si tu avais tout bien fait, ça fonctionnerait … montre ton code minimal …
Et pourquoi cette limite de 1Mo ? 

Montre le code. Celui avec l’allocation normale, pas celui ou tu passes par une pseudo-solution détournée.

-
Edité par yo@n97one 18 février 2017 à 22:32:08

Voila, ça bloque quand je veux dire que je veux mettre le contenu de ce qu'il y a dans les adresses dans la data_i j'ai un segment fault 11 comme si il acceptait pas. Si j'enlève l'étoile à ce moment il copie juste les adresses mais pas le contenu (ce qui est logique) (ligne 49). Je précise que le but de ma fonction est de remplir ma structure

<pre class="brush: as3;">

    struct particule_events{
    int multiplicity; // number of bit corrupted
    int naddress; // number of adress corrupted
    int **address; //pointer on board adress who contains the address who has the error, we have a double pointer because the compilator doesn't know the type int for address
    int *data_i; // pointer on board data_i who contains the data before fault injection
    int *data_f; // pointer on  board "data_f" who contains the data after fault injection
};


int generate_events(int address_min,int address_max,int nEvents,int multi_max,struct particule_events** pe)
{
    int k=0;
    int i=0;
    int j=0;
    
    srand((unsigned int)(time(NULL)));
    *pe = (particule_events* )malloc(nEvents*sizeof(particule_events));
    struct particule_events* local_pe = *pe;
    
    //test for the pointer
    if (local_pe==NULL)
    {
        printf("Erreur d'allocation mémoire dynamique\n");
        return 0;
    }
    else
    {
        if (multi_max>=1)
        {
            //loop for nEvents
            for (k=0;k<nEvents;k++)
            {
                local_pe[k].multiplicity=rand()%(multi_max-1+1)+1;
                local_pe[k].naddress=rand()%(local_pe[k].multiplicity-1+1)+1;
                
                local_pe[k].address=(int** )malloc(local_pe[k].naddress*sizeof(int));
                local_pe[k].data_i=(int* )malloc(local_pe[k].naddress*sizeof(int));
                local_pe[k].data_f=(int* )malloc(local_pe[k].naddress*sizeof(int));
                
                
                int nombredebitrestant=local_pe[k].multiplicity-local_pe[k].naddress; // number of bits remained
                
                
                // loop on adress numbers
                for (i=0;i<local_pe[k].naddress;i++)
                {
                    local_pe[k].address[i]=rand()%(address_max-address_min+1) +address_min;
                    
                    (local_pe[k].data_i[i])=*((local_pe[k].address[i])); // !!!!!!!!!!! PROBLEME ICI !!!!!!!!!!!</pre>

-
Edité par Guillou972 18 février 2017 à 22:55:01

• Plutôt que de passer ta structure particule_events en paramètre, ce serait plus simple de faire ta fonction la renvoyer.
• Le champ adress de ta structure est de type int ** or à ce que je vois, tu essaies d’allouer un tableau de int de taille local_pe[k].naddress pour ce champ. Ce champ devrait être de type int *.
• On ne caste pas le retour de malloc en C (enfin on peut, mais on ne le fait généralement pas).
• Utilise perror pour savoir pourquoi l’allocation a échouée si elle échoue.
• Vérifie aussi les allocations dans la boucle.

-
Edité par yo@n97one 18 février 2017 à 23:14:50

Tout d'abord, Merci de ta réponse super détaillée !

Pour répondre à ton 1er point : je suis obligé de la laisser en paramètre c'est imposé par mon professeur 

Pour répondre à ton deuxième point j'ai déjà essayé en mettant le deuxième int en int* mais ca n'a rien changé ...

Que veux dire ton troisième point ? 

Piur répondre à ton 4e point, j'essayerai et je te tiens au courant !

Pour répondre au dernier point les allocations dans la boucle m'ont l'air bonne, pour chaque événement on a un tableau de structure 

Merci en tout cas de toutes tes réponses et d'essayer de comprendre mon problème ! Je t'avoue que je bloque dessus depuis un mois et je n'arrive pas à avancer.....

Pour répondre à ton deuxième point j'ai déjà essayé en mettant le deuxième int en int* mais ca n'a rien changé

Ce n’est peut-être pas ça le seul problème, mais il ne faut pas essayer comme ça, il faut se demander de quel type est la variable que l’on utilise.

Que veux dire ton troisième point ?

Le (int *) ne sont pas obligatoires. Tu peux écrire ça.

int main(void)
{
    int *foo = malloc(4 * sizeof(foo));
    return 0; 
}

Pour répondre au dernier point les allocations dans la boucle m'ont l'air bonne, pour chaque événement on a un tableau de structure

Elles sont bonnes, mais elles peuvent quand même échouer comme la première.

PS : tu peux mettre le reste de la fonction ?

Merci pour ta réponse !

Voici mon code :

#include <stdlib.h>
#include <stdio.h>
#include <stddef.h>
#include <math.h>
#include <time.h>

typedef unsigned int uint32;


// particule event struct allows to define a lot of different
typedef struct particule_events particule_events;

struct particule_events{
    int multiplicity; // number of bit corrupted
    int naddress; // number of adress corrupted
    int **address; //pointer on board adress who contains the address who has the error, we have a double pointer because the compilator doesn't know the type int for address
    int *data_i; // pointer on board data_i who contains the data before fault injection
    int *data_f; // pointer on  board "data_f" who contains the data after fault injection
};


int generate_events(int address_min,int address_max,int nEvents,int multi_max,struct particule_events** pe)
{
    int k=0;
    int i=0;
    int j=0;
    
    srand((unsigned int)(time(NULL)));
    *pe = (particule_events* )malloc(nEvents*sizeof(particule_events));
    struct particule_events* local_pe = *pe;
    
    //test for the pointer
    if (local_pe==NULL)
    {
        printf("Erreur d'allocation mémoire dynamique\n");
        return 0;
    }
    else
    {
        if (multi_max>=1)
        {
            //loop for nEvents
            for (k=0;k<nEvents;k++)
            {
                local_pe[k].multiplicity=rand()%(multi_max-1+1)+1;
                local_pe[k].naddress=rand()%(local_pe[k].multiplicity-1+1)+1;
                
                local_pe[k].address=malloc(local_pe[k].naddress*sizeof(int*));
                local_pe[k].data_i=malloc(local_pe[k].naddress*sizeof(int));
                local_pe[k].data_f=malloc(local_pe[k].naddress*sizeof(int));
                
                
                int nombredebitrestant=local_pe[k].multiplicity-local_pe[k].naddress; // number of bits remained
                
                
                // loop on adress numbers
                for (i=0;i<local_pe[k].naddress;i++)
                {
                    local_pe[k].address[i]=rand()%(address_max-address_min+1) +address_min;
                    
                    (local_pe[k].data_i[i])=*((local_pe[k].address[i])); // !!!!!!!!!!! PROBLEME ICI !!!!!!!!!!!
                    
                    
                    //to edit the first bit of each address
                    int premierbitquejevaismodifier = rand()%(32-1-1) +1;
                    //masquage
                    int masque = 1u << premierbitquejevaismodifier;
                    int masque1 = 0u << premierbitquejevaismodifier;
                    
                    //test du bit
                    if (local_pe[k].data_i[i] & (1u << premierbitquejevaismodifier))
                    {
                        //si il est à 1, masque en et
                        local_pe[k].data_f[i]=local_pe[k].data_i[i] & masque1;
                    }
                    else
                    {
                        //masque en ou
                        local_pe[k].data_f[i]=local_pe[k].data_i[i] | masque;
                    }
                    
                    if (local_pe[k].naddress>1)
                    {
                        if (local_pe[k].multiplicity!=local_pe[k].naddress)
                        {
                            int nombredebitamodfierdansladresseencours=rand()%(nombredebitrestant-0+1) +0;
                            
                            if (nombredebitamodfierdansladresseencours>1)
                            {
                                for (j=0;j<nombredebitamodfierdansladresseencours;j++)
                                {
                                    int bitquejevaismodifier = rand()%(32-1-1) +1;
                                    //masquage
                                    int masque = 1u << bitquejevaismodifier;
                                    int masque1 = 0u << bitquejevaismodifier;
                                    
                                    if (local_pe[k].data_i[i] & (1u << bitquejevaismodifier))
                                    {
                                        //si il est à 1, masque en et
                                        local_pe[k].data_f[i]=local_pe[k].data_i[i] & masque1;
                                    }
                                    else
                                    {
                                        //masque en ou
                                        local_pe[k].data_f[i]=local_pe[k].data_i[i] | masque;
                                    }
                                    nombredebitrestant=nombredebitrestant - 1;
                                }
                            }
                            else if (nombredebitamodfierdansladresseencours<=1)
                            {
                                if (nombredebitamodfierdansladresseencours ==1)
                                {
                                    int bitquejevaismodifier = rand()%(32-1-1) +1;
                                    //masquage
                                    int masque = 1u << bitquejevaismodifier;
                                    int masque1 = 0u << bitquejevaismodifier;
                                    
                                    if (local_pe[k].data_i[i] & (1u << bitquejevaismodifier))
                                    {
                                        //si il est à 1, masque en et
                                        local_pe[k].data_f[i]=local_pe[k].data_i[i] & masque1;
                                    }
                                    else
                                    {
                                        //masque en ou
                                        local_pe[k].data_f[i]=local_pe[k].data_i[i] | masque;
                                    }
                                    nombredebitrestant=nombredebitrestant - 1;
                                }
                                /*else
                                 {
                                 nombredebitamodfierdansladresseencours=0;
                                 }*/
                            }
                        }
                        /*else
                         {
                         int nombredebitamodfierdansladresseencours=0;
                         
                         }*/
                        
                    }
                    else if (local_pe[k].naddress<local_pe[k].multiplicity)
                    {
                        int nombredebitamodfierdansladresseencours=nombredebitrestant;
                        
                        for (j=0;j<nombredebitamodfierdansladresseencours;j++)
                        {
                            int bitquejevaismodifier = rand()%(32-1-1) +1;
                            //masquage
                            int masque = 1u << bitquejevaismodifier;
                            int masque1 = 0u << bitquejevaismodifier;
                            
                            if (local_pe[k].data_i[i] & (1u << bitquejevaismodifier))
                            {
                                //si il est à 1, masque en et
                                local_pe[k].data_f[i]=local_pe[k].data_i[i] & masque1;
                            }
                            else
                            {
                                //masque en ou
                                local_pe[k].data_f[i]=local_pe[k].data_i[i] | masque;
                            }
                            nombredebitrestant=nombredebitrestant - 1;
                        }
                    }
                    /*else
                     {
                     int nombredebitamodfierdansladresseencours=0;
                     }*/
                }
            }
        }
        
        else
        {
            return 0;
        }
    }
    return *pe;
}

Mis à part les erreurs que j’ai déjà relevé, voici d’autres choses qui posent problème.

• adress est un tableau de int, non ? En tout cas, c’est comme ça que tu l’utilises vu la ligne 59. Ce serait bien que tu précises ce qu’est cette variable, à quoi elle sert et ce qu’elle doit contenir. Si c’est bien un tableau de int, alors dans la structure c’est int *adress.
• Lié au problème précédent, ligne 61, pourquoi une étoile ? data_i[i] est un int, adress[i] aussi, donc local_pe[k].data_i[i] = local_pe[k].address[i].
• Ligne 189, pourquoi retourner *pe, j’aurais pensé au retour d’une valeur pour indiquer que tout s’est bien passé. Par exemple 1, puisque tu utilises 0 s’il y a un problème.

Sinon, niveau style.

• Certains noms de variables sont beaucoup trop longs.
• La fonction en elle-même est beaucoup trop longue. Découpe la en plusieurs sous-fonctions qui font une action et la font bien. Ce sera alors plus simple de tester chaque fonction séparément car elles seront courtes (ce serait bien des fonctions de moins de 30 lignes) et la fonction principale sera beaucoup plus lisible. Pour faire ça, tu peux d’abord écrire du pseudo-code avec les actions principales que ton programme doit faire.
• Quand tu as des conditions, ce serait mieux de mettre le cas le plus simple d’abord.

yo@n97one a écrit:

Mis à part les erreurs que j’ai déjà relevé, voici d’autres choses qui posent problème.

• adress est un tableau de int, non ? En tout cas, c’est comme ça que tu l’utilises vu la ligne 59. Ce serait bien que tu précises ce qu’est cette variable, à quoi elle sert et ce qu’elle doit contenir. Si c’est bien un tableau de int, alors dans la structure c’est int *adress.

Address contient en faite toutes les adresses qui sont touchées par une erreur, au départ j'avais mis qu'une seule * mais le compilateur ne comprenait pas le type int pour une adresse, mon prof m'a dit que c'était normal car il faut mettre 2 * pour que le compilateur comprenne que l'on parle d'adresse

• Lié au problème précédent, ligne 61, pourquoi une étoile ? data_i[i] est un int, adress[i] aussi, donc local_pe[k].data_i[i] = local_pe[k].address[i].

L'étoile permet de récupérer le contenu de ce qu'il y avait dans les adresses et de le stocker dans data_i (ce sont les données initiales que contenaient les adresses avant d'être touchées par une faute

• Ligne 189, pourquoi retourner *pe, j’aurais pensé au retour d’une valeur pour indiquer que tout s’est bien passé. Par exemple 1, puisque tu utilises 0 s’il y a un problème.

J'ai juste  ça car mon prof m'avait dit que la fonction devait retourner la structure 

• Certains noms de variables sont beaucoup trop longs.

Pour les noms de variables, je vais les modifier après, c'était juste provisoire afin que le code paraisse plus clair et que je ne mélange pas les pinceaux

• La fonction en elle-même est beaucoup trop longue. Découpe la en plusieurs sous-fonctions qui font une action et la font bien. Ce sera alors plus simple de tester chaque fonction séparément car elles seront courtes (ce serait bien des fonctions de moins de 30 lignes) et la fonction principale sera beaucoup plus lisible. Pour faire ça, tu peux d’abord écrire du pseudo-code avec les actions principales que ton programme doit faire.

Je suis obligé de tout mettre dans la même fonction, directive du prof ...

Merci de ton aide précieuse !

-
Edité par Guillou972 19 février 2017 à 20:17:51

L'étoile permet de récupérer le contenu de ce qu'il y avait dans les adresses et de le stocker dans data_i (ce sont les données initiales que contenaient les adresses avant d'être touchées par une faute

Dans ce cas, c’est normal, OK.

J'ai juste ça car mon prof m'avait dit que la fonction devait retourner la structure

Dans ce cas, le prototype de ta fonction est incorrect et tu dois supprimer le return 0.

Je suis obligé de tout mettre dans la même fonction, directive du prof ...

Là, c’est clairement abusé quand même.

Sinon, puisque maintenant, il est établi que tu stockes des adresses, le gros problème à la ligne qui pose problème est que tu essayes d’accéder à une case mémoire entre adresse_min et adresse_max. Qui t’a dit que cette case mémoire appartient à ton programme

Dans ce cas, le prototype de ta fonction est incorrect et tu dois supprimer le return 0.

Le prototype de la fonction m'a aussi été obligé ... mais il m'a dit quelle était sensé retourné à la fin la structure.. car on utilisera son résultat pour une autre fonction 

"Sinon, puisque maintenant, il est établi que tu stockes des adresses, le gros problème à la ligne qui pose problème est que tu essayes d’accéder à une case mémoire entre adresse_min et adresse_max. Qui t’a dit que cette case mémoire appartient à ton programme"

Ah oui !!! Effectivement !!! Comment le savoir d'ailleurs ? J'ai regardé le fichier de linckage mais il m'apporte rien de nouveau. Comment savoir que ma case mémoire appartient à mon programme ? 

-
Edité par Guillou972 19 février 2017 à 21:07:38

Le prototype de la fonction m'a aussi été obligé ... mais il m'a dit quelle était sensé retourné à la fin la structure.. bizarre ?

Le mieux reste de demander des informations à ton prof à ton sujet, mais si tu fais une fonction qui retourne un int, elle ne retourne pas un pointeur sur ta structure.

Ah oui !!! Effectivement !!! Comment le savoir d'ailleurs ? J'ai regardé le fichier de linckage mais il m'apporte rien de nouveau. Comment savoir que ma case mémoire appartient à mon programme ?

C’est à toi de lui donner des cases dont tu sais qu’elles appartiennent à ton programme, soit parce que tu les allouées (malloc, etc.), soit parce qu’il s’agit d’adresses de variables de ton programme.

En faite ce sont des paramètres de ma fonction que je dois remplir dans le main, peut-on les considérer comme des variables de mon programme ?

Sinon il faudrait que j'alloue un espace mémoire entre adresse max et adresse min si j'ai bien compris ?

La question c’est quelle valeur veux-tu donner exactement à local_pe[k].data_i[i] ? Où est stockée cette valeur ?

Dans mas structure, 

• Dans naddress je mets le nombre d'adresses touché par une erreur
• Dans address, je mets les adresses tirées aléatoirement entre adresse max et adresse min qui subiront une injection de fautes (donc leur "localisation" dans la mémoire de mon ordi)
• Je souhaite remplir data_i par ce que contiennent les adresses sélectionnées
• data_f sera remplit en modifiant la data_i par un masque

Donc je souhaite placer dans local_pe[k].data_i[i] ce que contenait initialement les adresses sélectionnées et ceci sera sauvegardé dans la structure afin qu'à n'importe quel moment je puisse analyser si l'injection de fautes a fonctionné en analysant data_i et data_f

-
Edité par Guillou972 19 février 2017 à 21:42:35

• Dans address, je mets les adresses qui subiront une injection de fautes (donc leur "localisation" dans la mémoire de mon ordi)
• Je souhaite remplir data_i par ce que contiennent les adresses sélectionnées

Et comment sélectionnes-tu ces adresses ? Parce qu’il est bien là le problème. Là tu choisis des adresses entre adresse_min et adresse_max, mais il n’y a aucune garantie que ces adresses t’appartiennent. Tu devrais demander à ton prof sur quelles adresses tu dois travailler, comment sélectionner ces adresses ?

-
Edité par yo@n97one 19 février 2017 à 21:56:08

Maintenant que tu le dis je vois que c'est de la que proviens mon erreur !

Il m'a juste dit que ces adresses étaient sélectionnées entre adresse max et adresse min aléatoirement. Le problème c'est qu'il ne m'aide pas énormément, je ne suis pas sa priorité ... 

Un petit UP s'il vous plaît, j'ai mis à jour mon code, il est beaucoup plus clair ! Par contre je suis toujours bloqué au même endroit (ligne 60), voici mon code :

#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <time.h>

typedef unsigned int uint32;


// particule event struct allows to define a lot of different
typedef struct particule_events particule_events;

struct particule_events{
    int multiplicity; // number of bit corrupted
    int naddress; // number of adress corrupted
    int **address; //pointer on board adress who contains the address who has the error, we have a double pointer because the compilator doesn't know the type int for address
    int *data_i; // pointer on board data_i who contains the data before fault injection
    int *data_f; // pointer on  board "data_f" who contains the data after fault injection
};


int generate_events(int address_min,int address_max,int nEvents,int multi_max,struct particule_events** pe)
{
    int k=0;
    int i=0;
    int j=0;
    int remainingbit=0; // nombre de bit restant
    int modifiedbit=0; //bit que je vais modifier
    int remainingaddressbit=0; //nombre de bits à modifier dans l'adresse en cours
    
    srand((unsigned int)(time(NULL)));
    *pe = (particule_events* )malloc(nEvents*sizeof(particule_events));
    struct particule_events* local_pe = *pe;
    
    //test for the pointer
    if (local_pe==NULL)
    {
        printf("Erreur d'allocation mémoire dynamique\n");
        return 0;
    }
    else
    {
        //loop for nEvents
        for (k=0;k<nEvents;k++)
        {
            if (multi_max>=1)
            {
                local_pe[k].multiplicity=rand()%(multi_max-1+1)+1;
                local_pe[k].naddress=rand()%(local_pe[k].multiplicity-1+1)+1;
                //printf("naddress = %d \n",local_pe[k].naddress);
        
                local_pe[k].address=malloc(local_pe[k].naddress*sizeof(int*));
                local_pe[k].data_i=malloc(local_pe[k].naddress*sizeof(int));
                local_pe[k].data_f=malloc(local_pe[k].naddress*sizeof(int));
                
                remainingbit=local_pe[k].multiplicity-local_pe[k].naddress; // number of bits remained
                
                // loop on adress numbers
                for (i=0;i<local_pe[k].naddress;i++)
                {
                    local_pe[k].address[i]=&address_max; //********** Probleme ici si je fais un rand[address_min,address_max]*******
                    local_pe[k].data_i[i]=*(local_pe[k].address[i]);
                    
                    //to edit the first bit of each address
                    modifiedbit = rand()%(32-1-1) +1;
                    int maskOR = 1u << modifiedbit;
                    int maskAND = 1u << modifiedbit;
                    
                    //test du bit
                    if (local_pe[k].data_i[i] & (1u << modifiedbit))
                    {
                        //si il est à 1, masque en et
                        local_pe[k].data_f[i]=local_pe[k].data_i[i] &~ maskAND;
                    }
                    else
                    {
                        local_pe[k].data_f[i]=local_pe[k].data_i[i] | maskOR;
                    }
                    
                    if (local_pe[k].naddress>1 && local_pe[k].multiplicity!=local_pe[k].naddress)
                    {
                        remainingaddressbit=rand()%(remainingbit-0+1) +0;
                        
                        if (remainingaddressbit>1)
                        {
                            for (j=0;j<remainingaddressbit;j++)
                            {
                                modifiedbit = rand()%(32-1-1) +1;
                                int maskOR = 1u << modifiedbit;
                                int maskAND = 1u << modifiedbit;
                                
                                //test du bit
                                if (local_pe[k].data_i[i] & (1u << modifiedbit))
                                {
                                    local_pe[k].data_f[i]=local_pe[k].data_i[i] &~ maskAND;
                                }
                                else
                                {
                                    local_pe[k].data_f[i]=local_pe[k].data_i[i] | maskOR;
                                }
                                remainingbit=remainingbit - 1;
                            }
                        }
                        
                        else if (remainingaddressbit==1)
                        {
                            modifiedbit = rand()%(32-1-1) +1;
                            int maskOR = 1u << modifiedbit;
                            int maskAND = 1u << modifiedbit;
                            
                            //test du bit
                            if (local_pe[k].data_i[i] & (1u << modifiedbit))
                            {
                                local_pe[k].data_f[i]=local_pe[k].data_i[i] &~ maskAND;
                            }
                            else
                            {
                                local_pe[k].data_f[i]=local_pe[k].data_i[i] | maskOR;
                            }
                            remainingbit=remainingbit - 1;
                        }
                    }
                    else if (local_pe[k].naddress<local_pe[k].multiplicity)
                    {
                        remainingaddressbit=remainingbit;
                    
                        for (j=0;j<remainingaddressbit;j++)
                        {
                            modifiedbit = rand()%(32-1-1) +1;
                            int maskOR = 1u << modifiedbit;
                            int maskAND = 1u << modifiedbit;
                        
                            //test du bit
                            if (local_pe[k].data_i[i] & (1u << modifiedbit))
                            {
                                local_pe[k].data_f[i]=local_pe[k].data_i[i] &~ maskAND;
                            }
                            else
                            {
                                local_pe[k].data_f[i]=local_pe[k].data_i[i] | maskOR;
                            }
                            remainingbit=remainingbit - 1;
                        }
                    }
                }
            }
            else
            {
                return 0;
            }
        }
        free(*pe);
        return *pe;
    }
}



int fault_injection(int nEvents, struct particule_events** pe)
 {
 struct particule_events* local_pe = *pe;
 int k=0;
 int i=0;
 
 for (k=0;k<nEvents;k++)
 {
     for (i=0;i<local_pe[k].naddress;i++)
     {
         *(local_pe[k].address[i])=local_pe[k].data_f[i];
         //printf("contenu de data_f = %d \n",local_pe[k].data_f[i]);
         //printf("contenu de address = %d \n",*(local_pe[k].address[i]));
     }
 }
 return 0;
}

int main ()
{
    printf ("****** Programme Injection de fautes ****** \n \n");
    particule_events* pe=0;
    
    //Allocation d'un tableau de 1 Megaoctets, sachant que le type char représente un octet, représentation de la mémoire à cibler
    /*char *memory = NULL;
    memory = calloc(1000000,sizeof(char));
    if (memory == NULL)
    {
        printf("Error \n");
        return 0;
    }
    printf("Adresse du premier élément est %d \n",&memory[0]);*/
    
    /*int address_min=0;
     int address_max=0;
     int nEvents=0;
     int multi_max=0;
     printf("Veuillez saisir une adresse minimal : \n");
     scanf("%s",&address_min);
     printf("Veuillez saisir une adresse maximale : \n");
     scanf("%d",&address_max);
     printf("Veuillez saisir un nombre d'évenements : \n");
     scanf("%d",&nEvents);
     printf("Veuillez saisir une multiplicité maximale : \n");
     scanf("%d",&multi_max);
     generate_events(address_min,address_max,nEvents,multi_max,&pe);*/
    
    
    generate_events(0,20,3,5,&pe);
    printf("***** fonction generate_events ***** \n \n");
    
    for (int k=0;k<3;k++) //nEvents
    {
        printf("La multiplicité de l'événement %d est égale à %d\n",k,pe[k].multiplicity);
        printf("Le nombre d'adresses corrompues à l'évenement %d est egale à %d\n",k,pe[k].naddress);
        printf("Les adresses corrompues sont %d \n",*(pe[k].address));
        printf("Les données initiales à l'évenement %d sont %d\n",k,*(pe[k].data_i));
        printf("Les données modifiées à l'évenement %d sont %d\n \n",k,*(pe[k].data_f));
        
        /*for (int i=0;i<pe[i].naddress;i++)
        {
            printf("Les adresses corrompues sont %d \n",pe[k].address[i]);
            printf("Les données initiales à l'évenement %d sont %d\n",k,pe[k].data_i[i]);
            printf("Les données modifiées à l'évenement %d sont %d\n \n",k,pe[k].data_f[i]);
        }*/
    }
    
    fault_injection(3,&pe);
    printf("***** fonction fault_injection ***** \n \n");
    
    for (int k=0;k<3;k++) //nEvents
    {
        for (int i=0;i<pe[k].naddress;i++)
        {
            printf("Pour l'évenement %d pour l'adresse %d on a comme nouvelle data %d \n",k,pe[k].address[i],*(pe[k].address[i]));
        }
    }
}

Il fonctionne si je met directement address_max ou address_min, mais si je prends une adresse au hasard entre ces 2 bornes, cela ne fonctionne plus, en effet rien me dit que les adresses entre ces 2 bornes sont libres. Comment le faire s'il vous plaît ?

Sinon j'ai une autre question, pour ma deuxième fonction, quand j'écris dans le main :

printf("Pour l'évenement %d pour l'adresse %d on a comme nouvelle data %d \n",k,pe[k].address[i],*(pe[k].address[i]));

Il ne me sort que 0 en nouvelle data ! Alors que dans le printf de la fonction, cela fonctionne bien ! Avez-vous une idée ?

Merci d'avance ...

-
Edité par Guillou972 21 février 2017 à 19:55:32