I have found a way to increase speed in this situation. I wrote a multi-threaded version of memcpy, splitting the area to be copied between threads. Here are some performance scaling numbers for a set block size, using the same timing code as found above. I had no idea that the performance, especially for this … Read more
You likely forgot to include <string.h>. Add #include <string.h> to the top of your file.
Memory is usually organized in 4k pages (although there’s also support for larger sizes). The virtual address space your program sees may be contiguous, but it’s not necessarily the case in physical memory. The OS, which maintains a mapping of virtual to physical addresses (in the page map) would usually try to keep the physical … Read more
memcpy is likely to be the fastest way you can copy bytes around in memory. If you need something faster – try figuring out a way of not copying things around, e.g. swap pointers only, not the data itself.
[I would make this a comment, but do not have enough reputation to do so.] I have a similar system and see similar results, but can add a few data points: If you reverse the direction of your naive memcpy (i.e. convert to *p_dest– = *p_src–), then you may get much worse performance than for … Read more
Why would the behavior of std::memcpy itself be undefined when used with non-TriviallyCopyable objects? It’s not! However, once you copy the underlying bytes of one object of a non-trivially copyable type into another object of that type, the target object is not alive. We destroyed it by reusing its storage, and haven’t revitalized it by … Read more
I have a draft version of the C standard (ISO/IEC 9899:1999), and it has some fun things to say about that call. For starters, it mentions (§7.21.1/2) in regards to memcpy that Where an argument declared as size_t n specifies the length of the array for a function, n can have the value zero on … Read more
This is a topic pretty near to my heart and recent investigations, so I’ll look at it from a few angles: history, some technical notes (mostly academic), test results on my box, and finally an attempt to answer your actual question of when and where rep movsb might make sense. Partly, this is a call … Read more
This vulnerability was definitely a heap overflow. How can writing 0XFFFFFFFE bytes (4 GB!!!!) possibly not crash the program? It probably will, but on some occasions you got time to exploit before the crash happens (sometimes, you can get the program back to its normal execution and avoid the crash). When the memcpy() starts, the … Read more
what could be done to see this effect Compile and run this code: void dump5(char *str); int main() { char s[5]={‘s’,’a’,’\0′,’c’,’h’}; char membuff[5]; char strbuff[5]; memset(membuff, 0, 5); // init both buffers to nulls memset(strbuff, 0, 5); strcpy(strbuff,s); memcpy(membuff,s,5); dump5(membuff); // show what happened dump5(strbuff); return 0; } void dump5(char *str) { char *p = … Read more