Discussion :

[gangsoleil]

Bonjour,

1/ La solution de Guyt54 est belle, econome, et probablement une des meilleures.
2/ Neanmoins (je n'allais pas m'arreter la non plus), elle oublie une specificite de l'enonce (a la con) :

"Les 2 fonctions renvoient un pointeur de type void* que si size est un multiple de 16."

Il convient donc de ne pas appeler xxx_Malloc (size+2), mais xxx_malloc (multiple de 16 immediatement superieur a size+2).

Je laisse le soin au posteur de chercher comment on calcule cela elegament (oui, je sais, c'est vil).

Mais bon, toute cette nostalgie être peut-être celle d'un has-been qui ne saisit pas les modes d'apprentissage de cette nouvelle génération.

J'ai eu a recruter des developpeurs, et cette absolue incomprehension de la base m'a autant choque qu'elle te choque : comment peut-on esperer faire quelque chose de correct lorsqu'on ne sait pas un minimum comment fonctionne la base ?

Ton analogie avec la voiture est bonne : pour simplement se deplacer d'un point A a un point B, on n'a pas besoin de savoir comment fonctionne le moteur. En revanche, pour economiser de l'essence sur sa conduite, ou tirer plus de performance de sa voiture, il est necessaire de savoir comment elle est construite, et ce qu'est un moteur.
Et ce n'est pas parce que beaucoup de developpeurs sont capables de realiser un logiciel qui fait le minimum vital que l'on doit pour autant s'en satisfaire.

[Bktero]

Il convient donc de ne pas appeler xxx_Malloc (size+2), mais xxx_malloc (multiple de 16 immediatement superieur a size+2).

J'avais failli faire la remarque, et je me suis dit que l'important était la méthode pour savoir s'il fallait appeler big ou small_malloc. Mais tu as tout à fait raison ^^

gangsoleil, c'est rare de te voir sur ce forum, non ?

[Guyt54]

Bonjour,

1/ La solution de Guyt54 est belle, econome, et probablement une des meilleures.
2/ Neanmoins (je n'allais pas m'arreter la non plus), elle oublie une specificite de l'enonce (a la con) :
Il convient donc de ne pas appeler xxx_Malloc (size+2), mais xxx_malloc (multiple de 16 immediatement superieur a size+2).

Je laisse le soin au posteur de chercher comment on calcule cela elegament (oui, je sais, c'est vil).

Hello

J'essaye de jauger mon interrogateur. S'il est un genre KR/Linux, je lui réponds ç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
void *malloc(int s)
{
  void *p ;
  s += sizeof(int) ;
  s = (s & 0xF) ?  (s & ~0xF)+ 0x10 : s ;
  p = (s > 512) ? big_Malloc(s) : small_Malloc(s) ;
  *((int*)p)++ = s ;
  return p ;
}

void free(void *p)
{
  int s ;
  s =  *(--(int*)p) ;
  (s > 512) ? big_free(p) : small_free(p);
}

J'ai bon?

[gangsoleil]

J'ai bon?

Peut-etre un peu violent pour un non-initie

Mais lorsque je disais

Je laisse le soin au posteur de chercher comment on calcule cela elegament

je ne parlais pas de toi, mais bien de la personne qui a initie le thread. Je n'avais aucun doute sur le fait que tu aurai une jolie solution a proposer si on te demandait.

[Guyt54]

Peut-etre un peu violent pour un non-initie

Entre nous, j'ai fait des efforts pour rendre le code le plus cryptique possible, pour la frime Jamais je ne montrerais du code comme ça à mes étudiants.

[Bktero]

Ce code est so K&R !

Code :

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

s = (s & 0xF) ?  (s & ~0xF)+ 0x10 : s ;

J'avoue que cette ligne reste assez ésotérique pour moi, même si je sais ce qu'elle fait !

Code :

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

Jamais je ne montrerais du code comme ça à mes étudiants.

Et jamais je ne ferai de code comme cela !

[Guyt54]

On continue le petit jeu de l'entrevue? Cette fois-ci, c'est moi l'interrogateur

question d'entrevue #2

Voici deux versions d'une fonction qui renvoie le caractère hex. des 4 bits les moins significatifs d'une donnée binaire:

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
char BinToHexChar1(int data)
{
  char c ;

  c=data&0xF ;
  c=(c<10)?c+48:c+55;
  return c ;
}

char BinToHexChar2(int data)
{
  char car ;

  car = data & 0xF ;
  if (car < 10)
    car = car + '0' ;
  else
    car = car - 10 + 'A' ;
  return car ;
}

Question #1:

Quelle fonction va prendre le moins d'octets lorsque compilée?

Question #2:

Quelle fonction vous apparait la mieux écrite et pourquoi?

[prgasp77]

Question #1:

Quelle fonction va prendre le moins d'octets lorsque compilée?

Si ces deux fonctions sont compilés avec des options d'optimisation (-O1 au minimum), elles prendront autant d'instructions l'une que l'autre.

Question #2:

Quelle fonction vous apparait la mieux écrite et pourquoi?

En revanche, la seconde version est un peu plus lisible.

Suis-je embauché ?

PS: un poil plus clair ... mais toujours équivalent une fois compilée

Code C :

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

1
2
3
4
5
char BinToHexChar1(int data)
{
   char c = data & 0xF;
   return c + (c < 10 ? '0' : 'A');
}

[Bktero]

Mes réponses sans avoir regarder ce qui a été posté entre temps ^^

1) Pas la moindre idée. Kif kif ?
2) La seconde car elle est bien plus compréhensible.

PS : je regarde la réponse de prgasp77 --> j'aime bien ta version

[Guyt54]

prgasp77, y a un petit bug dans ta fonction, t'as le temps de t'amender, la correction finale est ce soir.

les autres vous avez encore le temps de présenter votre BinToHexChar optimalisé en grosseur de code. Pas de tricherie non plus, pas le droit de regarder le résultat compilé, allez-y intuitivement!

ps: Environnement de correction (AVRStudio/GCC/ATMega16)

[prgasp77]

prgasp77, y a un petit bug dans ta fonction, t'as le temps de t'amender, la correction finale est ce soir.

Effectivement ... 'A'-10 serait plus approprié. Tant que j'y suis, un const serait le bienvenu. Ce qui donne au final :

Code C :

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

1
2
3
4
5
6
 
char BinToHexChar(int data)
{
   const char c = data & 0xF;
   return c + (c < 10 ? '0' : 'A'-10);
}

Ensuite, je pense qu'il y a une astuce que je ne trouve pas, mais est-elle réellement utile ? À partir du moment où tu écris une fonction, tu as un en-tête important, tant en terme de taille objet qu'en terme de temps d'exécution.

Edit : ok j'ai trouvé l'astuce. Il s'agit de faire en sorte qu'il y ait un if mais pas de else : on initialise c à partir de data et d'une constante et on ne le modifie que dans un cas >10 ou <10 au choix, mais un seul.

[Guyt54]

Edit : ok j'ai trouvé l'astuce. Il s'agit de faire en sorte qu'il y ait un if mais pas de else : on initialise c à partir de data et d'une constante et on ne le modifie que dans un cas >10 ou <10 au choix, mais un seul.

Donc, tu proposerais ça:

Code :

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

1
2
3
4
5
6
7
8
9
10
char BinToHexChar4(int data)

{
   char c = (data & 0xF) + '0' ;

   if (c > '9')
     c = c - '0' - 10 + 'A' ;
   return c ;   
}

Ajouté aux solutions!

[prgasp77]

Donc, tu proposerais ça

Ça plutôt

Code c :

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

1
2
3
4
5
6
7
8
char BinToHexChar4(int data)
{
   char c = data | '0' ; // Mais ne fonctionne que pour data < 0x30 :( Mais je ne vois pas pourquoi on autoriserait data supérieur à 15 en fait ...
 
   if (c > '9')
     c += 'A' - '0' - 10 ;
   return c ;
}

Évidement, je m'attends à ce que 'A' - '0' - 10 soit traité comme une unique constante. Je ne vois pas du tout comment faire mieux, j'attends la solution.

[prgasp77]

Et je me demande ce que donnerait

Code C :

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

1
2
3
4
5
char BinToHexChar(int data)
{
   static const char *const digits = "0123456789ABCDEF";
   return digits[data & 0xF] ;
}

Certains compilos font-il cela intelligemment ?

[Guyt54]

Mais je ne vois pas pourquoi on autoriserait data supérieur à 15 en fait ...

Ta solution (même en conservant le masque) est la plus petite en taille (détails à venir).

Une raison pourquoi on voudrait masquer les bits les plus significatifs dans "BinToHexChar":

Code :

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

1
2
3
4
5
6
7
8
9
10
void OutWord(char* dest, int data)
// met dans "dest" la valeur hex. de data (suivi d'un NULL)
{
  dest[0] = BinToHexChar(data >> 12) ;
  dest[1] = BinToHexChar(data >> 8) ;
  dest[2] = BinToHexChar(data >> 4) ;
  dest[3] = BinToHexChar(data) ;
  dest[4] = 0 ;
}

[gangsoleil]

On continue le petit jeu de l'entrevue? Cette fois-ci, c'est moi l'interrogateur

question d'entrevue #2

Voici deux versions d'une fonction qui renvoie le caractère hex. des 4 bits les moins significatifs d'une donnée binaire:

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
char BinToHexChar1(int data)
{
  char c ;

  c=data&0xF ;
  c=(c<10)?c+48:c+55;
  return c ;
}

char BinToHexChar2(int data)
{
  char car ;

  car = data & 0xF ;
  if (car < 10)
    car = car + '0' ;
  else
    car = car - 10 + 'A' ;
  return car ;
}

Question #1:

Quelle fonction va prendre le moins d'octets lorsque compilée?

Question bete : Est-ce que certains compilateurs, ou certaines options de compilation, ne travailleraient pas dans le premier cas en int, et dans le second uniquement en char ?

[Guyt54]

Question bete : Est-ce que certains compilateurs, ou certaines options de compilation, ne travailleraient pas dans le premier cas en int, et dans le second uniquement en char ?

La réponse ce soir (évidemment, y a le décalage horaire, alors pour vous, ça veut dire demain matin!)

[Guyt54]

Et je me demande ce que donnerait

Code C :

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

1
2
3
4
5
char BinToHexChar(int data)
{
   static const char *const digits = "0123456789ABCDEF";
   return digits[data & 0xF] ;
}

Certains compilos font-il cela intelligemment ?

Ta solution est ajouté (tu vas être déçu )

Histoire de ne pas ajouter le NULL inutile, j'ai essayé avec un tableau

Code :

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

1
2
3
4
5
6
7
8
char BinToHexByte5(int data)
{
  static char digits[] =  {'0','1','2','3','4',
                           '5','6','7','8','9',
                           'A','B','C','D','E','F'} ;
  return digits[data & 0x0F] ;
}

On gagne ou on perd? (là, j'ai été surpris)

[Guyt54]

Bon, les résultats maintenant, obtenu avec GCC pour ATMega16, optimisation -01.

Je vous donne dans le commentaire le nombre d'octets pour le code: résultats en bytes pour le code en commentaire:

Version "cryptique" versus "lisible":

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
char BinToHexChar1(int data)
// Code: 14 bytes
{
  char c ;

  c= data&0xF ;
  c=(c<10)?c+48:c+55;
  return c ;
}
char BinToHexChar2(int data)
// Code: 14 bytes

{
  char car ;

  car = data & 0xF ;
  if (car < 10)
    car = car + '0' ;
  else
    car = car - 10 + 'A' ;
  return car ;
}

Donc, l'opérateur "?" n'apporte strictement rien de positif. Je constate aussi en regardant l'assembleur généré que le compilateur de charge très bien de "pré-calculer" un terme du genre "car - 10 + 'A'" en "car+55".

La première proposition de prgasp77 n'a pas amélioré la performance, au contraire (18 byte de code, 4 de plus):

Code :

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

1
2
3
4
5
6
7
 char BinToHexChar3(int data)
// 18 bytes
{
   const char c = data & 0xF;
   return c + (c < 10 ? '0' : 'A' - 10);
}

Par contre, sa deuxième proposition est la gagnante, avec 12 bytes de code:

Code :

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

1
2
3
4
5
6
7
8
9
10
char BinToHexChar4(int data)
// 12 bytes
{
   char c = (data & 0xF) + '0' ;

   if (c > '9')
     c = c - '9' - 10 + 'A' ;
   return c ;   
}

Et quand on regarde le code généré en assembleur, difficile de faire mieux nous-même en codant en ASM:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
@00000058: BinToHexChar4
43:          char c = (data & 0xF) + '0' ;
+00000058:   708F        ANDI      R24,0x0F       Logical AND with immediate
+00000059:   5D80        SUBI      R24,0xD0       Subtract immediate
45:          if (c > '9')
+0000005A:   338A        CPI       R24,0x3A       Compare with immediate
+0000005B:   F008        BRCS      PC+0x02        Branch if carry set
46:            c = c - '9' - 10 + 'A' ;
+0000005C:   5082        SUBI      R24,0x02       Subtract immediate
48:       }
+0000005D:   9508        RET                      Subroutine return

Pour l'approche "table lookup", je vous reviens là-dessus, y a des résultats qui me surprennent.

A+

[Bktero]

La réponse ce soir (évidemment, y a le décalage horaire, alors pour vous, ça veut dire demain matin!)

On n'a pas eu la réponse à la question de gangsoleil me semble t-il ^^


Un jour, il faudrait que je regarde l'assembleur généré pour voir ce que ça fait