Luiz Gustavo Almeida Martins

Luiz Gustavo Almeida Martins

Auto-generated profile, based on publicly available information

Luiz Gustavo Almeida Martins

Federal University of Uberlândia

Research Focus & Metrics

Academic Career Length

20Years (2007-Present)

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

Representative Publications

View All Publications
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.

1 October 2009 in Electronic Notes in Theoretical Computer Science
Verified
Journal Article
Open access
GOGina M.B. Oliveira
Gina M.B. Oliveira
LMLuiz G.A. Martins
Luiz G.A. Martins
LCLaura B. de Carvalho
Laura B. de Carvalho
EFEnrique Fynn
Enrique Fynn
The study of computational aspects of cellular automata (CA) is a recurrent theme being that the investigation of specific tasks to be solved by CA rules a common and widely-known approach. We investigated two of the most-studied computational tasks: synchronization (ST) and density classification (DCT). Different specifications of CA rule space were analyzed for both tasks: one-dimensional rules with radius 1 and 2, and two-dimensional rules with von Neumann and Moore neighborhoods. We also analyzed different lattice sizes when trying to execute these tasks. Several evolutionary experiments were performed to characterize ST and DCT on these different scenarios. Some interesting results have been occurred from these experiments as the adequacy of the tasks to be solved in two-dimensional spaces instead of 1D even using rules with the same length and the dependency to the parity of the lattice size related to good rules for DCT in 1D and 2D spaces.

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.

1 June 2019
Verified
Conference Paper
Closed access
GOGina M. B. Oliveira
Gina M. B. Oliveira
RSReslley G. O. Silva
Reslley G. O. Silva
GFGiordano B. S. Ferreira
Giordano B. S. Ferreira
Micael Santos CouceiroMicael Santos Couceiro
Micael Santos Couceiro
LALaurence R. Do Amaral
Laurence R. Do Amaral
LMLuiz Gustavo A. Martins
Luiz Gustavo A. Martins
This work proposes a cellular automata-based model to solve a path-planning and formation control problem for a team of robots using local rules and discrete states. Planning collision-free trajectories is essential for autonomous robots when moving in unknown environments. The complexity of this task increases in multi-robot systems, in particular when all robots must adjust their path in order to keep their initial team formation pattern. Here, a decentralized and autonomous robot team path-planning model is proposed and tested. The proposed method is implemented on a simulation environment and on real e-puck robots. Results show improvements in the overall team efficiency and robustness in different scenarios using minimal robot-robot communication load.

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