L'opérateur ^ est le ou exclusif bit à bit. Tu as donc alloué 12 * sizeof(int) octets. Il n'y a pas d'opérateur pour la puissance en C, tu dois donc utiliser la fonction pow ou calculer à la main.
Sinon pour ta question de base, si tu demande N octets à malloc/calloc/realloc et que la valeur retournée n'est pas NULL, la zone mémoire pointée contient forcément au moins N octets disponibles pour ton programme (en mettant à part les considérations comme l'OOM killer sous Linux).
un Mo, c'est 1048576 octets (1024*1024). Et il est peu probable qu'un int fasse 1 octet. à ma connaissance, c'est le type char qui est représentatif d'un octet, quelque soit la taille de ce dernier.
C'est plutôt un Mio ça (préfixe binaire, en puissance de deux). Un Mo, comme toutes les unités décimales SI, c'est en puissance de dix, donc 1000000 octets dans un Mo.
En faite, ce que j'aimerai faire, c'est allouer un gigantesque tableau de façon à pouvoir travailler dessus par la suite en allouant d'autres pointeurs mais vers les adresses de ce tableau (en faite l'adresse initiale du tableau servirait d'offset). J'ai pu obtenir l'adresse du début de mon tableau maintenant est ce que vous savez par hasard comment utiliser cette adresse comme offset ? Par exemple je veux allouer un pointeur mais uniquement dans l'intervalle d'adresses allouées pour mon tableau, savez-vous comment faire ?
En faite c'est un tableau vide, je veux juste utiliser son espace mémoire pour être sur de ne pas avoir de bad acsess
Déjà il faut te demander si tu en as vraiment besoin. Un allocateur mémoire custom ça n'est pas un besoin courant. Dans l'écrasante majorité des cas, malloc est suffisant. C'est également un sujet très large, il y a énormément de stratégies d'allocation possibles.
Juste pour que tu voie à quoi ça peut ressembler, voici un exemple de bump allocator, qui est probablement la stratégie d'allocation la plus simple. On alloue les objets successivement dans un tableau et on libère tout d'un coup à la fin.
Ce serait beaucoup mieux que tu expliques ton vrai problème (ce que tu veux vraiment faire) car la solution que tu as trouvé (allouer un gigantesque tableau au départ pour ensuite travailler dessus) n’est peut-être pas une bonne solution.
Bonsoir, merci de vos réponses. Je fais cela car Xcode n'arrête pas de me sortir un problème de bad access alors que j'ai bien alloué !! Du coup mon prof m'a conseillé d'allouer un gigantesque tableau et de travailler dessus en utilisant justement les adresses allouées pour celui-ci pour faire mes manips. À la ligne 61 que j'ai toujours l'erreur !!!! Dans cette ligne, je souhaite prendre le contenu de ce qu'il y a dans "address" et le mettre dans "data_i" Je vous donne 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=(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 !!!!!!!!!!!
//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;
}
/*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];
}
}
//free (*pe);
return *pe;
}*/
int main ()
{
printf ("****** Programme Injection de fautes ****** \n \n");
particule_events* pe=0;
//Allocation d'un tableau de 1 Megaoctet, sachant que le type char représente un octet, représentation de la mémoire à cibler
char *memory = NULL;
memory = malloc(1000000 *sizeof(char));
if (memory == NULL)
{
printf("Error \n");
return 0;
}
printf("Adresse du premier éléement 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,10,3,5,&pe);
for (int i=0; i<3;i++)
{
printf("La multiplicité de l'événement numéro %d est égale à %d\n",i,pe[i].multiplicity);
printf("Le nombre d'adresses corrompues de l'évenement numéro %d est/sont egale(s) à %d\n",i,pe[i].naddress);
printf("La/les adresse(s) corrompue(s) est/sont %d\n",i,*(pe[i].address));
printf("Les données initiales de l'évenement numéro %d est %d\n",i,*(pe[i].data_i));
printf("Les données modifiées de l'évenement numéro %d est %d\n \n",i,*(pe[i].data_f));
}
//fault_injection(1,&pe);
}
Je dois faire une injection de fautes. Je dois donc remplir ma structure. Je choisis une multiplicité aléatoire, un nombre d'adresse aléatoire impactées, puis remplir dans la structure " address " le numéro de toutes les adresses impactées, dans data_i leurs contenus initialement, data_f leurs contenus finals
Mais mon problème est juste la ligne 61, le reste est bon. Dans la ligne 61 j'ai un segment fault je sais pas pourquoi ...
Mais mon problème est juste la ligne 61, le reste est bon. Dans la ligne 61 j'ai un segment fault je sais pas pourquoi ...
Tu as écrit une fonction avec un if else dans un for dans un if dans un if dans un if dans un for dans un for dans un if dans un else. C'est ingérable.
Mais mon problème est juste la ligne 61, le reste est bon. Dans la ligne 61 j'ai un segment fault je sais pas pourquoi ...
Tu as écrit une fonction avec un if else dans un for dans un if dans un if dans un if dans un for dans un for dans un if dans un else. C'est ingérable.
C'est plutôt un Mio ça (préfixe binaire, en puissance de deux). Un Mo, comme toutes les unités décimales SI, c'est en puissance de dix, donc 1000000 octets dans un Mo.
C'est vrai dans l'absolu, sauf que (sous windows au moins), quand il est affiché 1Mo, c'est 1024Ko. Donc s'il veux stocker, par exemple un fichier qui affiche 1Mo, il sera trop court avec la définition (rigoureuse) du million.
Je suis d'accord avec ça, un Mx, c'est un millions d'unités x, mais Microsoft (et d'autres) ne l'entend pas de cette oreille et il faut savoir faire avec. Perso, je ne suis pas certain d'arriver à faire plier Microsoft sur ce point.
Et ce n'est pas nouveau, déjà gamin je me demandais comment en ajoutant 512Ko à mon Amiga de 512Ko, je n'arrivais qu'à 1 Mo et non à 1.024 Mo
La rigueur ne l'emporte pas toujours sur la pratique populaire. Sinon on s'attacherait toujours à définir une vitesse en Km PAR heure et non en Km heure comme tout le monde dit. Le Km heure n'a aucun sens en soi : plus tu roules longtemps et moins tu vas loin...
Si on devait reproduire toutes les erreurs de Microsoft on n'irait pas bien loin. Puis bon, le PO semble développer sur MacOSX, donc c'est complètement hors sujet.
Savez-vous comment réaliser un offset, à partir de la première adresse de mon tableau (vide) alloué de 1 Mo, afin que je puisse travailler sur son espace mémoire et donc utiliser ses adresses libres (de cette façon je n'aurai jamais de segment fault 11) ?
Merci d'avance,
- Edité par Guillou972 18 février 2017 à 21:05:36
Affichage mémoire dynamique ?
× Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
× Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
Bonhomme !! | Jeu de plateforme : Prototype.
Bonhomme !! | Jeu de plateforme : Prototype.