Lab 2 - 6502 Assembly Language Lab

Hello, my name is Pat and this is my Lab 2 write-up for my Software Portability and Optimization course at Seneca. Guidelines for this lab can be found here. Short version of it is, I was given some 6502 assembly language code (included below) and given some tasks to do with that code. The code given is very simple and fills the display with the colour yellow by looping through all of the pixels on the display.

	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

Part 1 - Calculating Performance

First step was to calculate how long it takes for the code to execute assuming a 1 MHz clock speed. I calculated it would take 11323 μs. The table below shows my work for this calculation. 

    cycles cycle count alt cycles alt count total  
               
  lda #$00 2 1     2  
  sta $40 3 1     3  
  lda #$02 2 1     2  
  sta $41 3 1     3  
               
  lda #$07 2 1     2  
               
loop: sta ($40),y 6 1024     6144  
               
  iny 2 1024     2048  
  bne loop 3 1020 2 4 3068  
               
  inc $41 5 4     20  
  ldx $41 3 4     12  
  cpx #$06 2 4     8  
  bne loop 3 3 2 1 11  
               
          Total: 11323 cycles
          CPU speed: 1 MHz
          uS per clock: 1  
          Time:  11323 uS

The next step was to find optimizations in this code, and then calculate the runtime, however I was unfortunately unable to find any optimizations.

Part 2 - Modifying the code

The first step of this part is to modify the code to fill the display with light blue instead of yellow. To do this I change line 6 from lda #$07 to lda #$0e. Full code is displayed below.

	lda #$00	; set a pointer at $40 to point to $0200
	sta $40
	lda #$02
	sta $41

	lda #$0e	; 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

Second step was to make each page of the display a different. To do this, I added 1 to the colour value every time the page changed. This is a somewhat simple approach, but it's drawbacks are that the colours display must all be consecutive according to the assembly languages listing. Some variance can be achieved by changing how much the value increments by (e.g. by 2 or 3) but not much. Code displayed below.

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
	adc #$01

	cpx #$06	; compare with 6
	bne loop	; continue until done all pages

Part 3 - Experience with the lab

I enjoyed this lab. Figuring out how to make every page a different colour ended up being somewhat challenging, and I felt I ended up using a sort of "lazy" fix, as there is no option for customizing the colours on each page. Definitely could have tried using variables or something but I kept it simple. What I learned in the process was there is no equivalent increment command for a, like there is with x and y (inc and iny). The work around was simple but still that was interesting. Otherwise, to address the obvious elephant in the room, (or at least obvious to me and my professor who will be reading this) I am very behind in this course. I have skipped Lab 1 because it involves research and I am bad at research. I wish I could have spent more time on this lab so I could do the optional sections but that's not realistic, and even then I wasn't able to find any optimizations in the code for Part 1, and that wasn't optional. I spent quite a bit of time trying to find a way to optimize it, but in the end I gave up because I really do need to start moving on in this course. 





Comments

Post a Comment

Popular posts from this blog

SPO600 - Final Thoughts

Hey here's a last minute blog post to try and bump up the number of blog posts for April. It's really just a sort of a farewell to this course and some of my thoughts on it.  Overall this course was really neat. I had never worked with assembly language code before and it was certainly something. Honestly it feels really restrictive and generally difficult to work with but it was definitely an enjoyable experience. Though I can't say it's something I want to continue in. But learning more about the compiler and it's optimizations is definitely something I'll take away from this course. I never had the compiler explained to me in any depth before, hell I didn't even realize -Wall meant turning on all warnings. I just always read it very literally as wall and gave it no thought. It was always just something I was told to type to run my program but no one had ever offered any deeper explanation into it (nor did I even think to ask) so it was a cool thing to lea
Read more

SPO600 Project - Stage 1: Selection

Hello again, this post is my summary for Stage 1 of my SPO600 project. I'll be explaining the project in this post but the instructions for this project can be found here . The premise of this project is to add Scalable Vector Extension version two (SVE2) optimizations to an existing open source project. An introduction to SVE2 can be found here . To keep it incredibly short, SVE2 is a new, minor refinement over SVE, which itself is an improvement of SIMD (Single Instruction Multiple Data) optimizations. These are optimizations that improve code that process multitudes of data through a single instruction. Sorry I know this probably isn't the best explanation but that's the best I can do to give new readers some context. So with that let's dive into my project. Step 1 - Candidate Identification The first step is to identify some candidates to optimize. As a starting point to look for these candidates, I based my search around video games and the libraries these games us
Read more

Lab 4 - 64-bit Assembly Language Lab - Part 4

 Welcome to part 3 of lab 4. This lab goes over some basics of 64-bit assembly languages, specifically in the AArch64 and x86_64 platforms. This specific part will be going over the second half of the lab in the AArch64 system. Links for the other parts are listed here: Part 1 - First half in AArch64 Part 2 - First half in x86_64 Part 3 - Second half in AArch64 I'll be outlining the steps in detail as I go along but the full instructions for this lab can be found here . Okay we're in the homestretch. Just like part 3 we're making our loop print from 00-30. I learned my lesson from part 3 and pre-labelled my code, and I was already planning on trying to reduce the overall amount of registers I use but x86_64 seems to have less safe registers anyways so I was somewhat forced to. Major difference here is the div function. The div function in x86_64 calculates the remainder too so that was pretty convenient. It's a bit less intuitive, it takes one argument, a register, a
Read more