Fonctions C pour manipuler les chaines - Page 1

J'ai essayé d'optimiser des fonctions pour manipuler les chaine comme strlen() et strcmp() mais elles sont bien plus lentes que celles de TIGCC (je suppose que c'est celles de l'AMS.

Voici par exemple strcmp() que j'ai essayé de programmer mais elle est trop lente :

unsigned char FastStrCmp(const char *str_1, const char *str_2)
{
unsigned int i;
i =0;
while((str_1[i] == str_2[i]) && (str_1[i] && str_2[i]))
i++;


return (str_1[i]==0 && str_2[i]==0);


}

Et voici ma fonction strlen() :

unsigned int StrLen(const char *str)
{
unsigned int i=0;
while(str[i++]);
return i-1;

}

Au début je pensais que les fonctions de TIGCC assez lentes et qu'il serait facile d'en programmer des plus rapide mais vu qu'en moyenne elles sont trois fois plus rapide que les miennes, ce n'est pas trop le cas !

Alors je voulais savoir si en C il y avait moyen de d'obtenir des fonctions plus rapides que celles utilisées par TIGCC ?

Et puistant qu'à faire voici la fonction la plus utilisé dans mon programme :

unsigned int FindNextChar(unsigned char Char,unsigned int current_position,unsigned char *buffer)
{
unsigned long len=strlen(buffer);
while(buffer[current_position]!=Char && current_position<len)
{
current_position++;
};

return current_position;

}


C'est une fonction qui cherche le prochain caractère Char dans la chaine buffer à partir de la coordonnée current_position.
Si quelqu'un sait comment optimiser ça en C ça serait génial. Et si en C vous pensez que ça ne se peut pas mais que vous connaissez des routines asm, je prends aussi !

Les fonctions utilisées par TIGCC sont en effet celles de AMS, et je te conseille de les utiliser, tout simplement. Il paraît que les fonctions mem* et str* de AMS soient les fonctions écrites en assembleur optimisé en vitesse par Motorola, ce qui expliquerait pourquoi tu n'arrives pas à atteindre leur vitesse en C.

Ok, bah au moins c'est clair ! Et sinon pour ma dernière fonction (il n'y a pas d'équivalant avec TIGCC ?) c'est possible de l'optimiser ?

Les fonctions style memcpy, memset, et surement les str* sont assez déroulées (8 fois de suite la même instruction si je me souviens bien), tu auras du mal à faire plus rapide sans faire une fonction énorme ("technique" XLib )

Sinon pour ta fonction, vu qu'elle est très petite tu devrais en effet la faire en ASM

Extrait de AMS 2.05:

strlen:
  link    a6,#$FFFC
  movea.l 8(a6),a1
  movea.l a1,a0
boucle:
  tst.b   (a0)+
  bne     boucle
  subq.l  #1,a0
  suba.l  a1,a0
  move.l  a0,d0
  unlk    a6
  rts

strcmp:
  movea.l 4(a7),a0
  movea.l 8(a7),a1
  bra.s   lbl2
lbl1:
  cmp.b   (a0)+,d1
  beq.s   lbl2
  clr.w   d0
  move.b  -(a0),d0
  andi.w  #$FF,d1
  sub.w   d1,d0
  rts
lbl2:
  move.b (a1)+,d1
  bne.s  lbl1
  move.b (a0),d0
  ext.w  d0
  rts

Donc on peut facilement faire un peu mieux pour strlen. strcmp est pas mal faite quand même, mais j'ai l'impression qu'on pourrait changer l'ordre des 2 parties pour éviter le bra du début.
En recopiant des fonctions comme ça dans ton code, tu éviteras l'appel à une ROMCALL qui est un peu plus long, mais je pense pas que la différence soit significative. Dans tous les cas, utilise au moins les ROMCALL parce que tes fonctions sont pas très optimisées. Il faut éviter d'accéder aux élements avec [] et plutôt utiliser les pointeurs.
Par exemple, strlen je l'aurais plutôt codé comme ça en C:

unsigned long StrLen(char *str)
{
	unsigned long len = 0;
	while(*(str++))
		len++;
	return len;
}

Sinon pour ton autre fonction, j'arrive à gagner 28 octets mais je sais pas ce que je gagne en vitesse avec

unsigned short FindNextChar(char Char, unsigned short current_position, char *buffer)
{
  buffer += current_position;
  while(*buffer && *(buffer++) != Char)
    current_position++;
  return current_position;
}

[Edit: J'ai changé FindNextChar pour enlever une variable locale qui servait à rien.]

Ah, merci c'est super sympa !

Par contre je ne connais pas l'asm dc je vais devoir me contenter du C.

Par contre, il y a un truc que mon FindNextChar ne fait pas et que le tien fait, c'est vérifier qu'on ne déborde pas du buffer.
Si on fait FindNextChar(c, 4, "ab"), le mien ira chercher plus loin jusqu'à trouver un \0 ou un caractère c, tandis que le tien s'arrêtera et renverra 4.

Oui, je le faisais aussi mais dans mon programme il n'y en a pas besoin (enfin c'était pour alléger mon programme surtout).
Alors sinon je n'ai pas becnhé la fonction mais mon programme résultat : 24 fois plus vite !!!!!!!!!!!!!
J'en reviens tjrs pas ! J'avais commencé à optimiser certaines fonctions avec des pointeurs mais pas celle là qui est la plus importante ! Avant j'avais une barre de loading mais là j'en aurais plus besoin ! ....
C'est comme ça que j'aurais pû faire pour mon moteur 3D... d'ailleurs c'est peut-être ce que je vais faire.
Encore merci ! Et le fonction strlen est presque aussi rapide que celle de l'AMS en mettant unsigned int (je n'ai pas besoin de plus non plus là).

BiHi
: En recopiant des fonctions comme ça dans ton code, tu éviteras l'appel à une ROMCALL qui est un peu plus long,

...et violeras les droits d'auteur de TI.

n'importe quoi.... et puis il l'a trouvée tout seul cette fonction

Faux:

BiHi
: Extrait de AMS 2.05:

Oui c'est vrai. Je mérite de brûler en enfer!

Mais si j'ai bien compris, selon PpHd, les fonctions str* et mem* viennent de la bibliothèque de motorola qui est fournie avec le compilateur officiel (ou une histoire proche de ça ^^). Donc je pense pas qu'il y ait des droits d'auteurs vu que ce n'est pas TI qui les a écrites (apparement).

Et puis en fait je mettais le code pour montrer que contrairement à ce qui a été dit plusieurs fois, les fonctions mem* et str* ne sont pas parfaites, on peut encore optimiser des trucs. Enfin le principal est que je conseillais à Raphaël de ne pas utiliser ses routines qui n'étaient pas très optimisées et d'utiliser les fonctions de la librairie standart.

Et à propos du strlen, j'y ai réfléchi un peu plus, et en fait ça doit être mieux de faire la différence des pointeurs (comme c'est fait dans AMS) que d'ajouter 1 à len pour chaque caractère.

Et alors BiHi celle-là tu l'optimiserai comment ?

char *sub_str(int begin, int end, char *str)
{
int i=0,j=0;
char *str_return = malloc((end-begin+1));
for(i=begin;i<end;i++)
{
str_return[j]=str[i];
j++;
}
str_return[j]=0;
return str_return;
}

parce-que j'ai essayé de l'optimiser en faisant comme toi ppour l'autre mais ça ne marche pas pour celle-là.

Je ne sais pas du tout si ça a des chances d'être plus rapide, ça dépend de la façon dont GCC transforme ton code, mais essaye ça à tout hazard :

char *sub_str(int begin, int end, char *str)
 {
 unsigned char *cur = str + begin, *new, *str_return;
 short i = end - begin + 1;

 if (!(str_return = malloc(i))) return NULL;
 new = str_return;

 while (i--) *new++ = *cur++;
 *new = 0;

 return str_return;
 }

(j'ai pas testé, il se peut que ça ne marche pas)
[edit] bug

je reconnais bien là le bob-style

(pas comprit là...)

moi non plus, est ce que ça rend plus rapide de travailller avec un register char * ?
et ça serait pas plutot *cur = str + begin ?

J'avais pas comprit pour le "bob-style".
Sinon oui c'est évidement *cur = str + begin.

d'en ecrire le maximum sur chaque ligne en prenant le moins deplace possible, c'est tout toi

liquid
: moi non plus, est ce que ça rend plus rapide de travailller avec un register char * ?

Non, GCC se contrefiche du mot-clé register.

La déclaration en register char ne fait strictement rien.

ah ok, ça plus qu'autre chose

Elle ne marche pas ta fonction @Vertyos, dans mon programme ça plante
Il n'y aurait pas quelqu'un qui aurait une autre solution ?

T'as tenu compte de la remarque de liquid ? (c'est str + begin et non pas str + end)
[edit] J'ai édité le post, tant qu'à faire passe aussi "i" en short, au cas ou ta chaine fasse plus de 255 caractères.

Ah ouais, ok.

Bah, non ça ne marche tjrs pas.

heu, si ça doit marcher

Avec cette routine, j'ai les mêmes résultats qu'avec la tienne. J'ai regardé assez vite et je crois que c'est la même que celle de Vertyos.

char *sub_str(int begin, int end, char *str)
{
  int i = end-begin+1;
  char *str_return = malloc(i), *tmp;

  str += begin;
  if(!(tmp = str_return))
    return NULL;
  while(--i) {
    *tmp++ = *str++;
  }
  *tmp = 0;
  return str_return;
}

Oublie pas de libérer les espaces mémoires qu'allouent cette fonction.
Par contre, faudrait penser à chercher un peu avant.

Heu... C'est exactement ma routine ça BiHi