Namespaces
	core

	file_mem_manager

	mem_mapper

	mode

Classes
struct	region

class	region_set

class	cache_manager

class	cache_profiler_disabled

class	cache_profiler_stats

class	cache_full_exception

class	cache_system

class	coll_mem

class	coll_mem_manager

class	file_mem

class	global_ref

class	global_ptr

class	global_ref< T, std::enable_if_t< std::is_trivially_copyable_v< T > > >

struct	is_global_ptr

struct	is_global_ptr< global_ptr< T > >

struct	test_template_type

class	home_manager

class	home_profiler_disabled

class	home_profiler_stats

class	root_resource

class	noncoll_mem

struct	cache_size_option

struct	sub_block_size_option

struct	max_dirty_cache_size_option

struct	noncoll_allocator_size_option

struct	lazy_release_check_interval_option

struct	lazy_release_make_mpi_progress_option

struct	runtime_options

class	ori

struct	prof_event_get

struct	prof_event_put

struct	prof_event_checkout_nb

struct	prof_event_checkout_comp

struct	prof_event_checkin

struct	prof_event_release

struct	prof_event_release_lazy

struct	prof_event_acquire

struct	prof_event_acquire_wait

struct	prof_event_cache_mmap

struct	prof_event_home_mmap

class	prof_events

class	release_manager

class	tlb

Typedefs
using	block_region = region< block_size_t >

using	block_region_set = region_set< block_size_t >

using	cache_profiler = ITYR_CONCAT(cache_profiler_, ITYR_ORI_CACHE_PROF)

template<typename Key , typename Value >
using	unordered_map = std::unordered_map< Key, Value >

using	cache_entry_idx_t = int

using	coll_mem_id_t = uint64_t

using	home_profiler = ITYR_CONCAT(home_profiler_, ITYR_ORI_CACHE_PROF)

using	instance = common::singleton< ori >

using	release_handler = core::instance::instance_type::release_handler

using	block_size_t = uint32_t

Functions
template<typename T >
bool	operator== (const region< T > &r1, const region< T > &r2) noexcept

template<typename T >
bool	operator!= (const region< T > &r1, const region< T > &r2) noexcept

template<typename T >
bool	overlap (const region< T > &r1, const region< T > &r2)

template<typename T >
bool	contiguous (const region< T > &r1, const region< T > &r2)

template<typename T >
region< T >	get_union (const region< T > &r1, const region< T > &r2)

template<typename T >
region< T >	get_intersection (const region< T > &r1, const region< T > &r2)

template<typename T >
bool	operator== (const region_set< T > &rs1, const region_set< T > &rs2) noexcept

template<typename T >
bool	operator!= (const region_set< T > &rs1, const region_set< T > &rs2) noexcept

template<typename T >
region_set< T >	get_complement (const region_set< T > &rs, const region< T > &r)

template<typename T >
region_set< T >	get_intersection (const region_set< T > &rs, const region< T > &r)

template<typename T >
region_set< T >	get_intersection (const region_set< T > &rs1, const region_set< T > &rs2)

template<typename Fn >
void	for_each_mem_segment (const coll_mem &cm, const void *addr, std::size_t size, Fn fn)

template<typename T1 , typename T2 >
auto	operator- (const global_ptr< T1 > &p1, const global_ptr< T2 > &p2)

template<typename T >
constexpr bool	operator== (const global_ptr< T > &p1, const global_ptr< T > &p2) noexcept

template<typename T >
constexpr bool	operator== (const global_ptr< T > &p, std::nullptr_t) noexcept

template<typename T >
constexpr bool	operator== (std::nullptr_t, const global_ptr< T > &p) noexcept

template<typename T >
constexpr bool	operator!= (const global_ptr< T > &p1, const global_ptr< T > &p2) noexcept

template<typename T >
constexpr bool	operator!= (const global_ptr< T > &p, std::nullptr_t) noexcept

template<typename T >
constexpr bool	operator!= (std::nullptr_t, const global_ptr< T > &p) noexcept

template<typename T >
constexpr bool	operator< (const global_ptr< T > &p1, const global_ptr< T > &p2) noexcept

template<typename T >
constexpr bool	operator> (const global_ptr< T > &p1, const global_ptr< T > &p2) noexcept

template<typename T >
constexpr bool	operator<= (const global_ptr< T > &p1, const global_ptr< T > &p2) noexcept

template<typename T >
constexpr bool	operator>= (const global_ptr< T > &p1, const global_ptr< T > &p2) noexcept

template<typename T >
constexpr void	swap (global_ptr< T > &p1, global_ptr< T > &p2) noexcept

template<typename T , typename U >
global_ptr< T >	static_pointer_cast (const global_ptr< U > &p) noexcept

template<typename T , typename U >
global_ptr< T >	dynamic_pointer_cast (const global_ptr< U > &p) noexcept

template<typename T , typename U >
global_ptr< T >	const_pointer_cast (const global_ptr< U > &p) noexcept

template<typename T , typename U >
global_ptr< T >	reinterpret_pointer_cast (const global_ptr< U > &p) noexcept

template<typename T >
void	swap (global_ref< T > r1, global_ref< T > r2)

template<typename T , typename MemberT >
auto	operator->* (global_ptr< T > ptr, MemberT T::*mp)

void	print_compile_options ()

void	init (MPI_Comm comm=MPI_COMM_WORLD)

void	fini ()

template<typename T >
global_ptr< T >	malloc_coll (std::size_t count)

template<typename T , template< block_size_t > typename MemMapper, typename... MemMapperArgs>
global_ptr< T >	malloc_coll (std::size_t count, MemMapperArgs &&... mmargs)

template<typename T >
global_ptr< T >	malloc (std::size_t count)

template<typename T >
void	free_coll (global_ptr< T > ptr)

template<typename T >
void	free (global_ptr< T > ptr, std::size_t count)

template<typename ConstT , typename T >
void	get (global_ptr< ConstT > from_ptr, T *to_ptr, std::size_t count)

template<typename T >
void	put (const T *from_ptr, global_ptr< T > to_ptr, std::size_t count)

template<bool SkipFetch, typename T >
T *	checkout_with_getput (global_ptr< T > ptr, std::size_t count)

template<typename T >
std::pair< T *, bool >	checkout_nb (global_ptr< T > ptr, std::size_t count, mode::read_t)

template<typename T >
std::pair< T *, bool >	checkout_nb (global_ptr< T > ptr, std::size_t count, mode::write_t)

template<typename T >
std::pair< T *, bool >	checkout_nb (global_ptr< T > ptr, std::size_t count, mode::read_write_t)

void	checkout_complete ()

template<typename T , typename Mode >
auto	checkout (global_ptr< T > ptr, std::size_t count, Mode mode)

template<bool RegisterDirty, typename T >
void	checkin_with_getput (T *raw_ptr, std::size_t count)

template<typename T >
void	checkin (T *raw_ptr, std::size_t count, mode::read_t)

template<typename T >
void	checkin (T *raw_ptr, std::size_t count, mode::write_t)

template<typename T >
void	checkin (T *raw_ptr, std::size_t count, mode::read_write_t)

void	release ()

auto	release_lazy ()

void	acquire ()

void	acquire (release_handler rh)

template<typename T >
void	set_readonly_coll (global_ptr< T > ptr, std::size_t count)

template<typename T >
void	unset_readonly_coll (global_ptr< T > ptr, std::size_t count)

void	poll ()

void	collect_deallocated ()

void	cache_prof_begin ()

void	cache_prof_end ()

void	cache_prof_print ()

void *	file_mem_alloc_coll (const std::string &fpath, bool mlock)

void	file_mem_free_coll (void *addr)

file_mem &	file_mem_get (void *addr)

std::string	str (mode::read_t)

std::string	str (mode::write_t)

std::string	str (mode::read_write_t)

std::size_t	sys_mmap_entry_limit ()

Variables
template<typename T >
constexpr bool	is_global_ptr_v = is_global_ptr<T>::value

constexpr block_size_t	block_size = ITYR_ORI_BLOCK_SIZE

constexpr bool	force_getput = ITYR_ORI_FORCE_GETPUT

Typedef Documentation

◆ block_region

using ityr::ori::block_region = typedef region<block_size_t>

◆ block_region_set

using ityr::ori::block_region_set = typedef region_set<block_size_t>

◆ block_size_t

using ityr::ori::block_size_t = typedef uint32_t

◆ cache_entry_idx_t

using ityr::ori::cache_entry_idx_t = typedef int

◆ cache_profiler

using ityr::ori::cache_profiler = typedef ITYR_CONCAT(cache_profiler_, ITYR_ORI_CACHE_PROF)

◆ coll_mem_id_t

using ityr::ori::coll_mem_id_t = typedef uint64_t

◆ home_profiler

using ityr::ori::home_profiler = typedef ITYR_CONCAT(home_profiler_, ITYR_ORI_CACHE_PROF)

◆ instance

using ityr::ori::instance = typedef common::singleton<ori>

◆ release_handler

using ityr::ori::release_handler = typedef core::instance::instance_type::release_handler

◆ unordered_map

template<typename Key , typename Value >

using ityr::ori::unordered_map = typedef std::unordered_map<Key, Value>

Function Documentation

◆ acquire() [1/2]

void ityr::ori::acquire ( )

inline

◆ acquire() [2/2]

void ityr::ori::acquire ( release_handler rh )

inline

◆ cache_prof_begin()

void ityr::ori::cache_prof_begin ( )

inline

◆ cache_prof_end()

void ityr::ori::cache_prof_end ( )

inline

◆ cache_prof_print()

void ityr::ori::cache_prof_print ( )

inline

◆ checkin() [1/3]

template<typename T >

void ityr::ori::checkin	(	T *	raw_ptr,
		std::size_t	count,
		mode::read_t
	)

inline

◆ checkin() [2/3]

template<typename T >

void ityr::ori::checkin	(	T *	raw_ptr,
		std::size_t	count,
		mode::read_write_t
	)

inline

◆ checkin() [3/3]

template<typename T >

void ityr::ori::checkin	(	T *	raw_ptr,
		std::size_t	count,
		mode::write_t
	)

inline

◆ checkin_with_getput()

template<bool RegisterDirty, typename T >

void ityr::ori::checkin_with_getput	(	T *	raw_ptr,
		std::size_t	count
	)

inline

◆ checkout()

template<typename T , typename Mode >

auto ityr::ori::checkout	(	global_ptr< T >	ptr,
		std::size_t	count,
		Mode	mode
	)

inline

◆ checkout_complete()

void ityr::ori::checkout_complete ( )

inline

◆ checkout_nb() [1/3]

template<typename T >

std::pair<T*, bool> ityr::ori::checkout_nb	(	global_ptr< T >	ptr,
		std::size_t	count,
		mode::read_t
	)

inline

◆ checkout_nb() [2/3]

template<typename T >

std::pair<T*, bool> ityr::ori::checkout_nb	(	global_ptr< T >	ptr,
		std::size_t	count,
		mode::read_write_t
	)

inline

◆ checkout_nb() [3/3]

template<typename T >

std::pair<T*, bool> ityr::ori::checkout_nb	(	global_ptr< T >	ptr,
		std::size_t	count,
		mode::write_t
	)

inline

◆ checkout_with_getput()

template<bool SkipFetch, typename T >

T* ityr::ori::checkout_with_getput	(	global_ptr< T >	ptr,
		std::size_t	count
	)

inline

◆ collect_deallocated()

void ityr::ori::collect_deallocated ( )

inline

◆ const_pointer_cast()

template<typename T , typename U >

global_ptr<T> ityr::ori::const_pointer_cast ( const global_ptr< U > & p )

inlinenoexcept

◆ contiguous()

template<typename T >

bool ityr::ori::contiguous	(	const region< T > &	r1,
		const region< T > &	r2
	)

inline

◆ dynamic_pointer_cast()

template<typename T , typename U >

global_ptr<T> ityr::ori::dynamic_pointer_cast ( const global_ptr< U > & p )

inlinenoexcept

◆ file_mem_alloc_coll()

void* ityr::ori::file_mem_alloc_coll	(	const std::string &	fpath,
		bool	mlock
	)

inline

◆ file_mem_free_coll()

void ityr::ori::file_mem_free_coll ( void * addr )

inline

◆ file_mem_get()

file_mem& ityr::ori::file_mem_get ( void * addr )

inline

◆ fini()

void ityr::ori::fini ( )

inline

◆ for_each_mem_segment()

template<typename Fn >

void ityr::ori::for_each_mem_segment	(	const coll_mem &	cm,
		const void *	addr,
		std::size_t	size,
		Fn	fn
	)

inline

◆ free()

template<typename T >

void ityr::ori::free	(	global_ptr< T >	ptr,
		std::size_t	count
	)

inline

◆ free_coll()

template<typename T >

void ityr::ori::free_coll ( global_ptr< T > ptr )

inline

◆ get()

template<typename ConstT , typename T >

void ityr::ori::get	(	global_ptr< ConstT >	from_ptr,
		T *	to_ptr,
		std::size_t	count
	)

inline

◆ get_complement()

template<typename T >

region_set<T> ityr::ori::get_complement	(	const region_set< T > &	rs,
		const region< T > &	r
	)

inline

◆ get_intersection() [1/3]

template<typename T >

region<T> ityr::ori::get_intersection	(	const region< T > &	r1,
		const region< T > &	r2
	)

inline

◆ get_intersection() [2/3]

template<typename T >

region_set<T> ityr::ori::get_intersection	(	const region_set< T > &	rs,
		const region< T > &	r
	)

inline

◆ get_intersection() [3/3]

template<typename T >

region_set<T> ityr::ori::get_intersection	(	const region_set< T > &	rs1,
		const region_set< T > &	rs2
	)

inline

◆ get_union()

template<typename T >

region<T> ityr::ori::get_union	(	const region< T > &	r1,
		const region< T > &	r2
	)

inline

◆ init()

void ityr::ori::init ( MPI_Comm comm = MPI_COMM_WORLD )

inline

◆ malloc()

template<typename T >

global_ptr<T> ityr::ori::malloc ( std::size_t count )

inline

◆ malloc_coll() [1/2]

template<typename T >

global_ptr<T> ityr::ori::malloc_coll ( std::size_t count )

inline

◆ malloc_coll() [2/2]

template<typename T , template< block_size_t > typename MemMapper, typename... MemMapperArgs>

global_ptr<T> ityr::ori::malloc_coll	(	std::size_t	count,
		MemMapperArgs &&...	mmargs
	)

inline

◆ operator!=() [1/5]

template<typename T >

constexpr bool ityr::ori::operator!=	(	const global_ptr< T > &	p,
		std::nullptr_t
	)

inlineconstexprnoexcept

◆ operator!=() [2/5]

template<typename T >

constexpr bool ityr::ori::operator!=	(	const global_ptr< T > &	p1,
		const global_ptr< T > &	p2
	)

inlineconstexprnoexcept

◆ operator!=() [3/5]

template<typename T >

bool ityr::ori::operator!=	(	const region< T > &	r1,
		const region< T > &	r2
	)

inlinenoexcept

◆ operator!=() [4/5]

template<typename T >

bool ityr::ori::operator!=	(	const region_set< T > &	rs1,
		const region_set< T > &	rs2
	)

inlinenoexcept

◆ operator!=() [5/5]

template<typename T >

constexpr bool ityr::ori::operator!=	(	std::nullptr_t	,
		const global_ptr< T > &	p
	)

inlineconstexprnoexcept

◆ operator-()

template<typename T1 , typename T2 >

auto ityr::ori::operator-	(	const global_ptr< T1 > &	p1,
		const global_ptr< T2 > &	p2
	)

inline

◆ operator->*()

template<typename T , typename MemberT >

auto ityr::ori::operator->*	(	global_ptr< T >	ptr,
		MemberT T::*	mp
	)

inline

◆ operator<()

template<typename T >

constexpr bool ityr::ori::operator<	(	const global_ptr< T > &	p1,
		const global_ptr< T > &	p2
	)

inlineconstexprnoexcept

◆ operator<=()

template<typename T >

constexpr bool ityr::ori::operator<=	(	const global_ptr< T > &	p1,
		const global_ptr< T > &	p2
	)

inlineconstexprnoexcept

◆ operator==() [1/5]

template<typename T >

constexpr bool ityr::ori::operator==	(	const global_ptr< T > &	p,
		std::nullptr_t
	)

inlineconstexprnoexcept

◆ operator==() [2/5]

template<typename T >

constexpr bool ityr::ori::operator==	(	const global_ptr< T > &	p1,
		const global_ptr< T > &	p2
	)

inlineconstexprnoexcept

◆ operator==() [3/5]

template<typename T >

bool ityr::ori::operator==	(	const region< T > &	r1,
		const region< T > &	r2
	)

inlinenoexcept

◆ operator==() [4/5]

template<typename T >

bool ityr::ori::operator==	(	const region_set< T > &	rs1,
		const region_set< T > &	rs2
	)

inlinenoexcept

◆ operator==() [5/5]

template<typename T >

constexpr bool ityr::ori::operator==	(	std::nullptr_t	,
		const global_ptr< T > &	p
	)

inlineconstexprnoexcept

◆ operator>()

template<typename T >

constexpr bool ityr::ori::operator>	(	const global_ptr< T > &	p1,
		const global_ptr< T > &	p2
	)

inlineconstexprnoexcept

◆ operator>=()

template<typename T >

constexpr bool ityr::ori::operator>=	(	const global_ptr< T > &	p1,
		const global_ptr< T > &	p2
	)

inlineconstexprnoexcept

◆ overlap()

template<typename T >

bool ityr::ori::overlap	(	const region< T > &	r1,
		const region< T > &	r2
	)

inline

◆ poll()

void ityr::ori::poll ( )

inline

◆ print_compile_options()

void ityr::ori::print_compile_options ( )

inline

◆ put()

template<typename T >

void ityr::ori::put	(	const T *	from_ptr,
		global_ptr< T >	to_ptr,
		std::size_t	count
	)

inline

◆ reinterpret_pointer_cast()

template<typename T , typename U >

global_ptr<T> ityr::ori::reinterpret_pointer_cast ( const global_ptr< U > & p )

inlinenoexcept

◆ release()

void ityr::ori::release ( )

inline

◆ release_lazy()

auto ityr::ori::release_lazy ( )

inline

◆ set_readonly_coll()

template<typename T >

void ityr::ori::set_readonly_coll	(	global_ptr< T >	ptr,
		std::size_t	count
	)

inline

◆ static_pointer_cast()

template<typename T , typename U >

global_ptr<T> ityr::ori::static_pointer_cast ( const global_ptr< U > & p )

inlinenoexcept

◆ str() [1/3]

std::string ityr::ori::str ( mode::read_t )

inline

◆ str() [2/3]

std::string ityr::ori::str ( mode::read_write_t )

inline

◆ str() [3/3]

std::string ityr::ori::str ( mode::write_t )

inline

◆ swap() [1/2]

template<typename T >

constexpr void ityr::ori::swap	(	global_ptr< T > &	p1,
		global_ptr< T > &	p2
	)

inlineconstexprnoexcept

◆ swap() [2/2]

template<typename T >

void ityr::ori::swap	(	global_ref< T >	r1,
		global_ref< T >	r2
	)

inline

◆ sys_mmap_entry_limit()

std::size_t ityr::ori::sys_mmap_entry_limit ( )

inline

◆ unset_readonly_coll()

template<typename T >

void ityr::ori::unset_readonly_coll	(	global_ptr< T >	ptr,
		std::size_t	count
	)

inline

Variable Documentation

◆ block_size

constexpr block_size_t ityr::ori::block_size = ITYR_ORI_BLOCK_SIZE

inlineconstexpr

◆ force_getput

constexpr bool ityr::ori::force_getput = ITYR_ORI_FORCE_GETPUT

inlineconstexpr

◆ is_global_ptr_v

template<typename T >

constexpr bool ityr::ori::is_global_ptr_v = is_global_ptr<T>::value

inlineconstexpr

Namespaces

Classes

Typedefs

Functions

Variables

Typedef Documentation

◆ block_region

◆ block_region_set

◆ block_size_t

◆ cache_entry_idx_t

◆ cache_profiler

◆ coll_mem_id_t

◆ home_profiler

◆ instance

◆ release_handler

◆ unordered_map

Function Documentation

◆ acquire() [1/2]

◆ acquire() [2/2]

◆ cache_prof_begin()

◆ cache_prof_end()

◆ cache_prof_print()

◆ checkin() [1/3]

◆ checkin() [2/3]

◆ checkin() [3/3]

◆ checkin_with_getput()

◆ checkout()

◆ checkout_complete()

◆ checkout_nb() [1/3]

◆ checkout_nb() [2/3]

◆ checkout_nb() [3/3]

◆ checkout_with_getput()

◆ collect_deallocated()

◆ const_pointer_cast()

◆ contiguous()

◆ dynamic_pointer_cast()

◆ file_mem_alloc_coll()

◆ file_mem_free_coll()

◆ file_mem_get()

◆ fini()

◆ for_each_mem_segment()

◆ free()

◆ free_coll()

◆ get()

◆ get_complement()

◆ get_intersection() [1/3]

◆ get_intersection() [2/3]

◆ get_intersection() [3/3]

◆ get_union()

◆ init()

◆ malloc()

◆ malloc_coll() [1/2]

◆ malloc_coll() [2/2]

◆ operator!=() [1/5]

◆ operator!=() [2/5]

◆ operator!=() [3/5]

◆ operator!=() [4/5]

◆ operator!=() [5/5]

◆ operator-()

◆ operator->*()

◆ operator<()

◆ operator<=()

◆ operator==() [1/5]

◆ operator==() [2/5]

◆ operator==() [3/5]

◆ operator==() [4/5]

◆ operator==() [5/5]

◆ operator>()

◆ operator>=()

◆ overlap()

◆ poll()

◆ print_compile_options()

◆ put()

◆ reinterpret_pointer_cast()

◆ release()

◆ release_lazy()

◆ set_readonly_coll()

◆ static_pointer_cast()

◆ str() [1/3]

◆ str() [2/3]