mmap() vs. reading blocks

by

I was trying to find the final word on mmap / read performance on Linux and I came across a nice post (link) on the Linux kernel mailing list. It’s from 2000, so there have been many improvements to IO and virtual memory in the kernel since then, but it nicely explains the reason why mmap or read might be faster or slower.

  • A call to mmap has more overhead than read (just like epoll has more overhead than poll, which has more overhead than read). Changing virtual memory mappings is a quite expensive operation on some processors for the same reasons that switching between different processes is expensive.
  • The IO system can already use the disk cache, so if you read a file, you’ll hit the cache or miss it no matter what method you use.

However,

  • Memory maps are generally faster for random access, especially if your access patterns are sparse and unpredictable.
  • Memory maps allow you to keep using pages from the cache until you are done. This means that if you use a file heavily for a long period of time, then close it and reopen it, the pages will still be cached. With read, your file may have been flushed from the cache ages ago. This does not apply if you use a file and immediately discard it. (If you try to mlock pages just to keep them in cache, you are trying to outsmart the disk cache and this kind of foolery rarely helps system performance).
  • Reading a file directly is very simple and fast.

The discussion of mmap/read reminds me of two other performance discussions:

  • Some Java programmers were shocked to discover that nonblocking I/O is often slower than blocking I/O, which made perfect sense if you know that nonblocking I/O requires making more syscalls.

  • Some other network programmers were shocked to learn that epoll is often slower than poll, which makes perfect sense if you know that managing epoll requires making more syscalls.

Conclusion: Use memory maps if you access data randomly, keep it around for a long time, or if you know you can share it with other processes (MAP_SHARED isn’t very interesting if there is no actual sharing). Read files normally if you access data sequentially or discard it after reading. And if either method makes your program less complex, do that. For many real world cases there’s no sure way to show one is faster without testing your actual application and NOT a benchmark.

(Sorry for necro’ing this question, but I was looking for an answer and this question kept coming up at the top of Google results.)

More Related Contents:

  1. Getting a FILE* from a std::fstream
  2. fstream won’t create a file [duplicate]
  3. How to count lines of a file in C++?
  4. How to shift characters to ASCII values in a file based on user input c++ [closed]
  5. c++ open file in one line
  6. How do I take values from text file and input into a 2D array? c++
  7. Read file line by line using ifstream in C++
  8. Read whole ASCII file into C++ std::string [duplicate]
  9. How do I read an entire file into a std::string in C++?
  10. Reading from text file until EOF repeats last line [duplicate]
  11. Difference between files written in binary and text mode
  12. How to write a large buffer into a binary file in C++, fast?
  13. In C++ is there a way to go to a specific line in a text file?
  14. Read file-contents into a string in C++ [duplicate]
  15. Elegant ways to count the frequency of words in a file
  16. Using C++ filestreams (fstream), how can you determine the size of a file?
  17. C++ Filehandling: Difference between ios::app and ios::ate?
  18. checking for eof in string::getline
  19. How to read a file into vector in C++?
  20. Intercept windows open file
  21. How to write to middle of a file in C++?
  22. Why is failbit set when eof is found on read?
  23. std::fstream buffering vs manual buffering (why 10x gain with manual buffering)?
  24. What’s the difference between opening a file with ios::binary or ios::out or both?
  25. Efficiently reading a very large text file in C++
  26. std::ofstream, check if file exists before writing
  27. CLion C++ can’t read/open .txt file in project directory
  28. Why can’t I move std::ofstream?
  29. Reading files larger than 4GB using c++ stl
  30. Performance Difference Between C and C++ Style File IO

Leave a Comment