Practical Applications of an E cient Time ... are annotated with a delay range d; D] (integers with. 0 d .... Instead of forming a single function, we can perform.
Practical Applications of an Ecient Time Separation of Events Algorithm Henrik Hulgaard, Steven M. Burns, Tod Amon1, and Gaetano Borriello Department of Computer Science and Engineering, FR{35 University of Washington, Seattle, WA 98195
Abstract Determining the time separation of events is a fundamental problem in the analysis, synthesis, and optimization of concurrent systems. We present results of applying an ecient algorithm to solve this problem to three di erent application domains. These are: analysis of instruction execution times of an asynchronous microprocessor, analysis of a high-performance mixed asynchronous/synchronous communication interface, and isochronic fork analysis in asynchronous circuit synthesis. The algorithm we use yields exact (tight) bounds on the separation time of events in an arbitrary process graph without conditional behavior. This class of graphs is quite large and includes graphs that are not strongly connected. The algorithm is based on a functional decomposition technique that permits the implicit evaluation of an in nitely unfolded process graph.
1 Introduction Event based speci cations naturally model communication and concurrency and are thus a popular model for a wide range of concurrent systems. Depending on the level of abstraction in the speci cation, events may represent low-level signal transitions at a circuit interface or abstract behavioral control ow. We represent a concurrent system as a cyclic connected digraph, called the process graph2. The vertices of the graph, E 0 , represent events and the edges, R0, represent delay relations between the events and are annotated with a delay range [d; D] (integers with 0 d D) and an occurrence index o set3 ". FigNow at the Department of Computer Science, Southwest Texas State, San Marcos, TX 78666{4616 2 Also called a timed event graph [3], a marked graph or a decision free Petri net. 3 The occurrence index o set is used to specify how much the occurrence index is incremented when the edge is executed. 1
ure 1 shows a simple process graph with two events. [4,10]
[1,2]
a
b
[5,20]
[1,6] Figure 1: A process graph with two events, E 0 = fa; bg and edges R0 = fa[47?;10] !;1a; a [17?;2]!;0 b; b [17?;6]!;1 a; b [57?;20] !;1 bg. The number of lines drawn through an edge indicates the value of the occurrence index o set, ", for the edge (e.g., b [17?;6]!;1 a constrains ak relative to bk?1 ).
We can represent each of the iterations of the process graph explicitly by unfolding the process graph. That is, we construct a new in nite digraph, hE; Ri, where E is the set of vertices (event occurrences), E = fvk j v 2 E 0 ; k 0g and R is the set of edges generated by instantiating each edge of the process !] vk j graph at each occurrence index, R = fuk?" [7?d;D u [d;D 7?!];" v 2 R0; k "g. We model the initial startup behavior of the processes by adding edges to a distinguished root event and include special startup edges root [7?d;D !] vk in R. Let (vk ) denote the time of the kth occurrence of event v. An event can only occur when all of its incident events have occurred, thus acting as synchronization points. Each event u incident to v in the process graph is delayed by some number in the bounded interval ([d; D]) associated with the edge from u to v. Formally, the constraints on the timing assignment (vk ) are
[d;D]
(vk ) max (uk?") + d uk?" 7?! vk 2 R
[d;D]
(vk ) max (uk?") + D uk?" 7?! vk 2 R : Figure 2 shows a possible timing assignment of the
example in Figure 1 obtained by choosing the upper bound, D, for all delays. [0, 0] root [0, 0]
0
a0
[1,2]
[4, 10] [1,6]
b0 2
10
a1
[1,2] [5, 20]
[4, 10] [1,6]
b1
22
28
a2
[1,2] [5, 20]
[4, 10] [1,6]
b2
42
48
a3
[1,2] [5, 20]
[4, 10] [1,6]
b3
62
68
a4
[5, 20]
Figure 2: A portion of the unfoldedprocess graph for the process graph in Figure 1. Two startup edges have been added, specifying that both a0 and b0 must occur after root . The vertices are annotated with the timing assignment (vk ) obtained by choosing the upper bound, D, for all delays.
This paper describes applications of an algorithm that determines tight bounds on the separation in time between two arbitrary events for all possible in nite executions of the system. That is, given two events, s and t, and a separation in occurrence index , determine the largest and the smallest such that
8k max(0; ) : (tk ) ? (sk? ) : We address only the problem of nding the maximum separation, since the minimum separation, , can be obtained from (sk ) ? (tk?(? )) ?. The timing assignment in Figure 2 indicates that the separation between two consecutive a events is between 10 and 20, i.e., that 10 (ak ) ? (ak?1) 20. However, it turns out that there exists a timing assignment such that (ak ) ? (ak?1) = 4 (for some k) and another assignment such that (ak ) ? (ak?1) = 25. These are the extreme cases and thus the tightest bounds are = 4 and = 25. This paper is composed of six sections. We follow this introduction with a review of the algorithm that solves the maximum separation problem. The next three sections illustrate the generality of the algorithm by describing three applications. Section 3 shows how the algorithm can be used to obtain performance numbers for an asynchronous microprocessor. An implementation of the STARI communication protocol is veri ed in Section 4, and in Section 5 we show how the algorithm can be used to relax timing constraints when designing asynchronous circuits. Finally, Section 6 summarizes the contributions.
2 The Algorithm In this section, we give an intuitive description of our time separation of events algorithm (details can be found in [2]). Our algorithm for analyzing a process graph is based on an algorithm by McMillan and
Dill [8] that determines the maximum separation in an acyclic graph. Let be the strongest bound for the separation problem given a particular occurrence index , i.e., (t ) ? (s ? ) . We determine by applying McMillan and Dill's algorithm to the nite portion of the unfolded process graph created by only including the vertices for which there is a path to either t or s ? . The algorithm consists of two simple phases. We rst compute m-values h m(vk ) = max d(h) all paths vk ; s ?
n
o
where d(h) is sum of the d values of the edges on the path h. m(vk ) thus corresponds to the longest path from s ? to vk . We can compute the m-values by a reverse topological traversal from s ? . If there is no path from vk to s ? , denoted by vk 6; s ? , we can assign an arbitrary constant to m(vk ). Normally, we use m(vk ) = 0 although it sometimes is advantageous to choose di erent constants for the various vk (see below). Second, we compute M-values using D values by assigning M(root ) = 0 and then for all other occurrences in (normal) topological order
!] vk ; r 2 R M(vk ) = max Xr r = uk?" [7?d;D where
(1)
min(0; M(uk?") + D ? m(uk?") + m(vk )) if vk ; s ? Xr = > > M(uk?") + D ? m(uk?" ) + m(vk ) > : if vk 6; s ? The maximum separation between s ? and t is now simply = M(t ) ? m(t ). However, since we are interested in the bound on the separation in time of two events over all occurrences, we would need to apply the McMillan and Dill algorithm an in nite number of times to be certain that we have found the pair of events that exhibit the worst-case behavior, i.e., = maxf j max(0; )g. We can reformulate the problem in terms of an algebra that will permit us to implicitly analyze the in nite graph, thus obtaining a nite algorithm. We introduce (F ; max ; ; 0; 1), an algebraic structure where the elements of F are piecewise-linear monotonic non-decreasing functions. The operator max denotes function maximization and denotes function composition. 0 and 1 are appropriate identity elements for max and , respectively. 8 > > >
