champsim Namespace Reference

Namespaces
	decomp_tags
	defaults
	detail
	msl
	test

Classes
struct	deadlock
struct	cache_queue_stats
class	channel
struct	environment
struct	inf_istream
class	operable
struct	phase_info
struct	phase_stats
struct	repeatable
class	plain_printer
class	json_printer
class	tracereader
class	bulk_tracereader
struct	nonesuch
struct	is_specialization

Typedefs
template<template< class... > class Op, class... Args>
using	is_detected = typename detail::detector< nonesuch, void, Op, Args... >::value_t
template<template< class... > class Op, class... Args>
using	detected_t = typename detail::detector< nonesuch, void, Op, Args... >::type
template<class Default , template< class... > class Op, class... Args>
using	detected_or = detail::detector< Default, void, Op, Args... >
template<class Default , template< class... > class Op, class... Args>
using	detected_or_t = typename detected_or< Default, Op, Args... >::type
template<class Expected , template< class... > class Op, class... Args>
using	is_detected_exact = std::is_same< Expected, detected_t< Op, Args... > >
template<class To , template< class... > class Op, class... Args>
using	is_detected_convertible = std::is_convertible< detected_t< Op, Args... >, To >

Functions
template<typename R , typename F >
void	range_print_deadlock (const R &range, std::string kind_name, detail::fmtstr_type< R, F > fmtstr, F &&packing_func)
ooo_model_instr	apply_branch_target (ooo_model_instr branch, const ooo_model_instr &target)
template<typename It >
void	set_branch_targets (It begin, It end)
std::string	get_fptr_cmd (std::string_view fname)
template<typename InputIt , typename OutputIt , typename F >
auto	extract_if (InputIt begin, InputIt end, OutputIt d_begin, F func)
template<typename R , typename Output , typename F , typename G >
long int	transform_while_n (R &queue, Output out, long int sz, F &&test_func, G &&transform_func)
template<typename E >
constexpr std::underlying_type_t< E >	to_underlying (E e) noexcept
template<typename It >
std::pair< It, It >	get_span (It begin, It end, typename std::iterator_traits< It >::difference_type sz)
template<typename It , typename F >
std::pair< It, It >	get_span_p (It begin, It end, typename std::iterator_traits< It >::difference_type sz, F &&func)
template<typename It , typename F >
std::pair< It, It >	get_span_p (It begin, It end, F &&func)
phase_stats	do_phase (phase_info phase, environment &env, std::vector< tracereader > &traces)
std::vector< phase_stats >	main (environment &env, std::vector< phase_info > &phases, std::vector< tracereader > &traces)
void	to_json (nlohmann::json &j, const champsim::phase_stats stats)
template<template< class, class > typename R, typename T >
champsim::tracereader	get_tracereader_for_type (std::string fname, uint8_t cpu)

Variables
constexpr bool	debug_print = false
constexpr char	REG_STACK_POINTER = 6
constexpr char	REG_FLAGS = 25
constexpr char	REG_INSTRUCTION_POINTER = 26
template<template< class... > class Op, class... Args>
constexpr bool	is_detected_v = is_detected<Op, Args...>::value
template<class Expected , template< class... > class Op, class... Args>
constexpr bool	is_detected_exact_v = is_detected_exact<Expected, Op, Args...>::value
template<class To , template< class... > class Op, class... Args>
constexpr bool	is_detected_convertible_v = is_detected_convertible<To, Op, Args...>::value
template<typename T , template< typename... > typename Primary>
constexpr bool	is_specialization_v = false
template<template< typename... > typename Primary, typename... Args>
constexpr bool	is_specialization_v< Primary< Args... >, Primary > = true

Typedef Documentation

detected_or

template<class Default , template< class... > class Op, class... Args>

using champsim::detected_or = typedef detail::detector<Default, void, Op, Args...>

detected_or_t

template<class Default , template< class... > class Op, class... Args>

using champsim::detected_or_t = typedef typename detected_or<Default, Op, Args...>::type

detected_t

template<template< class... > class Op, class... Args>

using champsim::detected_t = typedef typename detail::detector<nonesuch, void, Op, Args...>::type

is_detected

template<template< class... > class Op, class... Args>

using champsim::is_detected = typedef typename detail::detector<nonesuch, void, Op, Args...>::value_t

is_detected_convertible

template<class To , template< class... > class Op, class... Args>

using champsim::is_detected_convertible = typedef std::is_convertible<detected_t<Op, Args...>, To>

is_detected_exact

template<class Expected , template< class... > class Op, class... Args>

using champsim::is_detected_exact = typedef std::is_same<Expected, detected_t<Op, Args...> >

Function Documentation

apply_branch_target()

ooo_model_instr champsim::apply_branch_target	(	ooo_model_instr	branch,
		const ooo_model_instr &	target
	)

do_phase()

phase_stats champsim::do_phase	(	phase_info	phase,
		environment &	env,
		std::vector< tracereader > &	traces
	)

extract_if()

template<typename InputIt , typename OutputIt , typename F >

auto champsim::extract_if	(	InputIt	begin,
		InputIt	end,
		OutputIt	d_begin,
		F	func
	)

get_fptr_cmd()

std::string champsim::get_fptr_cmd

(

std::string_view

fname

)

get_span()

template<typename It >

std::pair<It, It> champsim::get_span	(	It	begin,
		It	end,
		typename std::iterator_traits< It >::difference_type	sz
	)

get_span_p() [1/2]

template<typename It , typename F >

std::pair<It, It> champsim::get_span_p	(	It	begin,
		It	end,
		F &&	func
	)

get_span_p() [2/2]

template<typename It , typename F >

std::pair<It, It> champsim::get_span_p	(	It	begin,
		It	end,
		typename std::iterator_traits< It >::difference_type	sz,
		F &&	func
	)

get_tracereader_for_type()

template<template< class, class > typename R, typename T >

champsim::tracereader champsim::get_tracereader_for_type	(	std::string	fname,
		uint8_t	cpu
	)

main()

std::vector< phase_stats > champsim::main	(	environment &	env,
		std::vector< phase_info > &	phases,
		std::vector< tracereader > &	traces
	)

range_print_deadlock()

template<typename R , typename F >

void champsim::range_print_deadlock	(	const R &	range,
		std::string	kind_name,
		detail::fmtstr_type< R, F >	fmtstr,
		F &&	packing_func
	)

set_branch_targets()

template<typename It >

void champsim::set_branch_targets	(	It	begin,
		It	end
	)

to_json()

void champsim::to_json	(	nlohmann::json &	j,
		const champsim::phase_stats	stats
	)

to_underlying()

template<typename E >

constexpr std::underlying_type_t<E> champsim::to_underlying ( E  e )

constexprnoexcept

transform_while_n()

template<typename R , typename Output , typename F , typename G >

long int champsim::transform_while_n	(	R &	queue,
		Output	out,
		long int	sz,
		F &&	test_func,
		G &&	transform_func
	)

Variable Documentation

debug_print

constexpr bool champsim::debug_print = false

constexpr

is_detected_convertible_v

template<class To , template< class... > class Op, class... Args>

constexpr bool champsim::is_detected_convertible_v = is_detected_convertible<To, Op, Args...>::value

inlineconstexpr

is_detected_exact_v

template<class Expected , template< class... > class Op, class... Args>

constexpr bool champsim::is_detected_exact_v = is_detected_exact<Expected, Op, Args...>::value

inlineconstexpr

is_detected_v

template<template< class... > class Op, class... Args>

constexpr bool champsim::is_detected_v = is_detected<Op, Args...>::value

inlineconstexpr

is_specialization_v

template<typename T , template< typename... > typename Primary>

constexpr bool champsim::is_specialization_v = false

inlineconstexpr

is_specialization_v< Primary< Args... >, Primary >

template<template< typename... > typename Primary, typename... Args>

constexpr bool champsim::is_specialization_v< Primary< Args... >, Primary > = true

inlineconstexpr

REG_FLAGS

constexpr char champsim::REG_FLAGS = 25

constexpr

REG_INSTRUCTION_POINTER

constexpr char champsim::REG_INSTRUCTION_POINTER = 26

constexpr

REG_STACK_POINTER

constexpr char champsim::REG_STACK_POINTER = 6

constexpr