Rate-Optimal Unfolding of Balanced Synchronous Data-Flow Graphs

Transcription

1 Rate-Optimal Unfolding of Balanced Synchronous Data-Flow Graphs Timothy W. O Neil Dept. of Computer Science, The University of Akron, Akron OH USA toneil@uakron.edu Abstract Many common iterative or recursive DSP applications can be represented by synchronous data-flow graphs (SDFGs). Despite claims to the contrary, the unfolding of such graphs proves to be a non-trivial problem. We demonstrated this in our previous work and now specify the properties of the special class of synchronous graphs that satisfy the conditions for unfolding. 1 Introduction Since the most time-critical parts of DSP applications are loops, we must explore the parallelism embedded in the repetitive pattern of a loop. One of the most useful models for representing DSP applications has proven to be the multirate or synchronous data-flow graph (SDFG) first proposed by Lee [5]. The nodes (vertices) of a SDFG represent functional elements, while edges between nodes represent data channels between them. Each node consumes and produces a predetermined fixed number of delays (i.e., data tokens) on each invocation. Additionally, each edge may contain some initial number of delays. This model has proven popular with designers of signal processing programming environments with its use leading to numerous important results regarding DSP programs. A great deal of research has been done attempting to optimize various aspects of an application s execution by applying various graph transformation techniques to the application s flow graph. One of the more effective of these techniques is unfolding [11], which alters the graph by making multiple iterations visible simultaneously. The size of the graph is increased, but we derive some benefit by creating more options for parallel execution. It was assumed in [4] that unfolding of the synchronous model is the same as for the traditional single-rate model but we demonstrated that this is not the case in [8]. In this paper, we will review the basic definitions and results necessary for specifying and manipulating a SDFG, and specify the circumstances under which an SDFG may be unfolded. We will then define a certain class of foldable SDFGs and develop the theory behind such graphs. In the next section, we will formalize the fundamental concepts related to the studies of synchronous data-flow graphs and unfolding. We then develop the theory behind a subclass of synchronous graph that can be unfolded. Finally, we summarize our work and point to future directions for study. 2 Background In this section we review the relevant definitions and ideas regarding synchronous data-flow graphs (balanced and unbalanced) and unfolding in order to formalize these concepts. 2.1.Synchronous Data-Flow Graphs Originally developed in [5], a synchronous data-flow graph (SDFG) is a finite, directed, weighted graph G = V,E,d,t,p,k where 1. V is the vertex set of nodes or actors, which transform input data streams into output streams; 2. E V V is the edge set, representing channels which carry data streams; 3. d : E N { 0 } is a function with d(e) the number of initial tokens (delays) on edge e; 4. t : V N is a function with t(v) the execution time of node v; 5. p : E N is a function with p(e) the number of data tokens produced at e's source node to be carried by e; and 6. k : E N is a function with k(e) the number of data tokens consumed from e by e's sink node. (In this definition N is the set of natural numbers {1, 2, 3,...}.) If p(e) = k(e) = 1 for all edges e, we say that G is a homogeneous data-flow graph (HDFG). HDFGs are also sometimes referred to as single-rate data-flow graphs or simply data-flow graphs. To illustrate, consider the SDFG given in Figure 1 below. Because it does not matter to the topic at hand, we will assume all such graphs given in this paper to be unit / copyright ISCA, CATA 2014 March 24-26, 2014, Las Vegas, Nevada, USA 261

2 time, i.e. ( ) = 1 for all nodes. The small numbers at either end of an edge denote tokens produced or consumed. In this example, the numbers at either end of the edge connecting and indicate that node produces two tokens on this edge when it executes, while node consumes one token from this edge each time it runs. The short bar-lines cutting the edge from node to node, hereafter denoted (A,B), represent initial tokens to be consumed by. Figure 1 Sample balanced SDFG. It is sometimes useful to characterize an SDFG by its topology matrix, an E V matrix similar to an incidence matrix. Each row corresponds to one edge in the graph, while each column corresponds to a node. A positive (i,j) th entry in the topology matrix indicates the number of tokens produced by the j th node on the i th edge, while a negative entry here gives the number of tokens consumed by node j from edge i. All other entries are zero. As an example, the topology matrix of Figure 1 is M For purposes of this representation, nodes A, B and C are designated nodes 0, 1 and 2, respectively, while the edges are numbered in the order (A,B), (B,C) and (C,A). In [5] it was demonstrated that a repeating sequential schedule can be constructed for a SDFG G if the rank of the graph s topology matrix is one less than the number of nodes in the SDFG. If this condition holds there is a positive integer vector q in the null space of the topology matrix called a repetition vector for G. The repetition vector for G with the smallest norm is called the basic repetition vector (BRV) for G [5]. For example, the BRV for the SDFG in Figure 1 is q = [ ] T. The elements of a BRV q indicate that q j copies of node v j must be executed during every iteration of the static schedule. In our example we must schedule two copies of A, one of B and four of C each time. Finally, a SDFG is consistent if it has a BRV. (1) 2.2.Unfolding and Unfolded Data-Flow Graphs The concept of unfolding of homogeneous graphs appears throughout the literature [2, 10]. Let f be a positive integer. We wish to alter our graph so that f consecutive iterations are visible simultaneously. To do this, we create f copies of each node, replacing node u in the original graph by the nodes u 1 through u f in our new graph. This process is known as unfolding the graph G f times and results in the unfolded graph G f = V f,e f,d f,t f. The vertex set V f is simply the union of the f copies of each node in V. Since they are all exact copies, the computation times remain the same, i.e. t f (u f ) = t(u) for every copy u f of u V. Each edge of G also corresponds to f copies in the unfolded graph. However, the delay counts of the copies do not match that of the original edge. It is in the construction of these edges where the complication lies. 2.3.Balanced SDFGs As in [8], if d(e) is divisible by q v k(e) for all edges in an SDFG, the SDFG is balanced. Figure 1 above is an example of a balanced SDFG (BSDFG). Note that singlerate graphs are balanced by default. Our work in [8] demonstrated that the traditional unfolding algorithm operates as commonly understood only when applied to balanced SDFGs. The only required change is to move groups of delays rather than individual ones. This described method, a variation on the O( E ) unfolding algorithm for DFGs from [11], appears as Algorithm 1 below. After verifying that the input SDFG is balanced (and terminating with an error if it is not), copies of nodes and edges are created. Tokens are then distributed in groups among the edges. As an example, consider the balanced SDFG in Figure 1 unfolded twice. After verifying balance and creating node copies, the third loop in Algorithm 1 considers edges. Creating copies of (C,A) is straight-forward. For (A,B), first set and. The first sub-loop then creates an edge (A 0,B 1 ) with no delays, while the second produces (A 1,B 0 ) with 2. Similarly (B,C) is translated into the zero-delay edge (B 0,C 1 ) and the 4-delay edge (B 1,C 0 ), as pictured in Figure 2. It was established in [8] that balanced SDFGs may be legally unfolded via Algorithm 1 as demonstrated. 3 Properties of BSDGFs With the basic paradigm of the balanced SDFG in place, we now develop some simple properties of these graphs. Let G be a balanced SDFG unfolded f times. As with any data-flow model, edges without delay represent intra-iteration dependencies. However, a dependence from the k th iteration to the (k+n) th iteration in G is represented 262

3 Algorithm 1. Unfolding a balanced synchronous dataflow graph. Input: A SDFG G = V,E, d, t, p, k, an integer f Output: The unfolded graph G f = V f,e f, d f, t f, p f, k f Figure 2 Figure 1 unfolded twice via Algorithm 1. by an edge e = (u,v) with nk(e)q v delays. Since f iterations are represented simultaneously in the unfolded graph, every fk(e)q v delays in G are represented by k(e)q v delays in G f. Therefore, for 0 i, j < f, an edge e f = (u i,v j ) in E f with d(e f ) = nk(e)q v delays implies a dependence from node u in iteration i to node v in iteration. This dependence is represented by an edge e = (u,v) in G with groups of k(e)q v delays; thus d(e) = d f (e f ) f + (j i) k(e)q v. Since by this logic, and knowing that there are f copies of (u,v) in the unfolded graph, we see that the f copies are the edges (u i,v j ) where for 0 i < f. The value of d f (e f ) can be derived from Algorithm 1. Finally, summing the delay counts of all copies of e in the unfolded graph yields for all edges e = (u, v) in E do if d(e) mod k(e)q v 0 then return false /* Not balanced; stop. */ end if for all nodes u V do for i = 0 to f 1 do Add a copy of node u as u i to V f t f (u i ) t(u) for all edges e = (u, v) E do for i = 0 to f 1 do Add edge e f = (u i, v i+ ) to E f p f (e f ) p(e) k f (e f ) k(e) d f (e f ) k(e)q v for i = f to f 1 do Add edge e f = (u i, v i+ -f ) to E f p f (e f ) p(e) k f (e f ) k(e) d f (e f ) ( +1)k(e)q v return true since the f occurrences of become zero as a result of the modulus operator and the divisibility of d(e) due to balance. To summarize we have established the following. Theorem 1 Let u, v be nodes in a balanced SDFG G with e = (u,v). 1. For any 0 i, j < f, there is an edge e f = (u i,v j ) in E f if and only if d(e) = d f (e f ) f + (j i) k(e)q v. 2. For any 0 i, j < f with j i d(e) mod f, there is an edge e f = (u i,v j ) in E f with 3. The f copies of edge e in G f consists of the set of edges (u i,v j ) for every 0 i < f, where 4. The total number of delays of the f copies of edge e is d(e), i.e. d(e) = d f (e 0 ) + d f (e 1 ) + + d f (e f-1 ). The analogous result for homogeneous DFGs was proven in [2] and quoted in [8]. 263

4 4 Rate-Optimal Unfolding This line of inquiry began with the erroneous assumption in [10] that generic synchronous graphs could be unfolded for purposes of scheduling. Since we have now defined a class of SDFG that we can unfold, we can ask how much unfolding is necessary for scheduling balanced SDFGs optimally. As in [8, 9], an iteration is simply a single execution of all copies of all nodes of a SDFG. The iteration period of the SDFG is then the average computation time of one iteration. In synchronous graphs containing loops, this figure is bounded from below by the graph s maximum cycle mean or iteration bound [12], denoted B(G). While complicated to derive for SDFGs in general, as shown in [10], its calculation is straight-forward for balanced SDFGs: where the balanced synchronous graph G has a basic repetition vector of [q 0,...,q V -1 ]. Returning to Figure 1, the depicted graph includes one loop with an adjusted delay count of two and node computation times summing to 3; therefore B(G) = 3 ₂ for Figure 1. There are two models we consider when discussing static scheduling, only one of which is relevant to our work. A function s : V {0,1,2,3,} {0,1,2,3,} is an integral schedule for a SDFG G where s(v,i) is the starting time of node v in iteration i (i 0). Such a schedule is legal if for each edge e = (u,v) and iteration i 0 [10], repeating for cycle period c and unfolding factor f if s(v, i + f) = s(v, i) + c for all nodes v and iterations i [2] and rate-optimal if its iteration period equals the graph s iteration bound [10]. Repeating schedules may be characterized by their initial iterations, given the fact that the full legal schedule may be constructed by commencing f new copies of the partial timetable every c clock ticks. Thus, on average, one iteration takes clock ticks to execute, making this fraction the iteration period. Finally, a schedule is static or processor-static if a node s execution is designated to proceed on the same functional unit in every partial schedule instantiation [2]. We are now prepared to derive the smallest unfolding factor f necessary to achieve a rate-optimal schedule for a given balanced SDFG. If c is the corresponding cycle period for such a schedule, we see from our above discussion that c = f B(G). If we write B(G) as where gcd(d,t) = 1, we observe that f must be divisible by D since c is integral by definition. Therefore f = kd for some integer k. (2) In [10] we demonstrated that a legal, repeating static schedule for an SDFG exists under these circumstances provided that t(v) c for all nodes v; thus for all v. Consequently we estimate that, leading to the assertion that (3) is the minimum necessary rate-optimal unfolding factor for any balanced SDFG. Clearly any rate-optimal schedule with this unfolding factor will be legal, repeating and static as argued. We now must demonstrate that f is minimal. By way of contradiction, let be a rate-optimal unfolding factor with < f. As before, the corresponding clock period B(G) must exceed the execution time of any node, so that for some integer. Thus or Since no such integral exists we conclude that f is minimal. The figure in (3) matches the minimum rateoptimal unfolding factor for single-rate DFGs as derived in [3], although the authors there derive a better result if the functional units are pipelined. Considering Figure 1 once more, since all node computation times are 1 and the iteration bound is 3 ₂, we see that the minimum rate-optimal unfolding factor is or 2. Thus Figure 2 represents an optimized graph, leading to the partial schedule in Figure 3. The depicted schedule can be repeated to infinity to create the complete schedule. TIME: B 0 A 0 A 1 C 0 A 0 A 1 C 0 C 1 B 1 C 0 C 1 C 0 C 1 C 1 Figure 3 Partial rate-optimal static schedule for the SDFG of Figure 1. 5 Perfect-Rate SDFGs Finally, in [11], the authors identified a class of DFGs that they dubbed perfect-rate. Due to the importance of these graphs (as established there), we now briefly discuss their analogue in the case of synchronous data flow. A perfect-rate synchronous data-flow graph (PSDFG) is one which satisfies two conditions: (1) any loop l in the PSDFG has all of its delays contained on one critical edge 264

5 (u l,v l ), and (2) the delay count of any critical edge e = (u,v) is k(e)q v. The SDFG in Figure 2 is an example of a perfectrate graph. Clearly the iteration bound of a PSDFG is the maximum sum of node computation times in any loop. PSDFGs are nice in that they can be easily and directly scheduled to achieve this optimal cycle period from the directed acyclic graph (DAG) found by removing all edges containing delays. This leaves only zero-weight edges representing direct precedence relations. As suggested in [11], simply schedule the loop remnants in decreasing order of computation time to derive the rate optimal schedule. For example, in Figure 2, these paths would include B 0 C 1 A 1 and C 0 A 0 B 1. Since the total computation times are the same, they can be scheduled in any order to produce the partial schedule of Figure 3. This scheduling algorithm assumes no resource limitations, although an upper bound on the number of resources can be found by multiplying the total number of loops by the maximum q v for any node v. In the case of Figure 2, there are two loops and a BRV of [ ] T, leading to an anticipated need of 8 functional units, an overestimate of 2. Our work in [9] discusses the more realistic case when we are constrained by a lack of processors. In conclusion, suppose we choose an unfolding factor for a generic balanced SDFG which is the least common multiple of the values for all edges e with non-zero delay counts. By Theorem 1(2), any loop in the unfolded graph will contain exactly one group of k(e)q v delays and thus the unfolded graph will be perfect-rate and quickly schedulable. In a similar vein, the authors in [7] define a slowed circuit as one derived by multiplying the delay counts in a DFG by a fixed integer. The claimed advantage is that such a DFG can often be retimed to have a shorter clock period than any of its reduced forms [7]. Applying a slowdown equal to the least common multiple of the values k(e)q v for all edges e with non-zero delay counts will transform a generic SDFG to become balanced. 6 Example We conclude by considering the modem implementation that appeared originally in [6] and was extensively discussed in [1], pictured in Figure 4 below. For purposes of this illustration we will assume all functional units execute in unit time except for input and output (shaded) which require three clock ticks to complete. As demonstrated in [1] this graph has a BRV with q = q FILT = 16, q HIL = 2 and q v = 1 for all other nodes v. Figure 4 A voice-band data modem. There are only two edges containing delays, and in both cases d(e) = q v k(e), and thus the SDFG of Figure 4 is balanced. Furthermore, there are three loops in the graph, each with a single critical edge, making this BSDFG perfect-rate. We can thus schedule by observing the longest zero-delay path (, FILT, HIL, EQ, PLL, DECI, DECO and OUT) and scheduling executions consecutively in this order. Overlapping the executions of MUL and DECO (as indicated by the graph) yields the final repeating schedule in Figure 5. t FU1 FU2 FU FILT HIL EQ PLL DECI DECO OUT OUT OUT FILT HIL MUL FILT Figure 5 Repeating part of schedule for Figure 4. Of the three loops in Figure 4, two yield an iteration bound of 2: the tight loop between PLL and DECI, and the larger loop EQ PLL DECI MUL EQ with total execution time 4 and adjusted delay count 2. Since and OUT each require three clock ticks to complete, we conclude that the minimum rate-optimal unfolding factor for this PSDFG is or 2. Unfolding Figure 4 twice now produces the PSDFG in Figure 6 and the schedule in Figure 7. The benefits are clear. While the original modem requires 12 clocks cycles to complete a single iteration, the unfolded graph completes two iterations in 14 cycles, an average of 7 clock cycles per iteration. Our work herein also indicates that further unfolding of the graph will require additional functional units without achieving an improved result. 7 Conclusion In this paper and in [8] we have seen that unfolding is problematic for complex data-flow models and specified the circumstances under which it can be performed for 265

6 Acknowledgement Financial support for this work provided by the University of Akron s Buchtel College of Arts and Sciences, with additional support through the university s Professional Development Leave program. References 1. Bhattacharya, S.S., Murthy, P.K. and E.A. Lee, E.A.. Software Synthesis from Dataflow Graphs. Kluwer Academic Publishers, 1996 Figure 6 Figure 4 unfolded twice. t FU1 FU2 FU3 FU4 FU16 FU17 FU HIL0 EQ0 PLL0 DECI0 PLL1 DECI1 MUL1 OUT1 OUT1 OUT1 HIL0 EQ1 MUL0 DECO1 HIL1 DECO0 OUT0 OUT0 OUT0 HIL FILT FILT1 Figure 7 Repeating part of schedule for Figure 6. synchronous DFGs. To quickly summarize, our work in [8] indicates that, in order for a variation on the traditional unfolding algorithm to apply to the more complicated synchronous model, either the SDFG in question must be balanced, or we must assume that the data tokens produced by copies of a node are interchangeable. In the case of the latter, we must also make certain assumptions about the start times of a node s copies. In this paper we have further developed the theory behind the specialized class of balanced SDFGs first defined in [8]. In addition to filling out some basic properties involving the unfolding of these graphs, we have derived the value of the minimum rate-optimal unfolding factor. Finally we have considered the subclass of perfect rate graphs which can always be scheduled rate optimally. While useful, the class of data-flow graphs under consideration is restricted enough for there to be a great deal of room for improvement. One key to extending these results to more general DFGs may be alteration of the basic algorithm, as was briefly outlined in [2]. There remains considerable hope that these ideas can be refined and enhanced so as to be applicable to a wider variety of data flow models. 2. Chao, L.F. Scheduling and Behavioral Transformations for Parallel Systems. Ph.D. thesis : Princeton University, Chao, L.-F. and Sha, E. H.-M. Static Scheduling for Synthesis of DSP Algorithms on Various Models. Journal of VLSI Signal Processing, Vol. 10, pp Geilen, M. Reduction techniques for synchronous dataflow graphs. In Proc. Design Automation Conference, pp , Lee, E.A. and Messerscmitt, D.G. Static scheduling of synchronous data-flow programs for digital signal processing. IEEE Transactions on Computers, Vol. 36, pp Lee, E.A. and Messerschmitt, D.G. Synchronous data flow. Proceedings of the IEEE, 75: , Leiserson, C.E. and Saxe, J.B. Retiming Synchronous Circuitry. Algorithmica, Vol. 6, pp O'Neil, T.W. Unfolding Synchronous Data-flow Graphs. In Proc. IASTED International Conference on Parallel and Distributed Computing and Systems, pp , O'Neil, T.W. Static Scheduling of Synchronous Data-Flow Graphs Under Resource Constraints. Journal of Parallel and Distributed Computing and Networks, Vol. 2, DOI: /Journal O'Neil, T.W., Khasawneh, S.F., Richter, M.E. and Pullaguntla, R.K. Transforming synchronous data-flow graphs to reduce execution time. International Journal of Computers and Their Applications, Vol. 18, pp , Parhi, K.K. and Messerschmitt, D.G. Static Rate-Optimal Scheduling of Iterative Data-Flow Programs via Optimum Unfolding. IEEE Transactions on Computers, Vol. 40, pp Renfors, M. and Neuvo, Y. The maximum sampling rate of digital filters under hardware speed. Transactions on Circuits and Sampling, Vols. CAS-28, pp