Ricardo Nobre

Ricardo Nobre

Auto-generated profile, based on publicly available information

Ricardo Nobre

Inesc-ID, Instituto Superior Técnico, Universidade de Lisboa, Lisboa, Portugal

Research Focus & Metrics

Academic Career Length

15Years (2012-Present)

(Calculated once Scilit publication data is synced: current year − year of first publication + 1)

Representative Publications

View All Publications
25 March 2012
Verified
Conference Paper
Open access
PDF file
João CardosoJoão Cardoso
João Cardoso
TCTiago Carvalho
Tiago Carvalho
JCJosé G.F. Coutinho
José G.F. Coutinho
WLWayne Luk
Wayne Luk
RNRicardo Nobre
Ricardo Nobre
ZPZlatko Petrov
Zlatko Petrov

28 March 2016 in ACM Transactions on Architecture and Code Optimization
Verified
Journal Article
Open access
LMLuiz G. A. Martins
Luiz G. A. Martins
RNRicardo Nobre
Ricardo Nobre
João CardosoJoão Cardoso
João Cardoso
ADALEXANDRE CLAUDIO BOTAZZO DELBEM
ALEXANDRE CLAUDIO BOTAZZO DELBEM
EMEduardo Marques
Eduardo Marques
A large number of compiler optimizations are nowadays available to users. These optimizations interact with each other and with the input code in several and complex ways. The sequence of application of optimization passes can have a significant impact on the performance achieved. The effect of the optimizations is both platform and application dependent. The exhaustive exploration of all viable sequences of compiler optimizations for a given code fragment is not feasible. As this exploration is a complex and time-consuming task, several researchers have focused on Design Space Exploration (DSE) strategies both to select optimization sequences to improve the performance of each function of the application and to reduce the exploration time. In this article, we present a DSE scheme based on a clustering approach for grouping functions with similarities and exploration of a reduced search space resulting from the combination of optimizations previously suggested for the functions in each group. The identification of similarities between functions uses a data mining method that is applied to a symbolic code representation. The data mining process combines three algorithms to generate clusters: the Normalized Compression Distance, the Neighbor Joining, and a new ambiguity-based clustering algorithm. Our experiments for evaluating the effectiveness of the proposed approach address the exploration of optimization sequences in the context of the ReflectC compiler, considering 49 compilation passes while targeting a Xilinx MicroBlaze processor, and aiming at performance improvements for 51 functions and four applications. Experimental results reveal that the use of our clustering-based DSE approach achieves a significant reduction in the total exploration time of the search space (20× over a Genetic Algorithm approach) at the same time that considerable performance speedups (41% over the baseline) were obtained using the optimized codes. Additional experiments were performed considering the LLVM compiler, considering 124 compilation passes, and targeting a LEON3 processor. The results show that our approach achieved geometric mean speedups of 1.49 × , 1.32 × , and 1.24 × for the best 10, 20, and 30 functions, respectively, and a global improvement of 7% over the performance obtained when compiling with -O2.

13 June 2016 in ACM SIGPLAN Notices
Verified
Conference Paper
Open access
RNRicardo Nobre
Ricardo Nobre
LMLuiz G. A. Martins
Luiz G. A. Martins
João CardosoJoão Cardoso
João Cardoso
Nowadays compilers include tens or hundreds of optimization passes, which makes it difficult to find sequences of optimizations that achieve compiled code more optimized than the one obtained using typical compiler options such as -O2 and -O3. The problem involves both the selection of the compiler passes to use and their ordering in the compilation pipeline. The improvement achieved by the use of custom phase orders for each function can be significant, and thus important to satisfy strict requirements such as the ones present in high-performance embedded computing systems. In this paper we present a new and fast iterative approach to the phase selection and ordering challenges resulting in compiled code with higher performance than the one achieved with the standard optimization levels of the LLVM compiler. The obtained performance improvements are comparable with the ones achieved by other iterative approaches while requiring considerably less time and resources. Our approach is based on sampling over a graph representing transitions between compiler passes. We performed a number of experiments targeting the LEON3 microarchitecture using the Clang/LLVM 3.7 compiler, considering 140 LLVM passes and a set of 42 representative signal and image processing C functions. An exhaustive cross-validation shows our new exploration method is able to achieve a geometric mean performance speedup of 1.28x over the best individually selected -OX flag when considering 100,000 iterations; versus geometric mean speedups from 1.16x to 1.25x obtained with state-of-the-art iterative methods not using the graph. From the set of exploration methods tested, our new method is the only one consistently finding compiler sequences that result in performance improvements when considering 100 or less exploration iterations. Specifically, it achieved geometric mean speedups of 1.08x and 1.16x for 10 and 100 iterations, respectively.

1 June 2015
Verified
Conference Paper
Open access
RNRicardo Nobre
Ricardo Nobre
LMLuiz G. A. Martins
Luiz G. A. Martins
João CardosoJoão Cardoso
João Cardoso
This paper presents a new approach to efficiently search for suitable compiler pass sequences, a challenge known as phase ordering. Our approach relies on information about the relative positions of compiler passes in compiler pass sequences previously generated for a set of functions when compiling for a specific processor. We enhanced two iterative compiler pass exploration schemes, one relying on simple sequential compiler pass insertion and other implementing an auto-tuned simulated annealing process, with a data structure that holds information about the relative positions of compiler sequences; in order to reduce the set of compiler passes considered for insertion in a given position of a given candidate compiler pass sequence to include only the passes that have a higher probability of performing well on that relative position in the compiler sequence, speeding up the exploration time as a result. We tested our approach with two different compilers and two different targets; the ReflectC and the LLVM compilers, targeting a MicroBlaze processor and a LEON3 processor, respectively. The experimental results show that we can considerably reduce the number of algorithm iterations by a factor of up to more than an order of magnitude when targeting the MicroBlaze or the LEON3, while finding compiler sequences that result in binaries that when executed on the target processor/simulator are able to outperform (i.e. use less CPU cycles) all the standard optimization levels (i.e., we compare against the most performing optimization level flag on each kernel, e.g. -O1, -O2 or -O3 in the case of LLVM) by a geometric mean performance improvement of 1.23x and 1.20x when targeting the MicroBlaze processor, and 1.94x and 2.65x when targetting the LEON3 processor; for each of the two exploration algorithms and two kernel sets considered.

12 June 2014
Verified
Conference Paper
Open access
LMLuiz G.A. Martins
Luiz G.A. Martins
RNRicardo Nobre
Ricardo Nobre
ADALEXANDRE CLAUDIO BOTAZZO DELBEM
ALEXANDRE CLAUDIO BOTAZZO DELBEM
EMEduardo Marques
Eduardo Marques
João CardosoJoão Cardoso
João Cardoso

23 January 2018
Verified
Conference Paper
Open access
PDF file
RNRicardo Nobre
Ricardo Nobre
LRLuís Reis
Luís Reis
JBJoão Bispo
João Bispo
TCTiago Carvalho
Tiago Carvalho
João CardosoJoão Cardoso
João Cardoso
GAGiovanni Agosta
Giovanni Agosta