map_handle.hpp File Reference

Provides `map_handle`. More...

#include "file_handle.hpp"

Classes
class	llfio_v2_xxx::section_handle
	A handle to a source of mapped memory. More...
struct	llfio_v2_xxx::construct< section_handle >
	Constructor for section_handle More...
class	llfio_v2_xxx::map_handle
	A handle to a memory mapped region of memory, either backed by the system page file or by a section. More...
struct	llfio_v2_xxx::map_handle::cache_statistics
	Statistics about the map handle cache. More...
struct	llfio_v2_xxx::construct< map_handle >
	Constructor for map_handle More...
struct	in_place_attach_detach::traits::disable_attached_for< llfio_v2_xxx ::map_handle >

Namespaces
namespace	llfio_v2_xxx
	The LLFIO namespace.

Functions
std::ostream &	llfio_v2_xxx::operator<< (std::ostream &s, const section_handle::flag &v)
byte_io_handle::const_buffer_type	llfio_v2_xxx::nvram_barrier (byte_io_handle::const_buffer_type req, bool evict=false) noexcept
template<class T >
constexpr span< T >	llfio_v2_xxx::in_place_attach (map_handle &mh) noexcept
	Declare map_handle as a suitable source for P1631 attached<T>.
result< byte_io_handle::registered_buffer_type >	llfio_v2_xxx::detail::map_handle_allocate_registered_buffer (size_t &bytes) noexcept
void	llfio_v2_xxx::swap (section_handle &self, section_handle &o) noexcept
	Swap with another instance.
result< section_handle >	llfio_v2_xxx::section (file_handle &backing, section_handle::extent_type maximum_size, section_handle::flag _flag) noexcept
	Create a memory section backed by a file.
result< section_handle >	llfio_v2_xxx::section (file_handle &backing, section_handle::extent_type bytes=0) noexcept
	Create a memory section backed by a file.
result< section_handle >	llfio_v2_xxx::section (section_handle::extent_type bytes, const path_handle &dirh=path_discovery::storage_backed_temporary_files_directory(), section_handle::flag _flag=section_handle::flag::read|section_handle::flag::write) noexcept
	Create a memory section backed by an anonymous, managed file.
result< section_handle::extent_type >	llfio_v2_xxx::length (const section_handle &self) noexcept
	Return the current maximum permitted extent of the memory section.
result< section_handle::extent_type >	llfio_v2_xxx::truncate (section_handle &self, section_handle::extent_type newsize=0) noexcept
void	llfio_v2_xxx::swap (map_handle &self, map_handle &o) noexcept
	Swap with another instance.
result< void >	llfio_v2_xxx::close (map_handle &self) noexcept
	Unmap the mapped view.
result< map_handle >	llfio_v2_xxx::map (map_handle::size_type bytes, bool zeroed=false, section_handle::flag _flag=section_handle::flag::readwrite) noexcept
result< map_handle >	llfio_v2_xxx::map (section_handle &section, map_handle::size_type bytes=0, map_handle::extent_type offset=0, section_handle::flag _flag=section_handle::flag::readwrite) noexcept
map_handle::size_type	llfio_v2_xxx::length (const map_handle &self) noexcept
	The size of the memory map. This is the accessible size, NOT the reservation size.
result< map_handle::size_type >	llfio_v2_xxx::truncate (map_handle &self, map_handle::size_type newsize, bool permit_relocation=false) noexcept
map_handle::io_result< map_handle::buffers_type >	llfio_v2_xxx::read (map_handle &self, map_handle::io_request< map_handle::buffers_type > reqs, deadline d=deadline()) noexcept
	Read data from the mapped view.
map_handle::io_result< map_handle::const_buffers_type >	llfio_v2_xxx::write (map_handle &self, map_handle::io_request< map_handle::const_buffers_type > reqs, deadline d=deadline()) noexcept
	Write data to the mapped view.
result< size_t >	llfio_v2_xxx::detail::pagesize_from_flags (section_handle::flag _flag) noexcept

Detailed Description

Provides `map_handle`.

Function Documentation

map_handle_allocate_registered_buffer()

result< byte_io_handle::registered_buffer_type > llfio_v2_xxx::detail::map_handle_allocate_registered_buffer ( size_t &  bytes )

inlinenoexcept

  {
    LLFIO_EXCEPTION_TRY
    {
      auto make_shared = [](map_handle h) -> byte_io_handle::registered_buffer_type
      {
        struct registered_buffer_type_indirect : byte_io_multiplexer::_registered_buffer_type
        {
          map_handle h;
          registered_buffer_type_indirect(map_handle _h)
              : byte_io_multiplexer::_registered_buffer_type(_h.as_span())
              , h(std::move(_h))
          {
          }
        };
        return byte_io_handle::registered_buffer_type(std::make_shared<registered_buffer_type_indirect>(std::move(h)));
      };
      const auto &page_sizes = utils::page_sizes(true);
      size_t idx = 0;
      for(size_t n = 0; n < page_sizes.size(); ++n)
      {
        if(page_sizes[n] > bytes)
        {
          break;
        }
        if((bytes & (page_sizes[n] - 1)) == 0)
        {
          idx = n;
        }
      }
      section_handle::flag flags = section_handle::flag::readwrite;
      if(idx > 0)
      {
        switch(idx)
        {
        case 1:
          flags |= section_handle::flag::page_sizes_1;
          break;
        case 2:
          flags |= section_handle::flag::page_sizes_2;
          break;
        case 3:
          flags |= section_handle::flag::page_sizes_3;
          break;
        default:
          break;
        }
        auto r = map_handle::map(bytes, false, flags);
        if(r)
        {
          bytes = (bytes + page_sizes[idx] - 1) & ~(page_sizes[idx] - 1);
          return make_shared(std::move(r).value());
        }
      }
      auto r = map_handle::map(bytes, false);
      if(r)
      {
        bytes = (bytes + page_sizes[0] - 1) & ~(page_sizes[0] - 1);
        return make_shared(std::move(r).value());
      }
      return errc::not_enough_memory;
    }
    LLFIO_EXCEPTION_CATCH_ALL
    {
      return error_from_exception();
    }
  }

pagesize_from_flags()

result< size_t > llfio_v2_xxx::detail::pagesize_from_flags ( section_handle::flag  _flag )

inlinenoexcept

  {
    LLFIO_EXCEPTION_TRY
    {
      const auto &pagesizes = utils::page_sizes();
      if((_flag & section_handle::flag::page_sizes_3) == section_handle::flag::page_sizes_3)
      {
        if(pagesizes.size() < 4)
        {
          return errc::invalid_argument;
        }
        return pagesizes[3];
      }
      else if((_flag & section_handle::flag::page_sizes_2) == section_handle::flag::page_sizes_2)
      {
        if(pagesizes.size() < 3)
        {
          return errc::invalid_argument;
        }
        return pagesizes[2];
      }
      else if((_flag & section_handle::flag::page_sizes_1) == section_handle::flag::page_sizes_1)
      {
        if(pagesizes.size() < 2)
        {
          return errc::invalid_argument;
        }
        return pagesizes[1];
      }
      return pagesizes[0];
    }
    LLFIO_EXCEPTION_CATCH_ALL
    {
      return error_from_exception();
    }
  }