{"id":2306,"date":"2017-05-02T09:23:03","date_gmt":"2017-05-02T09:23:03","guid":{"rendered":"http:\/\/support.plunify.com\/en\/?p=2306"},"modified":"2017-05-02T09:23:03","modified_gmt":"2017-05-02T09:23:03","slug":"do-more-with-less-with-the-new-hot-start-recipe","status":"publish","type":"post","link":"https:\/\/support.plunify.com\/jp\/2017\/05\/02\/do-more-with-less-with-the-new-hot-start-recipe\/","title":{"rendered":"Do more with less with the new Hot Start Recipe"},"content":{"rendered":"

Introduction<\/b><\/p>\n

One of our most common customer requests is for a smaller\u00a0number of compilation runs to get to timing closure. For example, can InTime meet timing in 50 runs instead of 100 on average? Well, that depends; InTime generally has an idea of what settings will help your design meet timing, and in rare cases it is possible to meet timing even within the first 10 runs.<\/span>
\n<\/span>
\n<\/span>Each design is unique and thus the set of settings that work well on one design will probably not work as well on another unless the two designs are similar. Typically, InTime has to learn and customize a new set of settings for each new design. In order to learn, InTime requires data in the form of multiple compilation runs, so that it can make informed decisions and fine-tune the synthesis and place-and-route settings for your designs.<\/span><\/p>\n

With increasing design complexity and FPGA compiler runtimes, it is therefore critical that InTime achieves the required timing or area performance in as fewer a number of runs as possible. <\/span><\/p>\n

We are pleased to announce the release of a new recipe named \u201cHot Start\u201d. Here at Plunify Labs, we constantly compile a variety of designs using different FPGA tools and have come up with a database of tried and tested settings that guarantees timing improvements for practically any design. Hot Start is the name of our algorithm that generates these settings. In addition, this recipe learns from past compilations and selects settings suitable for each unique design. With this recipe, reducing the number of iterations while meeting timing is no longer a dream but a reality.<\/span><\/p>\n

Comparison<\/b><\/p>\n

In this blog post, we compare the InTime Default recipe\u2019s results against those of Hot Start. <\/span><\/p>\n

We perform an experiment to see if Hotstart indeed uses less runs to achieve a better TNS (Total Negative Slack) score as compared to InTime Default. Three projects, each with varying device type and area, were compiled using InTime Default (10 rounds of 10 runs) and Hotstart (two rounds of 50). Details of the three projects can be found in the table below<\/span><\/p>\n\n\n\n\n\n\n
Project Name<\/span><\/td>\nToolchain<\/span><\/td>\nDevice Name<\/span><\/td>\nArea<\/span><\/td>\n<\/tr>\n
Bitcoin miner<\/span><\/td>\nQuartus 14.0.0<\/span><\/td>\nCyclone IV<\/span><\/td>\n99<\/span><\/td>\n<\/tr>\n
SOC<\/span><\/td>\nQuartus 16.0.0<\/span><\/td>\nCyclone V<\/span><\/td>\n11<\/span><\/td>\n<\/tr>\n
PCIe<\/span><\/td>\nQuartus 14.0.0<\/span><\/td>\nArria V<\/span><\/td>\n7<\/span><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n


\nWe plot the best TNS against the number of runs. The blue lines in the ensuing graphs represent the Hot Start recipe results while the red line shows the InTime Default recipe results.<\/span><\/p>\n

Here is the plot for the Cyclone IV bitcoin miner design:<\/span><\/p>\n

\"hotstart_default_comparison_bemicro\"<\/span><\/p>\n

Notice that the best result for Hot Start is always better than the best result for InTime Default.\u00a0<\/span><\/p>\n

For Hot Start, the best TNS was found in less than 50 iterations. InTime Default took more than 50 runs to achieve the best TNS and even then the TNS was not as good as the TNS found by Hot Start.<\/span>
\nHere is a similar plot showing the results for the Cyclone V SOC design.<\/span><\/p>\n

\"hotstart_default_comparison_borax\"<\/span><\/p>\n

From the above plot, we can see that Hot Start performed better than InTime Default. Hot Start also achieved a better TNS using fewer runs than InTime Default. There was a short window period from 30 runs to 40 runs where InTime Default outperformed Hot Start. This is because the learning algorithm for Hot Start typically kicks in at around 40-50 runs and that was when the Hot Start started to consistently produce better results than InTime Default.<\/span>
\nLast but not least, the plot showing the results for an Arria V PCIe design is shown below.<\/span><\/p>\n

\"hotstart_default_comparison_av_x4\"<\/span><\/p>\n

Here we notice that the best TNS for InTime Default is much better than that for Hot Start for the majority of runs. However, after 80 runs, Hot Start managed to achieve a better TNS then InTime Default. Notice how InTime Default plateau-ed and no improvements in TNS values were found from the 40th run onwards. This was not the case for Hotstart. The Hot Start algorithm did not perform very well in the first 40-50 runs but the algorithm continued to learn from previous runs and finally managed to pull ahead of the InTime Default.<\/span><\/p>\n

How to use Hot Start<\/b><\/p>\n

Note - this recipe is currently only available for Quartus projects.<\/span><\/i><\/p>\n