Une question d'optimisation... - Page 1

J'aimerais savoir si la différence de vitesse entre la lecture octet par octet ou mot par mot est très importante ou pas... en fait j'ai fait ceci à titre d'essai mais je ne sais pas si c'est vraiment utile :

byte get_byte (unsigned long address) {  
  return (address < data_head.resident_bytes ? base_ptr[address]
          : fetch_page(address / BLOCK_SIZE)[address % BLOCK_SIZE]);
}

word get_word (unsigned long address) {
  word temp = get_byte(address++) << 8;
  return ((word)(temp | get_byte(address)));
}

word get_aligned_word (unsigned long address) {
  return (*(word*)(address < data_head.resident_bytes ? base_ptr + address
                   : fetch_page(address / BLOCK_SIZE) + address % BLOCK_SIZE));
}

void prt_coded (unsigned long address) {
  word data;
  word (*lit_mot) (unsigned long) = (address & 1) ? get_word : get_aligned_word;
    /* Last word has high bit set */
  do {
    data = lit_mot(address);
    decode(data);
    address += 2;
  } while ((data & 0x8000) == 0);
}

La dernière fonction sert à décoder une chaîne de caractères Z-code, qui est constituée de mots mais peut commencer à une adresse impaire. Cependant, la structure du Z-code fait que la plupart des longues chaînes statiques (descriptions etc.) sont stockées à des adresses paires à la fin du fichier ; les chaînes manipulées dynamiquement par le jeu peuvent, elles, apparaître n'importe où, mais au total il est nettement plus fréquent que ça commence à une adresse paire. Donc à votre avis, est-ce que ça valait la peine de faire deux fonctions ou est-ce que le gain est faible ?

Je pense que ça vaut le coup perso, vu que lire un mot ou un octet prennent le même nombre de cycles processeur, si tu lis les octets deux par deux tu gagnes en vitesses.
Et manifestement ça ne t'oblige pas à rajouter des kos de code à ta source.
Après ça dépend de la proportion de chaines alignées/non alignées.

Ok... en plus en fait il n'y a pas que la lecture, j'avais oublié que quand je lis mot par mot ça m'oblige à faire deux fois plus de tests, plus le découpage de l'adresse en bloc+offset (BLOCK_SIZE est une puissance de 2 donc c'est juste un shift et un and, mais quand même).
Tiens je viens de réaliser que ce code suppose que resident_bytes est toujours pair, j'espère que c'est vrai