Project stage 2 Implementation

In this project, we aimed to implement and test AFMV capability in the GCC for AArch64 systems. AFMV allows the compiler to automatically create multiple versions of a function optimized for different processor features, thereby enhancing performance without requiring manual intervention from the developer. To implement and test the AFMV capability, we created a series of test cases that define functions with the target_clones attribute.

link to github: https://github.com/zijunlii/gcc/tree/master/gcc/testsuite/g%2B%2B.target/aarch64/afmv

Test cases:

1. Test to verify that multiple versions of a simple function foo are created and executed correctly. 

#include <stdio.h>

__attribute__((target_clones("default", "sse4.2", "avx2")))
void foo() {
    printf("Function foo\n");
}

int main() {
    foo();
    return 0;
}

2. Test to verify AFMV functionality with different optimization levels, ensuring that the function bar
is optimized and executed correctly.

#include <stdio.h>

__attribute__((target_clones("default", "sse4.2", "avx2")))
void bar() {
    printf("Function bar\n");
}

int main() {
    bar();
    return 0;
}

3. Test to verify that AFMV can be applied to inline functions. The baz function should be multiple
versions created and executed correctly.

#include <stdio.h>

__attribute__((target_clones("default", "sse4.2", "avx2")))
inline void baz() {
    printf("Function baz\n");
}

int main() {
    baz();
    return 0;
}

along with the test file:
# Load the DejaGnu framework load_lib gcc-dg.exp # Set the source directory set srcdir [file dirname [info script]] # Define the test dg-init set testname "afmv_test_1" set srcfile "${srcdir}/afmv_test_1.c" dg-runtest $srcfile "-O2 -fdump-tree-all" "" dg-finish

An Makefile is also setup to run the above tests using DejaGnu:
dg-runtest $(srcdir)/gcc/testsuite/g++.target/aarch64/afmv/*.exp

This project was an excellent opportunity to dive deep into the GCC internals and understand how
AFMV can significantly optimize performance for various architectures. Learning to use DejaGnu for
automated testing was beneficial. It is a powerful tool for running test suites in a consistent and
repeatable manner.
The ability of GCC to automatically generate optimized versions of functions based on different
instruction sets is fascinating. It allows developers to write code without worrying about low-level
optimizations for different hardware. Building GCC from source and configuring it correctly was
challenging. Ensuring all dependencies were met and the build environment was correctly set up
required careful attention.
There are still many advanced features of GCC that I need to explore further. Gaining proficiency in
these areas will require more hands-on experience and study.

Comments

Post a Comment

Popular posts from this blog

Project stage 3 Integrate, Tidy, & Wrap

 The project code's location in class git repository should be under  https://github.com/Seneca-CDOT/gcc/tree/2024-S-tests/gcc/testsuite/g%2B%2B.target/aarch64  with folder name afmv, but its still waiting for review required approve.   It is located in my branch waiting for the merge:  https://github.com/zijunlii/gcc/tree/master/gcc/testsuite/g%2B%2B.target/aarch64/afmv The directory structure is as follows: gcc/testsuite/g++.target/aarch64/  └── afmv/         ├── afmv_test_1.c         ├── afmv_test_1. exp          ├── afmv_test_2.c         ├── afmv_test_2. exp          ├── afmv_test_3.c         ├── afmv_test_3. exp          └── Makefile The AFMV capability correctly creates and executes multiple versions of functions. Only basic functionality is verified. More complex functions ...
Read more

Project stage 1 GCC build

This is the project stage 1, we will become familiar with the GCC build process on AArch86 and x86 platforms.  1. Clone the GCC repository from the official source git clone git://gcc.gnu.org/git/gcc.git cd gcc For AArch86 2. Creating build directory and configure GCC for AArch64 mkdir build-aarch64 cd build-aarch64 ../configure --target=aarch64-linux-gnu --prefix=$HOME/gcc-aarch64 --disable-multilib 3. Starting the build process and install GCC  make -j$(nproc) make install For x86 2. Creating build directory and configure GCC for x86 mkdir build-x86 cd build-x86 ../configure --prefix=$HOME/gcc-x86 --disable-multilib 3. Starting the build process and install GCC make -j$(nproc) make install While working on this project I leanred the build process and the necessary configurations for different architectures. The challenges was dealing with build dependenicies and managing long build times.
Read more

lab 1 mob programming

In this lab our focus was on the 6502 Emulator, a tool that simulates the classic 6502 microprocessor. The task involved filling a bitmapped display with different colors and optimizing the performance of the code. This blog post will outline our experiments, performance calculations, code modifications, and personal reflections on the process. Initial Code:  lda #$00    ; set a pointer in memory location $40 to point to $0200 sta $40     ; ... low byte ($00) goes in address $40 lda #$02     sta $41     ; ... high byte ($02) goes into address $41 lda #$07    ; colour number ldy #$00    ; set index to 0 loop:   sta ($40),y  ; set pixel colour at the address (pointer)+Y     iny     ; increment index     bne loop    ; continue until done the page (256 pixels)     inc $41     ; increment the page     ldx $41  ...
Read more