We often need to copy a block of memory from one location to another or to set a block of memory to a specified value. So we will create functions like memcpy and memset.
memcpy Implementation
The memcpy function copies a specified number of bytes from a source memory location to a destination memory location. There are various variations of memcpy that operate on different sizes of data units: byte, words, and double words.
void *memcpy(void *dest, const void *src, size_t n)Function Purpose:
memcpy is designed to copy a block of memory (n bytes) from the source (src) to the destination (dest).
The function signature specifies void*, indicating that it returns a generic pointer (void *). In C, void * is used to represent a pointer to an unspecified type of data. It can be casted to any data type.
At the end of the function, return dest; is used to return the pointer to the destination memory location (dest). This allows the caller to potentially chain operations or perform further checks after the copying operation. In some scenarios, after copying data using memcpy, the caller might need to perform additional operations on the copied memory or verify its contents. Returning dest enable this flexibility.
Example Setup:
Consider we have a source array of 8 bytes, and we want to copy these bytes to a destination array using memcpy.
// Source array
char src[] = "ABCDEFGH"; // 8 bytes including the null terminator
char dest[9]; // Destination array (one extra byte for null terminator)
// Use memcpy to copy data from src to dest
memcpy(dest, src, 9); // Copy 9 bytes (including the null terminator)
// Print the copied array
printf("Destination array: %s\n", dest);Initial State:
- Source Array
src:
Memory Address Content
0x1000 'A'
0x1001 'B'
0x1002 'C'
0x1003 'D'
0x1004 'E'
0x1005 'F'
0x1006 'G'
0x1007 'H'
0x1008 '\0'
- Destination Array
dest:
Memory Address Content
0x2000 ?? (uninitialized)
0x2001 ?? (uninitialized)
0x2002 ?? (uninitialized)
0x2003 ?? (uninitialized)
0x2004 ?? (uninitialized)
0x2005 ?? (uninitialized)
0x2006 ?? (uninitialized)
0x2007 ?? (uninitialized)
0x2008 ?? (uninitialized)
Step-by-Step Copying:
1 First Iteration (n = 9):
Copy byte from 0x1000 ('A') to 0x2000
Source: 'A' B C D E F G H \0
Destination: 'A' ?? ?? ?? ?? ?? ?? ?? ??
2 Second Iteration (n = 8):
Copy byte from 0x1001 ('B') to 0x2001
Source: A 'B' C D E F G H \0
Destination: A 'B' ?? ?? ?? ?? ?? ?? ??
3 Third Iteration (n = 7):
Copy byte from 0x1002 ('C') to 0x2002
Source: A B 'C' D E F G H \0
Destination: A B 'C' ?? ?? ?? ?? ?? ??
4 Fourth Iteration (n = 6):
Copy byte from 0x1003 ('D') to 0x2003
Source: A B C 'D' E F G H \0
Destination: A B C 'D' ?? ?? ?? ?? ??
5 Fifth Iteration (n = 5):
Copy byte from 0x1004 ('E') to 0x2004
Source: A B C D 'E' F G H \0
Destination: A B C D 'E' ?? ?? ?? ??
6 Sixth Iteration (n = 4):
Copy byte from 0x1005 ('F') to 0x2005
Source: A B C D E 'F' G H \0
Destination: A B C D E 'F' ?? ?? ??
7 Seventh Iteration (n = 3):
Copy byte from 0x1006 ('G') to 0x2006
Source: A B C D E F 'G' H \0
Destination: A B C D E F 'G' ?? ??
8 Eight Iteration (n = 2):
Copy byte from 0x1007 ('H') to 0x2007
Source: A B C D E F G 'H' \0
Destination: A B C D E F G 'H' ??
9 Ninth Iteration (n = 1):
Copy byte from 0x1008 ('\0') to 0x2008
Source: A B C D E F G H '\0'
Destination: A B C D E F G H '\0'
Final State:
- Source Array
src:
Memory Address Content
0x1000 'A'
0x1001 'B'
0x1002 'C'
0x1003 'D'
0x1004 'E'
0x1005 'F'
0x1006 'G'
0x1007 'H'
0x1008 '\0'
- Destination Array
dest:
Memory Address Content
0x2000 'A'
0x2001 'B'
0x2002 'C'
0x2003 'D'
0x2004 'E'
0x2005 'F'
0x2006 'G'
0x2007 'H'
0x2008 '\0'Drawbacks of memcpy
memcpy is a fundamental function for copying blocks of memory from one location to another. However, despite its widespread use, memcpy has several potential drawbacks and limitations. Understanding these can help developers avoid common pitfalls and choose alternative methods when necessary.
1 Lack of Overlap Handling
memcpy does not handle overlapping memory regions correctly. If the source and destination memory blocks overlap, the behavior of memcpy is undefined, which can lead to data corruption.
char buffer[] = "Hello, World!";
memcpy(buffer + 6, buffer, 5); // Undefined behavior
Solution:
Use memove instead, which handles overlapping regions properly.
memmove(buffer + 6, buffer, 5);
2 Fixed Byte Copy
memcpy copies memory byte-by-byte, which might not be the most efficient method on architectures that can handle larger data types more efficiently (e.g., word or double-word operations).
char src[] = {0x01, 0x02, 0x03, 0x04};
char dest[4];
memcpy(dest, src, 4); // Copies byte-by-byte
Solution:
For performance-critical applications, consider using optimized variants like memcpyw or memcpydw for word or double-word copying.
3 Performance Issues with Small Data Blocks
For very small memory blocks, the overhead of calling memcpy can be significant relative to the time taken to perform the copy. Inline copying or manual copying might be faster for small, known sizes.
char a = 'A';
char b;
memcpy(&b, &a, sizeof(char)); // Overhead might be too high
Solution:
Inline Copying:
b = a;4 Alignment Issues
memcpy may not perform optimally if the source and destination pointers are not properly aligned. Misaligned memory accesses can be slower on some architectures and can even cause exceptions on others.
char src[10];
char *unaligned_dest = src + 1; // Potential misalignment
memcpy(unaligned_dest, src, 5); // Performance hit or exception
Solution: Ensure proper alignment or use aligned memory functions.
Variants of memcpy
1 memcpyb (Byte-wise memcpy):
void *memcpyb(void *dest, const void *src, size_t n) {
unsigned char *d = (unsigned char *)dest;
const unsigned char *s = (const unsigned char *)src;
// Copy bytes from src to dest
while (n--) {
*d++ = *s++;
}
return dest;
}
Explanation:
- Usage:
memcpybis a straightforward implementation that copiesnbytes fromsrctodest. - It copies data one byte at a time. it is the most straightforward implementation and is useful when dealing with unaligned memory regions or small amounts of data.
- Parameters:
dest: Pointer to the destination memory location.src: Pointer to the source memory location.n: Number of bytes to copy.
- Use Case: Ideal for small data transfers or when alignment cannot be guaranteed.
Example:
// Source array
int src[] = {1, 2, 3, 4, 5};
int n = sizeof(src) / sizeof(src[0]);
// Destination array
int dest[n];
// Use memcpy to copy data from src to dest
memcpy(dest, src, n * sizeof(int));
// Print the copied array
printf("Destination array: ");
for (int i = 0; i < n; i++) {
printf("%d ", dest[i]);
}
printf("\n");2 memcpyw (Word-wise memcpy):
typedef unsigned short uint16_t;
void *memcpyw(void *dest, const void *src, size_t n) {
uint16_t *d = (uint16_t *)dest;
const uint16_t *s = (const uint16_t *)src;
// Copy words (16-bit) from src to dest
while (n >= sizeof(uint16_t)) {
*d++ = *s++;
n -= sizeof(uint16_t);
}
// Copy remaining bytes (if any)
memcpyb(d, s, n);
return dest;
}
Explanation:
- Usage:
memcpywcopiesnbytes fromsrctodest, treating the data as 16-bit words (assuminguint16_t). - It copies data one word (16 bits) at a time. This approach can be more efficient on architectures optimized for word operations.
- Parameters:
dest: Pointer to the destination memory location.src: Pointer to the source memory location.n: Number of bytes to copy.
- Use Case: Suitable for medium-sized data transfers where memory alignment is generally word-aligned (16-bit).
3 memcpydw (Double-word memcpy):
typedef unsigned int uint32_t;
void *memcpydw(void *dest, const void *src, size_t n) {
uint32_t *d = (uint32_t *)dest;
const uint32_t *s = (const uint32_t *)src;
// Copy double words (32-bit) from src to dest
while (n >= sizeof(uint32_t)) {
*d++ = *s++;
n -= sizeof(uint32_t);
}
// Copy remaining bytes (if any)
memcpyb(d, s, n);
return dest;
}
Explanation:
- Usage:
memcpydwcopiesnbytes fromsrctodest, treating the data as 32-bit double words (assuminguint32_t). - It copies data one double word (32 bits) at a time. It is the most efficient for large data transfers on architectures optimized for double word operations.
- Parameters:
dest: Pointer to the destination memory location.src: Pointer to the source memory location.n: Number of bytes to copy.
- Use Case: Best for large data transfers where memory alignment is double word-aligned (32-bit).
memset Implementation
memset stands for "memory set" and is used to fill a block of memory with a particular value. It's a fundamental function in memory manipulation, often used for tasks such as initializing arrays or setting memory regions to specific patterns.
- The primary purpose of
memsetis to initialize a block of memory with a specified value.
1 memsetb (Byte-wise memset):
This variation sets each byte of the memory area to a specified value. It's straightforward and commonly used for initializing arrays and buffers.
void *memsetb(void *s, int c, int n) {
unsigned char *p = (unsigned char *)s;
while (n--) {
*p++ = (unsigned char)c;
}
return s;
}
2 memsetw (Word-wise memset):
For architectures where memory access is optimized for larger data units (e.g., 16-bit words), memsetw can set memory using word-sized operations.
typedef unsigned short uint16_t;
void *memsetw(void *s, int c, size_t n) {
uint16_t *p = (uint16_t *)s;
uint16_t value = (uint16_t)c | ((uint16_t)c << 8);
while (n >= sizeof(uint16_t)) {
*p++ = value;
n -= sizeof(uint16_t);
}
memsetb(p, c, n); // Set remaining bytes
return s;
}
3 memsetdw (Double-word memset):
This variant operates on 32-bit double words, suitable for architectures that support efficient access to larger data units.
typdef unsigned int uint32_t;
void *memsetdw(void *s, int c, size_t n) {
uint32_t *p = (uint32_t *)s;
uint32_t value = (uint32_t)c | ((uint32_t)c << 8) | ((uint32_t)c << 16) | ((uint32_t)c << 24);
while (n >= sizeof(uint32_t)) {
*p++ = value;
n -= sizeof(uint32_t);
}
memsetb(p, c, n); // Set remaining bytes
return s;
}Source Code
The source code at this point is available with this commit: https://github.com/The-Jat/TheTaaJ/tree/daa2025685b24f61c8fdea18e557bf194a46d20a