CI is the practice of teams making continuous, incremental changes to a FPGA design’s code base, thereby providing higher quality, more predictable releases. Code is automatically and frequently built and tested to ensure high quality, bug-free systems. To achieve this, the code base is worked on simultaneously and regularly updated by all members of the team, sometimes as often as multiple times a day.
Version control systems, such as Git are mandatory for managing these changes. The entire system then undergoes a series of builds and tests known as a workflow. Since tests are a crucial part of CI, developers must keep tests up-to-date and constantly add tests as an application progresses. This provides higher quality releases than when testing is left till the end of development.
In the early days of FPGAs, they were often limited to glue logic or implementing different IO standards for embedded markets. FPGAs then began increasing in resources, complexity and speed, reducing power consumption, thereby opening them up to new applications. They began becoming a viable alternative to ASICs, as they were able to provide the required performance, whilst reducing the number of verification steps and having no manufacturing lead times. This makes FPGAs appealing in time-to-market critical applications, where any time lost leads to significant loss of sales.
More recently FPGAs are being used in preference over CPU and GPU technology for high speed applications as modern FPGAs can provide tenfold performance over CPUs and offer low performance per Watt compared to GPUs. However, many developers in these markets are still hesitant to use FPGAs, due to the large development times compared to CPUs and GPUs.
For FPGA applications to be competitive, the time taken for development must become comparable to CPUs and GPUs. Yet, as FPGAs become more advanced, development times are at risk of rising. As FPGA designs increase from thousands of lines of RTL code to hundreds of thousands, far more development time must be spent on implementation details. Systems may now consist of tens of modules, making it unrealistic for small teams of hardware engineers to rapidly design and debug every individual module. These modules must all be integrated into the system once they are complete. This integration requires large amounts of time devoted to debugging interfacing and communication.
The effect of this increasing complexity is that designers spend less time exploring the design space and novel solutions. Instead, they are forced to implement the fine details of a single design. If this trend continues, developers will need to either lengthen development time and sacrifice time-to-market advantage, or settle for less optimal designs, potentially harming the performance benefits of using FPGAs.
This has created a push for FPGA design process to adopt more modern, high-level productive methods that allow designers more time to work on value-added solutions. We have seen innovation in FPGA toolsets that are focused on making FPGA designs far more accessible to all types of developers, not only those skilled in RTL. For instance, new High Level Synthesis (HLS) tools allow software developers to program FPGA designs in C/C++. These new tools allow for a far more diverse and modern development force that can effectively explore the design space of complex systems.
New toolsets alone are not enough to overcome these development challenges. Diverse teams need to be able to coordinate with each other to build a system. Moreover, a system must be tested from the RTL level to the final software application, to guarantee correct functionality. To solve the problems faced by adopting high-level tools, FPGA designs must also be developed using modern software development practises. We believe that Continuous Integration practices present the solution to reducing development time, whilst ensuring novel, innovative designs are created on schedule.
By adopting CI, FPGA developers can accelerate their time to market, even as the complexity of their systems grow. Adopting CI leads to higher quality, more predictable releases. It will also show how CI reduces communication overhead and keeps teams integrated and efficient. CI also provides benefits to the individual developer by reducing the need for them to maintain their own developer environments and instead, focus on exploring the design space.