AArch64/x86_64 quiz & Lab 4 Info/Update

-
This post is going to serve as an info dump for the previous few weeks in class. I've had a pair of WIP posts for the AArch64/x86_64 quiz and Lab 4 sitting in my drafts, so i've decided to merge them.

The AArch64/x86_64 quiz went very well. Prior to the quiz, I met with some of my peers for a study session regarding the previous week's material. While the x86_64 architecture is significantly more confusing than the AArch64 architecture, both architectures have similar functionality i.e. accessing registers in 8, 16, 32, 64 bits, safe registers to avoid trampling, and specifying which register to store results. Outside of the architecture material, we also spent some time reviewing bit-flipping with XOR(EOR). Even though it was not on the quiz, I greatly enjoyed this topic. Working with logic gates was my gateway to programming, and using the exclusive-or gate to flip bits was an interesting miniature logic puzzle. I'm hoping to have XOR/EOR appear on a quiz later in the semester, perhaps as a bonus question.

Regarding Lab 4, my group has decided to pursue options 1 and 2. Option 1 being the two-digit addition calculator (0-99) and option 2 being the packaging label, requiring the user to input characters, the program to store those characters, and then output those characters to the screen. At the beginning of class, we were immediately stumped by the two-digit calculator, since we were just introduced to the character display the previous week. By the end of the class, we had ended up using some sample code provided on the wiki to output the instructions for option 2 to the character display. I may consider attempting to change one of our options to option 4, after speaking with some of my peers outside my group and seeing their success with that option. Option 4 works with code we have used before (filling the screen with a solid color) and has a significantly simpler character display portion. I will have to see what my group thinks.

Comments

Post a Comment

Popular posts from this blog

Project Part 3

-
Image
Alright, let's start off with the most relevant function: mainSimpleSort (50%, 28%) Right off the bat, there's a tiny bit of hoisting that was half-done but seems to have been forgotten. As you can see, lo + h - 1  is loop invariant. lo + h   is actually calculated outside the loop at the very beginning of the function, but   it is used as a counter. I will create a separate variable called loHi_1  and hoist this calculation. This hoist can be repeated three times, since there are three separate instances of this condition in three separate loops. Another hoist we can do is move the v+d  calculation outside the loop. I've repeated the same procedure, storing this result into a variable called  v_d . At this point in my blog post, I would like to thank the person who created the bZip2 makefile. At the end of the makefile, there are six small sample files that are run through the bZip2 function suite (decompress, compress, recompress) and their results are automatically
Read more

Lab 5 x86_64 Update

-
This post will serve as a follow up post to the previous. The second part of lab 5 was fairly straightforward, and therefore this post will be fairly short since most of the content was covered in the previous post. The logic between the AArch64 version and x86_64 version has barely changed, the main notable difference is the use of the rax and rdx registers as the division quotient and remainder. This also removes the msub logic required on the AArch64 version, meaning that the code is very slightly smaller. Finally, instead of using the 48 decimal value to convert to ascii, I opted to use the hexadecimal 0x30. This produces the same result, but I decided on hex just to prove that I can do it. You can take a look at the x86_64 version  here .
Read more

Project Part 2

-
Image
For the second phase of the final project, we have been instructed to profile our project and identify our optimization targets. This went terribly, and then very well. Profiling an application requires a few steps: Build a version of the app with the -Og flag Run the test case Parse the gmon.out file Make sure the results make sense Building the application was as simple as modifying the makefile, which went off without a hitch. I assumed that running my full run-tests.sh script on a profile-compatible version of the application would be the best approach. This was wrong for two reasons, which quickly became three reasons. If you remember (I don't blame you if not), the run-tests.sh  test case takes approx. 13 minutes and 20 seconds to execute completely. bZip does not spend an equal amount of time on each file, these 13 minutes are mostly consumed by the three focus-tests  that I defined in my previous post. Compiling with the -Og flag reduced optimization, which contin
Read more