How much does Gedae support RT control systems? For example, weapons control or flight control?
Discussion
Gedae can be used effectively to handle real time performanceconstraints. Real time systems require:
- Ability to keep up with incoming data,
- Guaranteed processing latency,
- Periodic scheduling of services, and
- Ability to respond quickly to interrupts.
A Gedae developer has several tools for meeting such requirements.
A Gedae application consists of multiple processors each dynamically
scheduling static schedules. Gedae provides control over both the
dynamic and the static scheduling of a Gedae graph giving the
developer the control he needs to meet real time performance criteria.
A static schedule is a precalculated list of primitive function
firings that does the work of the application. Static schedules have
the advantage of predictability and repeatability - important
considerations in a real time application. They also require very low
scheduling overhead as the schedules are determined prior to run time.
However some scheduling decisions need to be made at runtime such as
when a dynamic box steers data down one branch of a graph or another.
Gedae handles major portions of the graph as predictable static
schedules and only uses dynamic scheduling where needed to implement
dynamic graph behavior.
Solution
The execution of both the static and dynamic schedules can be tuned by
the developer to help insure that real time constraints and throughput
requirements are met. In addition graphs can be easily parallelized
in Gedae. The following shows some of the capabilities a developer
has to make real-time performance possible:
- Partitioning and Mapping: Graphs can be partitioned and mapped to
multiple processors to get the parallelism needed to keep up with
real-time input data.
- Static Schedules Granularity Control: The user can control a static
schedule by setting overall schedule granularity and the
granularity of individual function boxes. This allows the
developer to tradeoff latency and throughput.
- Static Schedule Priority: Frequently in a static schedule several
primitives may be able to fire at a given point. Gedae allows
the default decision made by the static scheduler to be overridden
by user set priorities.
- Periodic Scheduling: A static schedule can be marked to run
periodically (e.g., every 10msec) by the developer. Other timeout
and retry options can be set by the developer.
- Flexible Scheduling: A static schedule can be marked to run
flexibly. That is the schedule will adjust granularity on the fly
to handle the available data thus reducing latency.
- Round-Robin: A static schedule can be marked to run round-robin
insuring fairness.
- Dynamic Scheduling Priorities: The priority of a static schedule
can be set determining which of the runnable static schedules will
fire first.
- Interrupt Handling: Interrupt handlers can be incorporated into
Gedae graphs.
More Information
Web page describes how Gedae can use interrupt
handlers to create applications that use real-time data collection.
return to top