memset test psp

/*                             Makefile                              */


TARGET = memset_test
OBJS = main.o mips_memset.o

INCDIR =
CFLAGS = -G0 -Wall
CXXFLAGS = $(CFLAGS) -fno-exceptions -fno-rtti
ASFLAGS = $(CFLAGS)

LIBDIR =
LDFLAGS =
LIBS= -lpsprtc

EXTRA_TARGETS = EBOOT.PBP
PSP_EBOOT_TITLE = memset test

PSPSDK=$(shell psp-config --pspsdk-path)
include $(PSPSDK)/lib/build.mak


/*                          mips_memset.S                        */

#made by xerpi

.text
.global mips_memset

mips_memset:
    move $t0, $a0   #backup ptr
    move $t1, $a1   #c8  - $t1
    move $t2, $a1   #c16 - $t2
    sll $t2, $t2, 8
    or $t2, $t2, $a1
    move $t3, $t2   #c32 - $t3
    sll $t3, $t3, 16
    or $t3, $t3, $t2
_loop_memset:
    beqz $a2, _e_memset #if(size==0) return
    bge $a2, 4, _4_memset
    bge $a2, 2, _2_memset
    _1_memset:
        sb $t1, ($a0)
        addi $a1, $a0, 1
        addi $a2, $a2, -1
        j _loop_memset
    _2_memset:
        sh $t2, ($a0)
        addi $a0, $a0, 2
        addi $a2, $a2, -2
        j _loop_memset
    _4_memset:
        sw $t3, ($a0)
        addi $a0, $a0, 4
        addi $a2, $a2, -4
        j _loop_memset

_e_memset:
    move $v0, $t0   #return ptr
    jr $ra


/*                                               main.c                             */

//made by xerpi

#include <stdio.h>
#include <string.h>
#include <pspkernel.h>
#include <pspdebug.h>
#include <pspdisplay.h>
#include <psprtc.h>

#define ARRAY_SIZE 50000
#define LOOPS 5000

PSP_MODULE_INFO("memset_test", PSP_MODULE_USER, 0, 1);
PSP_MAIN_THREAD_ATTR(PSP_THREAD_ATTR_USER);

#define printf pspDebugScreenPrintf

typedef unsigned char  byte;

int run = 1;
int exit_callback(int arg1, int arg2, void *common);
int CallbackThread(SceSize args, void *argp);
int SetupCallbacks(void);


extern void *mips_memset(void *ptr, int c, size_t size);
void *memset1(void *ptr, int c, size_t size);
void *memset2(void *ptr, int c, size_t size);
void *memset3(void *ptr, int c, size_t size);

char array[ARRAY_SIZE];

int main()
{
    pspDebugScreenInit();
    SetupCallbacks();

    u64 before_tick, after_tick;
    u32 res = sceRtcGetTickResolution();
    double time1, time2, time3, timeMips;
    int i;
    printf("memset testing\n");
    sceRtcGetCurrentTick(&before_tick);
        for(i = 0; i < LOOPS; i++)
            memset1(array, 'a', ARRAY_SIZE);
    sceRtcGetCurrentTick(&after_tick);
    time1 = (after_tick-before_tick)/(double)res;
    printf("memset1 took: %f s\n", time1);

    sceRtcGetCurrentTick(&before_tick);
        for(i = 0; i < LOOPS; i++)
            memset2(array, 'a', ARRAY_SIZE);
    sceRtcGetCurrentTick(&after_tick);
    time2 = (after_tick-before_tick)/(double)res;
    printf("memset2 took: %f s\n", time2);

    sceRtcGetCurrentTick(&before_tick);
        for(i = 0; i < LOOPS; i++)
            memset3(array, 'a', ARRAY_SIZE);
    sceRtcGetCurrentTick(&after_tick);
    time3 = (after_tick-before_tick)/(double)res;
    printf("memset3 took: %f s\n", time3);

    sceRtcGetCurrentTick(&before_tick);
        for(i = 0; i < LOOPS; i++)
            mips_memset(array, 'a', ARRAY_SIZE);
    sceRtcGetCurrentTick(&after_tick);
    timeMips = (after_tick-before_tick)/(double)res;
    printf("mips   took: %f s\n\n", timeMips);


    printf("memset1 is x%f %s than memset2\n",
        (time1>time2?(time1/(double)time2):(time2/(double)time1)),
        (time1<time2?"faster":"slower"));
    printf("memset1 is x%f %s than memset3\n",
        (time1>time3?(time1/(double)time3):(time3/(double)time1)),
        (time1<time3?"faster":"slower"));
    printf("memset1 is x%f %s than mips_memset\n\n",
        (time1>timeMips?(time1/(double)timeMips):(timeMips/(double)time1)),
        (time1<timeMips?"faster":"slower"));

    printf("memset2 is x%f %s than memset1\n",
        (time2>time1?(time2/(double)time1):(time1/(double)time2)),
        (time2<time1?"faster":"slower"));
    printf("memset2 is x%f %s than memset3\n",
        (time2>time3?(time2/(double)time3):(time3/(double)time2)),
        (time2<time3?"faster":"slower"));
    printf("memset2 is x%f %s than mips_memset\n\n",
        (time2>timeMips?(time2/(double)timeMips):(timeMips/(double)time2)),
        (time2<timeMips?"faster":"slower"));

    printf("memset3 is x%f %s than memset1\n",
        (time3>time1?(time3/(double)time1):(time1/(double)time3)),
        (time3<time1?"faster":"slower"));
    printf("memset3 is x%f %s than memset1\n",
        (time3>time2?(time3/(double)time2):(time2/(double)time3)),
        (time3<time2?"faster":"slower"));
    printf("memset3 is x%f %s than mips_memset\n\n",
        (time3>timeMips?(time3/(double)timeMips):(timeMips/(double)time3)),
        (time3<timeMips?"faster":"slower"));

    printf("mips_memset is x%f %s than memset1\n",
        (timeMips>time1?(timeMips/(double)time1):(time1/(double)timeMips)),
        (timeMips<time1?"faster":"slower"));
    printf("mips_memset is x%f %s than memset2\n",
        (timeMips>time2?(timeMips/(double)time2):(time2/(double)timeMips)),
        (timeMips<time2?"faster":"slower"));
    printf("mips_memset is x%f %s than memset3\n\n",
        (timeMips>time3?(timeMips/(double)time3):(time3/(double)timeMips)),
        (timeMips<time3?"faster":"slower"));

    while(run) {
        sceKernelDelayThread(100 * 1000);
    }

    sceKernelExitGame();
    return 0;
}



void * memset1(void *ptr, int c, size_t size)
{
    byte *p = ptr;
    int c32 = c | (c<<8) | (c<<16) | (c<<24);
    byte *cp = (byte *)&c32;
    while(size) {
        if(size >= 4) {
            *((u32*)p) = *((u32*)cp);
            size -= 4; p += 4;
        } else if(size >= 2) {
            *((u16*)p) = *((u16*)cp);
            size -= 2; p += 2;
        } else {
            *p++ = *cp;
            --size;
        }
    }
    return ptr;
}

void * memset2(void *ptr, int c, size_t size)
{
    byte *p = ptr;
    byte c8 = (byte)c;
    u16 c16 = c8  | (c8<<8);
    u32 c32 = c16 | (c16<<16);
    while(size) {
        if(size >= 4) {
            *((u32*)p) = c32;
            size -= 4; p += 4;
        } else if(size >= 2) {
            *((u16*)p) = c16;
            size -= 2; p += 2;
        } else {
            *p++ = c8;
            --size;
        }
    }
    return ptr;
}

void * memset3(void *ptr, int c, size_t size)
{
    byte *p1 = ptr;
    byte *p2 = ptr + size;
    while(p1 != p2) {
        *p1 = c;
        p1++;
    }
    return ptr;
}


/* Exit callback */
int exit_callback(int arg1, int arg2, void *common)
{
    run = 0;
    return 0;
}

/* Callback thread */
int CallbackThread(SceSize args, void *argp)
{
    int cbid;

    cbid = sceKernelCreateCallback("Exit Callback", exit_callback, NULL);
    sceKernelRegisterExitCallback(cbid);
    sceKernelSleepThreadCB();

    return 0;
}

/* Sets up the callback thread and returns its thread id */
int SetupCallbacks(void)
{
    int thid = 0;

    thid = sceKernelCreateThread("update_thread", CallbackThread, 0x11, 0xFA0, 0, 0);
    if(thid >= 0) {
        sceKernelStartThread(thid, 0, 0);
    }

    return thid;
}