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
DX_PRAGMA_IGNORE_RETURN_VALUE_BEGIN virtual DX_PRAGMA_IGNORE_RETURN_VALUE_END void	operator<< (args &args) try
virtual void	operator<< (const args &args)
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
double	attenuation
uint32_t	dropout
engine_t *	engine
	this device's streaming engine, the harness's tests run under
bool	err
struct {
bool   ignore
}	error
double	frequency
bool	ignore
struct {
union {
struct {
bool   err:1
bool   log:1
bool   out:1
}
uint32_t   mask
}
}	log
bool	log
mask	mask
bool	out
bool	quiet
uint64_t	tick

Protected Types
typedef engine_t::io_t	io_t

Protected Member Functions
DX_PRAGMA_IGNORE_RETURN_VALUE_END void	_clocksource (const args &args={}) try
void	_generator (args &args) try
DX_PRAGMA_IGNORE_RETURN_VALUE_END void	_info (const args &) try
	list device information
DX_PRAGMA_IGNORE_RETURN_VALUE_END void	_iosize (const args &args) try
	set/get I/O streaming block size
DX_PRAGMA_IGNORE_RETURN_VALUE_END void	_license (const args &args) try
DX_PRAGMA_IGNORE_RETURN_VALUE_END void	_monitor (const args &args) try
DX_PRAGMA_IGNORE_RETURN_VALUE_END void	_reset (const args &={}) try
DX_PRAGMA_IGNORE_RETURN_VALUE_END void	_safety_offset (args &args, stream::role::role choice_role) try
	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
DX_PRAGMA_IGNORE_RETURN_VALUE_END void	_samplerate (const args &args={}) try
DX_PRAGMA_IGNORE_RETURN_VALUE_END void	_source (const args &args={}) try
DX_PRAGMA_IGNORE_RETURN_VALUE_END void	_strategy (args &args) try
	set/get the wait strategies of the streaming group's transport and clients, both unless one is named
DX_PRAGMA_IGNORE_RETURN_VALUE_END void	_streaming_reset (const args &={}) try
DX_PRAGMA_IGNORE_RETURN_VALUE_END void	_string (const args &args={}) try
DX_PRAGMA_IGNORE_RETURN_VALUE_END void	_sync_reference (const args &args) try
	set/get I/O streaming block size
DX_PRAGMA_IGNORE_RETURN_VALUE_END void	clock_monitor (std::chrono::high_resolution_clock::duration duration) try
virtual bool	head () const noexcept
virtual void	help (args &args) try
virtual void	help_head () const noexcept
virtual DX_PRAGMA_IGNORE_RETURN_VALUE_END void	indent (args &args) try
virtual DX_PRAGMA_IGNORE_RETURN_VALUE_END void	no_args (const args &args) try
void	notify () noexcept
void	process (int64_t) noexcept
DX_PRAGMA_IGNORE_RETURN_VALUE_END auto	select (const std::string &id) try
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 DX_PRAGMA_IGNORE_RETURN_VALUE_END void	version (const args &args={}) try

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::chrono::seconds	load_duration
std::deque< mask >	loopback
const char *	name
struct {
struct {
bool   ignore
}   error
struct {
union {
struct {
bool   err:1
bool   log:1
bool   out:1
}
uint32_t   mask
}
}   log
bool   quiet
}	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 {
double   attenuation = 1.
double   frequency = 440.
mask   mask
}	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()

DX_PRAGMA_IGNORE_RETURN_VALUE_END 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

_info()

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

inlineprotectedinherited

list device information

_iosize()

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

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

inlineprotectedinherited

_monitor()

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

inlineprotectedinherited

_reset()

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

inlineprotectedinherited

_safety_offset()

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

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

inlineprotectedinherited

_source()

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

inlineprotectedinherited

_strategy()

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

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

inlineprotectedinherited

_string()

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

inlineprotectedinherited

_sync_reference()

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

DX_PRAGMA_IGNORE_RETURN_VALUE_END 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 DX_PRAGMA_IGNORE_RETURN_VALUE_END 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 DX_PRAGMA_IGNORE_RETURN_VALUE_END 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]

DX_PRAGMA_IGNORE_RETURN_VALUE_BEGIN virtual DX_PRAGMA_IGNORE_RETURN_VALUE_END 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()

DX_PRAGMA_IGNORE_RETURN_VALUE_END 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 DX_PRAGMA_IGNORE_RETURN_VALUE_END void dx::parser::version ( const args & args = {} )

inlineprotectedvirtualinherited

Member Data Documentation

attenuation

double dx::test::device< super_device_t, typename super_device_t::group_t >::attenuation

inherited

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

err

bool dx::parser::err

inherited

[struct]

struct { ... } dx::parser::error

frequency

double dx::test::device< super_device_t, typename super_device_t::group_t >::frequency

inherited

generator

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

protectedinherited

ignore

bool dx::parser::ignore

inherited

load_duration

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

protectedinherited

[struct] [1/2]

struct { ... } dx::parser::log

log [2/2]

bool dx::parser::log

inherited

loopback

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

protectedinherited

mask

mask dx::test::device< super_device_t, typename super_device_t::group_t >::mask

inherited

name

const char* dx::parser::name

protectedinherited

out

bool dx::parser::out

inherited

[struct]

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

pattern

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

protectedinherited

quiet

bool dx::parser::quiet

inherited

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

[struct]

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