32 #include <sys/types.h> 33 #include <system_error> 51 "Maximum bytes to mlock/munlock/munmap at once " 52 "(will be rounded up to PAGESIZE). Ignored if negative.");
55 #define MAP_POPULATE 0 100 void getDeviceOptions(dev_t device, off_t& pageSize,
bool& autoExtend) {
108 inline void getDeviceOptions(dev_t, off_t&,
bool&) {}
115 const bool anon = !
file_;
116 CHECK(!(grow && anon));
125 bool autoExtend =
false;
129 CHECK_ERR(fstat(
file_.
fd(), &st));
132 getDeviceOptions(st.st_dev, pageSize, autoExtend);
136 DCHECK_EQ(offset, 0);
137 CHECK_EQ(pageSize, 0);
142 pageSize = off_t(sysconf(_SC_PAGESIZE));
145 CHECK_GT(pageSize, 0);
146 CHECK_EQ(pageSize & (pageSize - 1), 0);
150 off_t skipStart = offset % pageSize;
161 off_t remaining = anon ? length : st.st_size - offset;
166 if (length > remaining) {
169 PCHECK(0 == ftruncate(
file_.
fd(), offset + length))
170 <<
"ftruncate() failed, couldn't grow file to " 192 flags |= MAP_ANONYMOUS;
199 int prot = PROT_NONE;
206 unsigned char*
start =
static_cast<unsigned char*
>(mmap(
208 PCHECK(start != MAP_FAILED)
209 <<
" offset=" << offset <<
" length=" <<
mapLength_;
211 data_.
reset(start + skipStart,
size_t(length));
217 off_t memOpChunkSize(off_t length, off_t pageSize) {
218 off_t chunkSize = length;
219 if (FLAGS_mlock_chunk_size <= 0) {
223 chunkSize = off_t(FLAGS_mlock_chunk_size);
224 off_t r = chunkSize % pageSize;
226 chunkSize += (pageSize - r);
239 std::function<
int(
void*,
size_t)>
op,
243 size_t& amountSucceeded) {
251 size_t chunkSize = size_t(memOpChunkSize(off_t(bufSize), pageSize));
253 char*
addr =
static_cast<char*
>(mem);
256 while (amountSucceeded < bufSize) {
257 size_t size =
std::min(chunkSize, bufSize - amountSucceeded);
258 if (
op(addr + amountSucceeded, size) != 0) {
261 amountSucceeded +=
size;
270 size_t amountSucceeded = 0;
309 size_t amountSucceeded = 0;
331 size_t amountSucceeded = 0;
339 "munmap({}) failed at {}",
mapLength_, amountSucceeded);
350 <<
" offset: " << offset <<
" length: " << length
355 offset -= offMisalign;
356 length += offMisalign;
359 if (offset + length !=
size_t(mapLength_)) {
367 char* mapStart =
static_cast<char*
>(
mapStart_) + offset;
368 PLOG_IF(
WARNING, ::madvise(mapStart, length, advice)) <<
"madvise";
391 assert(reinterpret_cast<uintptr_t>(src) %
alignof(
unsigned long) == 0);
392 assert(reinterpret_cast<uintptr_t>(dst) %
alignof(
unsigned long) == 0);
394 auto srcl =
static_cast<const unsigned long*
>(src);
395 auto dstl =
static_cast<unsigned long*
>(dst);
397 while (size >=
sizeof(
unsigned long)) {
399 size -=
sizeof(
unsigned long);
402 auto srcc =
reinterpret_cast<const unsigned char*
>(srcl);
403 auto dstc =
reinterpret_cast<unsigned char*
>(dstl);
416 File(dest, O_RDWR | O_CREAT | O_TRUNC, mode),
422 destMap.writableRange().data(),
void swap(MemoryMapping &other) noexcept
DEFINE_int64(mlock_chunk_size, kDefaultMlockChunkSize,"Maximum bytes to mlock/munlock/munmap at once ""(will be rounded up to PAGESIZE). Ignored if negative.")
void swap(MemoryMapping &a, MemoryMapping &b) noexcept
constexpr detail::Map< Move > move
constexpr size_type size() const
—— Concurrent Priority Queue Implementation ——
requires E e noexcept(noexcept(s.error(std::move(e))))
const HugePageSize * getHugePageSizeForDevice(dev_t device)
void alignedForwardMemcpy(void *dst, const void *src, size_t size)
bool mlock(LockMode lock)
folly::Optional< PskKeyExchangeMode > mode
constexpr auto size(C const &c) -> decltype(c.size())
constexpr Iter data() const
void advise(int advice) const
static constexpr ssize_t kDefaultMlockChunkSize
auto lock(Synchronized< D, M > &synchronized, Args &&...args)
static Options writable()
void munlock(bool dontneed=false)
Formatter< false, Args... > format(StringPiece fmt, Args &&...args)
MemoryMapping & operator=(MemoryMapping)
void init(off_t offset, off_t length)
ThreadPoolListHook * addr
void mmapFileCopy(const char *src, const char *dest, mode_t mode)
void reset(Iter start, size_type size)