dx::usb::stream::group< device_t > Class Template Reference

USB isoc streaming group: one bus frame aligned tick per USB frame, the one thread running the pipes' request pipelines and moving their data. More...

#include <dx_usb_stream_group.h>

Inheritance diagram for dx::usb::stream::group< device_t >:

Collaboration diagram for dx::usb::stream::group< device_t >:

Public Types
typedef settings<device_t>::client	client
typedef dx::clock<clock::source<device_t>>	clock
	the one clock of this group, its source freely selectable
typedef dx::source<>::clock_t	clock_t
typedef device_t	device_t
typedef dx::source<>::event_t	event_t
typedef settings_promoted<device_t, store>::type	promoted
typedef settings_promoted<device_t, store>::type	promoted
typedef device_t::stream_t	stream_t
typedef settings<device_t>::transport	transport
	the group's two sides, reached as transport::/client:: members

Public Member Functions
void	conclude() noexcept
	group(device_t& device)
	the group's clock source ticks off the same device's frame counter, by the transport's wait strategy
void	halt() noexcept override
	the session's end: its pipes run out on the group's thread - from its own tick nothing ticks them, rest() takes them -, then the thread ends and the group rests
realtime&	initialize(const std::chrono::high_resolution_clock::duration& resolution)
void	initialize(const typename clock_t::duration& duration)
	operator event_t&() noexcept
	operator event_t*() noexcept
virtual void	sync(const typename clock_t::time_point& now)
virtual source&	wait(bool reset= false)

Static Public Member Functions
static std::string	key(direction::direction direction, uint32_t strategy)
static std::string	key(direction::direction direction, uint32_t)

Public Attributes
listener<dx::listen<std::function<void(const uint32_t &)>>>	iosize_listener
	a margin defaulted by the device's iosize (a host's tick is its buffer) reloads with it
promoted	safety_offset [direction::directions]
promoted	safety_offset [direction::directions]
promoted<uint32_t>	start
promoted<bool>	started
std::map<decltype(stream_t::target.idx()), std::weak_ptr<stream_t>>	streams
	shared stream ownership: central weak reference per stream, guarded by device
promoted	sync_strategy
promoted	sync_strategy

Protected Member Functions
void	discharge() noexcept override
	the session's end on its own thread: the group rests, each pipe that lost frames reported once
bool	locking() const
	the device's clock is still locking to a sample rate set: the session neither charges nor submits
virtual void	notify() noexcept
void	run() override
	a group streams as a unit: the streams of its descs no client opened yet are opened ahead of the session, so a client joining it finds its stream visited
bool	self() const
	the caller is the clock's own thread: a halt from its tick ends the loop, nobody joins it
void	tick() override
	this bus's own transport, ticked per bus frame by its clock source: the session's tick, once the device's clock locked to its rate - a rate change ending charges once locked

Protected Attributes
std::condition_variable	condition_variable
device_t&	device
	also the mutex serializing membership
_event_t	event
std::function<void()>	flush_hook
std::function<void()>	halt_hook
std::vector<std::shared_ptr<stream_t>>	members
	the session's streams: taken before the thread starts, released at its end - the tick visits them without a lock
dx::stream::clock::monitor*	monitor
	device.monitor cached at the session's start: the tick never maps shared memory
std::mutex	mutex
_clock_t::time_point	objective
const dx::stream::direction::direction&	order{this->device.start_stop_order}
	the direction the device stops first
unsigned int	reference{}
	the stream whose advance drives the clock domain, by its target index (0: none)
std::function<void()>	run_hook
std::atomic<bool>	running
os_result	status
const struct device_t::desc_t::stream*	sync_reference
	device.sync_reference cached: the tick never reads the promoted

Friends
struct	isoc::session<group>

Detailed Description

template<typename device_t>
class dx::usb::stream::group< device_t >

USB isoc streaming group: one bus frame aligned tick per USB frame, the one thread running the pipes' request pipelines and moving their data.

Member Typedef Documentation

client

typedef settings<device_t>::client dx::stream::group<device_t, clock::source<device_t>>::client

inherited

clock

typedef dx::clock<clock::source<device_t>> dx::stream::group<device_t, clock::source<device_t>>::clock

inherited

the one clock of this group, its source freely selectable

clock_t

typedef dx::source<>::clock_t dx::clock<dx::source<>>::clock_t

inherited

device_t

typedef device_t dx::stream::group<device_t, clock::source<device_t>>::device_t

inherited

event_t

typedef dx::source<>::event_t dx::clock<dx::source<>>::event_t

inherited

promoted [1/2]

typedef settings_promoted<device_t,store>::type dx::stream::settings<device_t, store>::promoted

inherited

promoted [2/2]

typedef settings_promoted<device_t,store>::type dx::stream::settings<device_t, store>::promoted

inherited

stream_t

typedef device_t::stream_t dx::stream::group<device_t, clock::source<device_t>>::stream_t

inherited

transport

typedef settings<device_t>::transport dx::stream::group<device_t, clock::source<device_t>>::transport

inherited

the group's two sides, reached as transport::/client:: members

Constructor & Destructor Documentation

group()

template<typename device_t>

dx::usb::stream::group<device_t>::group(device_t& device)

inline

the group's clock source ticks off the same device's frame counter, by the transport's wait strategy

Member Function Documentation

conclude()

void dx::stream::control<dx::clock<dx::source<>>>::conclude()

inlinenoexceptinherited

discharge()

template<typename device_t>

void dx::usb::stream::group<device_t>::discharge()

inlineoverrideprotectednoexcept

the session's end on its own thread: the group rests, each pipe that lost frames reported once

Here is the call graph for this function:

halt()

template<typename device_t>

void dx::usb::stream::group<device_t>::halt()

inlineoverridenoexcept

the session's end: its pipes run out on the group's thread - from its own tick nothing ticks them, rest() takes them -, then the thread ends and the group rests

Here is the call graph for this function:

initialize() [1/2]

realtime& dx::thread::prio::realtime::initialize(const std::chrono::high_resolution_clock::duration& resolution)

inlineinherited

Todo

dx::thread::prio: replace experimental hardcoded preemption limit with real limit obtained from machine

initialize() [2/2]

void dx::clock<dx::source<>>::initialize(const typename clock_t::duration& duration)

inlineinherited

key() [1/2]

std::string dx::stream::settings<device_t, store>::transport::key(direction::direction direction, uint32_t strategy)

inlinestaticinherited

key() [2/2]

std::string dx::stream::settings<device_t, store>::client::key(direction::direction direction, uint32_t)

inlinestaticinherited

locking()

template<typename device_t>

bool dx::usb::stream::group<device_t>::locking() const

inlineprotected

the device's clock is still locking to a sample rate set: the session neither charges nor submits

Here is the call graph for this function:

notify()

virtual void dx::clock<dx::source<>>::notify()

inlineprotectedvirtualnoexceptinherited

notify change from device requiring streaming reset

operator event_t &()

dx::clock<dx::source<>>::operator event_t&()

inlinenoexceptinherited

operator event_t *()

dx::clock<dx::source<>>::operator event_t*()

inlinenoexceptinherited

run()

template<typename device_t>

void dx::usb::stream::group<device_t>::run()

inlineoverrideprotected

a group streams as a unit: the streams of its descs no client opened yet are opened ahead of the session, so a client joining it finds its stream visited

Here is the call graph for this function:

self()

bool dx::clock<dx::source<>>::self() const

inlineprotectedinherited

the caller is the clock's own thread: a halt from its tick ends the loop, nobody joins it

Here is the caller graph for this function:

sync()

virtual void dx::source<_event_t, _clock_t>::sync(const typename clock_t::time_point& now)

inlinevirtualinherited

tick()

template<typename device_t>

void dx::usb::stream::group<device_t>::tick()

inlineoverrideprotected

this bus's own transport, ticked per bus frame by its clock source: the session's tick, once the device's clock locked to its rate - a rate change ending charges once locked

Here is the call graph for this function:

wait()

virtual source& dx::source<_event_t, _clock_t>::wait(bool reset= false)

inlinevirtualinherited

Friends And Related Symbol Documentation

isoc::session<group>

template<typename device_t>

friend struct isoc::session<group>

friend

Member Data Documentation

condition_variable

std::condition_variable dx::source<_event_t, _clock_t>::condition_variable

protectedinherited

device

device_t& dx::stream::group<device_t, clock::source<device_t>>::device

protectedinherited

also the mutex serializing membership

event

_event_t dx::source<_event_t, _clock_t>::event

protectedinherited

Todo

evaluate clock::status replacement (exception?)

flush_hook

std::function<void()> dx::stream::control<dx::clock<dx::source<>>>::flush_hook

protectedinherited

halt_hook

std::function<void()> dx::stream::control<dx::clock<dx::source<>>>::halt_hook

protectedinherited

iosize_listener

listener<dx::listen<std::function<void(const uint32_t&)>>> dx::stream::settings<device_t, store>::client::iosize_listener

inherited

a margin defaulted by the device's iosize (a host's tick is its buffer) reloads with it

members

std::vector<std::shared_ptr<stream_t>> dx::stream::group<device_t, clock::source<device_t>>::members

protectedinherited

the session's streams: taken before the thread starts, released at its end - the tick visits them without a lock

monitor

dx::stream::clock::monitor* dx::stream::group<device_t, clock::source<device_t>>::monitor

protectedinherited

device.monitor cached at the session's start: the tick never maps shared memory

mutex

std::mutex dx::source<_event_t, _clock_t>::mutex

protectedinherited

objective

_clock_t::time_point dx::source<_event_t, _clock_t>::objective

protectedinherited

order

template<typename device_t>

const dx::stream::direction::direction& dx::usb::stream::group<device_t>::order{this->device.start_stop_order}

protected

the direction the device stops first

reference

template<typename device_t>

unsigned int dx::usb::stream::group<device_t>::reference{}

protected

the stream whose advance drives the clock domain, by its target index (0: none)

run_hook

std::function<void()> dx::stream::control<dx::clock<dx::source<>>>::run_hook

protectedinherited

running

std::atomic<bool> dx::source<_event_t, _clock_t>::running

protectedinherited

safety_offset [1/2]

promoted dx::stream::settings<device_t, store>::safety_offset[direction::directions]

inherited

safety_offset [2/2]

promoted dx::stream::settings<device_t, store>::safety_offset[direction::directions]

inherited

start

promoted<uint32_t> dx::stream::control<dx::clock<dx::source<>>>::start

inherited

started

promoted<bool> dx::stream::control<dx::clock<dx::source<>>>::started

inherited

status

os_result dx::source<_event_t, _clock_t>::status

protectedinherited

streams

std::map<decltype(stream_t::target.idx()), std::weak_ptr<stream_t>> dx::stream::group<device_t, clock::source<device_t>>::streams

inherited

shared stream ownership: central weak reference per stream, guarded by device

sync_reference

const struct device_t::desc_t::stream* dx::stream::group<device_t, clock::source<device_t>>::sync_reference

protectedinherited

device.sync_reference cached: the tick never reads the promoted

sync_strategy [1/2]

promoted dx::stream::settings<device_t, store>::sync_strategy

inherited

sync_strategy [2/2]

promoted dx::stream::settings<device_t, store>::sync_strategy

inherited

---

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

• dx_usb_stream_group.h