Nicklas Bo Jensen

Technical University of Denmark

Author Statistics

Papers

Citation

H-Index

i-10 index

Research Trends

Author Order

Document Type

Co-Authors

Sven Karlsson

Technical University of Denmark

Gregory L. Lee

Lawrence Livermore National Laboratory

Dong H. Ahn

Nvidia (United States)

Andreas Erik Hindborg

Technical University of Denmark

Pascal Schleuniger

Technical University of Denmark

Niklas Quarfot Nielsen

Technical University of Denmark

Martin Schulz

Technical University of Munich

Matthew LeGendre

Lawrence Livermore National Laboratory

Ayal Zaks

Intel (United States)

Christian W. Probst

Unitec Institute of Technology

Cooperative Institutions

Technical University of Denmark

Embedded Systems (United States)

Lawrence Livermore National Laboratory

Georgia Institute of Technology

University of Utah

Bavarian Academy of Sciences and Humanities

Leibniz Supercomputing Centre

IBM (United States)

Intel (United States)

Purdue University West Lafayette

Author Statistics

Papers

Citation

H-Index

i-10 index

Research Field

Guiding Programmers to Higher Memory Performance

Nicklas Bo Jensen Per Larsen Razya Ladelsky Ayal Zaks Sven Karlsson

Source

Cite

Citations (4)

Collaborative Compiler Vectorization

Nicklas Bo Jensen Christian W. Probst Sven Karlsson

Vectorization (mathematics)

Source

Cite

Citations (0)

Code Commentary and Automatic Refactorings using Feedback from Multiple Compilers

HAL (Le Centre pour la Communication Scientifique Directe) (2015)

Nicklas Bo Jensen

Code (set theory)

Source

Cite

Citations (0)

A Scalable Prescriptive Parallel Debugging Model

Nicklas Bo Jensen Niklas Quarfot Nielsen Gregory L. Lee Sven Karlsson Matthew LeGendre

Debugging is a critical step in the development of any parallel program. However, the traditional interactive debugging model, where users manually step through code and inspect their application, does not scale well even for current supercomputers due its centralized nature. While lightweight debugging models, which have been proposed as an alternative, scale well, they can currently only debug a subset of bug classes. We therefore propose a new model, which we call prescriptive debugging, to fill this gap between these two approaches. This user-guided model allows programmers to express and test their debugging intuition in a way that helps to reduce the error space. Based on this debugging model we introduce a prototype implementation embodying this model, the DySectAPI, allowing programmers to construct probe trees for automatic, event-driven debugging at scale. In this paper we introduce the concepts behind DySectAPI and, using both experimental results and analytical modelling, we show that the DySectAPI implementation can run with a low overhead on current systems. We achieve a logarithmic scaling of the prototype and show predictions that even for a large system the overhead of the prescriptive debugging model will be small.

Algorithmic program debugging

Intuition

10.1109/ipdps.2015.15

Cite

Citations (2)

Experiences with Compiler Support for Processors with Exposed Pipelines

Nicklas Bo Jensen Pascal Schleuniger Andreas Erik Hindborg Maxwell Walter Sven Karlsson

Field programmable gate arrays, FPGAs, have become an attractive implementation technology for a broad range of computing systems. We recently proposed a processor architecture, Tinuso, which achieves high performance by moving complexity from hardware to the compiler tool chain. This means that the compiler tool chain must handle the increased complexity. However, it is not clear if current production compilers can successfully meet the strict constraints on instruction order and generate efficient object code. In this paper, we present our experiences developing a compiler backend using the GNU Compiler Collection, GCC. For a set of C benchmarks, we show that a Tinuso implementation with our GCC backend reaches a relative speedup of up to 1.73 over a similar Xilinx Micro Blaze configuration while using 30% fewer hardware resources. While our experiences are generally positive, we expose some limitations in GCC that need to be addressed to achieve the full performance potential of Tinuso.

Speedup

Interprocedural optimization

10.1109/ipdpsw.2015.9

Cite

Citations (2)

Improving Loop Dependence Analysis

ACM Transactions on Architecture and Code Optimization (2017)

Nicklas Bo Jensen Sven Karlsson

Programmers can no longer depend on new processors to have significantly improved single-thread performance. Instead, gains have to come from other sources such as the compiler and its optimization passes. Advanced passes make use of information on the dependencies related to loops. We improve the quality of that information by reusing the information given by the programmer for parallelization. We have implemented a prototype based on GCC into which we also add a new optimization pass. Our approach improves the amount of correctly classified dependencies resulting in 46% average improvement in single-thread performance for kernel benchmarks compared to GCC 6.1.

Programmer

Program optimization

Kernel (algebra)

10.1145/3095754

Cite

Citations (2)

Hardware realization of an FPGA processor — Operating system call offload and experiences

Andreas Erik Hindborg Pascal Schleuniger Nicklas Bo Jensen Sven Karlsson

Field-programmable gate arrays, FPGAs, are attractive implementation platforms for low-volume signal and image processing applications. The structure of FPGAs allows for an efficient implementation of parallel algorithms. Sequential algorithms, on the other hand, often perform better on a microprocessor. It is therefore convenient for many applications to employ a synthesizable microprocessor to execute sequential tasks and custom hardware structures to accelerate parallel sections of an algorithm. In this paper, we discuss the hardware realization of Tinuso-I, a small synthesizable processor core that can be integrated in many signal and data processing platforms on FPGAs. We also show how we allow the processor to use operating system services. For a set of SPLASH-2 and SPEC CPU2006 benchmarks we show a speedup of up to 64% over a similar Xilinx MicroBlaze implementation while using 27% to 35% fewer hardware resources.

MicroBlaze

Microprocessor

Multi-core processor

Speedup

10.1109/dasip.2014.7115604

Cite

Citations (3)

High Performance with Prescriptive Optimization and Debugging

Nicklas Bo Jensen

Algorithmic program debugging

Source

Cite