VrSigProc Class Reference

The base class for all signal processing modules. More...

#include <VrSigProc.h>

Inheritance diagram for VrSigProc:

List of all members.


Public Member Functions
	VrSigProc (int number_of_outputs, unsigned int arg_itype_size, unsigned int arg_type_size)
virtual	~VrSigProc ()
bool	connect_proc (VrSigProc *proc, port n)
	connect our next input to `proc's` nth output
virtual const char *	name ()
	default name for a module (override with actual name)
virtual int	forecast (VrSampleRange output, VrSampleRange inputs[])
	map output range to required input ranges
virtual float	memoryTouched ()
virtual int	work (VrSampleRange output, void o[], VrSampleRange inputs[], void i[])=0
	Generate up to output.size output points at o[output#][sample#] using data at the inputptrs[input#][sample#].
virtual float	averageInputUse (int n)
virtual int	checkOutputSamplingFrequency (float)
bool	isSink ()
	return true iff this VrSigProc is a sink
virtual int	setSamplingFrequency (double sf)
virtual bool	dataReady (VrSampleRange r)
	has the data been computed?
virtual void	size_setup (unsigned int size)
virtual void	setup ()
VrSampleIndex	getMarkedWP ()
unsigned int	getMaxOutputSize ()
VrSampleIndex	getWP ()
double	getSamplingFrequency ()
virtual int	callback (int attribute_number, float value)
Protected Member Functions
virtual VrSigProc *	getUpstreamModuleN (port p)
double	getInputSamplingFrequencyN (port p)
void	setOutputSize (int o)
	set required multiple for number of items produced
unsigned int	getOutputSize ()
void	setup_upstream ()
int	getNumberInputs ()
bool	is_synced (VrSampleIndex arg_index)
void	sync (VrSampleIndex arg_index)
	force rest of procedure to run sequentially
VrSampleIndex	proc_minRP ()
Protected Attributes
VrBuffer **	outBuffer
unsigned int	maxDSReadSize
	max Down Stream Read Size. How big a read we might get. maxOutSize should never exceed this.
unsigned int	numberInputs
unsigned int	numberOutputs
Private Member Functions
	MUTEX_DECLARE (mutex)
void	attach_writer (writerLL *r)
void	detach_writer (writerLL *r)
void	init_base ()
	Cause initialize methods to be called. This is called on all sinks for which isConnectedToSource is true, and results in the pre_initialize and initialize methods being called in the order source to sink.
virtual void	pre_initialize ()
	Set sampling frequency based on upstream sampling freq.
virtual void	initialize ()
	Initialize any local state that is dependent on sampling frequency.
virtual bool	isConnectedToSource ()
int	minwritespace (VrSampleIndex newWP, unsigned int desired)
void	initOutputBuffers (int n)
virtual void	initOutputBuffer (int n)
void	initMarkedData ()
virtual unsigned int	mapSizeUp (int i, unsigned int size)
virtual bool	dataMarked (VrSampleRange r)
	is data marked to be computed?
virtual int	markData (VrSampleRange r)
	figure out what data to compute
virtual int	markDataUpstream (VrSampleRange inputs, bool dataMarkedUpstream)
	propagate marking upstream
virtual bool	compute ()
	compute the marked data
Private Attributes
int	uses_sync
double	proc_samplingFrequency
volatile VrSampleIndex	WP
	data before this has been written
volatile VrSampleIndex	markedWP
	data before this has been marked and will be written
unsigned int	maxOutSize
	maximum size that we should ever output at once.
VrConnect **	inputConn
unsigned int	setupCalled
unsigned int	outputSize
unsigned int	type_size
unsigned int	itype_size
unsigned int	initializeCalled
VrSampleRange	myMarkedData
VrSampleRange *	inputs_forecasted
writerLL *	myWriterLL
readerLL *	myReaderLLs
volatile writerLL *	first
volatile writerLL *	last
Static Private Attributes
static const int	MARK_ALREADY = 2
	all data is already computed
static const int	MARK_READY = 1
	data is ready to be computed (and has been marked)
static const int	MARK_READY_NO_MARK = 0
	data is ready on this level or above,
static const int	MARK_NO_READY = -1
	no data is ready to be computed
static const int	MARK_THREAD = -2
	data is marked by another thread
static const int	MARK_continue = -3
	flag distinct from all others (keep last)
Friends
class	VrMultiTask

Detailed Description

The base class for all signal processing modules.

All signal processing modules are descendants from VrSigProc. In the simplest case a user defines a subclass of VrSigProc and overrides the forecast and work methods.

Constructor & Destructor Documentation

VrSigProc::VrSigProc ( int number_of_outputs,

unsigned int arg_itype_size,

unsigned int arg_type_size

)

VrSigProc::~VrSigProc ( ) [virtual]

Member Function Documentation

void VrSigProc::attach_writer ( writerLL * r ) [private]

virtual int VrSigProc::callback ( int attribute_number,

float value

) [inline, virtual]

bool VrSigProc::compute ( ) [private, virtual]

compute the marked data
Compute is the second part of the markData / compute dyad. These two methods are called from VrMultiTask::schedule to schedule and compute the work of the signal processing modules.
Note that this can run in parallel. All of the scheduling is done in markData, so there is very little overhead or contention here.

Returns:
true if we successfully computed all marked data. We return false if some module is not able to successfully compute the amount of data that it was expected to.

bool VrSigProc::connect_proc ( VrSigProc * proc,

port n

)

connect our next input to proc's nth output
Connect our next input to PROC's Pth output.

bool VrSigProc::dataMarked ( VrSampleRange r ) [private, virtual]

is data marked to be computed?

Returns:
true if all data in r is marked to be computed

bool VrSigProc::dataReady ( VrSampleRange r ) [virtual]

has the data been computed?

Returns:
true if all data in r has been computed.

void VrSigProc::detach_writer ( writerLL * r ) [private]

double VrSigProc::getInputSamplingFrequencyN ( port p ) [protected]

VrSampleIndex VrSigProc::getMarkedWP ( ) [inline]

unsigned int VrSigProc::getMaxOutputSize ( ) [inline]

int VrSigProc::getNumberInputs ( ) [inline, protected]

unsigned int VrSigProc::getOutputSize ( ) [inline, protected]

double VrSigProc::getSamplingFrequency ( ) [inline]

VrSigProc * VrSigProc::getUpstreamModuleN ( port p ) [protected, virtual]

VrSampleIndex VrSigProc::getWP ( ) [inline]

void VrSigProc::init_base ( ) [private]

Cause initialize methods to be called. This is called on all sinks for which isConnectedToSource is true, and results in the pre_initialize and initialize methods being called in the order source to sink.

virtual void VrSigProc::initialize ( ) [inline, private, virtual]

Initialize any local state that is dependent on sampling frequency.

Reimplemented in VrAudioDecoder< iType >, VrAudioEncoder< iType >, VrComplexDemod< iType >, VrComplexFIRfilter< iType >, VrCorr< iType, oType >, VrDigMod< iType, oType >, VrIIRfilter< iType, oType >, VrMixer< iType, oType >, VrPulseCorrelator< iType >, VrQuadratureDemod< oType >, VrRealFIRfilter< iType, oType >, VrSquelch< T >, VrSum< iType, oType >, VrSyncCorr< iType >, VrSyncFilter< iType >, VrAudioSink< iType >, VrAudioSource< oType >, VrComplexPlotSink, VrFileSink< iType >, VrPointSink, VrScopeSink< iType >, VrSigSource< oType >, VrTestCopySlow< iType, oType >, VrTestCountSink< iType >, VrTestCountSource< oType >, VrUDPSink< iType >, GrAtscFPLL, GrAdd< iType, oType >, GrAGC< iType, oType >, GrComplexVCOMixer< iType, oType >, GrCostasLoop< iType, oType >, GrFastChannelizer< iType >, GrFIRfilterCCC, GrFIRfilterCCF, GrFIRfilterFCC, GrFIRfilterFFF, GrFIRfilterFSF, GrFIRfilterSCC, GrFIRfilterSIS, GrFreqXlatingFIRfilterCCC, GrFreqXlatingFIRfilterCCF, GrFreqXlatingFIRfilterFCC, GrFreqXlatingFIRfilterFCF, GrFreqXlatingFIRfilterSCC, GrFreqXlatingFIRfilterSCF, GrIIRfilter< iType, oType, taptype >, GrMixer< iType, oType >, GrMultiply< iType, oType >, GrWeaverModHead< iType, oType >, GrAudioSink< iType >, GrAudioSource< oType >, GrFFTAvgSink< iType >, GrFFTSink< iType >, GrOscopeSinkC, GrOscopeSinkF, GrUsrpSink, VrChirpSource< oType >, and VrSyncCorr< char >.

void VrSigProc::initMarkedData ( ) [private]

void VrSigProc::initOutputBuffer ( int n ) [private, virtual]

Reimplemented in VrGuppiSource< oType >, and GrMC4020Source< oType >.

void VrSigProc::initOutputBuffers ( int n ) [private]

bool VrSigProc::is_synced ( VrSampleIndex arg_index ) [inline, protected]

Returns:
true if we're working on the current output block, else false, indicating that we're working on a future output block

bool VrSigProc::isConnectedToSource ( ) [private, virtual]

Reimplemented in VrSource< oType >, GrSource, and VrSource< unsigned long >.

bool VrSigProc::isSink ( )

return true iff this VrSigProc is a sink

int VrSigProc::markData ( VrSampleRange r ) [private, virtual]

figure out what data to compute
markData is the first part of the markData / VrSigProc::compute dyad. These two methods are called from VrMultiTask::schedule to schedule and compute the work of the signal processing modules.
markData is called from the downstream side (starting with the sinks) to determine what data to schedule for future computation.
Note that markData does NOT run in parallel (VrMultiTask is holding its mutex whenever it calls markData, and is the root of all calls to markData).
This function also has many side effects, including sometimes setting startMarkedModule. Really needs to be cleaned up.

Returns:
MARK_ALREADY if all data is already computed.
MARK_READY if data is ready to be computed (and has been marked).
MARK_READY_NO_MARK if data is ready on this level or above but no further data should be marked.
MARK_NO_READY if no data is ready to be computed.
MARK_THREAD if data is marked by another thread.

Check if unmarked data precedes us *
Mark data to be computed *
initialize pointers to thread-specific marking data *
save which range this thread marked *
save which input ranges were forcasted as needed for this marking *
create our entry in writer linked list *
create our entries in the reader linked lists upstream *
set the starting module for this compute block to this *

int VrSigProc::markDataUpstream ( VrSampleRange * inputs,

bool * dataMarkedUpstream

) [private, virtual]

propagate marking upstream
This is the embodiment of a bunch of heuristics determining which data to schedule when (Explain this mess.)
dataMarkedUpstream is set iff we successfully marked data upstream

Returns:
MARK_continue if the process was successful and we should continue to work on this module's data. Otherwise return a more specific MARK_xxx value indicating our status.

float VrSigProc::memoryTouched ( ) [virtual]

Returns the total number of bytes read (ignores written bytes) per second by the upstream chain ending with this module zero has a special meaning (no outputs in cache)
Reimplemented in VrFakeGuppiSource< oType >, VrGuppiSource< oType >, and GrMC4020Source< oType >.

int VrSigProc::minwritespace ( VrSampleIndex newWP,

unsigned int desired

) [private]

VrSigProc::MUTEX_DECLARE ( mutex ) [private]

VrSampleIndex VrSigProc::proc_minRP ( ) [protected]

Returns the minimum RP in downstream buffers' readers. computes the most up to date value possible.

void VrSigProc::setOutputSize ( int o ) [inline, protected]

set required multiple for number of items produced

int VrSigProc::setSamplingFrequency ( double sf ) [virtual]

void VrSigProc::setup ( ) [virtual]

Reimplemented in VrSink< iType >, GrSink, VrSink< unsigned long >, and VrSink< VrComplex >.

void VrSigProc::setup_upstream ( ) [protected]

Reimplemented in VrSink< iType >, GrSink, VrSink< unsigned long >, and VrSink< VrComplex >.

void VrSigProc::size_setup ( unsigned int size ) [virtual]

void VrSigProc::sync ( VrSampleIndex arg_index ) [protected]

force rest of procedure to run sequentially
Call sync (arg_index) from work(...) to ensure the rest of the procedure runs sequentially...

Friends And Related Function Documentation

friend class VrMultiTask [friend]

Member Data Documentation

volatile writerLL* VrSigProc::first [private]

Reimplemented in VrCorr< iType, oType >, VrSyncCorr< iType >, and VrSyncCorr< char >.

unsigned int VrSigProc::initializeCalled [private]

VrConnect** VrSigProc::inputConn [private]

VrSampleRange* VrSigProc::inputs_forecasted [private]

unsigned int VrSigProc::itype_size [private]

volatile writerLL * VrSigProc::last [private]

Reimplemented in GrTestSink, GrTestSkippingSink, and GrTestSource.

const int VrSigProc::MARK_ALREADY = 2 [static, private]

all data is already computed

const int VrSigProc::MARK_continue = -3 [static, private]

flag distinct from all others (keep last)

const int VrSigProc::MARK_NO_READY = -1 [static, private]

no data is ready to be computed

const int VrSigProc::MARK_READY = 1 [static, private]

data is ready to be computed (and has been marked)

const int VrSigProc::MARK_READY_NO_MARK = 0 [static, private]

data is ready on this level or above,

const int VrSigProc::MARK_THREAD = -2 [static, private]

data is marked by another thread

volatile VrSampleIndex VrSigProc::markedWP [private]

data before this has been marked and will be written

unsigned int VrSigProc::maxDSReadSize [protected]

max Down Stream Read Size. How big a read we might get. maxOutSize should never exceed this.

unsigned int VrSigProc::maxOutSize [private]

maximum size that we should ever output at once.
due to cache size and latency contraints we may actually output anywhere < 2*maxOutSize to prevent unnecessarily small chunks from being marked