maindoc.tex

TGFF省城程序

\item <flt>: a floating point number
\item <bool>: a boolean value which can be ``true'' or ``false''
\item <list(T)>: a comma separated series of zero or more values of type
T

\begin{itemize}
\item Note: the parentheses are meta-characters --- \textbf{Don't enter
them}!
\end{itemize}
\end{itemize}

\subsection{Basic commands}

\begin{itemize}
\item \emph{seed} <int>: Sets the seed for the pseudo-random number generator. 

\begin{itemize}
\item This allows users to command TGFF to create a family of closely related
outputs by changing the random number seed and leaving the other parameters
constant. 
\end{itemize}
\end{itemize}

\subsubsection{Task graph generation}

\begin{itemize}
\item \emph{tg\_cnt} <int>: Sets the number of task graphs to generate.
\item \emph{tg\_label} <string>: Sets the (case dependent) label
used for task graphs.
\item \emph{tg\_offset} <string> <int>: Sets the start index for named task
graph (default 0).
\item \emph{task\_cnt} <int> <int>: Sets the minimum number of tasks per
task graph (average, multiplier).
\item \emph{trans\_type\_cnt} <int>: Sets the number of possible transmit
types.
\item \emph{period\_mul} <list(<int>)>: Sets the multipliers for periods
in multirate systems.

\begin{itemize}
\item Allows the user to specify the periods relative to each other.
\item The multipliers are randomly selected from this list.
\end{itemize}
\item \emph{prob\_periodic} <flt>: Sets the probability that a graph is
periodic (default 1.0).

\begin{itemize}
\item Allows simultaneous generation of aperiodic and periodic task graphs.
\end{itemize}
\item \emph{prob\_multi\_start\_nodes} <flt>: Sets the probability that
a graph has more than one start node (default 0.0).
\item \emph{start\_node} <int> <int>: Sets the number of start nodes
for graphs which have multiple start nodes (average, multiplier).

\begin{itemize}
\item If \emph{prob\_multi\_start\_nodes} is zero, this option is ignored.
\end{itemize}
\end{itemize}

\subsubsection{Series-parallel commands (new algorithm)}

\begin{itemize}
\item \emph{gen\_series\_parallel} <bool>: If set, generate graphs with
a series-parallel structure (default false).

\begin{itemize}
\item \textbf{This command should be used to use the new graph generation
algorithm.}
\end{itemize}
\item \emph{series\_must\_rejoin} <bool>: If set, force subgraphs formed
in series chains to rejoin into the main graph

\begin{itemize}
\item This overrides \emph{series\_subgraph\_fork\_out} flag.
\end{itemize}
\item \emph{series\_subgraph\_fork\_out} <flt>: Sets the probability subgraphs
will not rejoin.
\item \emph{series\_len} <int>: Sets the length of series chains
  (average, multiplier).
\item \emph{series\_wid} <int>: Sets the width of series chains
  (average, multiplier).

\begin{itemize}
\item This is the number of parallel chains generated for each node
that is the head of a set of chains.
\end{itemize}
\item \emph{series\_local\_xover} <int>: Sets the number of extra local
arcs added.
\item \emph{series\_global\_xover} <int>: Sets the number of extra global
arcs added.
\end{itemize}

\subsubsection{Old algorithm parameters}

\begin{itemize}
\item \emph{task\_degree} <int> <int>: Sets the maximum number of transmits
(degree) per task (in, out).
\item \emph{task\_type\_cnt} <int>: Sets the number of possible task types.
\end{itemize}

\subsection{Table generation commands}

These commands are used to generate the tables:

\begin{itemize}
\item \emph{entries\_per\_type} <flt> <flt>: Sets the number of attribute
entries per task type for tables (average, multiplier).
\item \emph{table\_label} <string>: Sets the label used for the current
table.
\item \emph{table\_offset} <string> <int>: Sets the index for named table.
\item \emph{table\_cnt} <int>: Sets the number of tables (of current table
type) generated.
\item \emph{type\_table\_ratio} <flt>: Sets the ratio of statistical contributions
of type to table attributes (default 0.5).
\end{itemize}
These three commands are similar in format:

\begin{itemize}
\item \emph{task\_attrib} <list(<string> <flt> <flt> <flt>)>: 

\begin{itemize}
\item name: Sets the name of the attribute to the value in string.
\item average: Sets an average value for the attribute.
\item multiplier: Sets the multiplier.
\item round to: Sets the probability for rounding to occur {[}0, 1) (Default
0.0, 0.0 means no rounding).
\end{itemize}
\item \emph{table\_attrib} <list(<string> <flt> <flt> <flt> <flt>)>: name,
average, multiplier, jitter (default 0.5) round to (default 0.0, 0.0
means no rounding)
\item \emph{type\_attrib} <list(<string> <flt> <flt> <flt> <flt>)>: name,
average, multiplier, jitter (default 0.5), round to (default 0.0,
0.0 means no rounding)
\end{itemize}

\subsection{Output commands}

These commands are used to output the task graphs and corresponding
tables. \textbf{TGFF generate output based on current settings each
time it encounters a write command.} This leads to some interesting
properties. Two sequential write commands will cause output (to the
corresponding output file) to be duplicated. A write command followed
by a modification, such as a new tg count, will cause the latter option
to be ignored.


\subsubsection{{*}.tgff file}

\begin{itemize}
\item \emph{tg\_write}: Write the task graphs {[}to .tgff file{]}.
\item \emph{pe\_write}: Write PE information {[}to .tgff file{]}.
\item \emph{trans\_write}: Write transmission event information {[}to .tgff
file{]}.
\item \emph{misc\_write}: Write independant processor information {[}to
.tgff file{]}.

\begin{itemize}
\item misc\_type\_cnt: Set the number of types for misc\_write.
\end{itemize}
\item \emph{note\_write} <list(<string>)>: Write the string(s) {[}to .tgff
file{]}.
\end{itemize}

\subsubsection{{*}.eps file}

\begin{itemize}
\item \emph{eps\_write}: Create a PostScript plot of the task graphs {[}to
.eps file{]}.
\end{itemize}

\subsubsection{{*}.vcg file}

\begin{itemize}
\item \emph{vcg\_write}: Creates an input file for the graph visulization
tool VCG {[}to .vcg file{]}.

\begin{itemize}
\item \emph{vcg\_hide\_edge\_labels}: Suppresses display of edge labels
{[}for .vcg file{]}.
\end{itemize}
\end{itemize}

\subsection{Advanced commands}

\begin{itemize}
\item \emph{period\_laxity} <flt>: Sets the laxity of periods relative to
deadlines (default 1).

\begin{itemize}
\item Indicates whether task graphs deadlines are greater than, less than,
or equal to the periods.
\end{itemize}
\item \emph{period\_g\_deadline} <bool>: If true, then periods values are
forced to be greater than deadlines (default true).
\item \emph{prob\_hard\_deadline} <flt>: Sets the probability that a deadline
will be hard (vs. soft).
\item \emph{soft\_deadline\_mul} <flt>: Sets the multiplier applied to soft
deadlines (default 1).

\begin{itemize}
\item Used to increase create soft deadlines that are arbitrarily tighter
than the hard deadlines.
\end{itemize}
\item \emph{task\_trans\_time} <flt>: Sets the average time per task including
communication

\begin{itemize}
\item This value is used in setting deadlines.
\end{itemize}
\item \emph{deadline\_jitter} <flt>: Sets the proportional jitter for deadline.
\item \emph{task\_unique} <bool>: If true, tasks types are forced to be
unique (false by default).
\end{itemize}

\subsection{Untested legacy command}

\emph{pack\_schedule} <int> <int> <flt> <flt> <flt> <flt> ... <int>
<int> <int> <int> {[}<flt>{]} {[}to .tgff file \& .eps file{]} {[}...
on one line{]}

\begin{itemize}
\item This is a `self-contained' command, it generates PEs, COMs, TG, etc.
Other writes except note\_write should not be used. Only non-periodic
instances are generated, `task\_degree' and `seed' are only cmds that
affect its operation.
\item The args in-order are:
num\_task\_graphs avg\_task\_graphs\_per\_pe avg\_task\_time
mul\_task\_time task\_slack task\_round num\_pe\_types num\_pe\_soln
num\_com\_types num\_com\_soln and optionally arc\_fill\_factor.
\item \bf{Note: VCG output is not available for this command.}
\end{itemize}

\section{Examples}
\label{examples}
The examples directory contains sample files that use TGFF to
generate a variety of graphs and tables. The best way to learn TGFF
is to experiment by adding and removing options from these examples.
The examples described below can be found in the 
\textbf{\emph{examples}} directory.

\subsection{Basic example: simple.tgffopt}
The first line in this file, \emph{tg\_cnt} 3, tells TGFF to generate
3 task graphs based on the parameters that follow.  \emph{task\_cnt}
20 5, indicates that task graphs should have 20 tasks.  The first
number is the average value and the second is the +/- range by which
it can vary.  (Note that the graphs generated by this file actually
vary by more than this amount.  This is caused by the
\emph{period\_mul} command, which is discussed below.)  Since this
file does not contain the \emph{gen\_series\_parallel} command, the
old graph generation algorithm will be used.  This algorithm uses
the \emph{task\_degree} to indicate the maximum number of incoming
and outgoing arcs a task can have.  In this case, tasks can have up
to 3 incoming and 2 outgoing arcs.

The next two commands are slightly more complex.
\emph{period\_laxity} represents how much slack there is in the
relationship between deadlines and periods.  When set to it's
default value (1.0), the period of the task graph is equal to the
largest deadline.  \emph{period\_mul} is used to influence the
periodic relationship between the task graphs.  The setting in this
file (1, 0.5, and 2), indicate that there is a 1:0.5:2 ratio between
their periods.  TGFF selects a value from the list for each task
graph generated and scales the period (and largest deadline) based
on that value.

The next three lines are used to tell TGFF to generate output.  This
interface can be somewhat confusing at first, but makes TGFF more
general.  For example, if a user wants to generate two sets of
pe~tables.  Using explicit commands for printing allows users to
configure parameters once, print those tables, and then reconfigure
the parameters and print a second set of tables.  One reason for
doing this is that a user might want to generate pe~tables with
statistics for processors and then another for FPGAs.

The next four lines configure table printing for the transmission
(edges) table.  The first line, \emph{table\_label} COMMUN, labels
the table as COMMUN.  The next line, \emph{table\_cnt} 3, indicates
that three tables should be made based on these parameters.
\emph{table\_attrib\ price} 80 20, indicate that price is the only
variable for the table.  It's average value should be 80 +/- 20.
\emph{type\_attrib} exec\_time 50 20, indicates that each edge
should have a value corresponding to the transmission execution
time.  This value should be 50 +/- 20.  Finally, \emph{trans\_write}
indicates that the table should be generated based on these
parameters and then printed to file.

\subsection{Other examples}
As mentioned previously, the best method to learn TGFF is to
experiment by adding, removing and modifying options.
\textbf{\emph{kbasic\_task.tgffopt}} and
\textbf{\emph{kbasic\_tables.tgffopt}} are annotated example files
that depict the basics of generating tasks and tables, respectively.
\textbf{\emph{kseries\_parallel.tgffopt}} and
\textbf{\emph{kseries\_parallel\_xover.tgffopt}} are basic examples
of series\_parallel task graph generation.  The latter of the two
demonstrates how to use cross over edges.
\textbf{\emph{sp\_rand.tgffopt}} shows how to generate unstructured
graphs using the new algorithm.  Finally,
\textbf{\emph{kextended.tgffopt}} presents more advanced features.
These are the example source files that have been highly documented.
There are other source files, but these are not documented as well.



\end{document}