Perché memcpy () e memmove () sono più veloci degli incrementi del puntatore?

Sto copiando N byte da pSrca pDest. Questo può essere fatto in un unico ciclo:

for (int i = 0; i < N; i++)
    *pDest++ = *pSrc++

Perché è più lento di memcpyo memmove? Quali trucchi usano per accelerarlo?

Poiché memcpy usa puntatori a parole invece di puntatori a byte, anche le implementazioni di memcpy sono spesso scritte con istruzioni SIMD che rendono possibile mescolare 128 bit alla volta.

Le istruzioni SIMD sono istruzioni di assemblaggio che possono eseguire la stessa operazione su ogni elemento in un vettore lungo fino a 16 byte. Ciò include le istruzioni di caricamento e archiviazione.

Le routine di copia in memoria possono essere molto più complicate e veloci di una semplice copia in memoria tramite puntatori come:

void simple_memory_copy(void* dst, void* src, unsigned int bytes)
{
  unsigned char* b_dst = (unsigned char*)dst;
  unsigned char* b_src = (unsigned char*)src;
  for (int i = 0; i < bytes; ++i)
    *b_dst++ = *b_src++;
}

Miglioramenti

Il primo miglioramento che si può fare è allineare uno dei puntatori su un confine di parola (per parola intendo la dimensione intera nativa, di solito 32 bit / 4 byte, ma può essere 64 bit / 8 byte su architetture più recenti) e utilizzare lo spostamento di dimensioni di parola / copia le istruzioni. Ciò richiede l'utilizzo di una copia da byte a byte fino all'allineamento di un puntatore.

void aligned_memory_copy(void* dst, void* src, unsigned int bytes)
{
  unsigned char* b_dst = (unsigned char*)dst;
  unsigned char* b_src = (unsigned char*)src;

  // Copy bytes to align source pointer
  while ((b_src & 0x3) != 0)
  {
    *b_dst++ = *b_src++;
    bytes--;
  }

  unsigned int* w_dst = (unsigned int*)b_dst;
  unsigned int* w_src = (unsigned int*)b_src;
  while (bytes >= 4)
  {
    *w_dst++ = *w_src++;
    bytes -= 4;
  }

  // Copy trailing bytes
  if (bytes > 0)
  {
    b_dst = (unsigned char*)w_dst;
    b_src = (unsigned char*)w_src;
    while (bytes > 0)
    {
      *b_dst++ = *b_src++;
      bytes--;
    }
  }
}

Architetture diverse funzioneranno in modo diverso a seconda che il puntatore di origine o di destinazione sia allineato in modo appropriato. Ad esempio su un processore XScale ho ottenuto prestazioni migliori allineando il puntatore di destinazione anziché il puntatore di origine.

Per migliorare ulteriormente le prestazioni è possibile eseguire alcuni cicli di srotolamento, in modo che più registri del processore vengano caricati con i dati e ciò significa che le istruzioni di caricamento / memorizzazione possono essere intercalate e la loro latenza è nascosta da istruzioni aggiuntive (come il conteggio dei loop, ecc.). Il vantaggio che ciò comporta varia notevolmente a seconda del processore, poiché le latenze delle istruzioni di caricamento / memorizzazione possono essere molto diverse.

In questa fase il codice finisce per essere scritto in Assembly anziché in C (o C ++) poiché è necessario posizionare manualmente il caricamento e archiviare le istruzioni per ottenere il massimo vantaggio dall'occultamento della latenza e dalla velocità effettiva.

Generalmente un'intera linea di dati della cache dovrebbe essere copiata in un'iterazione del ciclo srotolato.

Il che mi porta al miglioramento successivo, aggiungendo il prelettura. Queste sono istruzioni speciali che indicano al sistema di cache del processore di caricare parti specifiche di memoria nella sua cache. Poiché c'è un ritardo tra l'emissione dell'istruzione e il riempimento della riga della cache, le istruzioni devono essere posizionate in modo tale che i dati siano disponibili proprio come devono essere copiati e non prima / poi.

Ciò significa inserire le istruzioni di precaricamento all'inizio della funzione e all'interno del ciclo di copia principale. Con le istruzioni di prefetch nel mezzo del ciclo di copia, si recuperano i dati che verranno copiati in diverse iterazioni.

Non ricordo, ma può anche essere utile precaricare gli indirizzi di destinazione oltre a quelli di origine.

Fattori

I principali fattori che influenzano la velocità di copia della memoria sono:

• La latenza tra il processore, le sue cache e la memoria principale.
• La dimensione e la struttura delle linee della cache del processore.
• Le istruzioni di spostamento / copia della memoria del processore (latenza, velocità effettiva, dimensione del registro, ecc.).

Quindi, se vuoi scrivere una routine di gestione della memoria efficiente e veloce, avrai bisogno di sapere abbastanza sul processore e sull'architettura per cui stai scrivendo. Basti dire che, a meno che tu non stia scrivendo su qualche piattaforma incorporata, sarebbe molto più facile usare semplicemente le routine di copia della memoria incorporate.

memcpypuò copiare più di un byte contemporaneamente a seconda dell'architettura del computer. La maggior parte dei computer moderni può funzionare con 32 bit o più in una singola istruzione del processore.

Da un'implementazione di esempio :

    00026 * Per una copia veloce, ottimizza il caso comune in cui entrambi i puntatori
    00027 * e la lunghezza è allineata alla parola e copia la parola alla volta
    00028 * di byte alla volta. Altrimenti, copia byte.

È possibile implementare memcpy()utilizzando una delle seguenti tecniche, alcune dipendono dalla propria architettura per migliorare le prestazioni e saranno tutte molto più veloci del codice:

1. Usa unità più grandi, come parole a 32 bit invece di byte. Puoi anche (o devi) occuparti dell'allineamento anche qui. Non puoi leggere / scrivere una parola a 32 bit in una posizione di memoria strana, ad esempio su alcune piattaforme, e su altre piattaforme paghi un'enorme penalità per le prestazioni. Per risolvere questo problema, l'indirizzo deve essere un'unità divisibile per 4. Puoi portarlo fino a 64 bit per CPU a 64 bit, o anche superiore utilizzando istruzioni SIMD (istruzione singola, dati multipli) ( MMX , SSE , ecc.)

2. Puoi usare istruzioni speciali della CPU che il tuo compilatore potrebbe non essere in grado di ottimizzare da C. Ad esempio, su un 80386, puoi usare l'istruzione prefisso "rep" + l'istruzione "movsb" per spostare N byte dettati inserendo N nel conteggio Registrati. I buoni compilatori lo faranno solo per te, ma potresti trovarti su una piattaforma che manca di un buon compilatore. Nota, quell'esempio tende ad essere una cattiva dimostrazione di velocità, ma combinato con l'allineamento + istruzioni di unità più grandi, può essere più veloce di quasi tutto il resto su alcune CPU.

3. Svolgimento loop : i rami possono essere piuttosto costosi su alcune CPU, quindi lo srotolamento dei loop può ridurre il numero di rami. Questa è anche una buona tecnica per combinare con istruzioni SIMD e unità di dimensioni molto grandi.

Ad esempio, http://www.agner.org/optimize/#asmlib ha memcpyun'implementazione che batte di più (di una quantità molto piccola). Se leggi il codice sorgente, sarà pieno di tonnellate di codice assembly inline che tira fuori tutte le tre tecniche precedenti, scegliendo quale di queste tecniche in base alla CPU su cui stai eseguendo.

Nota, ci sono ottimizzazioni simili che possono essere fatte anche per trovare byte in un buffer. strchr()e gli amici spesso passeranno più velocemente dell'equivalente rotolato della tua mano. Ciò è particolarmente vero per .NET e Java . Ad esempio, in .NET, il built-in String.IndexOf()è molto più veloce anche di una ricerca di stringhe Boyer – Moore , perché utilizza le tecniche di ottimizzazione di cui sopra.

Risposta breve:

• riempimento cache
• dove possibile i trasferimenti di parole anziché di byte
• Magia SIMD

Non so se sia effettivamente utilizzato in implementazioni del mondo reale di memcpy, ma penso che Duff's Device meriti una menzione qui.

Da Wikipedia :

send(to, from, count)
register short *to, *from;
register count;
{
        register n = (count + 7) / 8;
        switch(count % 8) {
        case 0:      do {     *to = *from++;
        case 7:              *to = *from++;
        case 6:              *to = *from++;
        case 5:              *to = *from++;
        case 4:              *to = *from++;
        case 3:              *to = *from++;
        case 2:              *to = *from++;
        case 1:              *to = *from++;
                } while(--n > 0);
        }
}

Nota che quanto sopra non è a memcpypoiché deliberatamente non incrementa il topuntatore. Implementa un'operazione leggermente diversa: la scrittura in un registro mappato in memoria. Vedere l'articolo di Wikipedia per i dettagli.

Come altri dicono che memcpy copia più grandi di blocchi di 1 byte. La copia in blocchi di dimensioni di una parola è molto più veloce. Tuttavia, la maggior parte delle implementazioni fa un ulteriore passo avanti ed esegue diverse istruzioni MOV (word) prima del ciclo. Il vantaggio di copiare, diciamo, 8 blocchi di parole per loop è che il loop stesso è costoso. Questa tecnica riduce il numero di rami condizionali di un fattore 8, ottimizzando la copia per i blocchi giganti.

Le risposte sono grandi, ma se si vuole ancora implementare un digiuno memcpyda soli, c'è un post sul blog interessante su memcpy veloce, memcpy veloce nel C .

void *memcpy(void* dest, const void* src, size_t count)
{
    char* dst8 = (char*)dest;
    char* src8 = (char*)src;

    if (count & 1) {
        dst8[0] = src8[0];
        dst8 += 1;
        src8 += 1;
    }

    count /= 2;
    while (count--) {
        dst8[0] = src8[0];
        dst8[1] = src8[1];

        dst8 += 2;
        src8 += 2;
    }
    return dest;
}

Può anche essere migliore ottimizzando gli accessi alla memoria.

Perché come molte routine di libreria è stato ottimizzato per l'architettura su cui stai eseguendo. Altri hanno pubblicato varie tecniche che possono essere utilizzate.

Data la scelta, usa le routine della libreria piuttosto che tirare le tue. Questa è una variazione di DRY che chiamo DRO (Don't Repeat Others). Inoltre, è meno probabile che le routine della libreria siano sbagliate rispetto alla tua implementazione.

Ho visto i controllori di accesso alla memoria lamentarsi di letture fuori limite sulla memoria o sui buffer di stringa che non erano un multiplo della dimensione della parola. Questo è il risultato dell'ottimizzazione utilizzata.

Puoi guardare l'implementazione MacOS di memset, memcpy e memmove.

Al momento dell'avvio, il sistema operativo determina su quale processore è in esecuzione. Ha incorporato un codice specificamente ottimizzato per ogni processore supportato e al momento dell'avvio memorizza un'istruzione jmp nel codice corretto in una posizione fissa di sola lettura.

Le implementazioni C memset, memcpy e memmove sono solo un salto verso quella posizione fissa.

Le implementazioni utilizzano codice diverso a seconda dell'allineamento di origine e destinazione per memcpy e memmove. Ovviamente usano tutte le capacità vettoriali disponibili. Utilizzano anche varianti non memorizzate nella cache quando si copiano grandi quantità di dati e dispongono di istruzioni per ridurre al minimo le attese per le tabelle di pagina. Non è solo codice assembler, è codice assembler scritto da qualcuno con un'ottima conoscenza dell'architettura di ogni processore.

Intel ha anche aggiunto le istruzioni dell'assemblatore che possono rendere più veloci le operazioni sulle stringhe. Ad esempio con un'istruzione per supportare strstr che esegue confronti a 256 byte in un ciclo.