Project Stage 2 - (Preparation part)

Introduction

Today, I am going to delve into the GCC codebase to understand its behavior better. The objective is to create a proof-of-concept for automatic function multi-versioning (AFMV) as an optional tool via command-line arguments when compiling with GCC. This will involve isolating and building on specific parts of the codebase to implement a given subtask.

How GCC Compiles Code

First, let’s explore how GCC operates when compiling source code. A "pass" refers to a stage in the compilation process where the compiler processes the source code to understand and transform it for subsequent stages. Early passes typically involve parsing command-line options, while later passes check for syntactic correctness, perform optimizations, generate machine code for the target architecture, and finally, assemble and link the code.

Detailed Plan for Implementation

Reviewing Cloned Functions

Create an analysis pass that scans the program's symbol table to find functions that have been cloned multiple times. Maintain records of the original function and its clones.

Analyze & Comparison

For each cloned function, compare it to the original function from which it was cloned. Compare both the generated code and optimization metadata such as flags and attributes.

Pruning

If a cloned function lacks optimizations and its code is identical to the original, mark it for deletion. Remove these functions from the symbol table and eliminate their corresponding code.

Integration with Pass Manager

Incorporate this pass into the pass manager, specifying the order in which this pass should be executed.

Execution

Ensure that this pass is run during compilation when the appropriate flag is set, either through command-line options or an indicator that all functions have been marked for cloning.

Testing

Thoroughly test the newly created pass to verify that it accurately identifies and prunes cloned functions that have not been optimized.

Key Files in the GCC Codebase

To implement the above tasks, the following files in the GCC codebase are particularly important:

  • gcc/gcc.cc: The main function for GCC's execution.
  • gcc/pass_manager.h: Manages the optimization passes during compilation and retrieves input/output from each pass.
  • gcc/tree_pass.h: Ensures that passes are executed in the correct order.
  • gcc/passes.cc: Implements the coordination and execution of optimization passes during compilation.
  • gcc/passes.def: Contains information related to a pass, including its name, description, and category.
  • gcc/symtab.h and gcc/symtab.cc: Define and implement the symbol table that manages symbols, particularly useful for function symbols in our context.
  • ipa-fnsummary.cc: An IPA pass that collects information about functions. One significant product of this pass is the determination of function body size, which can indicate whether a function has been altered.

댓글

댓글 쓰기

이 블로그의 인기 게시물

Project stage-3 (testing & reflection)

Introduction In this blog, we will test and validate the prune-clones I made last time. In this process, I will explain how I modified the files passes.cc and passes.def, and why I made prune_clones.h separately because prune_clones.cc was not enough. passes.cc and passes.def modification process 1. Modify passes.cc The passes.cc file defines and implements several optimization passes for GCC, where you might want to add a prune-clones pass: Define and implement prune_clones related classes and functions. Clearly define what role this path plays in the overall optimization process of the compiler. For example, passes.cc needs to declare a prune_clones class and add code to register it with pass_manager. passes.cc 's main task is to initialize and manage each optimization pass. // passes.cc #include "gcc.h"     ... #include "prune_clones.h" // function generating prune_clones pass gimple_opt_pass *  make_pass_prune_clones (gcc::context *ctxt )   {     retur...
자세한 내용 보기

Understanding SIMD and SVE: Harnessing Parallelism for Enhanced Performance

 In this post, I would like to share the research about SIMD and SVE. In modern computing, achieving optimal performance often relies on parallel processing techniques like SIMD (Single Instruction, Multiple Data) and SVE (Scalable Vector Extensions). Introduction SIMD executes a single instruction across multiple data elements simultaneously, while SVE offers scalable vector lengths for dynamic adaptation to computational needs. Evolution and Foundations Originally designed to accelerate mathematical operations, SIMD and SVE leverage specialized instruction sets to minimize instruction overhead and maximize data throughput. Real-World Impact SIMD and SVE find applications in diverse fields such as image processing, data analytics, and machine learning, delivering substantial performance gains compared to traditional scalar processing. Challenges and Future Directions Despite their benefits, programming for SIMD and SVE requires expertise due to architectural complexities and compa...
자세한 내용 보기

Lab3 - AArch64

Instruction In this lab, I explored assembly language programming on both x86_64 and Aarch64 platforms. The objective was to understand the differences in assembly code generation between these architectures and to implement a simple loop in assembly for both platforms. Connect AArch64 Server. ssh  username @aarch64-001.spo600.cdot.systems // replace username Unpack example code. once you connect to the server, unpack the example code with below command. tar -xzvf spo600-assembler-lab-examples.tgz Tasks Task 1: Reviewing Assembly Language Programs We used objdump -d to disassemble the compiled binaries and compared the output to the original source code. This helped us understand how the source code translates into machine instructions for both x86_64 and Aarch64 architectures. Disassemble the object Code: objdump -d hello > hello_aarch64_disassembly.txt Review the main section. 00000000004005d8 <main>:   4005d8: a9bf7bfd stp x29, x30, [sp, #-16]!   4005dc...
자세한 내용 보기