Verification of Parameterised FPGA Circuit Descriptions with Layout ...

Verification of Parameterised FPGA Circuit Descriptions with Layout ... Verification of Parameterised FPGA Circuit Descriptions with Layout ...

24.04.2013 Views

CHAPTER 7. CONCLUSION AND FUTURE WORK 170 7.3.3 Ruby and Lava Both Ruby [26] and Lava [7] have been used to generate placed circuit descriptions using their higher-order combinators. Ruby and Lava combinators can describe both function and placement, as with Quartz. Neither the Ruby nor Lava system supports the generation of parameterised output, instead they generate flattened netlists. Ruby uses a variable-free notation of relations to describe circuits and it is thus relatively easy to give key combinators, such as beside and below a layout interpretation which can then be used to generate placed output. Ruby’s design style does not support explicit instantiation and signal connection and can not support explicit co-ordinates. This is a limiting factor and the system can not support the irregular grid example. No explicit verification infrastructure is available for Ruby layouts, however since the output is a flattened netlist and placement is limited to beside/below relationships it should be impossible to describe invalid layouts. Lava is a more flexible system based on Haskell. Lava provides a combinators which place components below each other, beside each other or at the same location. Unlike Ruby, it does not enforce a variable-free notation and is thus more flexible. A version of Lava has also been demonstrated that supports layout with explicit co-ordinates [77]. While Lava provides constructs to aid the construction of correct layouts (using beside and below), it also permits possibly invalid layouts (by placing components in the same slice 2 , either explicitly or using the combinator provided for this purpose). Unlike Ruby, Lava does therefore permit the description of invalid layouts and there is no infrastructure available for verifying Lava layouts however our layout verification infrastructure could be adapted to this purpose. Ruby and Lava use recursion as their only means of repetition. The languages do not support iterative descriptions, which can be a clearer way of describing some circuit arrangements than recursion (although they are not more powerful per se), although this is less relevant than for Quartz since they do not produce output in a format that supports iteration. Ruby and Lava do not support giving combinators different layout interpretations in the 2 The version of Lava which supports placement was developed at Xilinx and is designed specifically to target Xilinx FPGAs.

CHAPTER 7. CONCLUSION AND FUTURE WORK 171 same way as our framework. Lava does support overloading but using Haskell type classes which are not suitable for overloading blocks with different parameterisations in the way that is required for providing additional layout parameters. 7.4 Future Work Several aspects of this work are particularly open ended and we will end by making a few recommendations for areas worthy of future investigation. 7.4.1 Further Support For Alternative Layout Interpretations We have demonstrated how blocks can be given different layout interpretations and over- loading used to give one of these interpretations the status of a “default”. However, this approach still requires that two or more different layouts are explicitly coded for combinator blocks. While there will be some cases where blocks are described with completely unrelated layout interpretations, in most cases we expect these different interpretations to be variations on a theme. It is possible that these operations could be better described by vertical and horizontal flipping or rotation and higher-order blocks which performed these operation on their parameter block could provide a simpler method of achieving this result. Combinators with could rotate or flip blocks allow abstraction of a particular kind of layout operation and promote separation of concerns in the same way as higher-order combinators do. Such layout-manipulation combinators would need to be based on a different theoretical basis to our current system, where one block can not alter the internal structure of another. The verification of such combinators would be an interesting exercise, particularly ensuring that they do not invalidate a previously valid layout. Another useful extension would be to provide a mechanism for series and parallel compositions to be given multiple layout interpretations. Lava achieves this for series composition by providing different combinators for different series composition layouts, Quartz could take a similar approach but achieve it more concisely since series composition is a language-level

CHAPTER 7. CONCLUSION AND FUTURE WORK 170<br />

7.3.3 Ruby and Lava<br />

Both Ruby [26] and Lava [7] have been used to generate placed circuit descriptions using<br />

their higher-order combinators. Ruby and Lava combinators can describe both function and<br />

placement, as <strong>with</strong> Quartz. Neither the Ruby nor Lava system supports the generation <strong>of</strong><br />

parameterised output, instead they generate flattened netlists.<br />

Ruby uses a variable-free notation <strong>of</strong> relations to describe circuits and it is thus relatively<br />

easy to give key combinators, such as beside and below a layout interpretation which can then<br />

be used to generate placed output. Ruby’s design style does not support explicit instantiation<br />

and signal connection and can not support explicit co-ordinates. This is a limiting factor and<br />

the system can not support the irregular grid example. No explicit verification infrastructure<br />

is available for Ruby layouts, however since the output is a flattened netlist and placement<br />

is limited to beside/below relationships it should be impossible to describe invalid layouts.<br />

Lava is a more flexible system based on Haskell. Lava provides a combinators which place<br />

components below each other, beside each other or at the same location. Unlike Ruby, it<br />

does not enforce a variable-free notation and is thus more flexible. A version <strong>of</strong> Lava has also<br />

been demonstrated that supports layout <strong>with</strong> explicit co-ordinates [77].<br />

While Lava provides constructs to aid the construction <strong>of</strong> correct layouts (using beside and<br />

below), it also permits possibly invalid layouts (by placing components in the same slice 2 ,<br />

either explicitly or using the combinator provided for this purpose). Unlike Ruby, Lava does<br />

therefore permit the description <strong>of</strong> invalid layouts and there is no infrastructure available for<br />

verifying Lava layouts however our layout verification infrastructure could be adapted to this<br />

purpose.<br />

Ruby and Lava use recursion as their only means <strong>of</strong> repetition. The languages do not support<br />

iterative descriptions, which can be a clearer way <strong>of</strong> describing some circuit arrangements<br />

than recursion (although they are not more powerful per se), although this is less relevant<br />

than for Quartz since they do not produce output in a format that supports iteration.<br />

Ruby and Lava do not support giving combinators different layout interpretations in the<br />

2 The version <strong>of</strong> Lava which supports placement was developed at Xilinx and is designed specifically to<br />

target Xilinx <strong>FPGA</strong>s.

Hooray! Your file is uploaded and ready to be published.

Saved successfully!

Ooh no, something went wrong!