Lab 1: Hello World, Adders, and Multipliers

Transcription

1 Lab 1: Hello World, Adders, and Multipliers Andy Wright Updated: December 30, Hello World! 1 interface GCD#(numeric type n); method Action computegcd(uint#(n) a, UInt#(n) b); method UInt#(n) getresult; endinterface module mkgcd( GCD#(n) ); Reg#(UInt#(n)) x <- mkreg(0); Reg#(UInt#(n)) y <- mkregu; rule swap (x > y); x <= y; y <= x; endrule rule subtract ((x <= y) && (x!= 0)); y <= y - x; endrule method Action computegcd(uint#(n) a, UInt#(n) b) if (x == 0); x <= a; y <= b; endmethod method UInt#(n) getresult() if (x == 0); return y; 1 In hardware design it does not make sense to write a program that prints Hello World! to the user, but it does make sense to write the description of a hardware block that computes the greatest common divisor of two inputs. 1

2 endmethod endmodule This is an example Bluespec module that computes the greatest common divisor (GCD) of two numbers using the euclidean algorithm. It has two interface methods that are used by other modules to interact with it: computegcd and getresult. This module can be compiled with the Bluespec compiler (bsc) to generate a simulation model for the Bluespec simulator (bsim) or it can be compiled to Verilog. Without a test bench, this module does not do anything when it is simulated 2. You can use the testbench below to compile and test this module. (* synthesize *) module mktb(); GCD#(8) dut <- mkgcd; Reg#(Bool) running <- mkreg(false); rule starttest (running == False); UInt#(8) a = 105; UInt#(8) b = 45; $display( "Computing the GCD of %d and %d", a, b ); dut.computegcd(a, b); running <= True; endrule rule endtest (running == True); let x = dut.getresult(); $display( "The result is %d", x ); $finish; endrule endmodule 1.1 Getting Started This example can be can be easily compiled and simulated on your computer assuming you have access to the Bluespec binaries and an appropriate license. To start, download the day-1 folder from the labs section of the course website The day-1 folder has a folder in it called gcd. This folder contains the code above in a file called gcd.bsv, and it contains a Makefile to build a simulation executable called sim when make is run. 2 Actually, it cannot even be compiled because it has a parameter in its interface. 2

3 To begin, make the code for the GCD module above and run the simulation executable, sim. You will see some output from the test bench that explains what is going on. As a simple test, change the test bench so it checks the GCD of 13 and 37. Run make and sim to see the output of the GCD module. 1.2 GCD Module for Larger Numbers Now try to run it for some larger numbers. Change the test bench to check the GCD of 270 and 363, and run make. What happens? If you did everything correctly, the compiler will give you the following error. Error: "gcd.bsv", line 35, column 22: (T0051) Literal 270 is not a valid UInt#(8). Since UInt#(8) uses 8 bits to represent an unsigned integer, it can represent integers from 0 to 255. The literal 270 is outside that bound, so the Bluespec compiler threw an error. The GCD module presented above is a parametric module, so it can be instantiated for any size of unsigned integers. The specific size of unsigned integers is specified when the module is instantiated in the test bench. GCD#(8) dut <- mkgcd; The 8 in the interface type GCD#(8) specifies 8-bit integers. Change that value to 32 so much larger numbers can be tested. If you try to run the compiler at this point, you will still hit the same error as before because a and b are still defined as 8-bit unsigned integers. You could change these to 32-bit unsigned integers, but every time you change the size of the GCD module under test you would also have to change the sizes of a and b. Instead you can get the Bluespec compiler to deduce the size of them using let in the following way. let a = 270; let b = 363; Bluespec will deduce the types of a and b from the context around it. Since they are used with a module that performs the GCD of 32-bit unsigned integers, the bluespec compiler knows they should be 32-bit unsigned integers. Change the declarations of a and b to use let, and run make and sim. You should now be testing a 32-bit GCD module as it performs the GCD of 270 and Next Steps Hopefully this example has given you a brief introduction to using Bluespec and its type system. Building any hardware design relies on the ability to design combinational circuits, 3

4 and in Bluespec, the ability to design combinational circuits depends on a solid understanding of types in Bluespec. From this point, you should review combinational circuits in the Bluespec introduction document found online. The introduction starts with basic types and user-defined types. It then covers functions and syntactic sugar. After that, it covers some common Bluespec compiler errors related to type errors in Bluespec code. After reviewing the introduction, you will be ready to continue constructing a carry select adder. 2 Adders In this portion of the lab you will be guided through the design of a carry select adder in Bluespec. A carry select adder is one of many adder architectures that obtains a shorter critical path by having more logic. It is made up of 4-bit adders and a multiplexer. You will construct functions for the multiplexer and the 4-bit adders, and then combine these functions to create the final adder. While doing this, you will learn and practice basic combinational logic design in Bluespec. The code for this portion of the lab is in the folder day-1/adder/. 2.1 Ripple Carry Adder Design The carry select adder adds prediction or speculation to a simple ripple carry adder to speed up execution. It computes the bottom bits the same way a ripple carry adder computes them, but it differs in the way it computes the top bits. Instead of waiting for the carry signal from the lower bits to be computed, it computes two possible results for the top bits: one results assumes there is no carry from the lower bits and the other assumes there is a bit carried over. Once that carry bit is calculated, a mux is used to select the top bits that correspond to the carry bit. An 8-bit carry select adder can be seen in figure Make a Multiplexer First you will need to implement a multiplexer. There is a skeleton function multiplexer n in the file Adders.bsv for your multiplexer. You should implement this function so if the sel is 0, then in0 is returned, else in1 is returned. You can check the correctness of the multiplexer n code by running the multiplexer test bench: $ make mux $./simmux An alternate test bench can be used to see outputs from the unit by running: $ make muxsimple $./simmuxsimple 4

5 a[7:4] b[7:4] c out a[7:4] b[7:4] a[3:0] b[3:0] c in s[7:4] Figure 1: 8-bit carry select adder s[3:0] 2.3 Make a 4-bit Adder Next you will need to implement an unsigned 4-bit adder that takes in a carry in and outputs a 5-bit result. There is a skeleton function add4 in the file Adders.bsv for your adder. You will need to extend all the inputs to 5-bit unsigned integers before adding them so you get a 5-bit result. The add4 function is used in the ripple carry adder implementation in Adders.bsv. The ripple carry adder (and therefore add4) can be tested by running the following: $ make rca $./simrca An alternate test bench can be used to see outputs from the unit by running: $ make rcasimple $./simrcasimple 2.4 Make a Carry Select Adder Now you are ready to implement a carry select adder. Fill in the code for a carry select adder in in the module mkcsadder. Use Figure 1 as a guide for the required hardware and connections. This module can be tested by running the following: $ make csa $./simcsa 5

6 An alternate test bench can be used to see outputs from the unit by running: $ make csasimple $./simcsasimple 3 Multipliers In this portion of the lab you will be building different multiplier implementations. You will start with implementing multipliers using repeated addition, and later you will implement a Booth Multiplier using a folded architecture. The output of all of these modules will be tested with test benches that compare the output of the modules to Bluespec s * operator for functionality. All of the materials for this portion of the lab are in the folder day-1/multiplier/. 3.1 Implementing Multiplication by Repeated Addition In Multipliers.bsv there is skeleton code for a function to calculate multiplication using repeated addition. Since this is a function, it must represent a combinational circuit. Fill in the code for multiply by adding so it calculates the unsigned product of a and b using repeated addition in a single clock cycle. You can test your implementation by running the following commands. $ make CombMultiplier.tb $./simcombmultiplier Multiplying two 32-bit numbers using repeated addition requires bit adders. Those adders can take a significant amount of area depending on the restrictions of your target and the rest of your design. In lecture, a folded version of the repeated addition multiplier was presented to reduce the amount of area needed for a multiplier. The folded version of the multiplier uses sequential circuitry to share a single 32-bit across all of the required computations by doing one of the required computations each clock cycle and storing the temporary result in a register. Fill in the code for the module mkfoldedmultiplier to implement a folded repeated addition multiplier. You can test your implementation by running the following commands. $ make FoldedMultiplier.tb $./simfoldedmultiplier 4 Booth s Multiplication Algorithm The repeated addition algorithm works well multiplying unsigned inputs, but it is not able to multiply (negative) numbers in two s complement encoding. To multiply signed numbers, you need a different multiplication algorithm. 6

7 Booth s Multiplication Algorithm is an algorithm that works with signed two s complement numbers. This algorithm encodes one of the operands with a special encoding that enables its use with signed numbers. This encoding is sometimes know as Booth encoding. A Booth encoding of a number is sometimes written with the symbols +, -, and 0 in a series like this: 0+-0b. This encoded number is similar to a binary number because each place in the number represents the same power of two. A + in the ith bit represents (+1) 2 i, but a - in the ith bit correspond to ( 1) 2 i. The Booth encoding for a binary number can be obtained bitwise by looking at the current bit and the previous bit of the original number. When encoding the least significant bit, a zero is assumed as the previous bit. The table below shows the conversion to Booth encoding. Current Bit Previous Bit Booth Encoding The Booth multiplication algorithm can best be described as the repeated addition algorithm using the Booth encoding of the multiplier. Instead of switching between adding 0 or adding the multiplicand as in repeated addition, the Booth algorithm switches between adding 0, adding the multiplicand, or subtracting the multiplicand, depending on the booth encoding of the multiplier. The example below shows a multiplicand m is being multiplied by a negative number by converting the multiplier to its booth encoding. 5 m = 1011b m = -+0-b m = ( m) m ( m) 2 0 = 8m + 4m m = 5m The Booth multiplication algorithm can be implemented efficiently in hardware using the following algorithm. This algorithm assumes an n-bit multiplicand m is being multiplied by an n-bit multiplier r. initialization: // All 2n+1 bits wide m_pos = {m, 0} m_neg = {(-m), 0} p = {0, r, 1 b0} repeat n times: let pr = two least significant bits of p if ( pr == 01 ): p = p + m_pos; 7

8 if ( pr == 10 ): p = p + m_neg; if ( pr == 00 or pr == 11 ): do nothing; Arithmetically shift p one bit to the right; res = 2n most significant bits of p; The notation (-m) is the two s complement inverse of m. Since the most negative number in two s complement has no positive counterpart, this algorithm does not work when m = b. Because of this restriction, the test bench has been modified to avoid the most negative number when testing 3. This algorithm also uses an arithmetic shift. This is a shift designed for signed numbers. When shifting the number to the right, it shifts in the old value of the most significant bit back into the MSB place to keep the sign of the value of the same. This is done by Bluespec when shifting values of type Int#(n). To do an arithmetic shift for Bit#(n), you may want to write your own function similar to multiply_signed. This function would convert Bit#(n) to Int#(n), do the shift, and then convert back. Fill in the implementation for a folded version of the Booth multiplication algorithm in the module mkbooth. This module uses a parameterized input size n; your implementation should work for all n 2. You can test your implementation by running the following commands. $ make BoothMultiplier.tb $./simboothmultiplier 5 Conclusion Throughout this lab, you have learned and used the basics of combinational and sequential logic in Bluespec to make adders and multipliers. These skills you learned now will be useful throughout the entire course. Later in the course, you will learn more about modules that have more than one rule and designs that have more than one module. When you are working with these more complicated designs, you will be focusing more on rule scheduling. If you have a good understanding of combinational and sequential logic in Bluespec, these later lessons will be much easier to learn. 3 This is not a good way to design hardware. Never remove tests from your test bench just because your hardware fails them. One way around this problem is to implement an (n+1)-bit Booth multiplier to perform n-bit signed multiplication by sign extending the inputs. If you zero extending the inputs instead of sign extending them, you can get the n-bit unsigned product of the two inputs. If add an extra input to the multiplier that allows you to switch between sign extending and zero extending the inputs, then you have a 32-bit multiplier that you can switch between signed and unsigned multiplication. This is functionality would be useful for a processor that has signed and unsigned multiplication instructions. 8