Bump,

so this writes 1000 times a 320*240*2 bytes buffer in RAM to another similar buffer in RAM. Start timing when the screen goes black, one second after you ran the program.

http://www.mirari.fr/xKZq

Well yeah, at this point CPU speed isn't important because it's huge compared to AHB speed (only when it comes to writing memory and doing only that of course).

So I came up with this, which actually seems to give 167 FPS (I guess this is the maximum the color Nspire's LCD can give) at any frequency on a color calc ; giving a mere 6 seconds at 132 MHz as well as 262 MHz, vs 12.58 seconds at 132 MHz and a bit more than 6 seconds at 262 MHz previously (all are aeTIos's tests).

Only problem, it crashes on exit (that is, after 6 seconds), and I have no idea why.

unsigned short *BUFF_BASE_ADDRESS;
void *SCREEN_BACKUP;

void initBuffering()
{
   void *temp;
   temp = malloc(BUFF_BYTES_SIZE);
   if(!temp)
      exit(0);
   BUFF_BASE_ADDRESS = (unsigned short*)malloc(BUFF_BYTES_SIZE);
   if(!BUFF_BASE_ADDRESS)
   {
      free(temp);
      exit(0);
   }
   
   SCREEN_BACKUP = *(void**)0xC0000010;
   
   // Handle monochrome screens-specific shit
   if(is_classic)
      *(int32_t*)0xC000001C = (*(int32_t*)0xC000001C & ~0x0e) | 0x08;
   
   *(void**)0xC0000010 = temp;
}

void updateScreen()
{
   // Screen-access delays make this the fastest method apparently
   memcpy(*(void**)0xC0000010, BUFF_BASE_ADDRESS, BUFF_BYTES_SIZE);
}

void deinitBuffering()
{
   void *temp = *(void**)0xC0000010;
   // Handle monochrome screens-specific shit again
   if(is_classic)
      *(int32_t*)0xC000001C = (*(int32_t*)0xC000001C & ~0x0e) | 0x04;
   *(void**)0xC0000010 = SCREEN_BACKUP;
   free(temp);
   free(BUFF_BASE_ADDRESS);
}

int main(void)
{
   int i;
   
   initBuffering();
   clearBufferB();
   
   for(i = 0; i < 1000; i++)
   {
      memcpy(*(void**)0xC0000010, BUFF_BASE_ADDRESS, BUFF_BYTES_SIZE);
   }
   
   deinitBuffering();
   return 0;
}

Binaries attached, but it does crash your calc.

EDIT : did some tests with the current version of nKaruga (source accessible from github). The game runs at 95 FPS on my 120 MHz grayscale TI-Nspire CAS with Ndless 3.1 r914, calculated by seeing that you take 3.4 seconds to cross 320 pixels by moving one pixel by one pixel.

DJ : what you don't understand is that the program is already 6 times faster (according to latest aeTIos's tests) on GS calcs than on color calcs at merely the same frequency (120 MHz for GS vs 132 MHz for color).

Vogtinator : I was wondering that. Will test when I can (probably in some minutes).

Well, I don't know but I'll try that, and if that's it I'll call it another thing that we should know.


EDIT : wait a minute you misunderstood. The program is 2.5 times faster on GS calcs than on color calcs, not the other way around.

I'm indeed copying to *(void**)0xC0000010. So would allocating a buffer in RAM and using it even on color calcs fix the speed issue ? (hopeless try)

Alright so that's what to test. It's simply memcpy-ing a buffer to the screen 1000 times.

So you mean copying a buffer 500 times to the screen, and comparing that with copying 500 times a buffer in another buffer ?