 |
|
 |
|
|
|
|
|
|
The MuDiSP3 is a set of C++ classes acting as a
framework for the execution of Digital Signal Processing (DSP) simulations. The
entire simulated system is represented by a "System" class which
inherits his properties from a general purpose DSP. The user can then add
blocks to give the desired functionalities to the system. These can be either
library blocks, blocks made out of other blocks, or new blocks written from
scratch.
The
two main features are a flexible way to pass system parameters to the
simulation, and a set of classes to collect statistical results of the
simulations. MuDiSP also provides a set of classes for random number
generation. They act as wrappers for the underlying random library which can be
easily replaced by the programmer.
The
MuDiSP environment is designed to simulate systems where events happen
synchronously with a discretized representation of time. A typical use of the
discrete timing is the modeling of Digital Signal Processing systems.
The
MuDiSP environment allows multi-rate and provides the user with a sophisticate
tool able to find automatically the execution rates for each region of the
system.
The basic element in the DSP
simulator is the block. Depending on their internal composition, blocks can be
of two types:
No limit is imposed to the
level of recursion of the compound blocks so very complicated systems can be
easily modeled and simulated. The block class has four basic methods for the
definition of its behavior:
Build()
contains the sub-blocks connection
instructions, it is executed once per simulation.
Setup()
contains the code for initializing the
processing of the block and permits the reading of the run-time parameters; it
is also executed once per simulation.
Run()
contains the code of the actual processing of
the block, it usually contains instructions for collecting data from the input
ports of the block and/or instructions for delivering processed data to the
output ports. It is executed once per iteration.
Finish()
it performs all the post-simulation processing,
organizing, displaying or saving results. It is executed once.
Another
feature is the ability to handle algorithms with feedback obtained by a special
delayed connection between the blocks. The data representation flowing through
the branches is generic and use templates so the user can propagate any kind of
data in the simulated systems; from elementary C++ data formats like integers
or floating point numbers to vectors, matrices and any user defined class. The
support for parameters gives an easy method for differentiating instances of
the same block class and allows to modify the behaviour of the blocks without
recompiling the system. This is particularly useful to build families of
simulations where only a few variables are modified from one to another.
Another essential feature of MuDiSP is the self-contained implementation of the
blocks which permits the building of large libraries and the total reuse of the
code. This is due to the high degree of abstraction of the Block class, from
which all the blocks in the system are derived.
Last modified: May 2005