Memory Mapping Techniques and Application Examples in C Language

In modern operating systems, memory mapping is an efficient method for file I/O operations. It allows programs to directly map files or devices into the process’s address space, enabling access to file contents as if they were memory. This technique is particularly effective when handling large files, as it avoids multiple read and write operations typical of traditional I/O.

What is Memory Mapping?

Memory mapping refers to the process of directly mapping the contents of a file or other object into the virtual address space of a process. This allows programs to access file data using pointers without the need for explicit read and write operations.

Advantages of Memory Mapping

Performance Improvement: By reducing the number of system calls, I/O performance is enhanced.
Simplified Code: Data can be handled with simple pointer operations, eliminating the need for complex read and write logic.
Shared Memory: Multiple processes can share the same memory area, facilitating efficient data exchange.

How to Implement Memory Mapping in C Language?

In C language, we typically use several functions provided by the POSIX standard to implement memory mapping. The main functions involved are:

open(): Opens a file and returns its descriptor.
mmap(): Creates a new memory mapping area.
munmap(): Unmaps a previously allocated memory area.
close(): Closes an open file descriptor.

Example Code

Below is a simple example demonstrating how to use memory mapping to read the contents of a text file and print it out.

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <unistd.h>

int main() {
    // Open the file to read
    int fd = open("example.txt", O_RDONLY);
    if (fd == -1) {
        perror("Error opening file");
        return EXIT_FAILURE;
    }

    // Get the file size
    off_t filesize = lseek(fd, 0, SEEK_END);

    // Map the file to the process address space
    char *mapped = mmap(NULL, filesize, PROT_READ, MAP_PRIVATE, fd, 0);
    if (mapped == MAP_FAILED) {
        perror("Error mapping file");
        close(fd);
        return EXIT_FAILURE;
    }

    // Print the data in the mapped area
    printf("%.*s", (int)filesize, mapped);

    // Unmap the mapped area
    if (munmap(mapped, filesize) == -1) {
        perror("Error unmapping file");
        close(fd);
        return EXIT_FAILURE;
    }

    // Close the opened descriptor
    close(fd);
    return EXIT_SUCCESS;
}

Program Explanation

Open File: Use the open function to open the text file named “example.txt” in read-only mode. If it fails, an error message is printed and the program exits.
Get Size: Use the lseek function to get the size of the text file for correct length data mapping.
Create Memory Mapping: Call the mmap function to load the entire text content into the current process address space. The parameters are explained as follows:

The first parameter is NULL, indicating that the system should choose an appropriate location;
The second parameter is the number of bytes to map, which is the size of the entire document;
The third parameter specifies the protection flags, set to read-only here;
The fourth parameter is set to private (MAP_PRIVATE), meaning modifications will not affect the original object;
The fifth parameter is the file descriptor obtained earlier;
The last parameter specifies the offset from which to start mapping, set to 0, meaning from the beginning.

Print Content: Use the %.*s format string to output the entire text content based on the calculated byte size.

Unbind and Close Descriptor: Finally, call munmap to unmap the allocated area and close the previously opened descriptor to free resources.

Conclusion

This article introduced the basic concepts and implementation methods of memory mapping in C language, demonstrating how to efficiently read large-scale data using memory mapping technology through practical code examples. In actual development, this technique can significantly improve I/O performance and is a very useful means when handling large datasets. I hope this article helps you better understand and apply this technology!