memory_mapping.hpp
Go to the documentation of this file.
#ifndef OSMIUM_UTIL_MEMORY_MAPPING_HPP
#define OSMIUM_UTIL_MEMORY_MAPPING_HPP
/*
This file is part of Osmium (http://osmcode.org/libosmium).
Copyright 2013-2016 Jochen Topf <jochen@topf.org> and others (see README).
Boost Software License - Version 1.0 - August 17th, 2003
Permission is hereby granted, free of charge, to any person or organization
obtaining a copy of the software and accompanying documentation covered by
this license (the "Software") to use, reproduce, display, distribute,
execute, and transmit the Software, and to prepare derivative works of the
Software, and to permit third-parties to whom the Software is furnished to
do so, all subject to the following:
The copyright notices in the Software and this entire statement, including
the above license grant, this restriction and the following disclaimer,
must be included in all copies of the Software, in whole or in part, and
all derivative works of the Software, unless such copies or derivative
works are solely in the form of machine-executable object code generated by
a source language processor.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
*/
#include <cassert>
#include <cerrno>
#include <stdexcept>
#include <system_error>
#include <osmium/util/compatibility.hpp>
#include <osmium/util/file.hpp>
#ifndef _WIN32
# include <sys/mman.h>
#else
# include <fcntl.h>
# include <io.h>
# include <windows.h>
# include <sys/types.h>
#endif
namespace osmium {
namespace util {
class MemoryMapping {
public:
enum class mapping_mode {
readonly = 0,
write_private = 1,
write_shared = 2
};
private:
size_t m_size;
off_t m_offset;
int m_fd;
mapping_mode m_mapping_mode;
#ifdef _WIN32
HANDLE m_handle;
#endif
void* m_addr;
bool is_valid() const noexcept;
void make_invalid() noexcept;
#ifdef _WIN32
typedef DWORD flag_type;
#else
typedef int flag_type;
#endif
flag_type get_protection() const noexcept;
flag_type get_flags() const noexcept;
// A zero-sized mapping is not allowed by the operating system.
// So if the user asks for a mapping of size 0, we map a full
// page instead. This way we don't have a special case in the rest
// of the code.
static size_t initial_size(size_t size) {
if (size == 0) {
return osmium::util::get_pagesize();
}
return size;
}
#ifdef _WIN32
HANDLE get_handle() const noexcept;
HANDLE osmium::util::MemoryMapping::create_file_mapping() const noexcept;
void* osmium::util::MemoryMapping::map_view_of_file() const noexcept;
#endif
int resize_fd(int fd) {
// Anonymous mapping doesn't need resizing.
if (fd == -1) {
return -1;
}
// Make sure the file backing this mapping is large enough.
if (osmium::util::file_size(fd) < m_size + m_offset) {
osmium::util::resize_file(fd, m_size + m_offset);
}
return fd;
}
public:
MemoryMapping(size_t size, mapping_mode mode, int fd=-1, off_t offset=0);
OSMIUM_DEPRECATED MemoryMapping(size_t size, bool writable=true, int fd=-1, off_t offset=0) :
MemoryMapping(size, writable ? mapping_mode::write_shared : mapping_mode::readonly, fd, offset) {
}
MemoryMapping(const MemoryMapping&) = delete;
MemoryMapping& operator=(const MemoryMapping&) = delete;
MemoryMapping(MemoryMapping&& other);
MemoryMapping& operator=(MemoryMapping&& other);
~MemoryMapping() noexcept {
try {
unmap();
} catch (std::system_error&) {
// Ignore any exceptions because destructor must not throw.
}
}
void unmap();
void resize(size_t new_size);
explicit operator bool() const noexcept {
return is_valid();
}
size_t size() const noexcept {
return m_size;
}
int fd() const noexcept {
return m_fd;
}
bool writable() const noexcept {
return m_mapping_mode != mapping_mode::readonly;
}
template <typename T = void>
T* get_addr() const {
if (is_valid()) {
return reinterpret_cast<T*>(m_addr);
}
throw std::runtime_error("invalid memory mapping");
}
}; // class MemoryMapping
class AnonymousMemoryMapping : public MemoryMapping {
public:
AnonymousMemoryMapping(size_t size) :
MemoryMapping(size, mapping_mode::write_private) {
}
#ifndef __linux__
void resize(size_t) = delete;
#endif
}; // class AnonymousMemoryMapping
template <typename T>
class TypedMemoryMapping {
MemoryMapping m_mapping;
public:
TypedMemoryMapping(size_t size) :
m_mapping(sizeof(T) * size, MemoryMapping::mapping_mode::write_private) {
}
TypedMemoryMapping(size_t size, MemoryMapping::mapping_mode mode, int fd, off_t offset = 0) :
m_mapping(sizeof(T) * size, mode, fd, sizeof(T) * offset) {
}
OSMIUM_DEPRECATED TypedMemoryMapping(size_t size, bool writable, int fd, off_t offset = 0) :
m_mapping(sizeof(T) * size, writable ? MemoryMapping::mapping_mode::write_shared : MemoryMapping::mapping_mode::readonly, fd, sizeof(T) * offset) {
}
TypedMemoryMapping(const TypedMemoryMapping&) = delete;
TypedMemoryMapping& operator=(const TypedMemoryMapping&) = delete;
TypedMemoryMapping(TypedMemoryMapping&& other) = default;
TypedMemoryMapping& operator=(TypedMemoryMapping&& other) = default;
~TypedMemoryMapping() noexcept = default;
void unmap() {
m_mapping.unmap();
}
void resize(size_t new_size) {
m_mapping.resize(sizeof(T) * new_size);
}
explicit operator bool() const noexcept {
return !!m_mapping;
}
size_t size() const noexcept {
assert(m_mapping.size() % sizeof(T) == 0);
return m_mapping.size() / sizeof(T);
}
int fd() const noexcept {
return m_mapping.fd();
}
bool writable() const noexcept {
return m_mapping.writable();
}
T* begin() {
return m_mapping.get_addr<T>();
}
T* end() {
return m_mapping.get_addr<T>() + size();
}
const T* cbegin() const {
return m_mapping.get_addr<T>();
}
const T* cend() const {
return m_mapping.get_addr<T>() + size();
}
const T* begin() const {
return m_mapping.get_addr<T>();
}
const T* end() const {
return m_mapping.get_addr<T>() + size();
}
}; // class TypedMemoryMapping
template <typename T>
class AnonymousTypedMemoryMapping : public TypedMemoryMapping<T> {
public:
AnonymousTypedMemoryMapping(size_t size) :
TypedMemoryMapping<T>(size) {
}
#ifndef __linux__
void resize(size_t) = delete;
#endif
}; // class AnonymousTypedMemoryMapping
} // namespace util
} // namespace osmium
#ifndef _WIN32
// =========== Unix implementation =============
// MAP_FAILED is often a macro containing an old style cast
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wold-style-cast"
inline bool osmium::util::MemoryMapping::is_valid() const noexcept {
return m_addr != MAP_FAILED;
}
inline void osmium::util::MemoryMapping::make_invalid() noexcept {
m_addr = MAP_FAILED;
}
#pragma GCC diagnostic pop
// for BSD systems
#ifndef MAP_ANONYMOUS
# define MAP_ANONYMOUS MAP_ANON
#endif
inline int osmium::util::MemoryMapping::get_protection() const noexcept {
if (m_mapping_mode == mapping_mode::readonly) {
return PROT_READ;
}
return PROT_READ | PROT_WRITE;
}
inline int osmium::util::MemoryMapping::get_flags() const noexcept {
if (m_fd == -1) {
return MAP_PRIVATE | MAP_ANONYMOUS;
}
if (m_mapping_mode == mapping_mode::write_shared) {
return MAP_SHARED;
}
return MAP_PRIVATE;
}
inline osmium::util::MemoryMapping::MemoryMapping(size_t size, mapping_mode mode, int fd, off_t offset) :
m_size(initial_size(size)),
m_offset(offset),
m_fd(resize_fd(fd)),
m_mapping_mode(mode),
m_addr(::mmap(nullptr, m_size, get_protection(), get_flags(), m_fd, m_offset)) {
assert(!(fd == -1 && mode == mapping_mode::readonly));
if (!is_valid()) {
throw std::system_error(errno, std::system_category(), "mmap failed");
}
}
inline osmium::util::MemoryMapping::MemoryMapping(MemoryMapping&& other) :
m_size(other.m_size),
m_offset(other.m_offset),
m_fd(other.m_fd),
m_mapping_mode(other.m_mapping_mode),
m_addr(other.m_addr) {
other.make_invalid();
}
inline osmium::util::MemoryMapping& osmium::util::MemoryMapping::operator=(osmium::util::MemoryMapping&& other) {
unmap();
m_size = other.m_size;
m_offset = other.m_offset;
m_fd = other.m_fd;
m_mapping_mode = other.m_mapping_mode;
m_addr = other.m_addr;
other.make_invalid();
return *this;
}
inline void osmium::util::MemoryMapping::unmap() {
if (is_valid()) {
if (::munmap(m_addr, m_size) != 0) {
throw std::system_error(errno, std::system_category(), "munmap failed");
}
make_invalid();
}
}
inline void osmium::util::MemoryMapping::resize(size_t new_size) {
assert(new_size > 0 && "can not resize to zero size");
if (m_fd == -1) { // anonymous mapping
#ifdef __linux__
m_addr = ::mremap(m_addr, m_size, new_size, MREMAP_MAYMOVE);
if (!is_valid()) {
throw std::system_error(errno, std::system_category(), "mremap failed");
}
m_size = new_size;
#else
assert(false && "can't resize anonymous mappings on non-linux systems");
#endif
} else { // file-based mapping
unmap();
m_size = new_size;
resize_fd(m_fd);
m_addr = ::mmap(nullptr, new_size, get_protection(), get_flags(), m_fd, m_offset);
if (!is_valid()) {
throw std::system_error(errno, std::system_category(), "mmap (remap) failed");
}
}
}
#else
// =========== Windows implementation =============
/* References:
* CreateFileMapping: http://msdn.microsoft.com/en-us/library/aa366537(VS.85).aspx
* CloseHandle: http://msdn.microsoft.com/en-us/library/ms724211(VS.85).aspx
* MapViewOfFile: http://msdn.microsoft.com/en-us/library/aa366761(VS.85).aspx
* UnmapViewOfFile: http://msdn.microsoft.com/en-us/library/aa366882(VS.85).aspx
*/
namespace osmium {
namespace util {
inline DWORD dword_hi(uint64_t x) {
return static_cast<DWORD>(x >> 32);
}
inline DWORD dword_lo(uint64_t x) {
return static_cast<DWORD>(x & 0xffffffff);
}
} // namespace util
} // namespace osmium
inline DWORD osmium::util::MemoryMapping::get_protection() const noexcept {
switch (m_mapping_mode) {
case mapping_mode::readonly:
return PAGE_READONLY;
case mapping_mode::write_private:
return PAGE_WRITECOPY;
case mapping_mode::write_shared:
return PAGE_READWRITE;
}
}
inline DWORD osmium::util::MemoryMapping::get_flags() const noexcept {
switch (m_mapping_mode) {
case mapping_mode::readonly:
return FILE_MAP_READ;
case mapping_mode::write_private:
return FILE_MAP_COPY;
case mapping_mode::write_shared:
return FILE_MAP_WRITE;
}
}
inline HANDLE osmium::util::MemoryMapping::get_handle() const noexcept {
if (m_fd == -1) {
return INVALID_HANDLE_VALUE;
}
return reinterpret_cast<HANDLE>(_get_osfhandle(m_fd));
}
inline HANDLE osmium::util::MemoryMapping::create_file_mapping() const noexcept {
if (m_fd != -1) {
_setmode(m_fd, _O_BINARY);
}
return CreateFileMapping(get_handle(), nullptr, get_protection(), osmium::util::dword_hi(static_cast<uint64_t>(m_size) + m_offset), osmium::util::dword_lo(static_cast<uint64_t>(m_size) + m_offset), nullptr);
}
inline void* osmium::util::MemoryMapping::map_view_of_file() const noexcept {
return MapViewOfFile(m_handle, get_flags(), osmium::util::dword_hi(m_offset), osmium::util::dword_lo(m_offset), m_size);
}
inline bool osmium::util::MemoryMapping::is_valid() const noexcept {
return m_addr != nullptr;
}
inline void osmium::util::MemoryMapping::make_invalid() noexcept {
m_addr = nullptr;
}
inline osmium::util::MemoryMapping::MemoryMapping(size_t size, MemoryMapping::mapping_mode mode, int fd, off_t offset) :
m_size(initial_size(size)),
m_offset(offset),
m_fd(resize_fd(fd)),
m_mapping_mode(mode),
m_handle(create_file_mapping()),
m_addr(nullptr) {
if (!m_handle) {
throw std::system_error(GetLastError(), std::system_category(), "CreateFileMapping failed");
}
m_addr = map_view_of_file();
if (!is_valid()) {
throw std::system_error(GetLastError(), std::system_category(), "MapViewOfFile failed");
}
}
inline osmium::util::MemoryMapping::MemoryMapping(MemoryMapping&& other) :
m_size(other.m_size),
m_offset(other.m_offset),
m_fd(other.m_fd),
m_mapping_mode(other.m_mapping_mode),
m_handle(std::move(other.m_handle)),
m_addr(other.m_addr) {
other.make_invalid();
other.m_handle = nullptr;
}
inline osmium::util::MemoryMapping& osmium::util::MemoryMapping::operator=(osmium::util::MemoryMapping&& other) {
unmap();
m_size = other.m_size;
m_offset = other.m_offset;
m_fd = other.m_fd;
m_mapping_mode = other.m_mapping_mode;
m_handle = std::move(other.m_handle);
m_addr = other.m_addr;
other.make_invalid();
other.m_handle = nullptr;
return *this;
}
inline void osmium::util::MemoryMapping::unmap() {
if (is_valid()) {
if (! UnmapViewOfFile(m_addr)) {
throw std::system_error(GetLastError(), std::system_category(), "UnmapViewOfFile failed");
}
make_invalid();
}
if (m_handle) {
if (! CloseHandle(m_handle)) {
throw std::system_error(GetLastError(), std::system_category(), "CloseHandle failed");
}
m_handle = nullptr;
}
}
inline void osmium::util::MemoryMapping::resize(size_t new_size) {
unmap();
m_size = new_size;
resize_fd(m_fd);
m_handle = create_file_mapping();
if (!m_handle) {
throw std::system_error(GetLastError(), std::system_category(), "CreateFileMapping failed");
}
m_addr = map_view_of_file();
if (!is_valid()) {
throw std::system_error(GetLastError(), std::system_category(), "MapViewOfFile failed");
}
}
#endif
#endif // OSMIUM_UTIL_MEMORY_MAPPING_HPP
osmium::util::MemoryMapping::~MemoryMapping
~MemoryMapping() noexcept
Definition: memory_mapping.hpp:218
osmium::util::TypedMemoryMapping::end
const T * end() const
Definition: memory_mapping.hpp:483
osmium::util::MemoryMapping::is_valid
bool is_valid() const noexcept
Definition: memory_mapping.hpp:520
OSMIUM_DEPRECATED
#define OSMIUM_DEPRECATED
Definition: compatibility.hpp:50
osmium::util::MemoryMapping::get_protection
flag_type get_protection() const noexcept
Definition: memory_mapping.hpp:535
osmium::util::TypedMemoryMapping::m_mapping
MemoryMapping m_mapping
Definition: memory_mapping.hpp:335
osmium::util::MemoryMapping::MemoryMapping
MemoryMapping(size_t size, mapping_mode mode, int fd=-1, off_t offset=0)
Definition: memory_mapping.hpp:552
osmium::util::file_size
size_t file_size(int fd)
Definition: file.hpp:69
osmium::util::MemoryMapping::mapping_mode::readonly
osmium::util::MemoryMapping::get_flags
flag_type get_flags() const noexcept
Definition: memory_mapping.hpp:542
osmium::util::MemoryMapping::fd
int fd() const noexcept
Definition: memory_mapping.hpp:269
osmium::util::MemoryMapping::initial_size
static size_t initial_size(size_t size)
Definition: memory_mapping.hpp:142
osmium::util::MemoryMapping::unmap
void unmap()
Definition: memory_mapping.hpp:584
osmium::util::MemoryMapping
Definition: memory_mapping.hpp:94
osmium::util::MemoryMapping::mapping_mode
mapping_mode
Definition: memory_mapping.hpp:97
osmium::util::TypedMemoryMapping::resize
void resize(size_t new_size)
Definition: memory_mapping.hpp:415
osmium::util::MemoryMapping::flag_type
int flag_type
Definition: memory_mapping.hpp:131
osmium::util::MemoryMapping::resize_fd
int resize_fd(int fd)
Definition: memory_mapping.hpp:155
osmium::util::TypedMemoryMapping::end
T * end()
Definition: memory_mapping.hpp:467
osmium::util::get_pagesize
size_t get_pagesize()
Definition: file.hpp:105
osmium::util::MemoryMapping::m_addr
void * m_addr
The address where the memory is mapped.
Definition: memory_mapping.hpp:122
osmium::util::TypedMemoryMapping::cbegin
const T * cbegin() const
Definition: memory_mapping.hpp:471
osmium::util::MemoryMapping::m_offset
off_t m_offset
Offset into the file.
Definition: memory_mapping.hpp:109
MAP_ANONYMOUS
#define MAP_ANONYMOUS
Definition: memory_mapping.hpp:532
osmium::util::MemoryMapping::m_fd
int m_fd
File handle we got the mapping from.
Definition: memory_mapping.hpp:112
osmium::util::MemoryMapping::size
size_t size() const noexcept
Definition: memory_mapping.hpp:260
osmium::util::MemoryMapping::m_mapping_mode
mapping_mode m_mapping_mode
Mapping mode.
Definition: memory_mapping.hpp:115
file.hpp
osmium
Namespace for everything in the Osmium library.
Definition: assembler.hpp:59
osmium::util::AnonymousMemoryMapping::AnonymousMemoryMapping
AnonymousMemoryMapping(size_t size)
Definition: memory_mapping.hpp:309
osmium::util::AnonymousTypedMemoryMapping
Definition: memory_mapping.hpp:490
osmium::util::TypedMemoryMapping::TypedMemoryMapping
OSMIUM_DEPRECATED TypedMemoryMapping(size_t size, bool writable, int fd, off_t offset=0)
Definition: memory_mapping.hpp:368
osmium::util::TypedMemoryMapping::TypedMemoryMapping
TypedMemoryMapping(size_t size, MemoryMapping::mapping_mode mode, int fd, off_t offset=0)
Definition: memory_mapping.hpp:359
osmium::util::TypedMemoryMapping::size
size_t size() const noexcept
Definition: memory_mapping.hpp:432
osmium::util::TypedMemoryMapping::begin
T * begin()
Definition: memory_mapping.hpp:458
osmium::util::AnonymousMemoryMapping
Definition: memory_mapping.hpp:305
osmium::util::MemoryMapping::make_invalid
void make_invalid() noexcept
Definition: memory_mapping.hpp:524
osmium::util::MemoryMapping::mapping_mode::write_private
osmium::util::AnonymousTypedMemoryMapping::AnonymousTypedMemoryMapping
AnonymousTypedMemoryMapping(size_t size)
Definition: memory_mapping.hpp:494
osmium::util::TypedMemoryMapping::fd
int fd() const noexcept
Definition: memory_mapping.hpp:442
osmium::util::MemoryMapping::mapping_mode::write_shared
osmium::util::MemoryMapping::resize
void resize(size_t new_size)
Definition: memory_mapping.hpp:593
osmium::util::MemoryMapping::operator=
MemoryMapping & operator=(const MemoryMapping &)=delete
You can not copy a MemoryMapping.
osmium::util::TypedMemoryMapping
Definition: memory_mapping.hpp:333
osmium::util::TypedMemoryMapping::unmap
void unmap()
Definition: memory_mapping.hpp:401
osmium::util::MemoryMapping::writable
bool writable() const noexcept
Definition: memory_mapping.hpp:276
osmium::util::resize_file
void resize_file(int fd, size_t new_size)
Definition: file.hpp:96
osmium::util::TypedMemoryMapping::begin
const T * begin() const
Definition: memory_mapping.hpp:479
osmium::util::MemoryMapping::m_size
size_t m_size
The size of the mapping.
Definition: memory_mapping.hpp:106
osmium::util::TypedMemoryMapping::cend
const T * cend() const
Definition: memory_mapping.hpp:475
osmium::util::TypedMemoryMapping::TypedMemoryMapping
TypedMemoryMapping(size_t size)
Definition: memory_mapping.hpp:345
osmium::util::MemoryMapping::MemoryMapping
OSMIUM_DEPRECATED MemoryMapping(size_t size, bool writable=true, int fd=-1, off_t offset=0)
Definition: memory_mapping.hpp:193
compatibility.hpp
osmium::util::MemoryMapping::get_addr
T * get_addr() const
Definition: memory_mapping.hpp:286
osmium::util::TypedMemoryMapping::writable
bool writable() const noexcept
Definition: memory_mapping.hpp:449