SPO600 Project Stage 2

 Let’s start implementing jpeg-compressor (https://github.com/richgel999/jpeg-compressor).

 

In Stage 1, I mentioned that I would choose to implement jpeg-compressor using intrinsics. When looking at the two main files (jpge.cpp and jpgd.cpp). It is possible that SVE intrinsics can be applied to many functions because many of those have a common pattern of using arrays as input arguments, for loop, and while loop, which is very similar to scale volume functions in Lab 6. For example:



However, it is not time efficient to do converting functions from the regular loop to the SVE2 loop. It may take days or even years to finish implementation, debugging, and testing for beginners. Thus, auto-vectorization should be a better solution for big projects.

Jpeg-compressor is already optimized with SSE, which is an Intel optimization equivalent to SVE2, which is ARM. So, I think SSE should be disabled to avoid any platform conflict.

Looking at jpeg-compressor documentation on GitHub, the author says to set JPGD_USE_SSE2 to 0 to completely disable the usage of jpgd_idct.h. By searching the keyword “SSE” in Visual Studio Code, I found the configuration is in jpgd.cpp:



Then I set all (1) to (0). After disabling SSE as instructed, I build the program on Visual Studio and run it with an image:



That is on the X86_64 platform. Let’s see what happens when I upload the source code to an ARM machine (israel.cdot.systems). To start with, there is a CmakeLists.txt that helps us to build programs that have a complex structure. After building the source, our program is in the bin folder:


Then I test it with an image:



A successful running means there is no platform conflict. We can start auto-vectorizing the program from this point.

CMake makes everything easier. Take a look at CmakeLists.txt, and I found the command Cmake uses to build the program:



We can put flags “ -O3 -march=armv8-a+sve2” to instruct Cmake to build the project with auto-vectorization. After that, we will have a new jpge in the bin folder. Let’s run it:


It is the same error I encountered in Lab 6 when running a SVE2 optimized program on a platform that does not support the architecture. We need qemu-aarch64 to simulate the new architecture on Armv8 (israel.cdot.systems):



Here we go! The program runs successfully as I expected. In Stage 3, I will do an analysis of how the SVE2 takes effect on the program’s performance compared to the original solution.

Comments

Post a Comment

Popular posts from this blog

SPO600 Lab 2

Image
 Lab 2, where I have a given 6502 assembly code: lda #$00 ; set a pointer at $40 to point to $0200 sta $40 lda #$02 sta $41 lda #$07 ; colour number ldy #$00 ; set index to 0 loop: sta ($40),y ; set pixel at the address (pointer)+Y iny ; increment index bne loop ; continue until done the page inc $41 ; increment the page ldx $41 ; get the current page number cpx #$06 ; compare with 6 bne loop ; continue until done all pages My job is to play around with the code, calculate the performance of the given code, and try to optimize the code to have a better performance. First, starting to run the code on  http://6502.cdot.systems/  - a website that stimulates a 6502 emulator, I got a result of a yellow screen, which consists of 4 pages.  Let's look at the performance by calculating the number of cycles and cycle count. We will do this on Microsoft Excel to have a clear perspective. After doing some calculations on Excel, I got a result of 0.012 seconds...
Read more

SPO600 Lab 1

Image
 In the first lab of SPO600 course, my work is to explore two open-source software projects. As an Android user, who like to root my phone (I have a Pixel 6, and I saw you are having one too), I am using several applications that take advantage of root permissions. One of those apps is Adaway – an application that blocks ads system-wide. Source: https://adaway.org/ Looking at its source code on Github, I found the software is distributed under GNU GENERAL PUBLIC LICENSE - Version 3. In short, PGLv3 is a copyleft license, which requires copies or modifications of the source must also be released under the same license. Everyone can make contributions to the project by reporting bugs, suggesting enhancements, or translating to languages. For example, look at the most commented pull request – pull request number 784: Source: https://github.com/AdAway/AdAway/pull Source: https://github.com/AdAway/AdAway/pull/784 There were 21 commits and months needed in total to resolve the i...
Read more

SPO600 Project Stage 3

Image
 We finally reached the final stage of the project!   In the last stage, I will perform a comparison of how jpeg-compressor’s performance differs in different architecture platforms. There are SSE (Intel) version, SVE2 (ARM) version, and the original source without any optimizations. The mutual system the three programs will run on is an X86_64 machine (portugal.cdot.systems)   Let’s start off with the original one. First, we need to disable SSE in jpgd.cpp by setting JPGD_USE_SSE2 to 0 because it is enabled by default. Then we config Cmake to build our program. After running the program with an image. Here is the result: Next, SSE is enabled: We can clearly see the decompress time is hugely different between 2 versions: 908 ms in non-optimized vs 830 ms in SSE optimized. Note that SSE optimization is only in decompress function, and there is no optimization in the encoder file (jpge.cpp). SSE has shown us a jump in performance compared to the original cod...
Read more