Implementing bit-intensive programs in StreamIt/StreamBit 1. Writing Bit manipulations using the StreamIt language with StreamBit Compiler

Transcription

1 Implementing bit-intensive programs in StreamIt/StreamBit 1. Writing Bit manipulations using the StreamIt language with StreamBit Compiler The StreamIt language, together with the StreamBit compiler, allows for a very different development process from a traditional language like C. Instead of having the algorithm and implementation encoded in a complex piece of code which you have to test and debug every time you want to try a different implementation strategy, the StreamBit compiler allows you to write your code once, at a high level of abstraction, and without having to worry about performance. Once your code has been written, the compiler allows you to suggest performance improving transformations which may be specific to a particular machine and a particular program, without letting you introduce errors in the program. For the contest, you will only have to write the high level StreamIt description. The rest of the document will explain everything you need to know in order to do this. It will cover the basics of StreamIt, as well as some of the limitations of the current implementation. Before you proceed, it is recommended that you install the StreamBit compiler so you can follow along the examples. You can download Windows/Cygwin binaries for the compiler from Or you can use it from any eecs research account on either an x86/linux or an IA64/Linux machine. To do this, simply type $ source ~asolar/install_sbit.sh from a command prompt. After that, you can compile your programs typing $ compilesbit.sh yourfile.str This will generate a C code that implements your program. You can then run the command: $ runprog yourfile.str To generate a harness that will call the C code, and then it will compile it and run it, so you can see the results of your program. 1

2 1.1. The basics of StreamIt The StreamBit system uses StreamIt as its input language. StreamIt is a dataflow language that was developed at MIT by Thies et. al., and it builds on some of the research on synchronous dataflow that was done at Berkeley in the 1980s by Edward Lee s group. The main unit of abstraction in StreamIt is the filter. A filter reads data from an input stream and writes it into a FIFO output stream. Additionally, as a consequence of being a synchronous dataflow language, all filters must specify their input and output rate statically, which enables the compiler to schedule filter execution statically at compile time. Statically declared input and output rates Input and output type of the filter bit->bit filter DropThird{ work pop 3 push 2{ push( pop() ); push( pop() ); pop(); Work function defines the behavior of the filter... For the particular subset of StreamIt that we handle, filters can be aggregated into splitjoins and pipelines. A pipeline is simply a sequence of filters that are linked together so the output of filter i becomes the input of filter i+1. bit->bit pipeline PL{ add A(); add B(); add C(); A splitjoin contains a splitter which takes the input stream and distributes it among its N children, and then a joiner that takes the output of the N filters and merges it in a predefined way. We currently support two different types of splitters: roundrobin splitters and duplication splitters. The duplication splitters, as their name implies, simply pass identical copies of their input to all the filters in the splitjoin. The roundrobin splitters, on the other hand, distribute the bits from the input to the individual filters in a roundrobin fashion. For the join points, we support two major classes of joiners, roundrobin joiners and aggregation joiners. The aggregation joiners read bits from each of the branches of the splitjoin and aggregate them to produce a single bit by using either the AND, OR or XOR operators; hence we distinguish three types of such joiners, one for each operator. The semantics of roundrobin joiners are very similar to those of the roundrobin splitters; they PL A B C 2

3 read bits in a roundrobin fashion from all the filters in the splitjoin and write them to the output. bit->bit splitjoin SJ{ split roundrobin(1,1,1); add A(); add B(); add C(); join roundrobin(1,1,1); A Split roundrobin(1,1,1) B C Join roundrobin(1,1,1) A Split roundrobin(1,1,1) B Join xor() C bit->bit splitjoin SJ{ split roundrobin(1,1,1); add A(); add B(); add C(); join xor(); ( xor xor ) Both splitjoins and pipelines involve implicit scheduling and buffer management. For example, if Filter A is defined to produce 5 bits, but Filter B transforms blocks of 6 bits, you can simply define the two filters separately and compose them in a pipeline, without having to worry about how to interleave the executions of filters A and B, or how much buffer space to allocate to store the results of A before B can read them. You can find some more examples of the use of pipelines and splitjoins, along with all the exercises described in this tutorial at: A Word on Native Filters The StreamBit compiler focuses on bit level manipulations, so we concentrate on filters that have input and output streams of type bit. Additionally, we need to be able to convert 3

4 the code into a Boolean expression, so we require that all loops have fixed number of iterations and that the number of bits read and the number of bits pushed or popped from the input/output streams can be determined at compile time. Finally, we don t allow such filters to have state. Our system also allows the user to write filters that do not adhere to the restrictions above. For example, filters that produce integers instead of bits, or filters that have state. We call these native filters, and their only requirement is that they push and pop exactly the declared number of data items into their streams; however, we only allow sketching for filters that satisfy the constraints mentioned above. Such native filters will be very useful, both to generate input for your program, and to produce debug output. As an example, consider the program: void->void pipeline testnatives{ add void->int filter { work push 2{ printf( Creating Input\n ); push( 0x0F0F0F0F ); push( 0xF0F0F0F0 ); add int->void filter { work pop 1{ int x = pop(); printf( Got %x\n, x); printb( x ); This program has only native filters. One is a void->int filter that produces bits, and the other one is an int->void filter that reads them. If you compile and run this program with: $ compilesbit.sh testnatives.str $ runprog.sh testnatives.str The first few lines of output will look like this: Creating Input Got f0f0f0f Got f0f0f0f Creating Input Got f0f0f0f Got f0f0f0f Filter is going to push two integers and will not pop anything In a native filter you can use printf just like in C Pipeline will take care of scheduling the two filters, so the mismatch in the input and output rates of the two filters is not a problem printb allows you to print integers bit by bit. 4

5 Note that because of the scheduling, the second filter executes twice for each time the first one executes Coding Bit manipulations in StreamIt Permutations Permutations play a very important role in bit manipulation tasks. In StreamIt, a permutation can be easily implemented in a filter. Within a filter, you can use the peek function to access a particular bit in the stream, and push it into the output. Examples: All the following are examples of permutations. Permutations can also be represented by matrices, where the input bits are multiplied as a vector with a matrix to produce the output bits. A filter to drop every third bit: bit->bit filter DropThird{ work pop 3 push 2{ push( pop() ); push( pop() ); pop();... A filter to reverse a 32 bit block: bit->bit filter Reverse{ work pop 32 push 32{ for(int i=0; i<32; ++i){ push( peek(31-i ) ); A filter to apply a permutation given by the list of numbers [4,1,2,3,0,5] bit->bit filter Arbitrary{ work pop 6 push 6{ int [6] X={4,1,2,3,0,5; for(int i=0; i<6; ++i) push( peek( X[i] ) ); for(int i=0; i<6; ++i) pop(); 1 1 The StreamIt language requires that you call pop as many times as you declared that you are going to pop. However, the StreamBit compiler does not require this. As long as you don t try to pop more than you declared, the compiler will add the necessary additional pops for you. 5

6 Exercise: Use the Filters provided in permutation.str to write the following program. You want to have a pipeline with the filters in the following order: Generate -> Shuffle -> Read The filters Generate, IntToBit, BitToInt and Read are already provided for you. You have to write Shiffle to satisfy the following specification. Shuffle must shuffle a block of 16 bits based on the following list of numbers. Shuffle := [11, 3, 15, 7, 10, 2, 14, 6, 9, 1, 13, 5, 8, 0, 12, 4]; This means that the first bit of the output will be bit 11 from the input, the second bit of the output will be bit 3 from the input, and so forth. After you compile and run the program, it should print the following list of numbers: Arbitrary Boolean Functions The filters can represent any arbitrary boolean mapping from the input to the output. However, the StreamBit compiler requires filters that take in bits and generate bits have to adhere to certain restrictions. In particular: - The number of push and pop statements must be independent of the input, and the compiler must be able to determine at compile time that you will not push or pop more bits than what you stated in the work declaration. o A corollary of this restriction is that if the argument to an if statement depends on the input then there must be the same number of push and pops on each branch. o Another corollary is that the number of iterations in a loop can not depend on a value that was popped from the stream if the loop body contains push or pop statements. - Filters that transform bits can not have state. Exercises: Using the filters in BoolFilterPL.str, you want to have a pipeline with the filters in the following order: Generate -> BoolFilter -> Read Where BoolFilter takes in 4 bits and produces 2 bits according to the following Boolean functions: Output[0] = (Input[1] and Input[2]) xor (Input[0] or Input[3]); Output[1] = (Input[2] or Input[3]) and Not( Input[2] and Input[1] ); 6

7 After running the filter you should get a list of numbers starting with Note: In the current version of StreamIt allows you to use most of the C bitwise operators on the bit data-types. These include &,, and ^. If you want to negate something, you have to xor it with 1. Also, you can NOT use the boolean operators &&, and! on bit data-types. The StreamBit compiler is a little more lenient, so it will allow all the operators mentioned above. Merging Streams As you saw in the StreamIt tutorial, splitjoins can be very useful when you have a stream, and you want to perform a different action with different elements of the stream. However, splitjoins can also be useful when you want to merge two streams together. In order to do this, you can use a splitjoin with a roundrobin splitter that passes zero bits to the filter producing the bits you want to merge. Example: Suppose you want to write a filter called Interleave, which takes an input stream, and between every bit, interleaves the bits generated by filter Gen which takes zero bits as input, and generates some bits every time it is fired. This can be done with the following code; the complete exaple is in merging1.str: bit->bit splitjoin Interleave{ split roundrobin( 1, 0); add Identity(); add Gen(); join roundrobin( 1, 1); Example: Suppose that instead of interleaving the bits, you want to AND the bits generated by Gen into the input stream. Then, all you have to do is use an AND joiner instead of a roundrobin: bit->bit splitjoin Interleave{ split roundrobin( 1, 0); add Identity(); add Gen(); join and(); 7

8 Try replacing this Interleave for the original Interleave in merging1. The result should be a list of numbers 1, 2,. You can also try it with different operators (i.e. OR or XOR joins). Representing Complex networks using splitjoins In some cases, the task may require a more complex interconnection pattern than what splitjoins offer. However, it is generally possible to achieve these interconnection patterns by combining several splitjoins with some permutations in between. Example: Consider the following example. You have a 32 bits wide block and you want to pass the Right Half (R), to filter R1, and the Left Half (L) to filter L1. Then you want to Xor L1(L) with R and R1(R) with L, and pass those quantities through L2 and R2 respectively to get the result. The process is shown in the figure. This can actually be implemented using splitjoins as follows. First, pass the complete block LR through a filter FDup that makes two copies of it. Then, pass it through a roundrobin splitter that takes one of the L s through L1, and the other one through an Identity filter, and similarly with R. After a roundrobin joiner, the result will be a block of the form [ L1(L), R, L, R1(R)]. That block can then be given to a filter FCombine that takes in 32 bit blocks (the size of [ L1(L), R] or [L, R1(R)]), and xors the first 16 bits with the second 32 bits. Finally, this can be passed to a roundrobin filter that applies L2 and R2, and the result will be the same as the network in the first figure, but using only what is provided in StreamIt. 8

9 Table Filters In many cases, a filter is best described as a mapping from input bits to output bits expressed as a table. The current StreamBit compiler allows you to express this through the use of sbox filters. The term sbox comes from the substitution boxes present in many public key ciphers. Example: A filter that takes in 3 bits, and it s output consists of 4 bits defined by the following table { 0xF, 0xE, 0x1, 0x3, 0x6, 0xA, 0xB, 0xC. This means that if the three input bits are 010, then we interpret them as 2, and we return the 4 bits corresponding to entry 2 in the table, which is bit->bit sbox test{ int[8] X = {0xF, 0xE, 0x1, 0x3, 0x6, 0xA, 0xB, 0xC; int input_rate=3; int output_rate=4; The rest of the example is in TestSbox.str. Note: If you are participating in the contest, this is all the information you need to know in order to complete the programming task. However, if you are interested in how to improve the performance of your application through sketching, read on. 9

10 1.3. Optimizing your Program One of our goals is to allow the programmer to write code without having to worry at all about performance. As we saw before, in languages like C, the goal of high performance often conflicts with the goal of having code that is easy to read and understand. The StreamBit compiler solves this problem by allowing you to tell the compiler to do many transformations that you would otherwise have to do yourself by hand (potentially making your code hard to read), and which you can t always trust a compiler to do well on its own given how unpredictable their effects on performance can be. The Optimization Specification Language In order to express the changes you want the compiler to make on your program, you can use the Optimization Specification Language. The language has three main components. First, there are rudimentary control structures, mainly for loops, along with basic integer arithmetic. Second, there is a simple mechanism for accessing any filter within your program. Finally, there is a set of transformations which can transform a filter in your program based on a complete or partial specification. The control structures In its current form, the language only provides a for loop construct, with syntax similar to the loops in java or C. In addition, the language provides basic integer arithmetic, including addition, subtraction, and multiplication, as well as basic Boolean operators. Variables don t have to be declared, and can be used as needed. The filter paths The language allows you to access any filter within your program by using a filter path. For the top level filter, the one that represents the complete program, the filter path will simply be the filter s name. For all other filters, the filter path will be the parent s filter path, followed by a dot, followed by their name. A filter s parent is the pipeline or splitjoin that contains it. If the path is ambiguous, for example because there are two filters with the same name in a pipeline, or if you want to access the filters in a pipeline using a loop, you can use the method filter(int i), to access the ith filter in a pipeline or a filter without using it s name. The Functions The most important piece of the Optimization specification language is a set of 10 Transformation functions and two display functions that can be combined to achieve a very large number of different optimizations. 10

11 Unroll[N](Filter); Copies the body of a filter N times, so the new filter will now take in N times as many bits as before and produce N times more bits as well. Useful for getting the size of the filter to be a multiple of the word size. ColSplit[sizelist](Filter); Takes in a filter, and splits it into a splitjoin of several smaller filter. Each new filter will produce the same number of bits as the original one, but they will each take only a fraction of the original bits. If no sizelist is given, the new filters will take in W bits, where W is the width of a word. If a sizelist is given, it will consist of a list of numbers, where the kth number will correspond to how many bits the new filter k will take in, and the sum of all numbers must equal the inputs size of the original filter. RowSplit[sizelist] (Filter); Similar to ColSplit described above, except in this case, the new filter will take in a filters will take in the same a complete copy of the input bits and will produce only a subset of the output bits. As before, if no seizelist is provided, the output sizes will be equal to W, the word size. DiagSplit(Filter); When you have a filter that takes in several words of input and produces the same number of words of output, and the nth word of output depends only on the nth word of input, you can use DiagSplit to break your filter into several independent filters, each taking one word in and producing one word out. SRRtoDUP(Filter); Takes in a splitjoin with a roundrobin splitter, and converts it into a splitjoin with a duplications splitter. JRRtoXOR(Filter); Similar to the previous one, but in this case, a splitjoin with a roundrobin joiner gets converted into a roundrobin with an or joiner. These two functions are useful 11

12 when the number of bits passed to the roundrobin splitter is not a multiple of the word size. StandardDecomp(Filter); This function takes in a filter whose input and output sizes are a multiple of the words size, and decomposes it into a set of filters each of them corresponding to individual instructions (shifts, ands, ors). It is unlikely that you will be using this function; it is mainly used by the system to generate code. MakeTable(Filter); This function takes in a filter, and replaces it with a table lookup. Keep in mind that the size of the table will be 2^in where in is the input size of the filter. Thus, it is unwise to use it on filters with input sizes greater than 10 or so. If you have a filter with a larger input size, you can use the ColSplit function to break it into filters with small input sizes, and apply MakeTable independently to each. Restructure[spec](Filter); Restructure takes in a pipeline, and a description of how that pipeline should look like after restructuring. A later section will explain this command in more detail. PermutFactor[spec](Filter); This command takes in a permutation and a partial description of how bits should be shifted at every step, and produces a sequence of filters each one implementing a step. It will be described in detail in the next section. Print[ fname,n](filter); The print command produces a picture of a filter/pipeline/splitjoin. The string fname specifies the name of the output file, and the optional parameter N determines how many levels of nesting deep to display. PrintMatrix[ fname ](Filter); This function shows the matrices used for the internal representations of the filters. It is useful when performing decompositions. 12

13 Decomposing permutations with PermutFactor To illustrate how PermutFactor works, consider the following example. You have the DropThird filter form the previous section, and you have already unrolled it and cut it out into filters that work on a 32 bit block. Now, you want to specify to the system that you want to implement it using log-shifting as explained earlier. At a high level, what you want is to implement the filter with only a few steps. The amount that we shift bits in a given step will be twice as much as in the previous step, but only a subset of the bits shift in every step. We can express all of these high level ideas in the following sketch: PermutFactor[ [ shift(0:31 by 0 1)], [ shift(0:31 by 0 2)], [ shift(0:31 by 0 4)], [ shift(0:31 by 0 8)] ]( DropThird ); What this means, is that in the first step, bits 0 through 31, which is all bits, will shift by either zero or 1. In the second step, they will shift by either 0 or 2; in the next by either zero or 4, and in the last by either zero or 8. This information is sufficient for the system to decompose DropThird into a sequence of 4 steps, each one corresponding to a step in the log-shifting as explained above. The precise semantics of the PermutFactor are as follows. Each one of the square brackets corresponds to a step. Thus, in the above example, you have four steps. On each step, you can have a list, potentially empty, of shift specifications. Shift specifications fall into four categories. Type 1 shift( bitlist by x) Type 2 shift(bitlist by?) Where x is an integer expression, and bitlist is a list of bits. A list of bits can include ranges of the form a:b, as well as individual numbers, all separated by commas. In this case, the meaning is that all bits in bitlist are to be shifted by amount x given. This is similar to the previous case, but now the amount by which all the bits in bitlist will move is up to the system to decide. This is useful when you know a set of bits will have to move together but you don t want to worry by how much. 13

14 Type 3 shfit(bitlist by a b ) Type 4 pos(bitlist to poslist) In this case, instead of a single shift amount, we are giving the system a limited number of choices of how much each of the bits in the list will be allowed to shift. In this case, instead of specifying by how much to shift, we specify that when we get to this step, we want the bits in bitlist to be in the positions specified in poslist. In this case, the two lists must be of the same size. This shift specification can not be included in the first step, since the position of the bits in the first step is what determines their numbering. In all steps, the bits are referred in the shift specifications by their original positions, where the first bit is bit zero. So going back to our original example DropThird, you can use the functions seen thus far to tell the system that you want to pack things first within words before packing into words, and then to tell the system that the packing within words should be done using log shifting. The full TSL spec would look like this: Unroll[WS](DropThird); PermutFactor[ [shift(0:1, 32:33, 64:65 by 0)], [shift(0:31 by?), shift(32:63 by?), shift(64:95 by?)] ](DropThird); DiagSplit( DropThird.filter(0) ); for( i = 0; i<3; i=i+1){ PermutFactor[ [ shift(0:31 by 0 1)], [ shift(0:31 by 0 2)], [ shift(0:31 by 0 4)], [ shift(0:31 by 0 8)] ] ( DropThird.filter(0) ); In this case, the first unroll converts the filter into a filter that produces multiples of the word size. Then, the first PermutFactor specifies that in the first step, bits 0,1,32,33,64 and 65 are not allowed to move, and in the second step, bits that started out in the same 32 bit word shift by the same amount. This means, that by this point, the bits must already be packed within the word. Now, given that this first filter in the decomposition operates on all words independently, we can use DiagSplit to break it into a splitjoin of 3 independent filters. Finally, on each of the three independent filters, we can specify how to decompose it using log-shifting. 14

15 Restructuring pipelines with the Restructure command There are three main types of restructurings that can be performed with the restructure command. Merge Several Matrix Filters together into a single filter that can be implemented more efficiently Merge a filter into a roundrobin splitter or joiner to improve its performance Merge several Filters into a pipeline to allow for further restructuring later on Restructure takes in a pipeline, and returns a new pipeline with the same semantics as the old one, but with a different structure. The syntax of restructure is as follows. Restructure[ filterspec, filterspec, ](pipeline) Each one of the filterspecs represents an element that will be added to the pipeline, and can be any of three things. A local name of a filter contained in the pipeline o In this case, the filter added to the pipeline is simply the filter referred to by this name. A list of filter specs enclosed in brackets o In this case, the filter represented by this filterspec is a pipeline, containing all the filters represented by the filterspecs in the list. If the first item on the list is a string, that s the name that will be given to the new pipeline. A Merge Specification. o This represents a set of filters that will be merged. Merge specifications have the following syntax: Merge[ type, Name, filter, filter, ] The type can be either: matrix, splitjoin, or pipeline, and the exact semantics of the Merge will depend on the type. In the case of pipeline, the effect of Merge will be the same as if you had specified [ Name, filter, filter, ]. If you use type matrix, the system will try to merge all the filters into a single filter, and the new filter will be called Name. Finally, if you use the type splitjoin, the system will try to merge all the filters that are not splitjoins into the filters that are. The following examples will help illustrate the power of Merge. 15

16 Example: Suppose you have the following filters: bit->bit filter A{ work pop 3 push 3{ boolean x = pop()==1; boolean y = pop()==1; boolean z = pop()==1; push( (x && y)? (bit)1: (bit)0); push( (x && z)? (bit)1: (bit)0 ); push( (y && z)? (bit)1: (bit)0 ); bit->bit filter B{ work pop 2 push 2{ push( peek(0) ); push( peek(1)==1 && peek(0)==1? (bit)1: (bit)0 ); pop(); pop(); bit->bit filter C{ work pop 2 push 2{ push( peek(1)!= peek(0)? (bit)1: (bit)0); push( pop() ); pop(); bit->bit pipeline ABCpl{ add A(); add B(); add C(); Then, then, you can use merge to do the following Transformations: First, the command Restructure[ A, [ BCpl, B, C] ](ABCpl); Will have the equivalent effect of rewriting the program as bit->bit pipeline BCpl{ add B(); add C(); bit->bit pipeline ABCpl{ add A(); add BCpl(); 16

17 And will be equivalent to the command Restructure[ A, Merge[pipeline, BCpl, B, C] ](ABCpl); Now, we can also use Restructure to merge A and B. Restructure[ Merge[matrix, AB, A, B], C](ABCpl); The result is a new filter AB which is equivalent to A followed by B. In general, the structure of A and B would determine whether the restructured pipeline is more efficient than the original one. ABCpl A B C ABCpl AB C Finally, suppose we start with the following filter: bit->bit splitjoin ABsj{ split roundrobin(3,2); add A(); add B(); join roundrobin(3, 2); bit->bit pipeline ABC{ add ABsj(); add C(); Then, we can apply the Restructure Command, Restructure[ Merge[splitjoin, ABsj, ABsj, C] ](ABC); The Result will be a pipeline containing a single splitjoin that looks like this: In this case, The splitjoin has been unrolled so it now has 4 branches instead of two, each with its own copy of A and B. C has also been unrolled, and pieces of C have been incorporated into each of the branches. Each of the branches will actually satisfy the hierustics for a table implementation, so the compiler will implement each of the branches as its own separate table. However, if you want to guarantee that all the branches will be implemented as tables, you can specify it with the following code: 17

18 Restructure[Merge[splitjoin, "ABsj", ABsj, C] ](tmp); for(i=0; i<4; i=i+1){ MakeTable( tmp.abcsj.filter(i) ); Limitations of Merge When merging into a matrix, it is only possible to merge several matrices of the same type. What this means, is that filters that use different operators, for example a filter that uses ANDs and ORs and a filter that uses XORs can not be merged together. In the above example, we could merge A and B, because they both use only AND operators. This is not a problem in the case of permutations, since those involve no operators among the bits. Merging a matrix into a splitjoin will have a different effect depending on the type of splitter and joiner. Splitjoins can be merged together only when the weights of the spliter and joiner match. 18