mirror of https://github.com/PCSX2/pcsx2.git
265 lines
8.2 KiB
C++
265 lines
8.2 KiB
C++
/* PCSX2 - PS2 Emulator for PCs
|
|
* Copyright (C) 2002-2010 PCSX2 Dev Team
|
|
*
|
|
* PCSX2 is free software: you can redistribute it and/or modify it under the terms
|
|
* of the GNU Lesser General Public License as published by the Free Software Found-
|
|
* ation, either version 3 of the License, or (at your option) any later version.
|
|
*
|
|
* PCSX2 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 PCSX2.
|
|
* If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include "common/Exceptions.h"
|
|
|
|
// pxUSE_SECURE_MALLOC - enables bounds checking on scoped malloc allocations.
|
|
|
|
#ifndef pxUSE_SECURE_MALLOC
|
|
#define pxUSE_SECURE_MALLOC 0
|
|
#endif
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
// Safe deallocation macros -- checks pointer validity (non-null) when needed, and sets
|
|
// pointer to null after deallocation.
|
|
|
|
#define safe_delete(ptr) \
|
|
((void)(delete (ptr)), (ptr) = NULL)
|
|
|
|
#define safe_delete_array(ptr) \
|
|
((void)(delete[](ptr)), (ptr) = NULL)
|
|
|
|
// No checks for NULL -- wxWidgets says it's safe to skip NULL checks and it runs on
|
|
// just about every compiler and libc implementation of any recentness.
|
|
#define safe_free(ptr) \
|
|
((void)(free(ptr), !!0), (ptr) = NULL)
|
|
//((void) (( ( (ptr) != NULL ) && (free( ptr ), !!0) ), (ptr) = NULL))
|
|
|
|
#define safe_fclose(ptr) \
|
|
((void)((((ptr) != NULL) && (fclose(ptr), !!0)), (ptr) = NULL))
|
|
|
|
// Implementation note: all known implementations of _aligned_free check the pointer for
|
|
// NULL status (our implementation under GCC, and microsoft's under MSVC), so no need to
|
|
// do it here.
|
|
#define safe_aligned_free(ptr) \
|
|
((void)(_aligned_free(ptr), (ptr) = NULL))
|
|
|
|
// aligned_malloc: Implement/declare linux equivalents here!
|
|
#if !defined(_MSC_VER)
|
|
extern void* __fastcall _aligned_malloc(size_t size, size_t align);
|
|
extern void* __fastcall pcsx2_aligned_realloc(void* handle, size_t new_size, size_t align, size_t old_size);
|
|
extern void _aligned_free(void* pmem);
|
|
#else
|
|
#define pcsx2_aligned_realloc(handle, new_size, align, old_size) \
|
|
_aligned_realloc(handle, new_size, align)
|
|
#endif
|
|
|
|
// --------------------------------------------------------------------------------------
|
|
// pxDoOutOfMemory
|
|
// --------------------------------------------------------------------------------------
|
|
|
|
typedef void FnType_OutOfMemory(uptr blocksize);
|
|
typedef FnType_OutOfMemory* Fnptr_OutOfMemory;
|
|
|
|
// This method is meant to be assigned by applications that link against pxWex. It is called
|
|
// (invoked) prior to most pxWex built-in memory/array classes throwing exceptions, and can be
|
|
// used by an application to remove unneeded memory allocations and/or reduce internal cache
|
|
// reserves.
|
|
//
|
|
// Example: PCSX2 uses several bloated recompiler code caches. Larger caches improve performance,
|
|
// however a rouge cache growth could cause memory constraints in the operating system. If an out-
|
|
// of-memory error occurs, PCSX2's implementation of this function attempts to reset all internal
|
|
// recompiler caches. This can typically free up 100-150 megs of memory, and will allow the app
|
|
// to continue running without crashing or hanging the operating system, etc.
|
|
//
|
|
extern Fnptr_OutOfMemory pxDoOutOfMemory;
|
|
|
|
|
|
// --------------------------------------------------------------------------------------
|
|
// BaseScopedAlloc
|
|
// --------------------------------------------------------------------------------------
|
|
// Base class that allows various ScopedMalloc types to be passed to functions that act
|
|
// on them.
|
|
//
|
|
// Rationale: This class and the derived varieties are provided as a simple autonomous self-
|
|
// destructing container for malloc. The entire class is almost completely dependency free,
|
|
// and thus can be included everywhere and anywhere without dependency hassles.
|
|
//
|
|
template <typename T>
|
|
class BaseScopedAlloc
|
|
{
|
|
protected:
|
|
T* m_buffer;
|
|
uint m_size;
|
|
|
|
public:
|
|
BaseScopedAlloc()
|
|
{
|
|
m_buffer = NULL;
|
|
m_size = 0;
|
|
}
|
|
|
|
virtual ~BaseScopedAlloc()
|
|
{
|
|
//pxAssert(m_buffer==NULL);
|
|
}
|
|
|
|
public:
|
|
size_t GetSize() const { return m_size; }
|
|
size_t GetLength() const { return m_size; }
|
|
|
|
// Allocates the object to the specified size. If an existing allocation is in
|
|
// place, it is freed and replaced with the new allocation, and all data is lost.
|
|
// Parameter:
|
|
// newSize - size of the new allocation, in elements (not bytes!). If the specified
|
|
// size is 0, the the allocation is freed, same as calling Free().
|
|
virtual void Alloc(size_t newsize) = 0;
|
|
|
|
// Re-sizes the allocation to the requested size, without any data loss.
|
|
// Parameter:
|
|
// newSize - size of the new allocation, in elements (not bytes!). If the specified
|
|
// size is 0, the the allocation is freed, same as calling Free().
|
|
virtual void Resize(size_t newsize) = 0;
|
|
|
|
void Free()
|
|
{
|
|
Alloc(0);
|
|
}
|
|
|
|
// Makes enough room for the requested size. Existing data in the array is retained.
|
|
void MakeRoomFor(uint size)
|
|
{
|
|
if (size <= m_size)
|
|
return;
|
|
Resize(size);
|
|
}
|
|
|
|
T* GetPtr(uint idx = 0) const
|
|
{
|
|
#if pxUSE_SECURE_MALLOC
|
|
IndexBoundsAssumeDev("ScopedAlloc", idx, m_size);
|
|
#endif
|
|
return &m_buffer[idx];
|
|
}
|
|
|
|
T& operator[](uint idx)
|
|
{
|
|
#if pxUSE_SECURE_MALLOC
|
|
IndexBoundsAssumeDev("ScopedAlloc", idx, m_size);
|
|
#endif
|
|
return m_buffer[idx];
|
|
}
|
|
|
|
const T& operator[](uint idx) const
|
|
{
|
|
#if pxUSE_SECURE_MALLOC
|
|
IndexBoundsAssumeDev("ScopedAlloc", idx, m_size);
|
|
#endif
|
|
return m_buffer[idx];
|
|
}
|
|
};
|
|
|
|
// --------------------------------------------------------------------------------------
|
|
// ScopedAlloc
|
|
// --------------------------------------------------------------------------------------
|
|
// A simple container class for a standard malloc allocation. By default, no bounds checking
|
|
// is performed, and there is no option for enabling bounds checking. If bounds checking and
|
|
// other features are needed, use the more robust SafeArray<> instead.
|
|
//
|
|
// See docs for BaseScopedAlloc for details and rationale.
|
|
//
|
|
template <typename T>
|
|
class ScopedAlloc : public BaseScopedAlloc<T>
|
|
{
|
|
typedef BaseScopedAlloc<T> _parent;
|
|
|
|
public:
|
|
ScopedAlloc(size_t size = 0)
|
|
: _parent()
|
|
{
|
|
Alloc(size);
|
|
}
|
|
|
|
virtual ~ScopedAlloc()
|
|
{
|
|
safe_free(this->m_buffer);
|
|
}
|
|
|
|
virtual void Alloc(size_t newsize)
|
|
{
|
|
safe_free(this->m_buffer);
|
|
this->m_size = newsize;
|
|
if (!this->m_size)
|
|
return;
|
|
|
|
this->m_buffer = (T*)malloc(this->m_size * sizeof(T));
|
|
if (!this->m_buffer)
|
|
throw Exception::OutOfMemory(L"ScopedAlloc");
|
|
}
|
|
|
|
virtual void Resize(size_t newsize)
|
|
{
|
|
this->m_size = newsize;
|
|
this->m_buffer = (T*)realloc(this->m_buffer, this->m_size * sizeof(T));
|
|
|
|
if (!this->m_buffer)
|
|
throw Exception::OutOfMemory(L"ScopedAlloc::Resize");
|
|
}
|
|
|
|
using _parent::operator[];
|
|
};
|
|
|
|
// --------------------------------------------------------------------------------------
|
|
// ScopedAlignedAlloc
|
|
// --------------------------------------------------------------------------------------
|
|
// A simple container class for an aligned allocation. By default, no bounds checking is
|
|
// performed, and there is no option for enabling bounds checking. If bounds checking and
|
|
// other features are needed, use the more robust SafeArray<> instead.
|
|
//
|
|
// See docs for BaseScopedAlloc for details and rationale.
|
|
//
|
|
template <typename T, uint align>
|
|
class ScopedAlignedAlloc : public BaseScopedAlloc<T>
|
|
{
|
|
typedef BaseScopedAlloc<T> _parent;
|
|
|
|
public:
|
|
ScopedAlignedAlloc(size_t size = 0)
|
|
: _parent()
|
|
{
|
|
Alloc(size);
|
|
}
|
|
|
|
virtual ~ScopedAlignedAlloc()
|
|
{
|
|
safe_aligned_free(this->m_buffer);
|
|
}
|
|
|
|
virtual void Alloc(size_t newsize)
|
|
{
|
|
safe_aligned_free(this->m_buffer);
|
|
this->m_size = newsize;
|
|
if (!this->m_size)
|
|
return;
|
|
|
|
this->m_buffer = (T*)_aligned_malloc(this->m_size * sizeof(T), align);
|
|
if (!this->m_buffer)
|
|
throw Exception::OutOfMemory(L"ScopedAlignedAlloc");
|
|
}
|
|
|
|
virtual void Resize(size_t newsize)
|
|
{
|
|
this->m_buffer = (T*)pcsx2_aligned_realloc(this->m_buffer, newsize * sizeof(T), align, this->m_size * sizeof(T));
|
|
this->m_size = newsize;
|
|
|
|
if (!this->m_buffer)
|
|
throw Exception::OutOfMemory(L"ScopedAlignedAlloc::Resize");
|
|
}
|
|
|
|
using _parent::operator[];
|
|
};
|