quark17
commented
2 months ago The type ArithOpGP2 is defined in the example:
interface ArithOpGP2#(type t);
...
endinterfaceAnd the type CFP is defined above that:
typedef Int#(18) CFP;They aren't from a library. They are user-defined types that only exist within this example.
These types add some realism to the example, by showing how the UniqueWrappers library can be used with your own types. However, they are not necessary for illustrating how to use UniqueWrappers, and I can see how they make the example less clear, by distracting from the part that's important.
Does that answer your question?
The UniqueWrappers library is not commonly used, so you probably don't need to worry about it. But here is a simpler example of what it does. (Well, it started simple, and then I added extra features, but hopefully it is still clear).
import UniqueWrappers::*;
// Change this to False to see the result of not using UniqueWrappers
Bool share = True;
(* synthesize *)
module mkTestUniqueWrappers ();
// -----
// Declare and instantiate an interface that takes 2 arguments, multiplies them
// and returns the result. It is a Wrapper2 because there are 2 arguments.
function Bit#(8) multFn (Bit#(8) x, Bit#(8) y);
return (x * y);
endfunction
Wrapper2#(Bit#(8),Bit#(8), Bit#(8)) shared_mult <- mkUniqueWrapper2(multFn);
// Below we define two rules that will share the function.
// Because they share it, they cannot both execute at the same time,
// so we introduce a condition:
Reg#(Bool) rg_cond <- mkRegU;
// -----
// The first user of the function
Reg#(Bit#(8)) rgA1 <- mkRegU;
Reg#(Bit#(8)) rgA2 <- mkRegU;
Reg#(Bit#(8)) rgA3 <- mkRegU;
rule rlA (rg_cond);
if (! share) begin
// If we wrote this, the logic would not be shared
rgA3 <= rgA1 * rgA2;
end
else begin
// By using an instantiated wrapper module, we force the logic to be shared
// in the generated Verilog from BSC:
// Note that "shared_mult" is a "Wrapper2" interface, so we call
// the method "func". It is an ActionValue method, so we need to get
// the value first, before assigning it to the register.
let mr <- shared_mult.func (rgA1, rgA2);
rgA3 <= mr;
end
endrule
// -----
// The second user of the function
Reg#(Bit#(8)) rgB1 <- mkRegU;
Reg#(Bit#(8)) rgB2 <- mkRegU;
Reg#(Bit#(8)) rgB3 <- mkRegU;
rule rlB (! rg_cond);
if (! share) begin
rgB3 <= rgB1 * rgB2;
end
else begin
let mr <- shared_mult.func (rgB1, rgB2);
rgB3 <= mr;
end
endrule
endmoduleIf you compile with with -verilog and search for * in the generated Verilog file, you should see only one occurrence:
assign IF_shared_mult_arg_whas_THEN_shared_mult_arg_w_ETC___d11 =
shared_mult_arg$wget[15:8] * shared_mult_arg$wget[7:0] ;However, if you change the variable shared to False and recompile, you should see two copies of * in the Verilog:
assign rgA1_MUL_rgA2___d4 = rgA1 * rgA2 ;
assign rgB1_MUL_rgB2___d9 = rgB1 * rgB2 ;
postoroniy
Hi, tried to follow the example in "Bluespec Compiler (BSC) Libraries Reference Guide" from page 218, and can't find
ArithOpGP2#(CFP)anywhere. Could you please suggest if below snippet is correct(checked in bsc compiler and to me it's ok)? Or may be suggest proper snippet as per example and interface. thanks