dx::test::wasapi::device< super_device_t, engine_t > Class Template Reference

WASAPI client test device: the generic test device plus the endpoint share mode. More...

#include <dx_test_wasapi.h>

Inheritance diagram for dx::test::wasapi::device< super_device_t, engine_t >:

Collaboration diagram for dx::test::wasapi::device< super_device_t, engine_t >:

Public Types
typedef std::deque< std::string >	args
typedef typename super_device_t::group_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
	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::wasapi::device< super_device_t, engine_t >

WASAPI client test device: the generic test device plus the endpoint share mode.

Member Typedef Documentation

args

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

inherited

engine_t

typedef typename super_device_t::group_t dx::test::device< super_device_t, typename super_device_t::group_t >::engine_t

inherited

io_t

typedef engine_t::io_t dx::test::device< super_device_t, typename super_device_t::group_t >::io_t

protectedinherited

Constructor & Destructor Documentation

device()

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

template<typename ... initializer_t>

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

inline

Member Function Documentation

_clocksource()

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

inlineprotectedinherited

_generator()

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

inlineprotectedinherited

_impulse()

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

inlineprotectedinherited

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

_info()

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

inlineprotectedinherited

list device information

_iosize()

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

inlineprotectedinherited

set/get I/O streaming block size

_license()

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

inlineprotectedinherited

_monitor()

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

inlineprotectedinherited

_reset()

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

inlineprotectedinherited

_safety_offset()

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

inlineprotectedinherited

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

_samplerate()

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

inlineprotectedinherited

_source()

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

inlineprotectedinherited

_strategy()

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

inlineprotectedinherited

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

_streaming_reset()

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

inlineprotectedinherited

_string()

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

inlineprotectedinherited

_sync_reference()

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

inlineprotectedinherited

set/get I/O streaming block size

clock_monitor()

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

inlineprotectedinherited

< 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()

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

inlineoverridenoexceptinherited

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

halt()

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

inlinenoexceptinherited

head()

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

inlineprotectedvirtualnoexceptinherited

help()

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

inlineprotectedvirtualinherited

help_head()

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

inlineprotectedvirtualnoexceptinherited

indent()

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

inlineprotectedvirtualinherited

launch()

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

inlineoverrideinherited

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

notify()

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

inlineprotectednoexceptinherited

operator<<() [1/2]

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

inlinevirtualinherited

operator<<() [2/2]

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

inlinevirtualinherited

process()

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

inlineprotectednoexceptinherited

quiet()

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

inlinevirtualnoexceptinherited

run()

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

inlineinherited

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

select()

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

inlineprotectedinherited

sweep_write()

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

inlineprotectedinherited

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

Member Data Documentation

consumer

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

protectedinherited

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

dictionary

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

protectedinherited

dropout

uint32_t dx::test::device< super_device_t, typename super_device_t::group_t >::dropout

inherited

engine

engine_t* dx::test::device< super_device_t, typename super_device_t::group_t >::engine

inherited

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

generator

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

protectedinherited

impulse

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

protectedinherited

load_duration

std::chrono::seconds dx::test::device< super_device_t, typename super_device_t::group_t >::load_duration

protectedinherited

loopback

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

protectedinherited

name

const char* dx::parser::name

protectedinherited

parameter

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

pattern

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

protectedinherited

scenarios

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

protectedinherited

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

sweep

uint32_t dx::test::device< super_device_t, typename super_device_t::group_t >::sweep

protectedinherited

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

stream::direction::direction dx::test::device< super_device_t, typename super_device_t::group_t >::sweep_direction

protectedinherited

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

sweep_transport

bool dx::test::device< super_device_t, typename super_device_t::group_t >::sweep_transport

protectedinherited

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

tick

uint64_t dx::test::device< super_device_t, typename super_device_t::group_t >::tick

inherited

tmp

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

---

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

• dx_test_wasapi.h