BSV by Example - Computation Structures Group

the repetition of the declaration in each of the implementation modules. All modules which share a
common interface have the same methods, and therefore the same number and types of inputs and
outputs.
It is important to distinguish between interface declarations and interface instances. A design may
contain one or more interface declarations, and each of these may have multiple instances. An
interface declaration can be thought of as declaring a new type similar to a struct type, where the
members are all method prototypes. The declaration states the new type, while the definition of how
the methods are implemented is contained within the module that contains the interface instance.
A method can be thought of like a function, i.e., it is a procedure that takes zero or more arguments
and returns a result. Thus, method declarations inside interface declarations look a lot like function
prototypes, the only difference being the use of the keyword method instead of the keyword function.
Each method represents one kind of transaction between a module and its clients. When translated
into RTL, each method becomes a bundle of wires. The definition of how a method is implemented
is contained in the interface definition within the module and may be different in each module where
the common interface is used. However the wires making up the interface, that is the inputs, outputs
and inouts, and the methods defined, will be the same in all instances.
Let’s look at the definition of interface Ifc_type. Interface names always start with an upper-case
letter, because they are a data type, in this case a user-defined data type. The interface declares a
value method named the_answer with three int arguments returning an int result. How the result
is calculated is left to the method definition.
interface Ifc_type;
method int the_answer (int x, int y, int z);
endinterface: Ifc_type
The module mkModuleDeepThought provides an interface of type Ifc_type, as shown in the module
definition statement:
module mkModuleDeepThought (Ifc_type);
To instantiate a module and obtain a handle on its interface, use a statement of the form:
Interface type identifier