How fast can a 6502 transfer memory

We can count jiffies on a Commodore to give us an idea of how fast this copy takes. Sure there's a slight overhead in the setup, but I think it's marginal enough that we can ignore it for our purposes.

Okay, that's pretty fast. Since that's 16k transferred, it works out to about 54.6 k per second.

Let's do a bunch of them and see what it comes out as.

We can call this pretty quickly 255 times and do the same math.

         lda #$00
         sta $a2
         sta $a1
         sta $a0

         ldx #255
         stx tmpx
lp
         jsr copyr
         dec tmpx
         ldx tmpx
         bne lp

         lda $a0
         jsr printbyte
         lda $a1
         jsr printbyte
         lda $a2
         jsr printbyte

So at $1128 jiffies(4392) and 255 transfers of 16,384, we're seeing around 57K per second.

Grain of salt, yes, but real-world enough.

Yeah, there's some overhead in the setup and running of the transfer. We could probably make this loop a few percentage points faster. Maybe if we make it tight, we could get 15% better out of it. But the point was real-world uses, and this is a pretty good example of a tight but flexible loop to transfer. Let's not get TOO pedantic here.

What's important to note is that transferring memory takes several clock cycles per byte. If we count them, it's about a dozen cycles, which tracks roughly with our results.

The KIM-1 is arguably the most simple and pure 6502 platform, so it will be interesting to try and do memory transfers on it.

It IS clocked a little slower than a Commodore 64, so I expect it to transfer slightly slower. But it doesn't have to compete for access time as VIC-II "badlines," so maybe it'll be pretty close.

Let's find out.

I don't own a "real" KIM-1, but I do own what is considered the best two clones. Today, let's use the Corsham KIM-1 Clone. I'm going to call it a KIM-1 from here forward, mostly because I enjoy getting angry letters about this. You've been warned.

Measuring time

The KIM-1 doesn't have a jiffy clock like the other Commodore machines.

The "Application ports" are easily accessible, so if we set a pin high when we start and set it low again when we finish, we can easily use an oscilloscope to measure the time.

With the expansion bus hooked up on my Corsham KIM board, the Application port A direction is set to output with.

	lda #$ff
	sta $1603

And then, we can toggle pin PA0 by setting it high or low. We'll use $FF and $0 for that for simplicity.

Side note: this is a non-standard location for this port, your KIM-1 or clone probably has it in the $1700 range. Check your documentation.

16k in 262 Milliseconds is around 62.5k per second. Slightly faster than a Commodore 64 even though an NTSC Commodore 64 runs at a slightly higher clock speed (1.023MHz) than our KIM here.

Let's do this 255 times in a tight loop, ignoring the overhead of things like JSR, which takes a few clock cycles each loop. We're going for a ballpark here.

So our loop code then looks something like

         lda #$ff
         sta $1603
         sta $1601 ;technically setting all pins high here
         		   ;could just use #$01


         ldx #255 
         stx tmpx
lp
         jsr copyr
         dec tmpx
         ldx tmpx
         bne lp
         
         lda #$00
         sta $1601


         brk

Then if we probe it with an oscilloscope, we can measure the 1+ minute square wave.

So 255 transfers of 16,384 bytes take 67 seconds. Or about 62k per second.

I happen to have a Cerberus 2080 board. As far as I know, mine is the only green one in the world.

This has dual-ported RAM and can clock the brand new (yes, they still make them) WDC 65c02S processor at a blazing 8Mhz. Let's see what kind of results we get from it.

Again, we have a no jiffy clock problem, so I'm going to skip right to the 4MB transfer, time it over the video capture, and have it show "done" on the screen when it finishes. Unlike the KIM-1, I don't have a straightforward way to time it with an I/O pin. It'll give us a good enough idea of where we are.

16,384 bytes 255 times took 6.29 seconds, so maxed out, a modern 6502 at 8MHz can do about 664.2k per second. Not too bad!

Sure, this was not a comprehensive set of tests. But in the real world, a 6502 can copy the entire contents of a Commodore 64's memory from one place to another in about a second. Pretty respectable, and it was pretty fast for the time.

Unrolling

You could certainly use self modifying code and unroll this copy routine to get better performance at the price of flexibility and arguably understanding for the average casual 6502 assembly coder.

Again, this was not a "how fast can we absolutely make it" but an everyday use examination.

This copy can handle from one to 2¹⁶ bytes and every number in between. And as my favorite Youtuber is fond of saying "I know I know, but I didn't do that. Let the angry emails begin."

REU

If you have an REU on your Commodore, that can theoretically swap out the memory at a byte per clock cycle. A true 1MB per second. I heard that games like Sam's Journey make use of this feature quite a bit.

I'd love to hear your thoughts on how you'd approach this, pedantic, nit-picky, and otherwise. Bonus points if you demonstrate methods that show dramatically better results.

Whatever you do, be sure to have fun and don't take marketing slides too seriously.