Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-06-06 04:43:45 +03:00
Code Issues Actions Packages Projects Releases Wiki Activity

Remove emualloc.*

Browse Source
This commit is contained in:
AJR 2021-06-22 09:00:11 -04:00
parent 1c0852d3d4
commit b915e69902
9 changed files with 3 additions and 364 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
scripts/src/emu.lua
View File

@ -111,8 +111,6 @@ files {
MAME_DIR .. "src/emu/driver.h",
MAME_DIR .. "src/emu/drivenum.cpp",
MAME_DIR .. "src/emu/drivenum.h",
MAME_DIR .. "src/emu/emualloc.cpp",
MAME_DIR .. "src/emu/emualloc.h",
MAME_DIR .. "src/emu/emucore.cpp",
MAME_DIR .. "src/emu/emucore.h",
MAME_DIR .. "src/emu/emumem.cpp",
@ -268,8 +266,7 @@ files {
}
pchsource(MAME_DIR .. "src/emu/main.cpp")
-- 3 files do not include emu.h
nopch(MAME_DIR .. "src/emu/emualloc.cpp")
-- 2 files do not include emu.h
nopch(MAME_DIR .. "src/emu/attotime.cpp")
nopch(MAME_DIR .. "src/emu/debug/textbuf.cpp")

1
src/emu/emu.h
View File

@ -38,6 +38,7 @@
#include "http.h"
// commonly-referenced utilities imported from lib/util
#include "corealloc.h"
#include "palette.h"
// emulator-specific utilities

207
src/emu/emualloc.cpp
View File

@ -1,207 +0,0 @@
// license:BSD-3-Clause
// copyright-holders:Aaron Giles
/***************************************************************************
emualloc.cpp
Memory allocation helpers for the core emulator.
***************************************************************************/
#include "emucore.h"
//**************************************************************************
// DEBUGGING
//**************************************************************************
#define LOG_ALLOCS (0)
//**************************************************************************
// GLOBALS
//**************************************************************************
osd::u64 resource_pool::s_id = 0;
//**************************************************************************
// RESOURCE POOL
//**************************************************************************
//-------------------------------------------------
// resource_pool - constructor for a new resource
// pool
//-------------------------------------------------
resource_pool::resource_pool(int hash_size)
: m_hash_size(hash_size),
m_hash(hash_size),
m_ordered_head(nullptr),
m_ordered_tail(nullptr)
{
memset(&m_hash[0], 0, hash_size*sizeof(m_hash[0]));
}
//-------------------------------------------------
// ~resource_pool - destructor for a resource
// pool; make sure all tracked objects are
// deleted
//-------------------------------------------------
resource_pool::~resource_pool()
{
clear();
}
//-------------------------------------------------
// add - add a new item to the resource pool
//-------------------------------------------------
void resource_pool::add(resource_pool_item &item, size_t size, const char *type)
{
std::lock_guard<std::mutex> lock(m_listlock);
// insert into hash table
int hashval = reinterpret_cast<uintptr_t>(item.m_ptr) % m_hash_size;
item.m_next = m_hash[hashval];
m_hash[hashval] = &item;
// fetch the ID of this item's pointer; some implementations put hidden data
// before, so if we don't find it, check 4 bytes ahead
item.m_id = ++s_id;
if (LOG_ALLOCS)
fprintf(stderr, "#%06d, add %s, %d bytes\n", u32(item.m_id), type, u32(size));
// find the entry to insert after
resource_pool_item *insert_after;
for (insert_after = m_ordered_tail; insert_after != nullptr; insert_after = insert_after->m_ordered_prev)
if (insert_after->m_id < item.m_id)
break;
// insert into the appropriate spot
if (insert_after != nullptr)
{
item.m_ordered_next = insert_after->m_ordered_next;
if (item.m_ordered_next != nullptr)
item.m_ordered_next->m_ordered_prev = &item;
else
m_ordered_tail = &item;
item.m_ordered_prev = insert_after;
insert_after->m_ordered_next = &item;
}
else
{
item.m_ordered_next = m_ordered_head;
if (item.m_ordered_next != nullptr)
item.m_ordered_next->m_ordered_prev = &item;
else
m_ordered_tail = &item;
item.m_ordered_prev = nullptr;
m_ordered_head = &item;
}
}
//-------------------------------------------------
// remove - remove a specific item from the
// resource pool
//-------------------------------------------------
void resource_pool::remove(void *ptr)
{
// ignore NULLs
if (ptr == nullptr)
return;
// search for the item
std::lock_guard<std::mutex> lock(m_listlock);
int hashval = reinterpret_cast<uintptr_t>(ptr) % m_hash_size;
for (resource_pool_item **scanptr = &m_hash[hashval]; *scanptr != nullptr; scanptr = &(*scanptr)->m_next)
// must match the pointer
if ((*scanptr)->m_ptr == ptr)
{
// remove from hash table
resource_pool_item *deleteme = *scanptr;
*scanptr = deleteme->m_next;
// remove from ordered list
if (deleteme->m_ordered_prev != nullptr)
deleteme->m_ordered_prev->m_ordered_next = deleteme->m_ordered_next;
else
m_ordered_head = deleteme->m_ordered_next;
if (deleteme->m_ordered_next != nullptr)
deleteme->m_ordered_next->m_ordered_prev = deleteme->m_ordered_prev;
else
m_ordered_tail = deleteme->m_ordered_prev;
// delete the object and break
if (LOG_ALLOCS)
fprintf(stderr, "#%06d, delete %d bytes\n", u32(deleteme->m_id), u32(deleteme->m_size));
delete deleteme;
break;
}
}
//-------------------------------------------------
// find - find a specific item in the resource
// pool
//-------------------------------------------------
resource_pool_item *resource_pool::find(void *ptr)
{
// search for the item
std::lock_guard<std::mutex> lock(m_listlock);
int hashval = reinterpret_cast<uintptr_t>(ptr) % m_hash_size;
resource_pool_item *item;
for (item = m_hash[hashval]; item != nullptr; item = item->m_next)
if (item->m_ptr == ptr)
break;
return item;
}
//-------------------------------------------------
// contains - return true if given ptr is
// contained by one of the objects in the pool
//-------------------------------------------------
bool resource_pool::contains(void *_ptrstart, void *_ptrend)
{
u8 *ptrstart = reinterpret_cast<u8 *>(_ptrstart);
u8 *ptrend = reinterpret_cast<u8 *>(_ptrend);
// search for the item
std::lock_guard<std::mutex> lock(m_listlock);
resource_pool_item *item = nullptr;
for (item = m_ordered_head; item != nullptr; item = item->m_ordered_next)
{
u8 *objstart = reinterpret_cast<u8 *>(item->m_ptr);
u8 *objend = objstart + item->m_size;
if (ptrstart >= objstart && ptrend <= objend)
return true;
}
return false;
}
//-------------------------------------------------
// clear - remove all items from a resource pool
//-------------------------------------------------
void resource_pool::clear()
{
// important: delete from earliest to latest; this allows objects to clean up after
// themselves if they wish
while (m_ordered_head != nullptr)
remove(m_ordered_head->m_ptr);
}

147
src/emu/emualloc.h
View File

@ -1,147 +0,0 @@
// license:BSD-3-Clause
// copyright-holders:Aaron Giles
/***************************************************************************
emualloc.h
Memory allocation helpers for the core emulator.
***************************************************************************/
#ifndef MAME_EMU_EMUALLOC_H
#define MAME_EMU_EMUALLOC_H
#pragma once
#include "osdcomm.h"
#include "corealloc.h"
#include <memory>
#include <mutex>
#include <new>
#include <vector>
//**************************************************************************
// MACROS
//**************************************************************************
// pool allocation helpers
#define pool_alloc(_pool, _type) (_pool).add_object(new _type)
#define pool_alloc_clear(_pool, _type) (_pool).add_object(make_unique_clear _type .release())
#define pool_alloc_array(_pool, _type, _num) (_pool).add_array(new _type [_num], (_num))
#define pool_alloc_array_clear(_pool, _type, _num) (_pool).add_array(make_unique_clear<_type []>(_num).release(), (_num))
#define pool_free(_pool, v) (_pool).remove(v)
//**************************************************************************
// TYPE DEFINITIONS
//**************************************************************************
// resource_pool_item is a base class for items that are tracked by a resource pool
class resource_pool_item
{
private:
resource_pool_item(const resource_pool_item &) = delete;
resource_pool_item &operator=(const resource_pool_item &) = delete;
public:
resource_pool_item(void *ptr, size_t size)
: m_next(nullptr)
, m_ordered_next(nullptr)
, m_ordered_prev(nullptr)
, m_ptr(ptr)
, m_size(size)
, m_id(~osd::u64(0))
{ }
virtual ~resource_pool_item() { }
resource_pool_item * m_next;
resource_pool_item * m_ordered_next;
resource_pool_item * m_ordered_prev;
void * m_ptr;
size_t m_size;
osd::u64 m_id;
};
// a resource_pool_object is a simple object wrapper for the templatized type
template <class ObjectClass>
class resource_pool_object : public resource_pool_item
{
private:
resource_pool_object(const resource_pool_object<ObjectClass> &) = delete;
resource_pool_object &operator=(const resource_pool_object<ObjectClass> &) = delete;
public:
resource_pool_object(ObjectClass *object)
: resource_pool_item(reinterpret_cast<void *>(object), sizeof(ObjectClass))
, m_object(object)
{ }
resource_pool_object(std::unique_ptr<ObjectClass> &&object)
: resource_pool_object(object.release())
{ }
virtual ~resource_pool_object() { delete m_object; }
private:
ObjectClass *const m_object;
};
// a resource_pool_array is a simple object wrapper for an allocated array of
// the templatized type
template <class ObjectClass> class resource_pool_array : public resource_pool_item
{
private:
resource_pool_array(const resource_pool_array<ObjectClass> &) = delete;
resource_pool_array &operator=(const resource_pool_array<ObjectClass> &) = delete;
public:
resource_pool_array(ObjectClass *array, int count)
: resource_pool_item(reinterpret_cast<void *>(array), sizeof(ObjectClass) * count)
, m_array(array)
, m_count(count)
{ }
virtual ~resource_pool_array() { delete[] m_array; }
private:
ObjectClass *const m_array;
int const m_count;
};
// a resource pool tracks items and frees them upon reset or destruction
class resource_pool
{
private:
resource_pool(const resource_pool &) = delete;
resource_pool &operator=(const resource_pool &) = delete;
public:
resource_pool(int hash_size = 193);
virtual ~resource_pool();
void add(resource_pool_item &item, size_t size, const char *type);
void remove(resource_pool_item &item) { remove(item.m_ptr); }
void remove(void *ptr);
void remove(const void *ptr) { remove(const_cast<void *>(ptr)); }
resource_pool_item *find(void *ptr);
bool contains(void *ptrstart, void *ptrend);
void clear();
template <class ObjectClass> ObjectClass *add_object(ObjectClass *object) { add(*new resource_pool_object<ObjectClass>(object), sizeof(ObjectClass), typeid(ObjectClass).name()); return object; }
template <class ObjectClass> ObjectClass *add_object(std::unique_ptr<ObjectClass> &&object) { return add_object(object.release()); }
template <class ObjectClass> ObjectClass *add_array(ObjectClass *array, int count) { add(*new resource_pool_array<ObjectClass>(array, count), sizeof(ObjectClass), typeid(ObjectClass).name()); return array; }
private:
int m_hash_size;
std::mutex m_listlock;
std::vector<resource_pool_item *> m_hash;
resource_pool_item * m_ordered_head;
resource_pool_item * m_ordered_tail;
static osd::u64 s_id;
};
#endif // MAME_EMU_EMUALLOC_H

1
src/emu/emucore.h
View File

@ -35,7 +35,6 @@
// core system includes
#include "osdcomm.h"
#include "emualloc.h"
#include "coretmpl.h"
#include "bitmap.h"
#include "strformat.h"

1
src/emu/http.h
View File

@ -17,6 +17,7 @@
#ifndef MAME_EMU_HTTP_H
#define MAME_EMU_HTTP_H
#include <mutex>
#include <thread>
#include <ctime>
#include "server_http.hpp"

3
src/emu/render.h
View File

@ -312,7 +312,6 @@ private:
// a render_texture is used to track transformations when building an object list
class render_texture
{
friend resource_pool_object<render_texture>::~resource_pool_object();
friend class simple_list<render_texture>;
friend class fixed_allocator<render_texture>;
friend class render_manager;
@ -378,7 +377,6 @@ private:
// a render_container holds a list of items and an orientation for the entire collection
class render_container
{
friend resource_pool_object<render_container>::~resource_pool_object();
friend class simple_list<render_container>;
friend class render_manager;
friend class render_target;
@ -499,7 +497,6 @@ private:
// a render_target describes a surface that is being rendered to
class render_target
{
friend resource_pool_object<render_target>::~resource_pool_object();
friend class simple_list<render_target>;
friend class render_manager;

1
src/emu/schedule.h
View File

@ -39,7 +39,6 @@ class emu_timer
friend class device_scheduler;
friend class simple_list<emu_timer>;
friend class fixed_allocator<emu_timer>;
friend class resource_pool_object<emu_timer>;
// construction/destruction
emu_timer();

1
src/emu/tilemap.h
View File

@ -410,7 +410,6 @@ class tilemap_t
friend class tilemap_device;
friend class tilemap_manager;
friend class simple_list<tilemap_t>;
friend resource_pool_object<tilemap_t>::~resource_pool_object();
// logical index
typedef u32 logical_index;