Jak nejrychleji porovnat 2 pole byte – C / C++ – Fórum – Programujte.com

čau, chci se jen zeptat, jestli je vůbec nějaká rychlejší metoda jak porovnat 2 pole byte bez použití cyklu

Momentálně používám memcmp, ale je to opravdu ten nejrychlejší způsob?
Předtim ještě musim ten blok bytů překopírovat do tempu (memcpy), což taky vezme nějakou rychlost

pokud chci porovnat pole, kde bude max 8 bytů, to jen explicitně přetypuju na short/int/long a jen porovnám čísla, takže tady rychlejší způsob už neexistuje, ale pokud pole bude větší jak 8byte, tak nějak nevim jak na to, aby to bylo opravdu rychlý

> Momentálně používám memcmp, ale je to opravdu ten nejrychlejší způsob?
Předtim ještě musim ten blok bytů překopírovat do tempu (memcpy), což taky vezme nějakou rychlost

1. Proč to musíš někam překopírovat? memcmp snad není destruktivní
2. Záleží na tom, kde nesmí být ten cyklus. memcmp vysoce pravděpodobně obsahuje také cyklus
3. Cyklus lze nahradit např. rekurzí, ale je samozřejmě nesmysl to tak dělat, protože cyklus má obvykle větší "kapacitu" naž zásobník.
4. Můžeš ten cyklus rozbalit na sérii ifů. To dá obvykle dost práce, ale pokud ta pole budou krátká, tak to lze udělat s využitím šikovných maker. Nebo si ten zdroják můžeš rovnou vygenerovat.
5. Zajímavý přístup může být s využitím šablon (ale opravdu jenom zajímavý, rozumně užitečné to asi nebude):
   

   #include <iostream>
   
   template<
       unsigned long L
   >
   bool array_equal(
       unsigned char* a1,
       unsigned char* a2
   )
   {
       return *a1 == *a2 && array_equal<L - 1>(++a1, ++a2);
   }
   
   template<>
   bool array_equal<0UL>(
       unsigned char* a1,
       unsigned char* a2
   )
   {
       return true;
   }
   
   int main()
   {
       unsigned char a1[] = { 1, 2, 3, 4 };
       unsigned char a2[] = { 1, 2, 3, 4 };
   
       std::cout
           << "a1 == a2 = "
           << std::boolalpha
           << array_equal<sizeof(a1)>(a1, a2)
           << '\n';
   }
   

s tím skopírováním jsem to neřekl přesně.. já porovnávám množinu bytů s jinou, která se nachází třeba uprostřed jinýho pole

pro lepsi pochopeni ukazka, jak to zhruba mam zatim reseny (pokud pocet hledanych bytu bude vic, nez 8)

// co hledam
byte find[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 }; // velikost 9 byte

// buffer kde hledam
byte buffer[] = { 1, 9, 8, 1, 2, 3, 4, 5, 6 ,7 ,8 ,9, 4 ,2 ,3 };

// pro tech 9 bytu ktere hledam (zde bude kopie te pozice z bufferu)
// alokuje se mimo smycku...
byte* temp = new byte[9];

// prekopiruje tu cast bufferu do tempu (3 je offset)
memcpy(temp, buffer + 3, 9);

// porovnam vyjmute byty s tim co hledam
if (!memcmp(temp, find, 9)) { /* ... */ }

a prave resim, jestli tohle je opravdu ta nejrychlejsi moznost to porovnat

#1 ingiraxo
Majú tie polia známu velkosť pri preklade?

#1 ingiraxo
Můj předpoklad je že memcmp je rozumně udělaný a optimalizovaný ačkoliv režie volání a optimalizace pro opravdu malá pole může být velká.

Teď několik tipů co mne tak z hlavy napadly:

-Použití maker pro jednotlivé velikosti porovnávaných polí, pokud jsou převážně jedné nebo několika málo stejných velikostí.

-Použití "šílených" maker, pokud to překladač zvládne optimalizovat tak si pro jednotlivé velikosti nadefinuješ přetypování/porovnání a pro moc velká pole použiješ memcmp. Bude ale třeba se kouknout do asm nebo změřit rychlost, to ostatně platí pro všechny optimalizace
něco jako  #define  mojecmp(data1,data2,velikost)  ((velikost==1)? ...:memcmp(data1,data2,velikost))

-pokud jsou data zarovnána např po 8byte tak si napsat cyklus nad polem uint_64 a skusit překladač přemluvit aby cyklus "rozvinul" tj přepsal na na kroky, skus kouknout co tvůj překladač umí.

-i když jsi nechtěl použít cyklus, existují specializované instrukce, pro x86 je to tuším REP+CMP.. kterými zapíšeš cyklus ve dvou instrukcích(+inicializace registrů). Toto by ale mněla dělat funkce memcmp i když s trochou režie na volání a ošetření okrajových podmínek(například lichý počet byte atp)

#4 vitamin
do funkce, ve který to hledam je jako parametr pole byte + jeho velikost fce(byte* data, const int size)

a buffer ma pevnou velikost, ale zapis do nej je dynamickej (nekdy 200 bytu, nekdy 5000 atd..) pocet zapsanych bytu si taky zjistuju - podle jejich poctu probiha pocet cyklů

Mozes skusit daco taketo:

template <size_t ArraySize>
inline bool array_cmp(char* array1, char* array2){
	return ((*array1) == (*array2)) & array_cmp<ArraySize-1>(array1+1, array2+1);	
}
template <>
inline bool array_cmp<0>(char* array1, char* array2){
	return true;	
}

Pripadne miesto char dat napr long, bohuzial to testuje cely buffer, takze si budes musiet nulovat nepouzite prvky.

A tazko povedat ci to bude rychlejsie :)

edit: Tak som si pozrel ten tvoj priklad a toto ti asi nepomoze :)

Preco nepouzies 

memcmp(buffer + 3, find, 9)

?

#7 vitamin
aha, já jsem trochu žil v představě, že memcmp potřebuje na porovnání pole o stejný velikosti... no na rychlosti to moc nepřidalo, když jsem dal pryč ten zbytečnej memcpy, ale nejspíš lepší možnost neni no

já právě když porovnávám něco do 8bytu, tak např. pokud jsou hledany 4 byty, tak to mam nasledovně 

if ((int&)*(buffer + offset) == (int)1234)
{
    // ...
}

což je podstatě instantní bez problevy, takže jsem se snažil najit nějakou možnost pro víc než 8byte :)