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

netlist: memory allocation clean-up. (nw)

Browse Source
This commit is contained in:
couriersud 2019-02-13 21:19:59 +01:00
parent 182a06055f
commit fb685c05b9
15 changed files with 184 additions and 173 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
scripts/src/netlist.lua
View File

@ -49,7 +49,6 @@ project "netlist"
MAME_DIR .. "src/lib/netlist/nl_setup.h",
MAME_DIR .. "src/lib/netlist/nl_time.h",
MAME_DIR .. "src/lib/netlist/plib/pconfig.h",
MAME_DIR .. "src/lib/netlist/plib/palloc.cpp",
MAME_DIR .. "src/lib/netlist/plib/palloc.h",
MAME_DIR .. "src/lib/netlist/plib/pchrono.cpp",
MAME_DIR .. "src/lib/netlist/plib/pchrono.h",
@ -64,6 +63,7 @@ project "netlist"
MAME_DIR .. "src/lib/netlist/plib/pdynlib.h",
MAME_DIR .. "src/lib/netlist/plib/pmain.cpp",
MAME_DIR .. "src/lib/netlist/plib/pmain.h",
MAME_DIR .. "src/lib/netlist/plib/pmempool.h",
MAME_DIR .. "src/lib/netlist/plib/pomp.h",
MAME_DIR .. "src/lib/netlist/plib/poptions.cpp",
MAME_DIR .. "src/lib/netlist/plib/poptions.h",

1
src/lib/netlist/build/makefile
View File

@ -80,7 +80,6 @@ OBJS = $(POBJS) $(NLOBJS)
POBJS := \
$(POBJ)/pstring.o \
$(POBJ)/palloc.o \
$(POBJ)/pchrono.o \
$(POBJ)/pdynlib.o \
$(POBJ)/pexception.o \

4
src/lib/netlist/devices/nld_7448.cpp
View File

@ -7,8 +7,8 @@
#include <array>
#include "nlid_truthtable.h"
#include "nld_7448.h"
#include "nld_7448.h"
#include "nlid_truthtable.h"
namespace netlist
{

2
src/lib/netlist/devices/nlid_system.h
View File

@ -28,7 +28,7 @@ namespace netlist
{
NETLIB_CONSTRUCTOR(netlistparams)
, m_use_deactivate(*this, "USE_DEACTIVATE", false)
, m_startup_strategy(*this, "STARTUP_STRATEGY", 0)
, m_startup_strategy(*this, "STARTUP_STRATEGY", 1)
{
}
NETLIB_UPDATEI() { }

7
src/lib/netlist/nl_base.cpp
View File

@ -9,6 +9,7 @@
#include "solver/nld_solver.h"
#include "plib/palloc.h"
#include "plib/pmempool.h"
#include "plib/putil.h"
#include "devices/nlid_proxy.h"
@ -29,10 +30,8 @@ namespace detail
static plib::mempool *pool()
{
static plib::mempool *s_pool = nullptr;
if (s_pool == nullptr)
s_pool = new plib::mempool(65536, 16);
return s_pool;
static plib::mempool s_pool(655360, 32);
return &s_pool;
}
void * object_t::operator new (size_t size)

14
src/lib/netlist/nl_setup.h
View File

@ -8,21 +8,22 @@
#ifndef NLSETUP_H_
#define NLSETUP_H_
#include <memory>
#include <stack>
#include <unordered_map>
#include <vector>
#include "plib/pparser.h"
#include "plib/pstate.h"
//#include "plib/pstate.h"
#include "plib/pstream.h"
#include "plib/pstring.h"
#include "plib/putil.h"
#include "netlist_types.h"
#include "nl_config.h"
#include "nl_errstr.h"
//#include "nl_errstr.h"
#include "nl_factory.h"
#include <memory>
#include <stack>
#include <vector>
//============================================================
// MACROS / inline netlist definitions
//============================================================
@ -112,7 +113,6 @@ void NETLIST_NAME(name)(netlist::setup_t &setup) \
setup.tt_factory_create(desc, __FILE__); \
}
namespace netlist
{

16
src/lib/netlist/plib/mat_cr.h
View File

@ -28,6 +28,9 @@
namespace plib
{
// FIXME: causes a crash with GMRES handler
// template<typename T, int N, typename C = std::size_t>
template<typename T, int N, typename C = uint16_t>
struct matrix_compressed_rows_t
{
@ -69,7 +72,7 @@ namespace plib
~matrix_compressed_rows_t() = default;
index_type size() const { return m_size; }
constexpr index_type size() const { return (N>0) ? N : m_size; }
void set_scalar(const T scalar)
{
@ -382,7 +385,7 @@ namespace plib
*
*/
for (std::size_t i = 1; i < m_size; i++) // row i
for (std::size_t i = 1; i < size(); i++) // row i
{
const std::size_t p_i_end = row_idx[i + 1];
// loop over all columns k left of diag in row i
@ -398,8 +401,8 @@ namespace plib
while (i_j < p_i_end && k_j < p_k_end ) // pj = (i, j)
{
// we can assume that within a row ja increases continuously */
const auto c_i_j = col_idx[i_j]; // row i, column j
const auto c_k_j = col_idx[k_j]; // row i, column j
const std::size_t c_i_j = col_idx[i_j]; // row i, column j
const std::size_t c_k_j = col_idx[k_j]; // row i, column j
if (c_k_j < c_i_j)
k_j++;
else if (c_k_j == c_i_j)
@ -435,7 +438,7 @@ namespace plib
* This can be solved for x using backwards elimination in U.
*
*/
for (std::size_t i = 1; i < m_size; ++i )
for (std::size_t i = 1; i < size(); ++i )
{
T tmp = 0.0;
const std::size_t j1 = row_idx[i];
@ -443,11 +446,10 @@ namespace plib
for (std::size_t j = j1; j < j2; ++j )
tmp += A[j] * r[col_idx[j]];
r[i] -= tmp;
}
// i now is equal to n;
for (std::size_t i = m_size; i-- > 0; )
for (std::size_t i = size(); i-- > 0; )
{
T tmp = 0.0;
const std::size_t di = diag[i];

105
src/lib/netlist/plib/palloc.cpp
View File

@ -1,105 +0,0 @@
// license:GPL-2.0+
// copyright-holders:Couriersud
/*
* palloc.c
*
*/
#include "pconfig.h"
#include "palloc.h"
#include "pexception.h"
#include "pfmtlog.h"
#include "pstream.h"
#include <algorithm>
namespace plib {
//============================================================
// Memory pool
//============================================================
mempool::mempool(size_t min_alloc, size_t min_align)
: m_min_alloc(min_alloc), m_min_align(min_align)
{
}
mempool::~mempool()
{
for (auto & b : m_blocks)
{
if (b->m_num_alloc != 0)
{
perrlogger("Found block with {} dangling allocations\n", b->m_num_alloc);
}
::operator delete(b->data);
}
m_blocks.clear();
}
mempool::block * mempool::new_block()
{
auto *b = new block();
b->data = static_cast<char *>(::operator new(m_min_alloc));
b->cur_ptr = b->data;
b->m_free = m_min_alloc;
b->m_num_alloc = 0;
m_blocks.push_back(b);
return b;
}
size_t mempool::mininfosize()
{
size_t sinfo = sizeof(mempool::info);
#ifdef __APPLE__
size_t ma = 16;
#else
size_t ma = 8;
#endif
return ((std::max(m_min_align, sinfo) + ma - 1) / ma) * ma;
}
void *mempool::alloc(size_t size)
{
size_t rs = (size + mininfosize() + m_min_align - 1) & ~(m_min_align - 1);
for (auto &b : m_blocks)
{
if (b->m_free > rs)
{
b->m_free -= rs;
b->m_num_alloc++;
auto i = reinterpret_cast<info *>(b->cur_ptr);
i->m_block = b;
auto ret = reinterpret_cast<void *>(b->cur_ptr + mininfosize());
b->cur_ptr += rs;
return ret;
}
}
{
block *b = new_block();
b->m_num_alloc = 1;
b->m_free = m_min_alloc - rs;
auto i = reinterpret_cast<info *>(b->cur_ptr);
i->m_block = b;
auto ret = reinterpret_cast<void *>(b->cur_ptr + mininfosize());
b->cur_ptr += rs;
return ret;
}
}
void mempool::free(void *ptr)
{
auto p = reinterpret_cast<char *>(ptr);
auto i = reinterpret_cast<info *>(p - mininfosize());
block *b = i->m_block;
if (b->m_num_alloc == 0)
throw plib::pexception("mempool::free - double free was called\n");
else
{
//b->m_free = m_min_alloc;
//b->cur_ptr = b->data;
}
b->m_num_alloc--;
}
} // namespace plib

38
src/lib/netlist/plib/palloc.h
View File

@ -151,44 +151,6 @@ private:
bool m_is_owned;
};
class mempool
{
private:
struct block
{
block() : m_num_alloc(0), m_free(0), cur_ptr(nullptr), data(nullptr) { }
std::size_t m_num_alloc;
std::size_t m_free;
char *cur_ptr;
char *data;
};
block * new_block();
size_t mininfosize();
struct info
{
info() : m_block(nullptr) { }
block * m_block;
};
size_t m_min_alloc;
size_t m_min_align;
std::vector<block *> m_blocks;
public:
mempool(size_t min_alloc, size_t min_align);
COPYASSIGNMOVE(mempool, delete)
~mempool();
void *alloc(size_t size);
void free(void *ptr);
};
} // namespace plib
#endif /* PALLOC_H_ */

3
src/lib/netlist/plib/pmain.h
View File

@ -10,6 +10,7 @@
#ifndef PMAIN_H_
#define PMAIN_H_
#include "palloc.h"
#include "poptions.h"
#include "pstream.h"
#include "pstring.h"
@ -53,7 +54,7 @@ namespace plib {
template <class C, typename T>
static int mainrun(int argc, T **argv)
{
auto a = std::unique_ptr<C>(new C);
auto a = plib::make_unique<C>();
return a->main_utfX(argc, argv);
}

153
src/lib/netlist/plib/pmempool.h Normal file
View File

@ -0,0 +1,153 @@
// license:GPL-2.0+
// copyright-holders:Couriersud
/*
* palloc.h
*
*/
#ifndef PMEMPOOL_H_
#define PMEMPOOL_H_
#include "palloc.h"
#include "pstream.h"
#include "pstring.h"
#include "ptypes.h"
#include "putil.h"
#include <algorithm>
#include <cstddef>
#include <memory>
#include <unordered_map>
#include <utility>
#include <vector>
namespace plib {
//============================================================
// Memory pool
//============================================================
class mempool
{
private:
struct block
{
block(mempool *mp)
: m_num_alloc(0)
, m_free(mp->m_min_alloc)
, m_cur(0)
, m_data(nullptr)
, m_mempool(mp)
{
std::size_t alloc_bytes = (mp->m_min_alloc + mp->m_min_align - 1) & ~(mp->m_min_align - 1);
m_data_allocated = static_cast<char *>(::operator new(alloc_bytes));
void *r = m_data_allocated;
std::align(mp->m_min_align, mp->m_min_alloc, r, alloc_bytes);
m_data = reinterpret_cast<char *>(r);
}
std::size_t m_num_alloc;
std::size_t m_free;
std::size_t m_cur;
char *m_data;
char *m_data_allocated;
mempool *m_mempool;
};
struct info
{
info(block *b, std::size_t p) : m_block(b), m_pos(p) { }
info(const info &) = default;
info(info &&) = default;
block * m_block;
std::size_t m_pos;
};
block * new_block()
{
auto *b = new block(this);
m_blocks.push_back(b);
return b;
}
static std::unordered_map<void *, info> &sinfo()
{
static std::unordered_map<void *, info> spinfo;
return spinfo;
}
size_t m_min_alloc;
size_t m_min_align;
std::vector<block *> m_blocks;
public:
mempool(size_t min_alloc, size_t min_align)
: m_min_alloc(min_alloc), m_min_align(min_align)
{
}
COPYASSIGNMOVE(mempool, delete)
~mempool()
{
for (auto & b : m_blocks)
{
if (b->m_num_alloc != 0)
{
plib::perrlogger("Found block with {} dangling allocations\n", b->m_num_alloc);
}
::operator delete(b->m_data);
}
}
void *alloc(size_t size)
{
size_t rs = (size + m_min_align - 1) & ~(m_min_align - 1);
for (auto &b : m_blocks)
{
if (b->m_free > rs)
{
b->m_free -= rs;
b->m_num_alloc++;
auto ret = reinterpret_cast<void *>(b->m_data + b->m_cur);
sinfo().insert({ ret, info(b, b->m_cur)});
b->m_cur += rs;
return ret;
}
}
{
block *b = new_block();
b->m_num_alloc = 1;
b->m_free = m_min_alloc - rs;
auto ret = reinterpret_cast<void *>(b->m_data + b->m_cur);
sinfo().insert({ ret, info(b, b->m_cur)});
b->m_cur += rs;
return ret;
}
}
void free(void *ptr)
{
info i = sinfo().find(ptr)->second;
block *b = i.m_block;
if (b->m_num_alloc == 0)
throw plib::pexception("mempool::free - double free was called\n");
else
{
//b->m_free = m_min_alloc;
//b->cur_ptr = b->data;
}
b->m_num_alloc--;
}
};
} // namespace plib
#endif /* PMEMPOOL_H_ */

4
src/lib/netlist/plib/pstream.h
View File

@ -626,11 +626,11 @@ public:
{
std::size_t sz = 0;
read(sz);
auto buf = new plib::string_info<pstring>::mem_t[sz+1];
auto buf = plib::palloc_array<plib::string_info<pstring>::mem_t>(sz+1);
m_strm.read(reinterpret_cast<pistream::value_type *>(buf), sz);
buf[sz] = 0;
s = pstring(buf);
delete [] buf;
plib::pfree_array(buf);
}
template <typename T>

2
src/lib/netlist/solver/nld_ms_gmres.h
View File

@ -105,7 +105,7 @@ namespace devices
{
const std::size_t iN = this->size();
plib::parray<FT, SIZE> RHS(iN);
alignas(128) plib::parray<FT, SIZE> RHS(iN);
//float_type new_V[storage_N];
m_ops.m_mat.set_scalar(0.0);

4
src/lib/netlist/solver/nld_solver.cpp
View File

@ -343,8 +343,8 @@ void NETLIB_NAME(solver)::post_start()
break;
#endif
#if 0
case 87:
ms = create_solver<87,87>(87, sname);
case 86:
ms = create_solver<double,86>(86, sname);
break;
#endif
#endif

2
src/lib/netlist/tools/nl_convert.h
View File

@ -10,10 +10,10 @@
#ifndef NL_CONVERT_H_
#define NL_CONVERT_H_
#include "../plib/ptypes.h"
#include "../plib/plists.h"
#include "../plib/pparser.h"
#include "../plib/pstring.h"
#include "../plib/ptypes.h"
#include <memory>
/*-------------------------------------------------