Component Computation Customization

Often, variations in a design involve minor changes to the functionality of a hardware block. For example, most 2 level branch prediction schemes are similar and only vary in the way history bits are used to index the predictor and the way the history bits and program counter are used to access the predictors themselves.

In this situation one would like to be able to use a single branch predictor component and instantiate it with the lookup schemes of choice for the predictor. In some systems a component can provide a parameter that may choose between a variety of lookup schemes. However, if some non-standard scheme was in use one would be out of luck.

With a component computation customization~(CCC) interface, the branch predictor module can provide an interface by which users of the component can cleanly customize the way in which the lookups occurs for each copy of the component used.

In a structural system built on an object oriented language, inheritance can provide the CCC interface, however it is heavy weight and a bit cumbersome for the most common usage of CCC. As a result a better alternative is to use a special parameter system that can accept code as a parameter value. This parameter value can be different on an instance by instance basis.

Realize also, that the presence of an underlying object oriented system doesn't guarantee a component customization interface. SystemC, for example, does not actually support inheritance as a CCC mechanism. (Virtanen, et. al, SystemC Based Object Oriented System Design). Asim on the other hand is specifically designed to allow this. A summary of other structural systems and the CCC interface can be found here

Synergies and Interactions

Component polymorphism can greatly aid the environments in which a component can be used. However, if no mechanism to customize the computation based on the new data types is provided, then only components that do not manipulate the data (but only store it and pass it along) can benefit from the polymorphism in the system. A component computation customization interface along with polymorphism allows for far wider modular reuse of components in the system.

For example, the branch predictor in the previous example will have an input port that takes data for the instruction address to use in the lookup. If this data type is fixed, then it is not possible to mix in other data in the predictor lookup logic, such as the instruction opcode. However, if the input data type for predictor lookup was polymorphic, one could send both the instruction address and the opcode to the branch predictor and use the CCC interface to decide how to lookup predictors based on both the PC and the instruction opcode (implementing a custom PaS branch prediction scheme). In this way the branch predictor can be used across many more designs than if CCC or Polymorphism were employed independently.