blob: 1da8a82ff3ed4558318674522ccc3a5fd86d8ae6 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
|
This directory containing the component implementations that we use to
demonstrate how real-time behaviors can be composed into an
application using CIAO's real-time extension. Under the "descriptors"
subdirectory, you can find several example applications that consist
of different number of components, with different real-time behaviors
specifications. Component implementations used in these examples
are organized by component types under subdirectories as:
* Controller:
Subdirectory Controller contains definition for component type
Controller. A controller trigger the connecting worker receptacle
interface to perform some amount of work. Each controller component
implementation implements a different strategy of invoking the
"worker" receptacle. For example,
* The Controller_exec.* files contain the implementation of a
controller component that requests the "worker" to perform certain
amount of work (specified via the "start" method) continuously for
1000 times and print out the performance statistics (throughput,
latency, etc.) of making these 1000 requests.
* The Rate_Controller.* files contain the implementation of a
rate-based controller. When the "start" method of its supported
interface is invoked, the component start requsting the connecting
"worker" to perform specified amount of work at certain
predetermined rate (the rate is predetermined and is generated using
the timer in ACE_Ractor.) When the "stop" method of its supported
interface is called, the component stop the fix-rate requests and
print out the performance of the requests made between start and
stop methods are called. This will show the actual rate the
controller are able to sustain. The Rate_Controller.* files define
the homes for 3 Rate_Controllers that try to request the worker to
perform work at 25, 50, and 75 hertz.
* Worker: A worker component performs some amount of "work". Two
Worker component implementations are provided. Only CB_Worker is
used in the tests.
* CB_Worker.* files contain a compute-bound worker implementation.
Upon request, it tries to find a large prime number a certain number
of times (i.e., the amount of work.)
* IOB_Wroker.* files contain an I/O-bound worker implementation that
simply print out the requested amount of work upon request.
Several application assemblies are used to demonstrate how the
real-time extension in CIAO enforces the composed real-time behaviors.
The following document "NOTE.txt" under the "descriptors" subdirectory
explains how to run these examples.
|
