Structures et fichiers

Point de départ

// ── 1. Disposition mémoire et bourrage ────────────────────────────────────
const TAILLE = { char: 1, short: 2, int: 4, double: 8, pointeur: 8 };

// Un champ de k octets doit commencer à une adresse multiple de k.
function disposer(champs) {
  let decalage = 0, alignementMax = 1;
  const plan = [];
  for (const [nom, type] of champs) {
    const k = TAILLE[type];
    alignementMax = Math.max(alignementMax, k);
    // ← à écrire : avancer decalage jusqu'au prochain multiple de k,
    //   en notant le bourrage inséré
    plan.push({ nom, type, decalage, taille: k, bourrageAvant: 0 });
    decalage += k;
  }
  // ← et à la fin : la TAILLE TOTALE doit être un multiple de alignementMax
  return { plan, taille: decalage, alignementMax };
}

function montrer(nom, champs) {
  const d = disposer(champs);
  console.log("   " + nom + " -> sizeof = " + d.taille +
              " (somme des champs : " + champs.reduce((s, [, t]) => s + TAILLE[t], 0) + ")");
  for (const c of d.plan) {
    console.log("      offset " + String(c.decalage).padStart(2) + "  " + c.nom.padEnd(8) +
      c.type.padEnd(9) + (c.bourrageAvant ? "  (+" + c.bourrageAvant + " de bourrage avant)" : ""));
  }
}

// ── 2. Un mini-fichier texte ──────────────────────────────────────────────
function creerFichier(lignes) {
  let position = 0;
  return {
    // Rend la valeur lue, ou null en fin de fichier — comme fscanf rend 1 ou 0.
    lire() { return position < lignes.length ? lignes[position++] : null; },
    finAtteinte: () => position >= lignes.length,
    rembobiner() { position = 0; },
  };
}

// La boucle fautive du cours.
function lireAvecFeof(f) {
  const sortie = [];
  let n = "?";
  while (!f.finAtteinte()) {
    const lu = f.lire();
    if (lu !== null) n = lu;      // en C, un fscanf en échec NE TOUCHE PAS n
    sortie.push(n);
  }
  return sortie;
}

function lireCorrectement(f) {
  const sortie = [];
  // ← à écrire : tester le RETOUR de la lecture, pas la fin de fichier
  return sortie;
}

// ── À VOUS ────────────────────────────────────────────────────────────────
// 1. Écrivez disposer() et retrouvez les 12 puis les 8 octets du cours.
// 2. Écrivez lireCorrectement() et comparez les deux sorties.
// 3. Écrivez un enregistrement « en binaire » avec une disposition, relisez-le
//    avec une AUTRE disposition : c'est ce qu'un changement de machine fait.

montrer("Mesure  { char, int, char }", [["capteur", "char"], ["valeur", "int"], ["unite", "char"]]);

Solution

const TAILLE = { char: 1, short: 2, int: 4, double: 8, pointeur: 8 };

function alignerSur(x, k) { return Math.ceil(x / k) * k; }

function disposer(champs) {
  let decalage = 0, alignementMax = 1;
  const plan = [];
  for (const [nom, type] of champs) {
    const k = TAILLE[type];
    alignementMax = Math.max(alignementMax, k);
    // Le champ doit commencer à un multiple de sa taille : on avance
    // jusque-là, et l'écart est du bourrage perdu.
    const aligne = alignerSur(decalage, k);
    plan.push({ nom, type, decalage: aligne, taille: k, bourrageAvant: aligne - decalage });
    decalage = aligne + k;
  }
  // La taille totale doit être un multiple de l'alignement le plus
  // contraignant, sans quoi le DEUXIÈME élément d'un tableau serait mal aligné.
  const taille = alignerSur(decalage, alignementMax);
  return { plan, taille, alignementMax, bourrageFinal: taille - decalage };
}

function montrer(nom, champs) {
  const d = disposer(champs);
  const somme = champs.reduce((s, [, t]) => s + TAILLE[t], 0);
  console.log("   " + nom.padEnd(34) + " sizeof = " + String(d.taille).padStart(2) +
              "   (somme des champs : " + somme + ", perdu : " + (d.taille - somme) + ")");
  for (const c of d.plan) {
    console.log("      offset " + String(c.decalage).padStart(2) + "  " + c.nom.padEnd(9) +
      c.type.padEnd(9) + (c.bourrageAvant ? "  << " + c.bourrageAvant + " octets de bourrage avant" : ""));
  }
  if (d.bourrageFinal) console.log("      + " + d.bourrageFinal + " octets de bourrage en queue");
}

console.log("— 1. bourrage —");
montrer("{ char, int, char }", [["capteur", "char"], ["valeur", "int"], ["unite", "char"]]);
montrer("{ int, char, char }", [["valeur", "int"], ["capteur", "char"], ["unite", "char"]]);
montrer("{ char, double, int }", [["a", "char"], ["b", "double"], ["c", "int"]]);
montrer("{ double, int, char }", [["b", "double"], ["c", "int"], ["a", "char"]]);
console.log("   Mêmes champs, même contenu : seul l'ORDRE change.");

console.log("");
console.log("— 2. le piège de feof —");
function creerFichier(lignes) {
  let position = 0;
  return {
    lire() { return position < lignes.length ? lignes[position++] : null; },
    finAtteinte: () => position >= lignes.length,
    rembobiner() { position = 0; },
  };
}

function lireAvecFeof(f) {
  const sortie = [];
  let n = "?";
  while (!f.finAtteinte()) {
    const lu = f.lire();
    if (lu !== null) n = lu;
    sortie.push(n);
  }
  return sortie;
}

function lireCorrectement(f) {
  const sortie = [];
  // On tente la lecture, et on regarde si elle a réussi. On ne demande
  // jamais « suis-je à la fin ? » — la seule information fiable est le
  // retour de la lecture elle-même.
  let n;
  while ((n = f.lire()) !== null) sortie.push(n);
  return sortie;
}

const f = creerFichier([10, 20, 30]);
console.log("   avec feof        : " + lireAvecFeof(f).join(" "));
f.rembobiner();
console.log("   en testant la lecture : " + lireCorrectement(f).join(" "));
console.log("   Le fichier contient trois valeurs. La première boucle en produit");
console.log("   quatre — pas parce qu'elle lit une valeur de trop, mais parce que");
console.log("   la lecture ratée laisse la variable INCHANGÉE.");

console.log("");
console.log("— 3. le binaire n'est pas portable —");
// « Écrire » un enregistrement : on pose chaque champ à son décalage.
function ecrireBinaire(valeurs, champs) {
  const d = disposer(champs);
  const octets = new Array(d.taille).fill(0);
  d.plan.forEach((c, i) => { octets[c.decalage] = valeurs[i]; });
  return { octets, plan: d.plan };
}
function relireBinaire(octets, champs) {
  const d = disposer(champs);
  return d.plan.map((c) => octets[c.decalage]);
}

const CHAMPS_A = [["capteur", "char"], ["valeur", "int"], ["unite", "char"]];
const CHAMPS_B = [["valeur", "int"], ["capteur", "char"], ["unite", "char"]];
const ecrit = ecrireBinaire([7, 1234, 3], CHAMPS_A);
console.log("   écrit avec { char, int, char } : [" + ecrit.octets.join(",") + "]");
console.log("   relu   avec { char, int, char } : [" + relireBinaire(ecrit.octets, CHAMPS_A).join(",") + "]   correct");
console.log("   relu   avec { int, char, char } : [" + relireBinaire(ecrit.octets, CHAMPS_B).join(",") + "]   INCOHÉRENT");
console.log("   Un compilateur, une option, une architecture différente suffisent");
console.log("   à produire cet écart. Le texte, lui, se relit partout.");

Avant de commencer

• Les TP 1 à 8
• Un fichier de journaux réel d'au moins 100 000 lignes

Énoncé

1. Définir la structure — Définissez une structure représentant une ligne de journal : adresse, horodatage, méthode, chemin, code, taille. Affichez sa taille avec sizeof et comparez à la somme des champs.
2. Le remplissage — Expliquez l'écart mesuré, puis réorganisez les champs du plus grand au plus petit et remesurez. Indice : Un entier de 4 octets ne peut pas commencer à n'importe quelle adresse.
3. Lire et remplir — Branchez le découpage du TP 6 pour remplir un tableau dynamique de structures à partir du fichier. Comptez les lignes rejetées.
4. Le rapport — Produisez : nombre de requêtes, taux d'erreur, dix adresses les plus actives, répartition horaire. Comparez vos résultats à ceux obtenus au TP 2 de Systèmes avec des commandes shell.
5. Sauvegarder en binaire — Écrivez le tableau de structures dans un fichier avec fwrite, puis relisez-le avec fread. Comparez la taille et le temps de lecture avec le fichier texte d'origine.
6. Le piège de la portabilité — Relisez votre fichier binaire avec un programme compilé avec une déclaration de structure légèrement différente. Constatez, et dites comment un vrai format s'en protège.
7. Le pointeur dans la structure — Remplacez un champ de taille fixe par un pointeur sur une chaîne allouée. Écrivez la structure en binaire, relisez-la dans un autre programme, et expliquez le désastre.
8. Finaliser — Ajoutez les options de ligne de commande, les messages d'erreur sur la sortie d'erreur, les codes de retour, et le manuel d'usage. Passez valgrind une dernière fois.

C'est réussi quand

• ✓ sizeof de votre structure est plus petit après réorganisation des champs
• ✓ Vos chiffres coïncident exactement avec ceux de la chaîne shell du TP 2 de Systèmes
• ✓ La lecture binaire est plusieurs fois plus rapide que l'analyse du texte
• ✓ Vous savez expliquer pourquoi un pointeur écrit dans un fichier n'a aucun sens

Correction

struct Ligne {          taille des champs   ordre en mémoire
  char  code;            1                   0
  long  taille;          8                   8   ← 7 octets perdus
  char  methode;         1                  16
  int   heure;           4                  20   ← 3 octets perdus
};                                      sizeof = 32, somme = 14

/* réorganisé, du plus grand au plus petit */
struct Ligne { long taille; int heure; char code, methode; };
                                      sizeof = 16

typedef struct { long taille; int heure, code; 
               char adresse[46], chemin[256]; } Ligne;

int analyser_fichier(const char *chemin, Ligne **out, size_t *n) {
  FILE *f = fopen(chemin, "r");
  if (!f) { perror(chemin); return -1; }

  Ligne *t = NULL; size_t cap = 0; *n = 0;
  char ligne[1024];
  size_t rejetees = 0;

  while (fgets(ligne, sizeof ligne, f)) {
      Ligne l;
      if (decouper_ligne(ligne, &l) < 0) { rejetees++; continue; }
      if (*n == cap) { /* doublement, TP 8 */ }
      t[(*n)++] = l;
  }
  fclose(f);
  if (rejetees) fprintf(stderr, "%zu lignes ignorées\n", rejetees);
  *out = t;
  return 0;
}

acces.log       : 128 Mo, analyse en 2,4 s
acces.bin       :  17 Mo, lecture en 0,08 s   (×30)

fwrite(t, sizeof(Ligne), n, f);       /* écriture d'un bloc */
fread (t, sizeof(Ligne), n, f);       /* relecture */

programme A : struct { long taille; int heure; }   sizeof 16
programme B : struct { int heure; long taille; }   sizeof 16
            → mêmes octets, champs INTERVERTIS, aucune erreur signalée

autres divergences : boutisme (petit/gros), taille de long
(4 sur Windows 64, 8 sur Linux 64), alignement selon l'ABI

/* ce que fait un vrai format */
- un nombre magique et un numéro de VERSION en en-tête
- des tailles explicites (int32_t, int64_t)
- un boutisme fixé, converti à la lecture
- ou un format autodescriptif : JSON, Protobuf, CBOR

typedef struct { char *chemin; int code; } Ligne;   /* pointeur ! */

fwrite(&l, sizeof l, 1, f);   /* écrit l'ADRESSE 0x55d3e8a04010 */

à la relecture, dans un autre processus :
l.chemin vaut 0x55d3e8a04010, adresse qui n'a AUCUN sens ici
→ texte aberrant, ou Segmentation fault