memmove Implementierung in C

Question

Kann mir jemand helfen zu verstehen, wie Memmove in C implementiert ist. Ich habe nur eine spezielle Bedingung richtig?

if((src<dst)&&((src+sz) > dst)) 

copy from the back 

Kommt es auch auf die Art und Weise an, wie der Stack wächst?

Answer 1

Mathematisch müssen Sie sich keine Gedanken darüber machen, ob sie sich überhaupt überschneiden. Wenn src kleiner als dst ist, kopieren Sie einfach vom Ende. Wenn src größer als dst ist, kopieren Sie einfach von Anfang an.

Wenn src und dst gleich sind, einfach gleich wieder verlassen.

Das ist, weil Ihre Fälle sind eines von:

1) <-----s----->    start at end of s 
       <-----d-----> 

2) <-----s----->    start at end of s 
      <-----d-----> 

3) <-----s----->    no action 
    <-----d-----> 

4)   <-----s----->  start at beginning of s 
    <-----d-----> 

5)    <-----s-----> start at beginning of s 
    <-----d-----> 

Auch wenn es keine Überlappung, die wird immer noch gut funktionieren und Ihre Bedingungen vereinfachen.

Wenn Sie einen effizienteren Weg haben, vorwärts als rückwärts zu kopieren, dann sollten Sie nach Überlappung suchen, um sicherzustellen, dass Sie die effizienteste Methode verwenden, wenn möglich. Mit anderen Worten, ändern Sie Option 1 oben, um von Anfang an zu kopieren.

Answer 2

Hängt vom Compiler ab. Gute Compiler verwenden gute Optimierungen abhängig vom Zielprozessor-Befehlssatz und der Busbreite.

Answer 3

memmove kann in einen Memcpy umgewandelt werden, wenn sich die beiden Speicherbereiche nicht überschneiden. Offensichtlich ist memcpy auf den meisten Systemen extrem optimiert (eine von denen, die ich verwende, macht fast jeden Trick aus dem Buch von entrollten Schleifen zu SSE-Operationen, wo für maximalen Durchsatz unterstützt wird).

Wenn sich die beiden Speicherbereiche überlappen, wird die zu kopierende Region praktisch in einen temporären Puffer verschoben und der temporäre Puffer wird (höchstwahrscheinlich mit memcpy) wieder über den ursprünglichen Puffer kopiert. Sie können nicht von Anfang an arbeiten oder von hinten mit einer überlappenden Region arbeiten, da Sie dadurch immer mindestens einige Daten verlieren, die dabei beschädigt werden.

Das ist gesagt, es ist eine lange Zeit her, seit ich den libc-Code angeschaut habe, also könnte es eine Optimierung für memmove und überlappende Regionen geben, an die ich noch nicht gedacht habe.

memmove hängt nicht davon ab, wie der Stack überhaupt wächst - er kopiert lediglich einen Speicherbereich an einen anderen Speicherort - genau wie memcpy, außer dass er überlappende Bereiche behandelt und memcpy nicht.

EDIT: Eigentlich darüber etwas mehr denken ... Arbeiten von der Rückseite kann funktionieren, wenn Sie von der richtigen "Quelle" gehen (sozusagen), abhängig von der Bewegung selbst (zB ist Quelle < dest oder nicht?). Sie können die Implementierung von newlib here lesen, und tt ist auch ziemlich gut kommentiert.