Discussion :

[_grom]

Bonjour à tous, voilà le problème qui m'ammène :

je voudrai savoir s'il est possible de s'assurer que tous les champs d'une structure C soient contenus dans un espace mémoire de manière contigüe ? Il faut bien sur que ma structure puisse contenir un tableau dynamique et des champs de différents type.

Je vais détailler un peu avec un exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
typedef struct {
int a;
int b[3];
double *v;
} maStruct;

Pour l'exemple disons que lors de l'exécution du programme, j'allouerai pour v une taille de N double. Comment faire (et d'ailleurs est-ce possible ?) pour que ma structure ait une taille de 4 int + N double avec mes différents champs contigüent dans cet espace ? Merci d'avance.

[Thierry Chappuis]

Salut,

tous les champs de ta structure sont contenus dans un espace mémoire contigu. Je ne vois donc pas de problème. Par contre, lors de l'allocation dynamique du tableau de double pointé par v, à l'aide de malloc() ou de calloc(), rien ne t'assure que l'espace ainsi alloué soit contigu à l'espace alloué pour ta structure.

Thierry

[_grom]

Justement, je voudrai savoir si c'est possible (par une bidouille quelconque) de rendre l'espace alloué pour mon tableau dynamique contigüe au reste de ma structure. Je me doute bien que ça doit pas être possible si je déclare ma structure telle quel et que plus loin dans le programme j'alloue mon tableau dynamique, mais si par exemple je déclare un pointeur sur ma structure et que j'utilise une fonction qui me l'alloue (y compris la partie dynamique), est-ce qu'il y a moyen de s'assurer de la contigüité du tableau dynamique avec le reste ?

[Emmanuel Delahaye]

je voudrai savoir s'il est possible de s'assurer que tous les champs d'une structure C soient contenus dans un espace mémoire de manière contigüe ?

Non.

Il y a des possibilités (packed etc.) selon l'implémentation, mais rien de portable. de plus, il reste le problème de la taille des types qui n'est pas garantie d'une implémentation à l'autre).

Pour être portable, il faut utiliser des tableaux de unsigned char et mettre les bytes un par un.

EDIT : J'ai lu le reste de la question. Ce n'est pas un problème de 'contigüe' mais de 'séquentielle'.

OK. Tu veux utiliser un vieux hack qui consiste à définir une sorte d'entête suivit d'un tableau de taille variable.

C'est possible comme ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
struct mydata
{
   int size;
   char arr [1];
};

(la première fois que j'ai vu ça, j'ai failli engueuler l'auteur !).

et ça s'utilise, par exemple comme ça :

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
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
struct mydata
{
   /* ... */
   int size;
   /* ... */
   char s[1];                   /* dernier champ */
};
 
int main (void)
{
 
   int size = 128;
   struct mydata *p = malloc (sizeof *p + size * sizeof (*p->s));
   if (p != NULL)
   {
      p->size = size;
 
      p->s[0] = 0;
 
      strncat (p->s, "hello world", p->size - 1);
 
      puts (p->s);
      /* liberation */
      free (p), p = NULL;
   }
 
   return 0;
}

[_grom]

Merci, je craignais devoir recourir à de telles astuces, me voilà fixé.

Pour être portable, il faut utiliser des tableaux de unsigned char et mettre les bytes un par un

Ok, je dois allouer un tableau de unsigned char de la taille cible de ma structure, mais ensuite pour faire la correspondance entre les champs et les éléments du tableau par contre j'avoue que là je vois pas concrètement comment faire ça...

[Thierry Chappuis]

Une solution peut-être d'allouer une certaine quantité de mémoire au lancement de ton programme et d'implanter ton propre mécanisme d'allocation de mémoire sur cet espace. Mais je ne comprends pas pourquoi tu désires que l'espace mémoire pointé par v soit contingü à l'espace mémoire alloué pour ta structure.

Thierry

[reptils]

quel est l'interet d'assurer la contiguité en memoire dans ton cas?

[Emmanuel Delahaye]

quel est l'interet d'assurer la contiguité en memoire dans ton cas?

Cette question est intéressante, parce que les cas où c'est nécessaire sont rares...

[Kr00pS]

Cette question est intéressante, parce que les cas où c'est nécessaire sont rares...

Le developpement sur Playstation, je crois.

[Emmanuel Delahaye]

Ok, je dois allouer un tableau de unsigned char de la taille cible de ma structure, mais ensuite pour faire la correspondance entre les champs et les éléments du tableau par contre j'avoue que là je vois pas concrètement comment faire ça...

Il faut spécifier le format de sortie des données, et écrire le code qui suit la spécification à la lettre. Si la définition du projet est bien faite, il y a une rubrique 'interface' qui définit ce genre de chose.

[_grom]

Merci pour le vieux hack, ça m'a rafraîchit la mémoire

Sinon pour répondre à vos questions, je voudrai faire ça pour faciliter la communication de ma structure entre deux sites par MPI (sans recopie supplémentaire dans des buffers d'envoi/réception, directement de struct à struct).

Alors oui à la réflexion je n'ai pas besoin que le tableau dynamique soit vraiment contigüe au reste, par contre si je veux décrire ma structure C par une structure MPI je dois lui fournir l'emplacement mémoire de chaque champ. Bref, je dois m'assurer que mon tableau dynamique se trouve toujours au même endroit (le même déplacement entre les adresses) par rapport au reste de ma structure lorsque je l'alloue.

[Thierry Chappuis]

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
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
struct mydata
{
   /* ... */
   int size;
   /* ... */
   char s[1];                   /* dernier champ */
};
 
int main (void)
{
 
   int size = 128;
   struct mydata *p = malloc (sizeof *p + size * sizeof (*p->s));
   if (p != NULL)
   {
      p->size = size;
 
      p->s[0] = 0;
 
      strncat (p->s, "hello world", p->size - 1);
 
      puts (p->s);
      /* liberation */
      free (p), p = NULL;
   }
 
   return 0;
}

Je découvre cette technique. Merci Emmanuel! As-tu un exemple ou écrire ce type de code est nécessaire? Optimization?

Thierry

[Emmanuel Delahaye]

Je découvre cette technique. Merci Emmanuel! As-tu un exemple ou écrire ce type de code est nécessaire?

Non.

[_grom]

Bien merci à tous, et à Emmanuel en particulier, ton bout de hack me permet de faire ce que je voulais : pour mes communications je passe classiquement l'adresse du début de mon buffer d'envoi (ici ma struct) et lui spécifie la taille de l'envoi, et pareillement pour ma réception directement dans une autre instance de ma struct.

Alors oui c'est pas très joli de programmer comme ça en général mais dans mon cas c'est une question de performance et d'optimisation (pas de recopies) donc ça me convient parfaitement. Résolu pour moi

[Ulmo]

Les RLE_sprites de la bibliothèque Allegro sont sur ce modèle. D'ailleurs il me semble que leur définition est même avec un :
char data[0];

[crocodilex]

Je découvre cette technique. Merci Emmanuel! As-tu un exemple ou écrire ce type de code est nécessaire? Optimization?

Thierry

J'ai déjà eu affaire à cette technique lorsque je développais du logiciel de base (BSP), notamment pour effectuer des transferts DMA entre deux ressources. Et en effet les blocs à transférer étaient composés d’une entête et d’une zone a taille variable.

[Emmanuel Delahaye]

Les RLE_sprites de la bibliothèque Allegro sont sur ce modèle. D'ailleurs il me semble que leur définition est même avec un :
char data[0];

C'est une extension de gcc. En C99, on peut mettre
char data[];