simulation limitation occupation memory

[Artouste]

Ai fait le test avec un résultat identique aux tiens.
Voilà comment je vois ton développement:

Le raz était obligatoire ?

pour le raz je l'avais mis par "securité , mais c'est plus là une demarche intellectuelle qu'un réel projet..

avec ton (tes) code c'est etonnant

ta version en 32 byte/ la mienne renvoi une légère diminution du temps de boucle 1780 ms contre 1784 en revanche l'occupation passe à
2640 contre 2598

ta version que j'ai passé en 8 unsigned long/ la mienne idem 1678 ms de boucle contre 1694 (diminution du temps de boucle + intéressant), mais là aussi l'occupation passe de 2752 contre 2658.

etonnant , mais interessant

[osaka]

Yop yop,
Ai fais les même testes, je les repostes histoire d'avoir les même versions.

Version byte ray[] :

Code: [Select]


void setup()
{
Serial.begin(115200);
}

byte ray[]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
byte top=0;
unsigned long act=0;
byte pass=0;
byte ir=0;
word ts=0;

void loop()
{
  act=millis();
  for (ts=0;ts<=50;ts ++)
  {
    for (ir=31;ir >0; ir --)
    {
      for (pass=0;pass <=7; pass ++)
      {
        top = random(2);
        top = top << pass;
       
        ray[ir]=ray[ir] | top;
      }
    }
  }
  act=millis()-act;
  Serial.println(act,DEC);
}


Code: [Select]


byte ray[32]={0};
unsigned long act=0;

void setup()
{
  Serial.begin(115200);
}

void loop()
{
  act=millis();
  for (byte ts=0;ts<=50;ts++)
  {
    for (byte ir=31;ir >0; ir--)
    {   
      for (byte pass=0;pass <=7; pass ++)
      {
        ray[ir] += random(2) << pass;
      }
    }
  }
 
  Serial.println(millis()-act,DEC);
//  delay(1000);
}


2572/2528 bytes (of a 30720 byte maximum)
1810/1807 ms

Version long ray[]:

Code: [Select]


void setup()
{
  Serial.begin(115200);
}

unsigned long ray[]={0,0,0,0,0,0,0,0};
unsigned long top=0;
unsigned long act=0;
byte pass=0;
byte ir=0;
word ts=0;

void loop()
{
  act=millis();
  for (ts=0;ts<=50;ts ++)
  {
    for (ir=7;ir >0; ir --)
    {
      for (pass=0;pass <=31; pass ++)
      {
        top = random(2);
        top = top << pass;

        ray[ir]=ray[ir] | top;

      }
    } 
  }
  act=millis()-act;
  Serial.println(act,DEC);
}


Code: [Select]


unsigned long ray[8]={0};
unsigned long act=0;

void setup()
{
  Serial.begin(115200);
}

void loop()
{
  act=millis();
  for (byte ts=0;ts<=50;ts ++)
  {
    for (byte ir=7;ir >0; ir --)
    {
      for (byte pass=0;pass <=31; pass ++)
      {
        ray[ir] += random(2) << pass; 
      }
    }
  }
  act=millis()-act;
  Serial.println(act,DEC);
}


2620/2578 bytes (of a 30720 byte maximum)
1718/1702 ms

Conclusion:

Je dirais que la plus grosse différence pour la taille en mémoire programme entre ta version et la mienne est l'utilisation de variable globale ou locale et niveau temps d'exécution la différence ce situe aux niveau du passage par une variable intermédiaire "top" dans la dernière boucle ?

Par contre la différence entre l'utilisation de byte et long vient peux être de là

Lorsqu'un programme utilise des types qui occupent plusieurs registres - typiquement des long - le compilateur traite et alloue les registres indépendamment les uns des autres ce qui permet de générer un code machine plus efficace.

[Artouste]

Yop yop,
Ai fais les même testes, je les repostes histoire d'avoir les même versions.


Par contre la différence entre l'utilisation de byte et long vient peux être de là

Lorsqu'un programme utilise des types qui occupent plusieurs registres - typiquement des long - le compilateur traite et alloue les registres indépendamment les uns des autres ce qui permet de générer un code machine plus efficace.

Tres humblement, cela dépasse mon niveau en prog , mais c'est intéressant de savoir qu'un code compact n'est pas nécessairement synonyme de rapidité.
Selon l'optimisation que l'on souhaite et si on est en limite, ça peut être à prendre en compte.
Ce qui n'est pas là mon cas 

[osaka]

le compilateur traite et alloue les registres indépendamment les uns des autres.

En fait je suppose que c'est du au fait de la largeur des registre (8bit) ?
Maintenant pour resituer se type (long/32bit) il y a des opérations à effectuer en plus (décalage, ...)  ?
Traitement dont byte (unsigned char) n'a pas besoin.
Enfin c'est une supposition parce que là ça dépasse également mon niveau question fonctionnement microcontrôleur, registres , ...  

permet de générer un code machine plus efficace.

C'est un peux contradictoire non ?

[Artouste]

permet de générer un code machine plus efficace.

C'est un peux contradictoire non ?

non , pas de contradiction
tout dépend de ce que l'on entend par efficacité :
Savoir pour un codeur, comment bien  optimiser l'occupation (taille code) Vs rapidité (d'exécution) selon les impératifs, est une demonstration d'efficacité. 

[osaka]

Ai fais le test avec des int 

Code: [Select]

unsigned int ray[16]={0};
unsigned long act=0;

void setup()
{
  Serial.begin(115200);
}

void loop()
{
  act=millis();
  for (byte ts=0;ts<=50;ts ++)
  {
    for (byte ir=15;ir >0; ir --)
    {
      for (byte pass=0;pass <=15; pass ++)
      {
        ray[ir] += random(2) << pass; 
      }
    }
  }
  act=millis()-act;
  Serial.println(act,DEC);
}


2558 bytes (of a 30720 byte maximum)
1773 ms