dx::test::device< super_device_t, _engine_t > Class Template Reference

the test harness's device: the bus device plus its command line parser, and the streaming engine its tests run under - its own group_t slot, or the app's consumer group on its clock divider More...

#include <dx_test_device.h>

Inheritance diagram for dx::test::device< super_device_t, _engine_t >:

Collaboration diagram for dx::test::device< super_device_t, _engine_t >:

Classes
struct	has_license
struct	has_license< type_t, decltype((void) type_t::license, void())>
struct	impulse
	one impulse test: what an analog loop keeps is its timing alone More...
struct	mask
	the channels a monitor's callback works on: one word per direction, plus the mix target More...
struct	sine
	one generator tone: the channels it feeds and its phase, carried between callbacks More...

Public Types
typedef std::deque< std::string >	args
typedef _engine_t	engine_t

Public Member Functions
void	conclude () noexcept override
	the pins go while their device still stands: their streams reach its pipe on the way out
template<typename ... initializer_t>
	device (decltype(super::driver)&driver, const decltype(super::id)&id, initializer_t... initializer)
void	halt () noexcept
void	launch () override
	the audio pins go into their group, which from then on is this device's streaming engine
virtual void	operator<< (argsargs &argsargs)
virtual void	operator<< (const argsargs &argsargs)
virtual void	quiet (const args &={}) noexcept
void	run ()
	starting/stopping the engine's pins is what starts/stops their group's streaming session

Public Attributes
uint32_t	dropout {}
engine_t *	engine {}
	this device's streaming engine, the harness's tests run under
uint64_t	tick {}

Protected Types
typedef engine_t::io_t	io_t

Protected Member Functions
void	_clocksource (const argsargs &argsargs={})
void	_generator (argsargs &argsargs)
void	_impulse (args &)
void	_info (const args &)
	list device information
void	_iosize (const argsargs &argsargs)
	set/get I/O streaming block size
void	_license (const argsargs &argsargs)
void	_monitor (const argsargs &argsargs)
void	_reset (const args &={})
void	_safety_offset (argsargs &argsargs, stream::role::role choice_role)
	set/get the streaming group's safety offset of its transport (default: the lead the tick keeps to the device, kept per wait strategy) or of its clients (the ring margin), in clock ticks, per direction
void	_samplerate (const argsargs &argsargs={})
void	_source (const argsargs &argsargs={})
void	_strategy (argsargs &argsargs)
	set/get the wait strategies of the streaming group's transport and clients, both unless one is named
void	_streaming_reset (const args &={})
void	_string (const argsargs &argsargs={})
void	_sync_reference (const argsargs &argsargs)
	set/get I/O streaming block size
void	clock_monitor (std::chrono::high_resolution_clock::duration duration)
virtual bool	head () const noexcept
virtual void	help (argsargs &argsargs)
virtual void	help_head () const noexcept
virtual void	indent (argsargs &argsargs)
virtual void	no_args (const argsargs &argsargs)
void	notify () noexcept
void	process (int64_t) noexcept
auto	select (const std::string &id)
void	sweep_write (stream::direction::direction direction, uint32_t value)
	writes the swept value to the engine's client safety_offset, or - if sweep_transport - the streaming group's transport lead
virtual void	version (const argsargs &argsargs={})

Protected Attributes
std::optional< engine_t >	consumer
	the engine where it is not this device's group_t slot
std::map< std::deque< std::string >, dispatch >	dictionary
std::deque< sine >	generator
std::deque< struct impulse >	impulse
std::chrono::seconds	load_duration {}
std::deque< mask >	loopback
const char *	name {}
struct dx::parser:: { ... }	parameter
std::deque< mask >	pattern
std::deque< std::string >	scenarios
	load: the scenarios the monitor runs its session under in turn, each for load_duration and closed by its own lead probe
uint32_t	sweep {}
	safety_offset ratchet: current in/out offset, raised on every pattern-test dropout for whichever direction's isr overload counted it; 0: off
stream::direction::direction	sweep_direction {stream::direction::any}
	sweep scope: any= both directions seeded/ratcheted, out/in= only that one, the other stays at its own current (manually set) value
bool	sweep_transport {}
	sweep target: the transport's lead (kept per wait strategy) if set, else the client's margin
struct dx::test::device:: { ... }	tmp

Detailed Description

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>
class dx::test::device< super_device_t, _engine_t >

the test harness's device: the bus device plus its command line parser, and the streaming engine its tests run under - its own group_t slot, or the app's consumer group on its clock divider

Member Typedef Documentation

args

typedef std::deque<std::string> dx::parser::args

inherited

engine_t

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

typedef _engine_t dx::test::device< super_device_t, _engine_t >::engine_t

io_t

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

typedef engine_t::io_t dx::test::device< super_device_t, _engine_t >::io_t

protected

Constructor & Destructor Documentation

device()

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

template<typename ... initializer_t>

dx::test::device< super_device_t, _engine_t >::device ( decltype(super::driver)& driver, const decltype(super::id)& id, initializer_t... initializer )

inline

Here is the caller graph for this function:

Member Function Documentation

_clocksource()

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

void dx::test::device< super_device_t, _engine_t >::_clocksource ( const args & args = {} )

inlineprotected

Here is the caller graph for this function:

_generator()

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

void dx::test::device< super_device_t, _engine_t >::_generator ( args & args )

inlineprotected

Here is the caller graph for this function:

_impulse()

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

void dx::test::device< super_device_t, _engine_t >::_impulse ( args & )

inlineprotected

< one sample's turn of the sine, none without

Here is the caller graph for this function:

_info()

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

void dx::test::device< super_device_t, _engine_t >::_info ( const args & )

inlineprotected

list device information

Here is the caller graph for this function:

_iosize()

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

void dx::test::device< super_device_t, _engine_t >::_iosize ( const args & args )

inlineprotected

set/get I/O streaming block size

Here is the caller graph for this function:

_license()

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

void dx::test::device< super_device_t, _engine_t >::_license ( const args & args )

inlineprotected

_monitor()

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

void dx::test::device< super_device_t, _engine_t >::_monitor ( const args & args )

inlineprotected

Here is the caller graph for this function:

_reset()

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

void dx::test::device< super_device_t, _engine_t >::_reset ( const args & = {} )

inlineprotected

Here is the caller graph for this function:

_safety_offset()

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

void dx::test::device< super_device_t, _engine_t >::_safety_offset ( args & args, stream::role::role choice_role )

inlineprotected

set/get the streaming group's safety offset of its transport (default: the lead the tick keeps to the device, kept per wait strategy) or of its clients (the ring margin), in clock ticks, per direction

Here is the caller graph for this function:

_samplerate()

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

void dx::test::device< super_device_t, _engine_t >::_samplerate ( const args & args = {} )

inlineprotected

Here is the caller graph for this function:

_source()

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

void dx::test::device< super_device_t, _engine_t >::_source ( const args & args = {} )

inlineprotected

Here is the caller graph for this function:

_strategy()

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

void dx::test::device< super_device_t, _engine_t >::_strategy ( args & args )

inlineprotected

set/get the wait strategies of the streaming group's transport and clients, both unless one is named

Here is the caller graph for this function:

_streaming_reset()

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

void dx::test::device< super_device_t, _engine_t >::_streaming_reset ( const args & = {} )

inlineprotected

Here is the caller graph for this function:

_string()

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

void dx::test::device< super_device_t, _engine_t >::_string ( const args & args = {} )

inlineprotected

Here is the caller graph for this function:

_sync_reference()

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

void dx::test::device< super_device_t, _engine_t >::_sync_reference ( const args & args )

inlineprotected

set/get I/O streaming block size

Here is the caller graph for this function:

clock_monitor()

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

void dx::test::device< super_device_t, _engine_t >::clock_monitor ( std::chrono::high_resolution_clock::duration duration )

inlineprotected

< sweep: a pattern lock survived the monitor clear settle - dropouts only count while armed

< sweep: isr[tx]/isr[rx] overload snapshot at arming, to attribute the next dropout to a direction

< sweep: time of the last (re)start at the current value - never locking within a timeout escalates too (the never-lock trap: a start below the floor never arms, so the dropout ratchet alone would hang forever)

< samples per tick: the client margins' unit

the least reserve each lead kept: host out/in from their own cells (frames), local out/in from the ring distances at the pipe's fill/take (bytes -> ticks)

< load: the most each lead needed over the scenarios, by its cell

the lead each side needs: what it had, less the least it kept since the last clear, plus a tick - under whatever load the run saw

< load: the running scenario's threads

conclude()

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

void dx::test::device< super_device_t, _engine_t >::conclude ( )

inlineoverridenoexcept

the pins go while their device still stands: their streams reach its pipe on the way out

halt()

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

void dx::test::device< super_device_t, _engine_t >::halt ( )

inlinenoexcept

head()

virtual bool dx::parser::head ( ) const

inlineprotectedvirtualnoexceptinherited

Reimplemented in dx::service::parser, and dx::test::driver< super_device_t, device_t, driver_t >.

Here is the caller graph for this function:

help()

virtual void dx::parser::help ( args & args )

inlineprotectedvirtualinherited

Here is the call graph for this function:

Here is the caller graph for this function:

help_head()

virtual void dx::parser::help_head ( ) const

inlineprotectedvirtualnoexceptinherited

Reimplemented in dx::select< parsers_t >, and dx::test::driver< super_device_t, device_t, driver_t >.

Here is the call graph for this function:

Here is the caller graph for this function:

indent()

virtual void dx::parser::indent ( args & args )

inlineprotectedvirtualinherited

Here is the call graph for this function:

Here is the caller graph for this function:

launch()

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

void dx::test::device< super_device_t, _engine_t >::launch ( )

inlineoverride

the audio pins go into their group, which from then on is this device's streaming engine

no_args()

virtual void dx::parser::no_args ( const args & args )

inlineprotectedvirtualinherited

Here is the call graph for this function:

Here is the caller graph for this function:

notify()

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

void dx::test::device< super_device_t, _engine_t >::notify ( )

inlineprotectednoexcept

operator<<() [1/2]

virtual void dx::parser::operator<< ( args & args )

inlinevirtualinherited

Reimplemented in dx::select< parsers_t >, and dx::test::driver< super_device_t, device_t, driver_t >.

Here is the call graph for this function:

operator<<() [2/2]

virtual void dx::parser::operator<< ( const args & args )

inlinevirtualinherited

Here is the caller graph for this function:

process()

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

void dx::test::device< super_device_t, _engine_t >::process ( int64_t )

inlineprotectednoexcept

quiet()

virtual void dx::parser::quiet ( const args & = {} )

inlinevirtualnoexceptinherited

Here is the caller graph for this function:

run()

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

void dx::test::device< super_device_t, _engine_t >::run ( )

inline

starting/stopping the engine's pins is what starts/stops their group's streaming session

Here is the caller graph for this function:

select()

auto dx::parser::select ( const std::string & id )

inlineprotectedinherited

Here is the call graph for this function:

Here is the caller graph for this function:

sweep_write()

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

void dx::test::device< super_device_t, _engine_t >::sweep_write ( stream::direction::direction direction, uint32_t value )

inlineprotected

writes the swept value to the engine's client safety_offset, or - if sweep_transport - the streaming group's transport lead

version()

virtual void dx::parser::version ( const args & args = {} )

inlineprotectedvirtualinherited

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

consumer

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

std::optional<engine_t> dx::test::device< super_device_t, _engine_t >::consumer

protected

the engine where it is not this device's group_t slot

dictionary

std::map<std::deque<std::string>, dispatch> dx::parser::dictionary

protectedinherited

Initial value:

{
        {{"--continue", "--no-error", "--ignore", "--ignore-error"},
                                {[this](args& args){parameter.error.ignore= true; no_args(args);}, "ignore errors and continue"}},
        {{"--indent", "--tab"},     {std::bind(&parser::indent, this, std::placeholders::_1), "set/get indention width and pattern", "[width [pattern]]", {},{
            {{"err", "stderr"},     {[this](args&){this->parameter.log.err= true;}, "select std error"}},
            {{"log", "stdlog"},     {[this](args&){this->parameter.log.log= true;}, "select std log"}},
            {{"out", "stdout"},     {[this](args&){this->parameter.log.out= true;}, "select std out"}},
        }}},
        {{"--quiet", "-q"},     {std::bind(&parser::quiet, this, std::placeholders::_1), "quiet!"}},
 
 
 
        {{"--version", "-v"},   {std::bind(&parser::version, this, std::placeholders::_1), std::string{"display "}+ name+ " version"}},
    }

dropout

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

uint32_t dx::test::device< super_device_t, _engine_t >::dropout {}

engine

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

engine_t* dx::test::device< super_device_t, _engine_t >::engine {}

this device's streaming engine, the harness's tests run under

generator

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

std::deque<sine> dx::test::device< super_device_t, _engine_t >::generator

protected

impulse

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

std::deque<struct impulse> dx::test::device< super_device_t, _engine_t >::impulse

protected

load_duration

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

std::chrono::seconds dx::test::device< super_device_t, _engine_t >::load_duration {}

protected

loopback

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

std::deque<mask> dx::test::device< super_device_t, _engine_t >::loopback

protected

name

const char* dx::parser::name {}

protectedinherited

parameter

struct { ... } dx::parser::parameter

pattern

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

std::deque<mask> dx::test::device< super_device_t, _engine_t >::pattern

protected

scenarios

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

std::deque<std::string> dx::test::device< super_device_t, _engine_t >::scenarios

protected

load: the scenarios the monitor runs its session under in turn, each for load_duration and closed by its own lead probe

sweep

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

uint32_t dx::test::device< super_device_t, _engine_t >::sweep {}

protected

safety_offset ratchet: current in/out offset, raised on every pattern-test dropout for whichever direction's isr overload counted it; 0: off

sweep_direction

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

stream::direction::direction dx::test::device< super_device_t, _engine_t >::sweep_direction {stream::direction::any}

protected

sweep scope: any= both directions seeded/ratcheted, out/in= only that one, the other stays at its own current (manually set) value

sweep_transport

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

bool dx::test::device< super_device_t, _engine_t >::sweep_transport {}

protected

sweep target: the transport's lead (kept per wait strategy) if set, else the client's margin

tick

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

uint64_t dx::test::device< super_device_t, _engine_t >::tick {}

tmp

struct { ... } dx::test::device< super_device_t, _engine_t >::tmp

---

The documentation for this class was generated from the following file:

• dx_test_device.h