From 844a332f8de4ab74ec1c739c2ab6f41e8d957d53 Mon Sep 17 00:00:00 2001
From: Yotam Barnoy
Date: Sun, 18 Jul 2010 06:59:25 +0000
Subject: PSP: forgot test files

svn-id: r50981
---
 backends/platform/psp/tests.cpp | 656 ++++++++++++++++++++++++++++++++++++++++
 backends/platform/psp/tests.h   |  26 ++
 2 files changed, 682 insertions(+)
 create mode 100644 backends/platform/psp/tests.cpp
 create mode 100644 backends/platform/psp/tests.h

diff --git a/backends/platform/psp/tests.cpp b/backends/platform/psp/tests.cpp
new file mode 100644
index 0000000000..25c07fd723
--- /dev/null
+++ b/backends/platform/psp/tests.cpp
@@ -0,0 +1,656 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * $URL: https://scummvm.svn.sourceforge.net/svnroot/scummvm/scummvm/trunk/backends/platform/psp/osys_psp.cpp $
+ * $Id: osys_psp.cpp 46126 2009-11-24 14:18:46Z fingolfin $
+ *
+ */
+
+#include "common/scummsys.h"
+#include <pspiofilemgr_fcntl.h>
+#include <pspiofilemgr_stat.h>
+#include <pspiofilemgr.h>
+#include <pspthreadman.h>
+#include <pspsdk.h>
+#include <psprtc.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <psputils.h>
+#include "backends/platform/psp/rtc.h"
+#include "backends/platform/psp/thread.h"
+#include "backends/platform/psp/memory.h"
+
+
+#define UNCACHED(x)		((byte *)(((uint32)(x)) | 0x40000000))	/* make an uncached access */
+#define CACHED(x)		((byte *)(((uint32)(x)) & 0xBFFFFFFF))	/* make an uncached access into a cached one */
+ 
+//#define __PSP_DEBUG_FUNCS__
+//#define __PSP_DEBUG_PRINT__
+ 
+// Results: (333Mhz/222Mhz)
+// Getting a tick: 1-2 us
+// Getting a time structure: 9/14us
+// ie. using a tick and just dividing by 1000 saves us time.
+  
+#include "backends/platform/psp/trace.h" 
+
+void test_ticks() {
+	uint32 ticksPerSecond = sceRtcGetTickResolution();
+	PSP_INFO_PRINT("ticksPerSecond[%d]\n", ticksPerSecond);
+
+	uint32 currentTicks1[2];
+	uint32 currentTicks2[2];
+	
+	sceRtcGetCurrentTick((u64 *)currentTicks1);
+	sceRtcGetCurrentTick((u64 *)currentTicks2);
+	PSP_INFO_PRINT("current tick[%x %x][%u %u]\n", currentTicks1[0], currentTicks1[1], currentTicks1[0], currentTicks1[1]);
+	PSP_INFO_PRINT("current tick[%x %x][%u %u]\n", currentTicks2[0], currentTicks2[1], currentTicks2[0], currentTicks2[1]);
+	
+	pspTime time;
+	sceRtcSetTick(&time, (u64 *)currentTicks2);
+	PSP_INFO_PRINT("current tick in time, year[%d] month[%d] day[%d] hour[%d] minutes[%d] seconds[%d] us[%d]\n", time.year, time.month, time.day, time.hour, time.minutes, time.seconds, time.microseconds);	
+	
+	pspTime time1;
+	pspTime time2;
+	sceRtcGetCurrentClockLocalTime(&time1);
+	sceRtcGetCurrentClockLocalTime(&time2);
+	PSP_INFO_PRINT("time1, year[%d] month[%d] day[%d] hour[%d] minutes[%d] seconds[%d] us[%d]\n", time1.year, time1.month, time1.day, time1.hour, time1.minutes, time1.seconds, time1.microseconds);
+	PSP_INFO_PRINT("time2, year[%d] month[%d] day[%d] hour[%d] minutes[%d] seconds[%d] us[%d]\n", time2.year, time2.month, time2.day, time2.hour, time2.minutes, time2.seconds, time2.microseconds);
+}
+
+void test_getMicros() {
+	uint32 time1, time2, time3, time4;
+	time1 = PspRtc::instance().getMicros();
+	time2 = PspRtc::instance().getMicros();
+	time3 = PspRtc::instance().getMicros();
+	time4 = PspRtc::instance().getMicros();
+	
+	PSP_INFO_PRINT("getMicros() times: %d, %d, %d\n", time4-time3, time3-time2, time2-time1);
+}
+
+void read_and_time(uint32 bytes, char *buffer, FILE *file) {
+	uint32 time1 = PspRtc::instance().getMicros();
+	// test minimal read
+	fread(buffer, bytes, 1, file);
+	uint32 time2 = PspRtc::instance().getMicros();
+	
+	PSP_INFO_PRINT("Reading %d byte takes %dus\n", bytes, time2-time1);	
+}
+
+/*
+	333MHz/222MHz
+	Reading 1 byte takes 2590us / 3167
+	Reading 10 byte takes 8us / 9
+	Reading 50 byte takes 8us / 11
+	Reading 100 byte takes 8us / 11
+	Reading 1000 byte takes 915us / 1131
+	Reading 1000 byte takes 911us
+	Reading 1000 byte takes 914us
+	Reading 1000 byte takes 943us
+	Reading 1000 byte takes 915us
+	Reading 1000 byte takes 923us
+	Reading 1000 byte takes 22us
+	Reading 1000 byte takes 916us 
+	Reading 1000 byte takes 913us / 1,120
+	Reading 1000 byte takes 909us / 1,122
+	Reading 2000 byte takes 1806us / 2,284
+	Reading 3000 byte takes 2697us / 3,374
+	Reading 4000 byte takes 3652us / 4,592
+	Reading 5000 byte takes 4551us / 5,544
+	Reading 6000 byte takes 5356us / 6,676
+	Reading 7000 byte takes 6800us / 8,358
+	Reading 8000 byte takes 6794us / 8,454
+	Reading 9000 byte takes 6782us / 8,563
+	Reading 10000 byte takes 8497us / 10,631
+	Reading 30000 byte takes 25995us / 32,473
+	Reading 50000 byte takes 42467us / 52,893
+	Reading 80000 byte takes 68457us / 85,291
+	Reading 100000 byte takes 85103us / 106,163
+	Reading 500000 byte takes 427337us / 531,679
+	Reading 1000000 byte takes 854831us / 1,063,107
+*/
+// Function to test the impact of MS reads
+// These tests can't be done from shell - the cache screws them up
+void test_ms_reads() {
+	FILE *file;
+	file = fopen("ms0:/psp/music/track1.mp3", "r");
+
+	char *buffer = (char *)malloc(2 * 1024 * 1024);
+	
+	read_and_time(1, buffer, file);
+	read_and_time(10, buffer, file);
+	read_and_time(50, buffer, file);
+	read_and_time(100, buffer, file);
+	for (int i = 0; i< 10; i++)
+		read_and_time(1000, buffer, file);
+	read_and_time(2000, buffer, file);
+	read_and_time(3000, buffer, file);
+	read_and_time(4000, buffer, file);
+	read_and_time(5000, buffer, file);
+	read_and_time(6000, buffer, file);
+	read_and_time(7000, buffer, file);
+	read_and_time(8000, buffer, file);
+	read_and_time(9000, buffer, file);	
+	read_and_time(10000, buffer, file);
+	read_and_time(30000, buffer, file);
+	read_and_time(50000, buffer, file);
+	read_and_time(80000, buffer, file);
+	read_and_time(100000, buffer, file);
+	read_and_time(500000, buffer, file);
+	read_and_time(1000000, buffer, file);	
+	
+	fclose(file);
+	free(buffer);	
+}
+ 
+void seek_and_time(int bytes, int origin, FILE *file) {
+	char buffer[1000];
+	
+	uint32 time1 = PspRtc::instance().getMicros();
+	// test minimal read
+	fseek(file, bytes, origin);
+	uint32 time2 = PspRtc::instance().getMicros();
+	
+	PSP_INFO_PRINT("Seeking %d byte from %d took %dus\n", bytes, origin, time2-time1);
+
+	time1 = PspRtc::instance().getMicros();
+	// test minimal read
+	fread(buffer, 1000, 1, file);
+	time2 = PspRtc::instance().getMicros();
+	
+	PSP_INFO_PRINT("Reading 1000 bytes took %dus\n", time2-time1);
+}
+
+/*
+333MHz
+Seeking 0 byte from 0 took 946us
+Reading 1000 bytes took 1781us
+Seeking 5 byte from 0 took 6us
+Reading 1000 bytes took 19us
+Seeking 1000 byte from 0 took 5us
+Reading 1000 bytes took 913us
+Seeking 100 byte from 0 took 955us
+Reading 1000 bytes took 906us
+Seeking 10000 byte from 0 took 963us
+Reading 1000 bytes took 905us
+Seeking -5 byte from 1 took 1022us
+Reading 1000 bytes took 949us
+Seeking -100 byte from 1 took 1040us
+Reading 1000 bytes took 907us
+Seeking 100 byte from 1 took 1044us
+Reading 1000 bytes took 930us
+Seeking 0 byte from 2 took 7211us
+Reading 1000 bytes took 80us
+Seeking 10000 byte from 2 took 3636us
+Reading 1000 bytes took 110us
+*/
+
+void test_seeks() {
+	FILE *file;
+	file = fopen("ms0:/psp/music/track1.mp3", "r");
+
+	seek_and_time(0, SEEK_SET, file);
+	seek_and_time(5, SEEK_SET, file);
+	seek_and_time(1000, SEEK_SET, file);
+	seek_and_time(100, SEEK_SET, file);
+	seek_and_time(10000, SEEK_SET, file);
+	seek_and_time(-5, SEEK_CUR, file);
+	seek_and_time(-100, SEEK_CUR, file);
+	seek_and_time(100, SEEK_CUR, file);
+	seek_and_time(0, SEEK_END, file);
+	seek_and_time(-10000, SEEK_END, file);
+
+	fclose(file);
+}
+
+// 222: 5-7us
+int testGetThreadId() {
+	uint32 time1 = PspRtc::instance().getMicros();
+	int threadId = sceKernelGetThreadId();
+	uint32 time2 = PspRtc::instance().getMicros();
+	
+	PSP_INFO_PRINT("Getting thread ID %d took %dus\n", threadId, time2-time1);
+	
+	return threadId;
+}
+
+// 222: 4-5us
+void testGetPriority() {
+	uint32 time1 = PspRtc::instance().getMicros();
+	int priority = sceKernelGetThreadCurrentPriority();
+	uint32 time2 = PspRtc::instance().getMicros();
+	
+	PSP_INFO_PRINT("Getting thread priority %d took %dus\n", priority, time2-time1);
+}
+
+// 222: 9-10us
+void testChangePriority(int id, int priority) {
+	uint32 time1 = PspRtc::instance().getMicros();
+	sceKernelChangeThreadPriority(id, priority);
+	uint32 time2 = PspRtc::instance().getMicros();
+	
+	PSP_INFO_PRINT("Changing thread priority to %d for id %d took %dus\n", priority, id, time2-time1);
+}
+
+void test_thread() {
+	int id;
+	id = testGetThreadId();
+	testGetThreadId();
+	testGetPriority();
+	testGetPriority();
+	testChangePriority(id, 30);
+	testChangePriority(id, 35);
+	testChangePriority(id, 25);
+	
+	// test context switch time
+	for (int i=0; i<10; i++) {
+		uint time1 = PspRtc::instance().getMicros();
+		PspThread::delayMicros(0);
+		uint time2 = PspRtc::instance().getMicros();
+		PSP_INFO_PRINT("poll %d. context switch Time = %dus\n", i, time2-time1);	// 10-15us	
+	}	
+}
+ 
+int test_mem_read(uint32 words) {
+	uint32 __attribute__((aligned(64))) buffer[1024];
+	register uint32 r = 0;
+	
+	// uncached
+	uint32 *pBuffer = (uint32 *)UNCACHED(buffer);
+
+	uint32 time1 = PspRtc::instance().getMicros();
+	
+	for (int i=0; i<words; i++) {
+		r += *pBuffer;
+		pBuffer++;
+	}
+	uint32 time2 = PspRtc::instance().getMicros();
+	
+	PSP_INFO_PRINT("read of %d words from uncached took %dus\n", words, time2-time1);
+	
+	// flush cache
+	sceKernelDcacheWritebackInvalidateAll();
+	
+	// cached
+	pBuffer = buffer;
+
+	time1 = PspRtc::instance().getMicros();
+	
+	for (int i=0; i<words; i++) {
+		r += *pBuffer;
+		pBuffer++;
+	}
+	time2 = PspRtc::instance().getMicros();
+	
+	PSP_INFO_PRINT("read of %d words from cached took %dus\n", words, time2-time1);
+
+	return r;
+} 
+
+void test_mem_write(uint32 words) {
+	uint32 __attribute__((aligned(64))) buffer[1024];
+	register uint32 r = 0;
+	
+	// uncached
+	uint32 *pBuffer = (uint32 *)UNCACHED(buffer);
+
+	uint32 time1 = PspRtc::instance().getMicros();
+	
+	for (int i=0; i<words; i++) {
+		*pBuffer = r;
+		pBuffer++;
+	}
+	uint32 time2 = PspRtc::instance().getMicros();
+	
+	PSP_INFO_PRINT("write of %d words to uncached took %dus\n", words, time2-time1);
+	
+	// flush cache
+	sceKernelDcacheWritebackInvalidateAll();
+
+	// cached
+	pBuffer = buffer;
+	
+	time1 = PspRtc::instance().getMicros();
+	
+	for (int i=0; i<words; i++) {
+		*pBuffer = r;
+		pBuffer++;
+	}
+	time2 = PspRtc::instance().getMicros();
+	
+	PSP_INFO_PRINT("writeof %d words to cached took %dus\n", words, time2-time1);	
+}
+
+/*
+read of 1 words from uncached took 2us
+read of 1 words from cached took 3us
+read of 64 words from uncached took 12us
+read of 64 words from cached took 6us
+read of 65 words from uncached took 12us
+read of 65 words from cached took 6us
+read of 128 words from uncached took 24us
+read of 128 words from cached took 8us
+read of 1024 words from uncached took 168us
+read of 1024 words from cached took 50us
+write of 1 words to uncached took 2us
+writeof 1 words to cached took 2us
+write of 64 words to uncached took 4us
+writeof 64 words to cached took 5us
+write of 65 words to uncached took 5us
+writeof 65 words to cached took 5us
+write of 128 words to uncached took 5us
+writeof 128 words to cached took 8us
+write of 1024 words to uncached took 32us
+writeof 1024 words to cached took 45us
+*/ 
+void test_memory() {
+	test_mem_read(1);
+	test_mem_read(64);
+	test_mem_read(65);
+	test_mem_read(128);
+	test_mem_read(1024);
+	test_mem_write(1);
+	test_mem_write(64);
+	test_mem_write(65);
+	test_mem_write(128);
+	test_mem_write(1024);	
+}
+
+void test_semaphore() { 
+	// create semaphore
+	int sem = sceKernelCreateSema("testSemaphore", 0, 1, 1, 0);
+	
+	uint32 time1 = PspRtc::instance().getMicros();
+	
+	sceKernelWaitSema(sem, 1, 0);
+	
+	uint32 time2 = PspRtc::instance().getMicros();
+	
+	PSP_INFO_PRINT("taking semaphore took %d us\n", time2-time1);	// 10us
+	
+	uint32 time3 = PspRtc::instance().getMicros();
+	
+	sceKernelSignalSema(sem, 1);
+	
+	uint32 time4 = PspRtc::instance().getMicros();
+	PSP_INFO_PRINT("releasing semaphore took %d us\n", time4-time3);	//10us-55us
+}
+
+int globalSem = 0;	// semaphore
+
+int threadFunc(SceSize args, void *argp) {
+	PSP_INFO_PRINT("thread %x created.\n", sceKernelGetThreadId());
+	
+	sceKernelWaitSema(globalSem, 1, 0);	// grab semaphore
+	PSP_INFO_PRINT("grabbed semaphore. Quitting thread\n");
+	
+	return 0;
+}
+
+void test_semaphore_many_threads() {	
+	globalSem = sceKernelCreateSema("testSemaphore2", 0, 0, 255, 0);
+
+	// create 4 threads
+	for (int i=0; i<4; i++) {
+		int thid = sceKernelCreateThread("my_thread", threadFunc, 0x18, 0x10000, THREAD_ATTR_USER, NULL);
+		sceKernelStartThread(thid, 0, 0);
+	}
+		
+	PSP_INFO_PRINT("main thread. created threads\n");
+
+	SceKernelSemaInfo info;
+	int waitingThreads = 0;
+	while (waitingThreads < 4) {
+		sceKernelReferSemaStatus(globalSem, &info);
+		waitingThreads = info.numWaitThreads;
+		PSP_INFO_PRINT("main thread: waiting threads[%d]\n", waitingThreads);
+	}
+	
+	PSP_INFO_PRINT("main: semaphore value[%d]\n", info.currentCount);
+	PSP_INFO_PRINT("main thread: waiting threads[%d]\n", info.numWaitThreads);
+	
+	sceKernelSignalSema(globalSem, 4);
+}
+
+void test_sce_ms_reads() { 
+	SceUID file;
+	char *buffer = (char *)malloc(2 * 1024 * 1024);
+	{
+		// get file size
+		SceIoStat stat;
+		
+		uint32 time1 = PspRtc::instance().getMicros();
+		
+		sceIoGetstat("ms0:/psp/music/track1.mp3", &stat);
+		
+		uint32 time2 = PspRtc::instance().getMicros();
+		
+		PSP_INFO_PRINT("getting size of %lld took %d us\n", stat.st_size, time2-time1); // 3180 us before an open
+	}
+	{
+		// open file
+		uint32 time1 = PspRtc::instance().getMicros();
+
+		file = sceIoOpen("ms0:/psp/music/track1.mp3", PSP_O_RDONLY, 0777);
+		
+		uint32 time2 = PspRtc::instance().getMicros();
+		
+		PSP_INFO_PRINT("opening scefile took %d us\n", time2-time1);	// 3355us (or 1223us if already got size)
+	}
+	{
+		// get file size
+		SceIoStat stat;
+		
+		uint32 time1 = PspRtc::instance().getMicros();
+		
+		sceIoGetstat("ms0:/psp/music/track1.mp3", &stat);
+		
+		uint32 time2 = PspRtc::instance().getMicros();
+		
+		PSP_INFO_PRINT("getting size of %lld took %d us\n", stat.st_size, time2-time1); // 1223us after an open
+	}
+	{
+		uint32 time1 = PspRtc::instance().getMicros();
+	
+		// asynchronous read
+		sceIoReadAsync(file, buffer, 100000);
+		
+		uint32 time2 = PspRtc::instance().getMicros();
+		
+		PSP_INFO_PRINT("async read of 100000 took %d us\n", time2-time1);  // 146us
+		
+		// poll for completion
+		SceInt64 result;
+		for (int i=0; i<10; i++) {
+			sceIoPollAsync(file, &result);
+			uint time3 = PspRtc::instance().getMicros();
+			PSP_INFO_PRINT("poll %d. result = %lld. Time = %d us.\n", i, result, time3-time1);
+			PspThread::delayMicros(100);
+		}	
+	
+	}
+	{
+		uint32 time1 = PspRtc::instance().getMicros();
+		sceIoClose(file);
+		uint32 time2 = PspRtc::instance().getMicros();
+		PSP_INFO_PRINT("file close took %d us\n", time2-time1);	// 230us
+	}
+	free(buffer);
+}
+
+#define MEMCPY_BUFFER_SIZE 4096
+
+void test_fastCopy_specific(byte *dst, byte *src, uint32 bytes) {
+	memset(dst, 0, bytes);
+	PspMemory::fastCopy(dst, src, bytes);
+	PSP_INFO_PRINT("\n");
+}
+
+void test_fastCopy_different_sizes(byte *dst, byte *src) {
+	test_fastCopy_specific(dst, src, 1);
+	test_fastCopy_specific(dst, src, 2);
+	test_fastCopy_specific(dst, src, 4);
+	test_fastCopy_specific(dst, src, 6);
+	test_fastCopy_specific(dst, src, 8);
+	test_fastCopy_specific(dst, src, 9);
+	test_fastCopy_specific(dst, src, 16);
+	test_fastCopy_specific(dst, src, 17);
+	test_fastCopy_specific(dst, src, 32);
+	test_fastCopy_specific(dst, src, 33);
+	test_fastCopy_specific(dst, src, 34);
+	test_fastCopy_specific(dst, src, 35);
+	test_fastCopy_specific(dst, src, 36);
+}
+
+void test_fastcopy() {
+	PSP_INFO_PRINT("running fastcopy test\n");
+
+	uint32 *bufferSrc32 = (uint32 *)memalign(16, MEMCPY_BUFFER_SIZE);
+	uint32 *bufferDst32 = (uint32 *)memalign(16, MEMCPY_BUFFER_SIZE);
+	
+	// fill buffer 1
+	for (int i=0; i<MEMCPY_BUFFER_SIZE/4; i++)
+		bufferSrc32[i] = i | (((MEMCPY_BUFFER_SIZE/4)-i)<<16);
+		
+	// print buffer
+	for (int i=0; i<50; i++)
+		PSP_INFO_PRINT("%x ", bufferSrc32[i]);
+	PSP_INFO_PRINT("\n");
+	
+	byte *bufferSrc = ((byte *)bufferSrc32);
+	byte *bufferDst = ((byte *)bufferDst32);
+	
+	//test_fastCopy_different_sizes(bufferDst, bufferSrc);
+	//test_fastCopy_different_sizes(bufferDst+1, bufferSrc+1);
+	//test_fastCopy_different_sizes(bufferDst+2, bufferSrc+2);
+	//test_fastCopy_different_sizes(bufferDst+3, bufferSrc+3);
+	//test_fastCopy_different_sizes(bufferDst, bufferSrc+1);
+	//test_fastCopy_different_sizes(bufferDst, bufferSrc+2);
+	//test_fastCopy_different_sizes(bufferDst, bufferSrc+3);
+	test_fastCopy_different_sizes(bufferDst+1, bufferSrc+2);
+	test_fastCopy_different_sizes(bufferDst+1, bufferSrc+3);
+	test_fastCopy_different_sizes(bufferDst+2, bufferSrc+1);
+	test_fastCopy_different_sizes(bufferDst+2, bufferSrc+3);
+	test_fastCopy_different_sizes(bufferDst+3, bufferSrc+1);
+	test_fastCopy_different_sizes(bufferDst+3, bufferSrc+2);	
+	
+	free(bufferSrc32);
+	free(bufferDst32);
+}
+
+void test_fastcopy_speed_specific(byte *dst, byte *src, uint32 bytes) {
+	byte *dstUncached = UNCACHED(dst);
+	byte *srcUncached = UNCACHED(src);
+//	byte *dstUncached = dst;
+//	byte *srcUncached = src;
+	
+	uint32 time1, time2;
+	const int iterations = 2000;
+	int intc;
+	
+	intc = pspSdkDisableInterrupts();
+	
+	time1 = PspRtc::instance().getMicros();
+	for (int i=0; i<iterations; i++) {
+		PspMemory::fastCopy(dstUncached, srcUncached, bytes);
+	}	
+	time2 = PspRtc::instance().getMicros();
+	
+	pspSdkEnableInterrupts(intc);
+	
+	PSP_INFO_PRINT("fastcppy() results: bytes[%d], iters[%d], time[%d]us\n",
+		bytes, iterations, time2-time1);
+	
+	intc = pspSdkDisableInterrupts();
+	
+	time1 = PspRtc::instance().getMicros();
+	for (int i=0; i<iterations; i++) {
+		memcpy(dstUncached, srcUncached, bytes);
+	}	
+	time2 = PspRtc::instance().getMicros();
+	
+	pspSdkEnableInterrupts(intc);
+	
+	PSP_INFO_PRINT("memcpy() results: bytes[%d], iters[%d], time[%d]us\n\n",
+		bytes, iterations, time2-time1);
+
+}
+
+void test_fastcopy_speed_bunch(byte *dst, byte *src) {
+	PSP_INFO_PRINT("new test bunch ******************\n");
+	PSP_INFO_PRINT("src[%p], dst[%p]\n", src, dst);
+	test_fastcopy_speed_specific(dst, src, 1);
+	test_fastcopy_speed_specific(dst, src, 2);
+	test_fastcopy_speed_specific(dst, src, 3);
+	test_fastcopy_speed_specific(dst, src, 4);
+	test_fastcopy_speed_specific(dst, src, 5);
+	test_fastcopy_speed_specific(dst, src, 8);
+	test_fastcopy_speed_specific(dst, src, 10);
+	test_fastcopy_speed_specific(dst, src, 16);
+	test_fastcopy_speed_specific(dst, src, 32);
+	test_fastcopy_speed_specific(dst, src, 50);
+	test_fastcopy_speed_specific(dst, src, 100);
+	test_fastcopy_speed_specific(dst, src, 500);
+	test_fastcopy_speed_specific(dst, src, 1024);
+	test_fastcopy_speed_specific(dst, src, 2048);
+}
+
+void test_fastcopy_speed() {
+	PSP_INFO_PRINT("running fastcopy speed test\n");
+
+	uint32 *bufferSrc32 = (uint32 *)memalign(16, MEMCPY_BUFFER_SIZE);
+	uint32 *bufferDst32 = (uint32 *)memalign(16, MEMCPY_BUFFER_SIZE);
+	
+	// fill buffer 1
+	for (int i=0; i<MEMCPY_BUFFER_SIZE/4; i++)
+		bufferSrc32[i] = i | (((MEMCPY_BUFFER_SIZE/4)-i)<<16);
+		
+	// print buffer
+	for (int i=0; i<50; i++)
+		PSP_INFO_PRINT("%x ", bufferSrc32[i]);
+	PSP_INFO_PRINT("\n");
+	
+	byte *bufferSrc = ((byte *)bufferSrc32);
+	byte *bufferDst = ((byte *)bufferDst32);
+	
+	test_fastcopy_speed_bunch(bufferDst, bufferSrc);
+	test_fastcopy_speed_bunch(bufferDst+1, bufferSrc+1);
+	test_fastcopy_speed_bunch(bufferDst, bufferSrc+1);
+	test_fastcopy_speed_bunch(bufferDst+1, bufferSrc);
+	
+	free(bufferSrc32);
+	free(bufferDst32);
+}
+
+
+ void tests() {
+	PSP_INFO_PRINT("in tests\n");
+	//test_ticks();
+	//test_getMicros();
+	//test_ms_reads();
+	//test_seeks();
+	//test_thread();
+	//test_memory();
+	//test_sce_ms_reads();
+	//test_semaphore();	
+	//test_semaphore_many_threads();
+	//test_fastcopy();
+	test_fastcopy_speed();
+}	
diff --git a/backends/platform/psp/tests.h b/backends/platform/psp/tests.h
new file mode 100644
index 0000000000..0a4fc074e3
--- /dev/null
+++ b/backends/platform/psp/tests.h
@@ -0,0 +1,26 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * $URL: https://scummvm.svn.sourceforge.net/svnroot/scummvm/scummvm/trunk/backends/platform/psp/psp_main.cpp $
+ * $Id: psp_main.cpp 49155 2010-05-23 11:48:21Z Bluddy $
+ *
+ */
+
+extern void tests();
\ No newline at end of file
-- 
cgit v1.2.3