Exploring Assembly Language on the 6502: A Hands-On Lab Experience: Sep 14, 2024
Gleison D.
Full Stack Software Developer | .NET, C# & SQL Expert | Building Secure, Scalable Web Applications
Hello everyone!
Propelled by a course I am taking as part of my Computer Programming and Analysis program, I am starting this blog post series to document the work I will be doing during this semester. The course is called Software Portability and Optimization and writing blog about our work is an integral part of it.
This first post I would like to describe the results of the First Lab we had. In this lab, we saw the basic of 6502 Assembly Language. To run our program, we were given a web based emulator, which you can find here.
To start our journey, we were given the following piece of code. I will include the comment of what each line of code does in the assumption that not everyone here will be familiar with assembly language. That might not always be the case, and when not, you can find the 6502 Instruction Set here.
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 ; get the current page number
CPX #$06 ; compare with 6
BNE LOOP ; continue until done all pages
When we assemble and executed, our emulator's bitmapped display is filled with the yellow color, as you can see below. This code used 25 bytes of memory.
The key for this lab however, is not just to make our screen yellow. We will dissect that code and, assuming a CPU running at 1 MHz (Megahertz) clock speed, calculate it's execution time. Then we will proceed to calculate memory use and any pointers or variables.
Calculating Run Time
To calculate run time for our program, we will follow these steps:
We can see all these steps being performed in the screenshot below. If you wish to download a copy of the sheet with the formulas in it, you can do so by following this link.
We can conclude that our program will take 0.01328 seconds to run and fill the emulator's bitmapped display with any color we choose.
Code Improvement
With that calculation out of way, we were tasked to improve our program to run faster. We need to modify the code so to create a solution that could perform the same task of filling the display as fast as we could.
My approach to improving this solution was to analyse it and look for areas of improvement. To that end, I observed which operations were consuming the most cycle times, as they would be the ones with the higher impact in performance. Then, I tried to streamline these operations so they would take less cycle times to run.
Our loops ware the part of the code consuming the most cycles. The original code had a nested loop where the first loop filled in one quarter of the display with pixel colors, and then a second loop to check if that was the last display, if not, the first loop would be repeated this time filling the subsequent screen, until all 4 screens were filled. I then thought of streamlining this process and fill all 4 screens in the same loop, so it would need to run once.
Below is the solution I came up with: (if you need any clarification on the instructions, click here)
LDA #$00
STA $40
STA $30
STA $20
STA $10
LDA #$02
STA $41
LDA #$03
STA $31
LDA #$04
STA $21
LDA #$05
STA $11
LDA #$07
LDY #$00
LOOP: STA ($40),Y
STA ($30),Y
STA ($20),Y
STA ($10),Y
INY
BNE LOOP
With this code, I was able to fill in all 4 displays at the same time, as you can see below. This code used 41 bytes of memory.
Calculating Run Time For Improved Code
However, before we can claim that this code runs faster, we need to perform the same steps outlined above and calculate its runtime.
Below we can see the result: (table can be found here)
Results Comparison
Our first code runs at 0.11328 seconds, whereas the second at: 0.00744 seconds. We were able to reduce the time by 0.00388 seconds, that represents an improvement in performance of approximately 34.32%.
Modifying the Code
The next step in our lab is to do some code modifications to the code and see how it behaves. There were 3 suggested modifications to do on our code so we could experiment with different parameters and see how our program behaves with each of them. I will outline each modification and the result of it.
1. Change the code to fill the display with light blue instead of yellow. (Tip: you can find the colour codes on the 6502 Emulator page).
This modification was the simplest. We just need to change the color code from yellow to blue.
Recommended by LinkedIn
LDA #$07 ; CHANGE THIS LINE OF CODE
LDA #$06 ; WITH THIS LINE
And this is the result:
2. Change the code to fill the display with a different colour on each page (each “page” will be one-quarter of the bitmapped display).
For this modification, I changed the accumulator by adding to it after each loop. So if each loop was filling one display, the following loop would have a different value for the color, filling the display with it.
My code looks like the following:
LDA #$00
STA $40
LDA #$02
STA $41
LDA #$07 ; LOADING THE DISPLAY WITH THE YELLOW COLOR
LDY #$00
LOOP: STA ($40),Y ; STORING THE ACCUMULATOR IN MEMORY
INY
BNE LOOP ; REPEAT UNTIL ENTIRE DISPLAY IS FILLED
ADC #$02 ; ADDING TO THE ACCUMULATOR WHICH WILL CHANGE THE COLOR
INC $41
LDX $41
CPX #$06
BNE LOOP ; REPEAT LOOP ABOVE UNTIL ALL DISPLAYS ARE FILLED
As result we have:
3. Make each pixel a random colour. (Hint: use the psudo-random number generator mentioned on the 6502 Emulator page).
For this modification, I changed the value of the value of the accumulator inside the first loop, hence, in each iteration of the loop, a different color would be loaded to the display. See the loop in the code block below. Only the loop was modified from the original code, so I will only add here the code for that part.
LOOP: STA ($40),Y
LDA $FE
INY
BNE LOOP
See in the gif below. The display will be filled 3 times, in each of the, each pixel will be filled with a random color.
Additional Experiments
For this article, I will complete one of the experiments in the lab instructions: Add this instruction after the loop: label and before the sta ($40),y instruction: tya. Then answer: What visual effect does this cause, and how many colours are on the screen? Why?
This is the result of that experiment:
We see a total of 16 colors filling the display. The display is 32 bits wide so each color will repeat once while filling the display.
If we go back to the colour codes on the 6502 Emulator page, we'll notice that the code for black, our first color, is $0. The line of code TYA that we added to our loop does just that, it transfers to the accumulator the current value of Y, which was defined immediately before the loop to 0. Inside the loop we will increment Y, therefore, in the next iteration, the Y value will be 1, this 1 will be again loaded in the accumulator, and then set to color the screen. $1 is the code for white, which is our second color. The loop goes on until $F, which is the code for light gray, our last color on the display. After the 15th run, our lower bit will be reset to 0, which also restarts our color to black.
Challenges
We were challenged with writing a program which draws lines around the edge of the display:
I wasn't able to finish the challenged with the time I had to dedicate to this assignment. I did the top and bottom lines but not the side ones. Below is the code I used for it.
LDA #$00 ; SET A POINTER IN MEMORY LOCATION $40 TO POINT TO $0200
STA $40 ; ... LOW BYTE ($00) GOES IN ADDRESS $40
STA $10
LDA #$02
STA $41 ; ... HIGH BYTE ($02) GOES INTO ADDRESS $41
LDA #$05
STA $11
LDA #$02 ;RED
LDY #$00 ; SET INDEX TO 0
RED_LOOP: STA ($40),Y ; SET PIXEL COLOUR AT THE ADDRESS (POINTER)+Y
INY ; INCREMENT INDEX
CPY #32
BNE RED_LOOP ; CONTINUE UNTIL DONE THE PAGE (256 PIXELS)
LDA #$04 ; PURPLE
LDY #$E0 ; SET INDEX TO 0
GREEN_LOOP: STA ($10),Y ; SET PIXEL COLOUR AT THE ADDRESS (POINTER)+Y
INY ; INCREMENT INDEX
BNE GREEN_LOOP ; CONTINUE UNTIL DONE THE PAGE (256 PIXELS)
We can see the result below.
I wanted to do something on the lines of, starting from the first display in the first pixel of the second line, add the pixel for the column color there, then adding 32 to my index, and do that until all lines of the first column of that page was filled, then do the same for following pages and to the other side of the scree. I might perform these challenges and post a new blog about it.
Conclusion
This lab was a valuable experience to better understand indexing, commands and how memory assignment works. Doing this made me have a much broader understanding of the core principles of the assembly language and how I can use it to manipulate each pixel of my display.
👏