libretro/scummvm
1
0
Fork 0
mirror of https://github.com/libretro/scummvm.git synced 2024-12-11 19:54:03 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

PSP: switched to using BufferedSeekableReadStream and BufferedWriteStream

Browse Source 
The last PSP optimization made reading much faster, but writing isn't buffered so saving the config file was VERY slow.
I decided the cleanest way to do this would be to add BWS and use BSRS.

svn-id: r52327
This commit is contained in:
Yotam Barnoy 2010-08-24 11:24:34 +00:00
parent 347accf2d7
commit b88f341b80
4 changed files with 334 additions and 222 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
backends/fs/psp/psp-fs.cpp
View File

@ -247,11 +247,19 @@ AbstractFSNode *PSPFilesystemNode::getParent() const {
} }
Common::SeekableReadStream *PSPFilesystemNode::createReadStream() { Common::SeekableReadStream *PSPFilesystemNode::createReadStream() {
return PSPIoStream::makeFromPath(getPath(), false); const uint32 READ_BUFFER_SIZE = 1024;
Common::SeekableReadStream *stream = PspIoStream::makeFromPath(getPath(), false);
return new PspIoBufferedReadStream(stream, READ_BUFFER_SIZE, DisposeAfterUse::YES);
} }
Common::WriteStream *PSPFilesystemNode::createWriteStream() { Common::WriteStream *PSPFilesystemNode::createWriteStream() {
return PSPIoStream::makeFromPath(getPath(), true); const uint32 WRITE_BUFFER_SIZE = 1024;
Common::WriteStream *stream = PspIoStream::makeFromPath(getPath(), true);
return new PspIoBufferedWriteStream(stream, WRITE_BUFFER_SIZE, DisposeAfterUse::YES);
} }
#endif //#ifdef __PSP__ #endif //#ifdef __PSP__

278
backends/fs/psp/psp-stream.cpp
View File

@ -58,32 +58,26 @@ void printBuffer(byte *ptr, uint32 len) {
} }
#endif #endif
// Class PspIoStream ------------------------------------------------
PSPIoStream::PSPIoStream(const Common::String &path, bool writeMode) PspIoStream::PspIoStream(const Common::String &path, bool writeMode)
: _handle(0), _path(path), _writeMode(writeMode), : _handle(0), _path(path), _fileSize(0), _writeMode(writeMode),
_ferror(false), _pos(0), _physicalPos(0), _pos(0), _eos(false), _error(false),
_physicalPos(0), _fileSize(0), _inCache(false), _eos(false), _errorSuspend(0), _errorSource(0), _errorPos(0), _errorHandle(0), _suspendCount(0) {
_cacheStartOffset(-1), _cache(0),
_errorSuspend(0), _errorSource(0),
_errorPos(0), _errorHandle(0), _suspendCount(0) {
DEBUG_ENTER_FUNC(); DEBUG_ENTER_FUNC();
// assert(!path.empty()); // do we need this? //assert(!path.empty()); // do we need this?
} }
PSPIoStream::~PSPIoStream() { PspIoStream::~PspIoStream() {
DEBUG_ENTER_FUNC(); DEBUG_ENTER_FUNC();
if (PowerMan.beginCriticalSection()) if (PowerMan.beginCriticalSection())
PSP_DEBUG_PRINT_FUNC("Suspended\n"); PSP_DEBUG_PRINT_FUNC("suspended\n");
PowerMan.unregisterForSuspend(this); // Unregister with powermanager to be suspended PowerMan.unregisterForSuspend(this); // Unregister with powermanager to be suspended
// Must do this before fclose() or resume() will reopen. // Must do this before fclose() or resume() will reopen.
sceIoClose(_handle);
sceIoClose(_handle); // We don't need a critical section. Worst case, the handle gets closed on its own
if (_cache)
free(_cache);
PowerMan.endCriticalSection(); PowerMan.endCriticalSection();
} }
@ -91,25 +85,26 @@ PSPIoStream::~PSPIoStream() {
/* Function to open the file pointed to by the path. /* Function to open the file pointed to by the path.
* *
*/ */
void *PSPIoStream::open() { void *PspIoStream::open() {
DEBUG_ENTER_FUNC(); DEBUG_ENTER_FUNC();
if (PowerMan.beginCriticalSection()) { if (PowerMan.beginCriticalSection()) {
// No need to open. Just return the _handle resume() already opened. // No need to open? Just return the _handle resume() already opened
PSP_DEBUG_PRINT_FUNC("Suspended\n"); PSP_DEBUG_PRINT_FUNC("suspended\n");
} }
_handle = sceIoOpen(_path.c_str(), _writeMode ? PSP_O_RDWR | PSP_O_CREAT : PSP_O_RDONLY, 0777); // open _handle = sceIoOpen(_path.c_str(), _writeMode ? PSP_O_RDWR | PSP_O_CREAT : PSP_O_RDONLY, 0777);
if (!_handle) {
_error = true;
_handle = NULL;
}
if (_handle) {
// Get the file size. This way is much faster than going to the end of the file and back // Get the file size. This way is much faster than going to the end of the file and back
SceIoStat stat; SceIoStat stat;
sceIoGetstat(_path.c_str(), &stat); sceIoGetstat(_path.c_str(), &stat);
_fileSize = *((uint32 *)(void *)&stat.st_size); // 4GB file is big enough for us _fileSize = *((uint32 *)(void *)&stat.st_size); // 4GB file (32 bits) is big enough for us
PSP_DEBUG_PRINT("%s filesize = %d\n", _path.c_str(), _fileSize);
// Allocate the cache PSP_DEBUG_PRINT("%s filesize[%d]\n", _path.c_str(), _fileSize);
_cache = (char *)memalign(64, CACHE_SIZE);
}
PowerMan.registerForSuspend(this); // Register with the powermanager to be suspended PowerMan.registerForSuspend(this); // Register with the powermanager to be suspended
@ -118,35 +113,48 @@ void *PSPIoStream::open() {
return (void *)_handle; return (void *)_handle;
} }
bool PSPIoStream::err() const { bool PspIoStream::err() const {
DEBUG_ENTER_FUNC(); DEBUG_ENTER_FUNC();
if (_ferror) // We dump since no printing to screen with suspend if (_error) // We dump since no printing to screen with suspend callback
PSP_ERROR("mem_ferror[%d], source[%d], suspend error[%d], pos[%d], \ PSP_ERROR("mem_error[%d], source[%d], suspend error[%d], pos[%d],"
_errorPos[%d], _errorHandle[%p], suspendCount[%d]\n", "_errorPos[%d], _errorHandle[%p], suspendCount[%d]\n",
_ferror, _errorSource, _errorSuspend, _pos, _error, _errorSource, _errorSuspend, _pos,
_errorPos, _errorHandle, _suspendCount); _errorPos, _errorHandle, _suspendCount);
return _ferror; return _error;
} }
void PSPIoStream::clearErr() { void PspIoStream::clearErr() {
_ferror = false; _error = false;
} }
bool PSPIoStream::eos() const { bool PspIoStream::eos() const {
return _eos; return _eos;
} }
int32 PSPIoStream::pos() const { int32 PspIoStream::pos() const {
return _pos; return _pos;
} }
int32 PSPIoStream::size() const { int32 PspIoStream::size() const {
return _fileSize; return _fileSize;
} }
bool PSPIoStream::seek(int32 offs, int whence) { bool PspIoStream::physicalSeekFromCur(int32 offset) {
int ret = sceIoLseek32(_handle, offset, PSP_SEEK_CUR);
if (ret < 0) {
_error = true;
PSP_ERROR("failed to seek in file[%s] to [%x]. Error[%x]\n", _path.c_str(), offset, ret);
return false;
}
_physicalPos += offset;
return true;
}
bool PspIoStream::seek(int32 offs, int whence) {
DEBUG_ENTER_FUNC(); DEBUG_ENTER_FUNC();
PSP_DEBUG_PRINT_FUNC("offset[0x%x], whence[%d], _pos[0x%x], _physPos[0x%x]\n", offs, whence, _pos, _physicalPos); PSP_DEBUG_PRINT_FUNC("offset[0x%x], whence[%d], _pos[0x%x], _physPos[0x%x]\n", offs, whence, _pos, _physicalPos);
_eos = false; _eos = false;
@ -157,195 +165,116 @@ bool PSPIoStream::seek(int32 offs, int whence) {
posToSearchFor = _pos; posToSearchFor = _pos;
break; break;
case SEEK_END: case SEEK_END:
posToSearchFor = _fileSize; // unsure. Does it take us here or to EOS - 1? posToSearchFor = _fileSize;
break; break;
} }
posToSearchFor += offs; posToSearchFor += offs;
// Check for bad values // Check for bad values
if (posToSearchFor < 0) { if (posToSearchFor < 0) {
_ferror = true; _error = true;
return false; return false;
} } else if (posToSearchFor > _fileSize) {
_error = true;
if (posToSearchFor > _fileSize) {
_ferror = true;
_eos = true; _eos = true;
return false; return false;
} }
// See if we can find it in cache
if (isOffsetInCache(posToSearchFor)) {
PSP_DEBUG_PRINT("seek offset[0x%x] found in cache. Cache starts[0x%x]\n", posToSearchFor, _cacheStartOffset);
_inCache = true;
} else { // not in cache
_inCache = false;
}
_pos = posToSearchFor; _pos = posToSearchFor;
return true; return true;
} }
uint32 PSPIoStream::read(void *ptr, uint32 len) { uint32 PspIoStream::read(void *ptr, uint32 len) {
DEBUG_ENTER_FUNC(); DEBUG_ENTER_FUNC();
PSP_DEBUG_PRINT_FUNC("filename[%s], len[0x%x], ptr[%p]\n", _path.c_str(), len, ptr); PSP_DEBUG_PRINT_FUNC("filename[%s], len[0x%x], ptr[%p], _pos[%x], _physPos[%x]\n", _path.c_str(), len, ptr, _pos, _physicalPos);
if (_ferror || _eos) if (_error || _eos || len <= 0)
return 0; return 0;
byte *destPtr = (byte *)ptr;
uint32 lenFromFile = len; // how much we read from the actual file
uint32 lenFromCache = 0; // how much we read from cache
uint32 lenRemainingInFile = _fileSize - _pos; uint32 lenRemainingInFile = _fileSize - _pos;
if (lenFromFile > lenRemainingInFile) { // check for getting EOS
lenFromFile = lenRemainingInFile; if (len > lenRemainingInFile) {
len = lenRemainingInFile;
_eos = true; _eos = true;
} }
// Are we in cache?
if (_inCache && isCacheValid()) {
uint32 offsetInCache = _pos - _cacheStartOffset;
// We can read at most what's in the cache or the remaining size of the file
lenFromCache = MIN2(lenFromFile, CACHE_SIZE - offsetInCache); // unsure
PSP_DEBUG_PRINT("reading 0x%x bytes from cache to %p. pos[0x%x] physPos[0x%x] cacheStart[0x%x]\n", lenFromCache, destPtr, _pos, _physicalPos, _cacheStartOffset);
memcpy(destPtr, &_cache[offsetInCache], lenFromCache);
_pos += lenFromCache;
if (lenFromCache < lenFromFile) { // there's more to copy from the file
lenFromFile -= lenFromCache;
lenRemainingInFile -= lenFromCache; // since we moved pos
destPtr += lenFromCache;
} else { // we're done
#ifdef DEBUG_BUFFERS
printBuffer((byte *)ptr, len);
#endif
return lenFromCache; // how much we actually read
}
}
if (PowerMan.beginCriticalSection()) if (PowerMan.beginCriticalSection())
PSP_DEBUG_PRINT_FUNC("Suspended\n"); PSP_DEBUG_PRINT_FUNC("suspended\n");
// check if we need to seek
synchronizePhysicalPos(); // we need to update our physical position if (_pos != _physicalPos)
PSP_DEBUG_PRINT("seeking from %x to %x\n", _physicalPos, _pos);
if (lenFromFile <= MIN_READ_SIZE) { // We load the cache in case the read is small enough if (!physicalSeekFromCur(_pos - _physicalPos)) {
// This optimization is based on the principle that reading 1 byte is as expensive as 1000 bytes _error = true;
uint32 lenToCopyToCache = MIN2((uint32)MIN_READ_SIZE, lenRemainingInFile); // at most remaining file size return 0;
PSP_DEBUG_PRINT("filling cache with 0x%x bytes from physicalPos[0x%x]. cacheStart[0x%x], pos[0x%x], fileSize[0x%x]\n", lenToCopyToCache, _physicalPos, _cacheStartOffset, _pos, _fileSize);
int ret = sceIoRead(_handle, _cache, lenToCopyToCache);
if (ret != (int)lenToCopyToCache) {
PSP_ERROR("in filling cache, failed to get 0x%x bytes. Only got 0x%x\n", lenToCopyToCache, ret);
_ferror = true;
} }
_cacheStartOffset = _physicalPos;
_inCache = true;
_physicalPos += ret; int ret = sceIoRead(_handle, ptr, len);
PSP_DEBUG_PRINT("copying 0x%x bytes from cache to %p\n", lenFromFile, destPtr);
// Copy to the destination buffer from cache
memcpy(destPtr, _cache, lenFromFile);
_pos += lenFromFile;
} else { // Too big for cache. No caching
PSP_DEBUG_PRINT("reading 0x%x bytes from file to %p. Pos[0x%x], physPos[0x%x]\n", lenFromFile, destPtr, _pos, _physicalPos);
int ret = sceIoRead(_handle, destPtr, lenFromFile);
_physicalPos += ret; // Update pos
_pos = _physicalPos;
if (ret != (int)lenFromFile) { // error
PSP_ERROR("fread returned [0x%x] instead of len[0x%x]\n", ret, lenFromFile);
_ferror = true;
_errorSource = 4;
}
_inCache = false;
}
PowerMan.endCriticalSection(); PowerMan.endCriticalSection();
#ifdef DEBUG_BUFFERS _physicalPos += ret; // Update position
printBuffer((byte *)ptr, len); _pos = _physicalPos;
#endif
return lenFromCache + lenFromFile; // total of what was copied if (ret != (int)len) { // error
} PSP_ERROR("sceIoRead returned [0x%x] instead of len[0x%x]\n", ret, len);
_error = true;
// TODO: Test if seeking backwards/forwards has any effect on performance _errorSource = 4;
inline bool PSPIoStream::synchronizePhysicalPos() {
if (_pos != _physicalPos) {
if (sceIoLseek32(_handle, _pos - _physicalPos, PSP_SEEK_CUR) < 0) {
_ferror = true;
return false;
} }
_physicalPos = _pos; return ret;
}
return true;
} }
inline bool PSPIoStream::isOffsetInCache(uint32 offset) { uint32 PspIoStream::write(const void *ptr, uint32 len) {
if (_cacheStartOffset != -1 &&
offset >= (uint32)_cacheStartOffset &&
offset < (uint32)(_cacheStartOffset + CACHE_SIZE))
return true;
return false;
}
uint32 PSPIoStream::write(const void *ptr, uint32 len) {
DEBUG_ENTER_FUNC(); DEBUG_ENTER_FUNC();
// Check if we can access the file PSP_DEBUG_PRINT_FUNC("filename[%s], len[0x%x], ptr[%p], _pos[%x], _physPos[%x] buf[%x %x %x %x..%x %x]\n", _path.c_str(), len, ptr, _pos, _physicalPos, ((byte *)ptr)[0], ((byte *)ptr)[1], ((byte *)ptr)[2], ((byte *)ptr)[3], ((byte *)ptr)[len - 2],
if (PowerMan.beginCriticalSection()) ((byte *)ptr)[len - 1]);
PSP_DEBUG_PRINT_FUNC("Suspended\n");
PSP_DEBUG_PRINT_FUNC("filename[%s], len[0x%x]\n", _path.c_str(), len); if (!len || _error) // we actually get some calls with len == 0!
if (!len || _ferror) // we actually get calls with len=0
return 0; return 0;
_eos = false; // we can't have eos with write _eos = false; // we can't have eos with write
synchronizePhysicalPos();
if (PowerMan.beginCriticalSection())
PSP_DEBUG_PRINT_FUNC("suspended\n");
// check if we need to seek
if (_pos != _physicalPos)
if (!physicalSeekFromCur(_pos - _physicalPos)) {
_error = true;
return 0;
}
int ret = sceIoWrite(_handle, ptr, len); int ret = sceIoWrite(_handle, ptr, len);
// If we're making the file bigger, adjust the size PowerMan.endCriticalSection();
if (_physicalPos + ret > _fileSize)
_fileSize = _physicalPos + ret; if (ret != (int)len) {
_error = true;
_errorSource = 5;
PSP_ERROR("sceIoWrite returned[0x%x] instead of len[0x%x]\n", ret, len);
}
_physicalPos += ret; _physicalPos += ret;
_pos = _physicalPos; _pos = _physicalPos;
_inCache = false;
_cacheStartOffset = -1; // invalidate cache
if (ret != (int)len) { // Set error if (_pos > _fileSize)
_ferror = true; _fileSize = _pos;
_errorSource = 5;
PSP_ERROR("fwrite returned[0x%x] instead of len[0x%x]\n", ret, len);
}
PowerMan.endCriticalSection();
return ret; return ret;
} }
bool PSPIoStream::flush() { bool PspIoStream::flush() {
return true; return true;
} }
// For the PSP, since we're building in suspend support, we moved opening // For the PSP, since we're building in suspend support, we moved opening
// the actual file to an open function since we need an actual PSPIoStream object to suspend. // the actual file to an open function since we need an actual PspIoStream object to suspend.
// //
PSPIoStream *PSPIoStream::makeFromPath(const Common::String &path, bool writeMode) { PspIoStream *PspIoStream::makeFromPath(const Common::String &path, bool writeMode) {
DEBUG_ENTER_FUNC(); DEBUG_ENTER_FUNC();
PSPIoStream *stream = new PSPIoStream(path, writeMode); PspIoStream *stream = new PspIoStream(path, writeMode);
if (stream->open() <= 0) { if (stream->open() <= 0) {
delete stream; delete stream;
@ -359,7 +288,7 @@ PSPIoStream *PSPIoStream::makeFromPath(const Common::String &path, bool writeMod
* Function to suspend the IO stream (called by PowerManager) * Function to suspend the IO stream (called by PowerManager)
* we can have no output here * we can have no output here
*/ */
int PSPIoStream::suspend() { int PspIoStream::suspend() {
DEBUG_ENTER_FUNC(); DEBUG_ENTER_FUNC();
_suspendCount++; _suspendCount++;
@ -380,7 +309,7 @@ int PSPIoStream::suspend() {
/* /*
* Function to resume the IO stream (called by Power Manager) * Function to resume the IO stream (called by Power Manager)
*/ */
int PSPIoStream::resume() { int PspIoStream::resume() {
DEBUG_ENTER_FUNC(); DEBUG_ENTER_FUNC();
int ret = 0; int ret = 0;
_suspendCount--; _suspendCount--;
@ -388,15 +317,15 @@ int PSPIoStream::resume() {
// We reopen our file descriptor // We reopen our file descriptor
_handle = sceIoOpen(_path.c_str(), _writeMode ? PSP_O_RDWR | PSP_O_CREAT : PSP_O_RDONLY, 0777); // open _handle = sceIoOpen(_path.c_str(), _writeMode ? PSP_O_RDWR | PSP_O_CREAT : PSP_O_RDONLY, 0777); // open
if (_handle <= 0) { if (_handle <= 0) {
PSP_ERROR("Couldn't reopen file %s\n", _path.c_str()); _errorSuspend = ResumeError;
_errorPos = _pos;
} }
// Resume our previous position // Resume our previous position if needed
if (_handle > 0 && _pos > 0) { if (_handle > 0 && _pos > 0) {
ret = sceIoLseek32(_handle, _pos, PSP_SEEK_SET); ret = sceIoLseek32(_handle, _pos, PSP_SEEK_SET);
_physicalPos = _pos; _physicalPos = _pos;
_inCache = false;
if (ret < 0) { // Check for problem if (ret < 0) { // Check for problem
_errorSuspend = ResumeError; _errorSuspend = ResumeError;
@ -407,5 +336,4 @@ int PSPIoStream::resume() {
return ret; return ret;
} }
#endif /* __PSP__ */ #endif /* __PSP__ */

48
backends/fs/psp/psp-stream.h
View File

@ -33,18 +33,33 @@
#include "common/stream.h" #include "common/stream.h"
#include "common/str.h" #include "common/str.h"
/* class PspIoBufferedReadStream : public Common::BufferedSeekableReadStream {
public:
PspIoBufferedReadStream(SeekableReadStream *parentStream, uint32 bufSize, DisposeAfterUse::Flag disposeParentStream = DisposeAfterUse::YES) : BufferedSeekableReadStream(parentStream, bufSize, disposeParentStream) {}
protected:
virtual void allocBuf(uint32 bufSize) { _buf = (byte *)memalign(64, bufSize); } // want 64 byte alignment for cache
virtual void deallocBuf() { free(_buf); }
};
class PspIoBufferedWriteStream : public Common::BufferedWriteStream {
public:
PspIoBufferedWriteStream(WriteStream *parentStream, uint32 bufSize, DisposeAfterUse::Flag disposeParentStream = DisposeAfterUse::YES) : BufferedWriteStream(parentStream, bufSize, disposeParentStream) {}
protected:
virtual void allocBuf(uint32 bufSize) { _buf = (byte *)memalign(64, bufSize); }
virtual void deallocBuf() { free(_buf); }
};
/**
* Class to handle special suspend/resume needs of PSP IO Streams * Class to handle special suspend/resume needs of PSP IO Streams
*/ */
class PSPIoStream : public Common::SeekableReadStream, public Common::WriteStream, public Common::NonCopyable, public Suspendable { class PspIoStream : public Common::SeekableReadStream, public Common::WriteStream, public Common::NonCopyable, public Suspendable {
protected: protected:
SceUID _handle; // file handle SceUID _handle; // file handle
Common::String _path; Common::String _path;
int _fileSize; int _fileSize;
bool _writeMode; // for resuming in the right mode bool _writeMode; // for resuming in the right mode
int _physicalPos; // position in the real file int _physicalPos; // physical position in file
int _pos; // position. Sometimes virtual int _pos; // position. Sometimes virtual
bool _inCache; // whether we're in cache (virtual) mode
bool _eos; // EOS flag bool _eos; // EOS flag
enum { enum {
@ -52,36 +67,26 @@ protected:
ResumeError = 3 ResumeError = 3
}; };
enum { // debug stuff
CACHE_SIZE = 1024, mutable int _error; // file error state
MIN_READ_SIZE = 1024 // reading less than 1024 takes exactly the same time as 1024
};
// For caching
char *_cache;
int _cacheStartOffset; // starting offset of the cache. -1 when cache is invalid
mutable int _ferror; // file error state
int _errorSuspend; // for debugging int _errorSuspend; // for debugging
mutable int _errorSource; mutable int _errorSource;
int _errorPos; int _errorPos;
SceUID _errorHandle; SceUID _errorHandle;
int _suspendCount; int _suspendCount;
bool synchronizePhysicalPos(); // synchronize the physical and virtual positions bool physicalSeekFromCur(int32 offset);
bool isOffsetInCache(uint32 pos); // check if an offset is found in cache
bool isCacheValid() { return _cacheStartOffset != -1; }
public: public:
/** /**
* Given a path, invoke fopen on that path and wrap the result in a * Given a path, invoke fopen on that path and wrap the result in a
* PSPIoStream instance. * PspIoStream instance.
*/ */
static PSPIoStream *makeFromPath(const Common::String &path, bool writeMode); static PspIoStream *makeFromPath(const Common::String &path, bool writeMode);
PSPIoStream(const Common::String &path, bool writeMode); PspIoStream(const Common::String &path, bool writeMode);
virtual ~PSPIoStream(); virtual ~PspIoStream();
void * open(); // open the file pointed to by the file path void * open(); // open the file pointed to by the file path
@ -97,6 +102,7 @@ public:
virtual bool seek(int32 offs, int whence = SEEK_SET); virtual bool seek(int32 offs, int whence = SEEK_SET);
virtual uint32 read(void *dataPtr, uint32 dataSize); virtual uint32 read(void *dataPtr, uint32 dataSize);
// for suspending
int suspend(); /* Suspendable interface (power manager) */ int suspend(); /* Suspendable interface (power manager) */
int resume(); /* " " */ int resume(); /* " " */
}; };

174
backends/platform/psp/tests.cpp
View File

@ -43,7 +43,9 @@
#include "backends/platform/psp/rtc.h" #include "backends/platform/psp/rtc.h"
#include "backends/platform/psp/thread.h" #include "backends/platform/psp/thread.h"
#include "backends/platform/psp/memory.h" #include "backends/platform/psp/memory.h"
#include "common/stream.h"
#include "common/file.h"
#include "common/fs.h"
#define UNCACHED(x) ((byte *)(((uint32)(x)) | 0x40000000)) /* make an uncached access */ #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 CACHED(x) ((byte *)(((uint32)(x)) & 0xBFFFFFFF)) /* make an uncached access into a cached one */
@ -445,6 +447,7 @@ void PspSpeedTests::fastCopySpeed() {
class PspUnitTests { class PspUnitTests {
public: public:
void testFastCopy(); void testFastCopy();
bool testFileSystem();
private: private:
enum { enum {
@ -453,6 +456,7 @@ private:
void fastCopySpecificSize(byte *dst, byte *src, uint32 bytes, bool swap = false); void fastCopySpecificSize(byte *dst, byte *src, uint32 bytes, bool swap = false);
void fastCopyDifferentSizes(byte *dst, byte *src, bool swap = false); void fastCopyDifferentSizes(byte *dst, byte *src, bool swap = false);
}; };
void PspUnitTests::testFastCopy() { void PspUnitTests::testFastCopy() {
@ -537,6 +541,171 @@ void PspUnitTests::fastCopySpecificSize(byte *dst, byte *src, uint32 bytes, bool
} }
} }
// This function leaks. For now I don't care
bool PspUnitTests::testFileSystem() {
// create memory
const uint32 BufSize = 32 * 1024;
char* buffer = new char[BufSize];
int i;
Common::WriteStream *wrStream;
Common::SeekableReadStream *rdStream;
PSP_INFO_PRINT("testing fileSystem...\n");
// fill buffer
for (i=0; i<(int)BufSize; i += 4) {
buffer[i] = 'A';
buffer[i + 1] = 'B';
buffer[i + 2] = 'C';
buffer[i + 3] = 'D';
}
// create a file
const char *path = "./file.test";
Common::FSNode file(path);
PSP_INFO_PRINT("creating write stream...\n");
wrStream = file.createWriteStream();
if (!wrStream) {
PSP_ERROR("%s couldn't be created.\n", path);
return false;
}
// write contents
char* index = buffer;
int32 totalLength = BufSize;
int32 curLength = 50;
PSP_INFO_PRINT("writing...\n");
while(totalLength - curLength > 0) {
if ((int)wrStream->write(index, curLength) != curLength) {
PSP_ERROR("couldn't write %d bytes\n", curLength);
return false;
}
totalLength -= curLength;
index += curLength;
//curLength *= 2;
//PSP_INFO_PRINT("write\n");
}
// write the rest
if ((int)wrStream->write(index, totalLength) != totalLength) {
PSP_ERROR("couldn't write %d bytes\n", curLength);
return false;
}
delete wrStream;
PSP_INFO_PRINT("reading...\n");
rdStream = file.createReadStream();
if (!rdStream) {
PSP_ERROR("%s couldn't be created.\n", path);
return false;
}
// seek to beginning
if (!rdStream->seek(0, SEEK_SET)) {
PSP_ERROR("couldn't seek to the beginning after writing the file\n");
return false;
}
// read the contents
char *readBuffer = new char[BufSize + 4];
memset(readBuffer, 0, (BufSize + 4));
index = readBuffer;
while (rdStream->read(index, 100) == 100) {
index += 100;
}
if (!rdStream->eos()) {
PSP_ERROR("didn't find EOS at end of stream\n");
return false;
}
// compare
for (i=0; i<(int)BufSize; i++)
if (buffer[i] != readBuffer[i]) {
PSP_ERROR("reading/writing mistake at %x. Got %x instead of %x\n", i, readBuffer[i], buffer[i]);
return false;
}
// Check for exceeding limit
for (i=0; i<4; i++) {
if (readBuffer[BufSize + i]) {
PSP_ERROR("read exceeded limits. %d = %x\n", BufSize + i, readBuffer[BufSize + i]);
}
}
delete rdStream;
PSP_INFO_PRINT("writing...\n");
wrStream = file.createWriteStream();
if (!wrStream) {
PSP_ERROR("%s couldn't be created.\n", path);
return false;
}
const char *phrase = "Jello is really fabulous";
uint32 phraseLen = strlen(phrase);
int ret;
if ((ret = wrStream->write(phrase, phraseLen)) != (int)phraseLen) {
PSP_ERROR("couldn't write phrase. Got %d instead of %d\n", ret, phraseLen);
return false;
}
PSP_INFO_PRINT("reading...\n");
delete wrStream;
rdStream = file.createReadStream();
if (!rdStream) {
PSP_ERROR("%s couldn't be created.\n", path);
return false;
}
char *readPhrase = new char[phraseLen + 2];
memset(readPhrase, 0, phraseLen + 2);
if ((ret = rdStream->read(readPhrase, phraseLen) != phraseLen)) {
PSP_ERROR("read error on phrase. Got %d instead of %d\n", ret, phraseLen);
return false;
}
for (i=0; i<(int)phraseLen; i++) {
if (readPhrase[i] != phrase[i]) {
PSP_ERROR("bad read/write in phrase. At %d, %x != %x\n", i, readPhrase[i], phrase[i]);
return false;
}
}
// check for exceeding
if (readPhrase[i] != 0) {
PSP_ERROR("found excessive copy in phrase. %c at %d\n", readPhrase[i], i);
return false;
}
PSP_INFO_PRINT("trying to read end...\n");
// seek to end
if (!rdStream->seek(0, SEEK_END)) {
PSP_ERROR("couldn't seek to end for append\n");
return false;
};
// try to read
if (rdStream->read(readPhrase, 2) || !rdStream->eos()) {
PSP_ERROR("was able to read at end of file\n");
return false;
}
PSP_INFO_PRINT("ok\n");
return true;
}
void psp_tests() { void psp_tests() {
PSP_INFO_PRINT("in tests\n"); PSP_INFO_PRINT("in tests\n");
@ -558,7 +727,8 @@ void psp_tests() {
// Unit tests // Unit tests
PspUnitTests unitTests; PspUnitTests unitTests;
unitTests.testFastCopy(); //unitTests.testFastCopy();
unitTests.testFileSystem();
#endif #endif
} }