skip to main content
research-article

Fast Turnaround HLS Debugging Using Dependency Analysis and Debug Overlays

Published:28 January 2020Publication History
Skip Abstract Section

Abstract

High-level synthesis (HLS) has gained considerable traction over recent years, as it allows for faster development and verification of hardware accelerators than traditional RTL design. While HLS allows for most bugs to be caught during software verification, certain non-deterministic or data-dependent bugs still require debugging the actual hardware system during execution. Recent work has focused on techniques to allow designers to perform in-system debug of HLS circuits in the context of the original software code; however, like RTL debug, the user must still determine the root cause of a bug using small execution traces, with lengthy debug turns.

In this work, we demonstrate techniques aimed at reducing the time HLS designers spend performing in-system debug. Our approaches consist of performing data dependency analysis to guide the user in selecting which variables are observed by the debug instrumentation, as well as an associated debug overlay that allows for rapid reconfiguration of the debug logic, enabling rapid switching of variable observation between debug iterations. In addition, our overlay provides additional debug capability, such as selective function tracing and conditional buffer freeze points. We explore the area overhead of these different overlay features, showing a basic overlay with only a 1.7% increase in area overhead from the baseline debug instrumentation, while a deluxe variant offers 2×--7× improvement in trace buffer memory utilization with conditional buffer freeze support.

References

  1. Altera. 2016. Altera Virtual JTAG (altera_virtual_jtag) IP Core User Guide. Retrieved from https://www.altera.com/en_US/pdfs/literature/ug/ug_virtualjtag.pdf.Google ScholarGoogle Scholar
  2. Altera. 2016. SDK for OpenCL. Retrieved from https://www.altera.com/products/design-software/embedded-software-developers/opencl/overview.html.Google ScholarGoogle Scholar
  3. P. K. Bussa, J. Goeders, and S. J. E. Wilton. 2017. Accelerating in-system FPGA debug of high-level synthesis circuits using incremental compilation techniques. In Proceedings of the International Conference on Field-Programmable Logic and Applications.Google ScholarGoogle ScholarCross RefCross Ref
  4. N. Calagar, S. D. Brown, and J. H. Anderson. 2014. Source-level debugging for FPGA high-level synthesis. In Proceedings of the International Conference on Field Programmable Logic and Applications.Google ScholarGoogle Scholar
  5. Keith Campbell, Leon He, Liwei Yang, Swathi Gurumani, Kyle Rupnow, and Deming Chen. 2016. Debugging and verifying SoC designs through effective cross-layer hardware-software co-simulation. In Proceedings of the 53rd Annual Design Automation Conference (DAC’16). ACM, New York, NY, Article 7, 6 pages. DOI:https://doi.org/10.1145/2897937.2898002Google ScholarGoogle ScholarDigital LibraryDigital Library
  6. A. Canis, J. Choi, et al. 2013. LegUp: An open-source high-level synthesis tool for FPGA-based processor/accelerator systems. ACM Transactions on Embedded Computing Systems 13, 2, Article 24 (Sept. 2013), 27 pages.Google ScholarGoogle ScholarDigital LibraryDigital Library
  7. P. Coussy, D. D. Gajski, M. Meredith, and A. Takach. 2009. An introduction to high-level synthesis. IEEE Des. Test Comput. 26, 4 (Jul. 2009), 8--17. DOI:https://doi.org/10.1109/MDT.2009.69Google ScholarGoogle ScholarDigital LibraryDigital Library
  8. F. Eslami and S. J. E. Wilton. 2015. An adaptive virtual overlay for fast trigger insertion for FPGA debug. In Proceedings of the International Conference on Field Programmable Technology. 32--39.Google ScholarGoogle ScholarCross RefCross Ref
  9. P. Fezzardi, M. Castellana, and F. Ferrandi. 2015. Trace-based automated logical debugging for high-level synthesis generated circuits. In Proceedings of the International Conference on Computer Design. 251--258. DOI:https://doi.org/10.1109/ICCD.2015.7357111Google ScholarGoogle Scholar
  10. P. Fezzardi and F. Ferrandi. 2016. Automated bug detection for pointers and memory accesses in High-Level Synthesis compilers. In Proceedings of the International Conference on Field Programmable Logic and Applications. 1--9. DOI:https://doi.org/10.1109/FPL.2016.7577369Google ScholarGoogle Scholar
  11. Pietro Fezzardi, Marco Lattuada, and Fabrizio Ferrandi. 2017. Using efficient path profiling to optimize memory consumption of on-chip debugging for high-level synthesis. ACM Trans. Embed. Comput. Syst. 16, 5s, Article 149 (Sept. 2017), 19 pages. DOI:https://doi.org/10.1145/3126564Google ScholarGoogle ScholarDigital LibraryDigital Library
  12. J. Goeders and S. J. E. Wilton. 2014. Effective FPGA debug for high-level synthesis generated circuits. In Proceedings of the International Conference on Field Programmable Logic and Applications. DOI:https://doi.org/10.1109/FPL.2014.6927498Google ScholarGoogle ScholarCross RefCross Ref
  13. J. Goeders and S. J. E. Wilton. 2017. Signal-tracing techniques for in-system FPGA debugging of high-level synthesis circuits. IEEE Trans. Comput.-Aid. Des. Integr. Circ. Syst. 36, 1 (Jan. 2017), 83--96.Google ScholarGoogle Scholar
  14. J. Goeders and S. J. E. Wilton. 2015. Allowing software developers to debug HLS hardware. In Workshop on FPGAs for Software Programmers.Google ScholarGoogle Scholar
  15. Y. Hara, H. Tomiyama, S. Honda, and H. Takada. 2009. Proposal and quantitative analysis of the CHStone benchmark program suite for practical C-based high-level synthesis. J. Inf. Process. 17 (2009), 242--254.Google ScholarGoogle ScholarCross RefCross Ref
  16. A. S. Jamal, J. Goeders, and S. J. E. Wilton. 2018. Architecture exploration for HLS-Oriented FPGA debug overlays. In Proceedings of the International Symposium on Field-Programmable Gate Arrays.Google ScholarGoogle ScholarDigital LibraryDigital Library
  17. J. S. Monson and B. Hutchings. 2014. New approaches for in-system debug of behaviorally-synthesized FPGA circuits. In Proceedings of the International Conference on Field-Programmable Logic and Applications. 1--6.Google ScholarGoogle Scholar
  18. J. S. Monson and Brad L. Hutchings. 2015. Using source-level transformations to improve high-level synthesis debug and validation on FPGAs. In Proceedings of the International Symposium on Field-Programmable Gate Arrays. 5--8.Google ScholarGoogle Scholar
  19. R. Nane, V. M. Sima, C. Pilato, J. Choi, B. Fort, A. Canis, Y. T. Chen, H. Hsiao, S. Brown, F. Ferrandi, J. Anderson, and K. Bertels. 2016. A survey and evaluation of FPGA high-level synthesis tools. IEEE Trans. Comput.-Aid. Des. Integr. Circ. Syst. 35, 10 (2016). DOI:https://doi.org/10.1109/TCAD.2015.2513673Google ScholarGoogle Scholar
  20. B. Reagen, R. Adolf, Y. S. Shao, Gu-Yeon Wai, and David Brooks. 2014. MachSuite: Benchmarks for accelerator design and customized architectures. In Proceedings of the International Symposium on Workload Characterization. 110--119.Google ScholarGoogle ScholarCross RefCross Ref
  21. Hayden Kwok-Hay So and Cheng Liu. 2016. FPGA Overlays. Springer International Publishing, Cham, 285--305. DOI:https://doi.org/10.1007/978-3-319-26408-0_16Google ScholarGoogle Scholar
  22. Mark Weiser. 1981. Program slicing. In Proceedings of the International Conference on Software Engineering. 439--449.Google ScholarGoogle ScholarDigital LibraryDigital Library
  23. Xilinx. 2016. Vivado Design Suite User Guide: High-Level Synthesis. Retrieved from http://www.xilinx.com/support/documentation/sw_manuals/xilinx2016_2/ug902-vivado-high-level-synthesis.pdf.Google ScholarGoogle Scholar
  24. Liwei Yang, Swathi Gurumani, Deming Chen, and Kyle Rupnow. 2016. AutoSLIDE: Automatic source-level instrumentation and debugging. In Proceedings of the International Symposium on Field-Programmable Custom Computing Machines. 127--130. DOI:https://doi.org/10.1109/FCCM.2016.38Google ScholarGoogle ScholarCross RefCross Ref
  25. Liwei Yang, Swathi Gurumani, Suhaib A. Fahmy, Deming Chen, and Kyle Rupnow. 2016. Automated verification code generation in HLS using software execution traces. In Proceedings of the International Symposium on Field-Programmable Gate Arrays. 278--278. DOI:https://doi.org/10.1145/2847263.2847313Google ScholarGoogle ScholarDigital LibraryDigital Library

Index Terms

  1. Fast Turnaround HLS Debugging Using Dependency Analysis and Debug Overlays

        Recommendations

        Comments

        Login options

        Check if you have access through your login credentials or your institution to get full access on this article.

        Sign in

        Full Access

        • Published in

          cover image ACM Transactions on Reconfigurable Technology and Systems
          ACM Transactions on Reconfigurable Technology and Systems  Volume 13, Issue 1
          March 2020
          135 pages
          ISSN:1936-7406
          EISSN:1936-7414
          DOI:10.1145/3377289
          • Editor:
          • Deming Chen
          Issue’s Table of Contents

          Copyright © 2020 ACM

          Publisher

          Association for Computing Machinery

          New York, NY, United States

          Publication History

          • Published: 28 January 2020
          • Accepted: 1 November 2019
          • Revised: 1 September 2019
          • Received: 1 June 2019
          Published in trets Volume 13, Issue 1

          Permissions

          Request permissions about this article.

          Request Permissions

          Check for updates

          Qualifiers

          • research-article
          • Research
          • Refereed

        PDF Format

        View or Download as a PDF file.

        PDF

        eReader

        View online with eReader.

        eReader

        HTML Format

        View this article in HTML Format .

        View HTML Format
        About Cookies On This Site

        We use cookies to ensure that we give you the best experience on our website.

        Learn more

        Got it!