summaryrefslogtreecommitdiffstatshomepage
diff options
context:
space:
mode:
-rw-r--r--src/devices/machine/netlist.cpp6
-rw-r--r--src/devices/machine/netlist.h2
-rw-r--r--src/lib/netlist/devices/nlid_system.h2
-rw-r--r--src/lib/netlist/devices/nlid_truthtable.cpp2
-rw-r--r--src/lib/netlist/nl_base.cpp22
-rw-r--r--src/lib/netlist/nl_base.h16
-rw-r--r--src/lib/netlist/nl_factory.cpp2
-rw-r--r--src/lib/netlist/nl_factory.h6
-rw-r--r--src/lib/netlist/nl_setup.cpp14
-rw-r--r--src/lib/netlist/nltypes.h6
-rw-r--r--src/lib/netlist/plib/palloc.h378
-rw-r--r--src/lib/netlist/plib/pconfig.h2
-rw-r--r--src/lib/netlist/plib/pdynlib.cpp8
-rw-r--r--src/lib/netlist/plib/pmatrix2d.h7
-rw-r--r--src/lib/netlist/plib/pmempool.h60
-rw-r--r--src/lib/netlist/plib/pstream.cpp44
-rw-r--r--src/lib/netlist/plib/pstream.h22
-rw-r--r--src/lib/netlist/plib/ptypes.h4
-rw-r--r--src/lib/netlist/prg/nltool.cpp2
-rw-r--r--src/lib/netlist/solver/nld_matrix_solver.h2
-rw-r--r--src/lib/netlist/solver/nld_solver.cpp10
-rw-r--r--src/lib/netlist/solver/nld_solver.h6
22 files changed, 308 insertions, 315 deletions
diff --git a/src/devices/machine/netlist.cpp b/src/devices/machine/netlist.cpp
index 7beb745cbf2..280973440a9 100644
--- a/src/devices/machine/netlist.cpp
+++ b/src/devices/machine/netlist.cpp
@@ -422,11 +422,11 @@ public:
struct channel
{
- netlist::poolptr<netlist::param_str_t> m_param_name;
+ netlist::pool_owned_ptr<netlist::param_str_t> m_param_name;
netlist::param_double_t *m_param;
stream_sample_t *m_buffer;
- netlist::poolptr<netlist::param_double_t> m_param_mult;
- netlist::poolptr<netlist::param_double_t> m_param_offset;
+ netlist::pool_owned_ptr<netlist::param_double_t> m_param_mult;
+ netlist::pool_owned_ptr<netlist::param_double_t> m_param_offset;
};
channel m_channels[MAX_INPUT_CHANNELS];
netlist::netlist_time m_inc;
diff --git a/src/devices/machine/netlist.h b/src/devices/machine/netlist.h
index db27b2860df..9ec58f614bc 100644
--- a/src/devices/machine/netlist.h
+++ b/src/devices/machine/netlist.h
@@ -159,7 +159,7 @@ private:
netlist::netlist_time m_rem;
netlist::netlist_time m_old;
- netlist::poolptr<netlist_mame_t> m_netlist;
+ netlist::pool_owned_ptr<netlist_mame_t> m_netlist;
func_type m_setup_func;
};
diff --git a/src/lib/netlist/devices/nlid_system.h b/src/lib/netlist/devices/nlid_system.h
index 95712fc3416..324ceb93c38 100644
--- a/src/lib/netlist/devices/nlid_system.h
+++ b/src/lib/netlist/devices/nlid_system.h
@@ -335,7 +335,7 @@ namespace netlist
param_int_t m_N;
param_str_t m_func;
analog_output_t m_Q;
- std::vector<poolptr<analog_input_t>> m_I;
+ std::vector<pool_owned_ptr<analog_input_t>> m_I;
std::vector<double> m_vals;
plib::pfunction m_compiled;
diff --git a/src/lib/netlist/devices/nlid_truthtable.cpp b/src/lib/netlist/devices/nlid_truthtable.cpp
index 622aee0e0c7..2221d855880 100644
--- a/src/lib/netlist/devices/nlid_truthtable.cpp
+++ b/src/lib/netlist/devices/nlid_truthtable.cpp
@@ -224,7 +224,7 @@ namespace netlist
: netlist_base_factory_truthtable_t(name, classname, def_param, sourcefile)
{ }
- poolptr<device_t> Create(netlist_state_t &anetlist, const pstring &name) override
+ pool_owned_ptr<device_t> Create(netlist_state_t &anetlist, const pstring &name) override
{
using tt_type = nld_truthtable_t<m_NI, m_NO>;
truthtable_parser desc_s(m_NO, m_NI, &m_ttbl.m_initialized,
diff --git a/src/lib/netlist/nl_base.cpp b/src/lib/netlist/nl_base.cpp
index 55560151e21..55e952ad723 100644
--- a/src/lib/netlist/nl_base.cpp
+++ b/src/lib/netlist/nl_base.cpp
@@ -82,15 +82,15 @@ public:
m_R_low = 1.0;
m_R_high = 130.0;
}
- poolptr<devices::nld_base_d_to_a_proxy> create_d_a_proxy(netlist_state_t &anetlist, const pstring &name, logic_output_t *proxied) const override;
- poolptr<devices::nld_base_a_to_d_proxy> create_a_d_proxy(netlist_state_t &anetlist, const pstring &name, logic_input_t *proxied) const override;
+ pool_owned_ptr<devices::nld_base_d_to_a_proxy> create_d_a_proxy(netlist_state_t &anetlist, const pstring &name, logic_output_t *proxied) const override;
+ pool_owned_ptr<devices::nld_base_a_to_d_proxy> create_a_d_proxy(netlist_state_t &anetlist, const pstring &name, logic_input_t *proxied) const override;
};
-poolptr<devices::nld_base_d_to_a_proxy> logic_family_ttl_t::create_d_a_proxy(netlist_state_t &anetlist, const pstring &name, logic_output_t *proxied) const
+pool_owned_ptr<devices::nld_base_d_to_a_proxy> logic_family_ttl_t::create_d_a_proxy(netlist_state_t &anetlist, const pstring &name, logic_output_t *proxied) const
{
return pool().make_poolptr<devices::nld_d_to_a_proxy>(anetlist, name, proxied);
}
-poolptr<devices::nld_base_a_to_d_proxy> logic_family_ttl_t::create_a_d_proxy(netlist_state_t &anetlist, const pstring &name, logic_input_t *proxied) const
+pool_owned_ptr<devices::nld_base_a_to_d_proxy> logic_family_ttl_t::create_a_d_proxy(netlist_state_t &anetlist, const pstring &name, logic_input_t *proxied) const
{
return pool().make_poolptr<devices::nld_a_to_d_proxy>(anetlist, name, proxied);
}
@@ -109,16 +109,16 @@ public:
m_R_low = 10.0;
m_R_high = 10.0;
}
- poolptr<devices::nld_base_d_to_a_proxy> create_d_a_proxy(netlist_state_t &anetlist, const pstring &name, logic_output_t *proxied) const override;
- poolptr<devices::nld_base_a_to_d_proxy> create_a_d_proxy(netlist_state_t &anetlist, const pstring &name, logic_input_t *proxied) const override;
+ pool_owned_ptr<devices::nld_base_d_to_a_proxy> create_d_a_proxy(netlist_state_t &anetlist, const pstring &name, logic_output_t *proxied) const override;
+ pool_owned_ptr<devices::nld_base_a_to_d_proxy> create_a_d_proxy(netlist_state_t &anetlist, const pstring &name, logic_input_t *proxied) const override;
};
-poolptr<devices::nld_base_d_to_a_proxy> logic_family_cd4xxx_t::create_d_a_proxy(netlist_state_t &anetlist, const pstring &name, logic_output_t *proxied) const
+pool_owned_ptr<devices::nld_base_d_to_a_proxy> logic_family_cd4xxx_t::create_d_a_proxy(netlist_state_t &anetlist, const pstring &name, logic_output_t *proxied) const
{
return pool().make_poolptr<devices::nld_d_to_a_proxy>(anetlist, name, proxied);
}
-poolptr<devices::nld_base_a_to_d_proxy> logic_family_cd4xxx_t::create_a_d_proxy(netlist_state_t &anetlist, const pstring &name, logic_input_t *proxied) const
+pool_owned_ptr<devices::nld_base_a_to_d_proxy> logic_family_cd4xxx_t::create_a_d_proxy(netlist_state_t &anetlist, const pstring &name, logic_input_t *proxied) const
{
return pool().make_poolptr<devices::nld_a_to_d_proxy>(anetlist, name, proxied);
}
@@ -578,7 +578,7 @@ core_device_t::core_device_t(core_device_t &owner, const pstring &name)
set_logic_family(owner.logic_family());
if (logic_family() == nullptr)
set_logic_family(family_TTL());
- state().add_dev(this->name(), poolptr<core_device_t>(this, false));
+ state().add_dev(this->name(), pool_owned_ptr<core_device_t>(this, false));
}
void core_device_t::set_default_delegate(detail::core_terminal_t &term)
@@ -894,7 +894,7 @@ logic_output_t::logic_output_t(core_device_t &dev, const pstring &aname)
, m_my_net(dev.state(), name() + ".net", this)
{
this->set_net(&m_my_net);
- state().register_net(poolptr<logic_net_t>(&m_my_net, false));
+ state().register_net(pool_owned_ptr<logic_net_t>(&m_my_net, false));
set_logic_family(dev.logic_family());
state().setup().register_term(*this);
}
@@ -923,7 +923,7 @@ analog_output_t::analog_output_t(core_device_t &dev, const pstring &aname)
: analog_t(dev, aname, STATE_OUT)
, m_my_net(dev.state(), name() + ".net", this)
{
- state().register_net(poolptr<analog_net_t>(&m_my_net, false));
+ state().register_net(pool_owned_ptr<analog_net_t>(&m_my_net, false));
this->set_net(&m_my_net);
//net().m_cur_Analog = NL_FCONST(0.0);
diff --git a/src/lib/netlist/nl_base.h b/src/lib/netlist/nl_base.h
index 66fc49d7e5e..4a48dc892b3 100644
--- a/src/lib/netlist/nl_base.h
+++ b/src/lib/netlist/nl_base.h
@@ -139,7 +139,7 @@ class NETLIB_NAME(name) : public device_t
#define NETLIB_TIMESTEP(chip) void NETLIB_NAME(chip) :: timestep(const nl_double step)
#define NETLIB_SUB(chip) nld_ ## chip
-#define NETLIB_SUBXX(ns, chip) poolptr< ns :: nld_ ## chip >
+#define NETLIB_SUBXX(ns, chip) pool_owned_ptr< ns :: nld_ ## chip >
#define NETLIB_HANDLER(chip, name) void NETLIB_NAME(chip) :: name() NL_NOEXCEPT
#define NETLIB_UPDATE(chip) NETLIB_HANDLER(chip, update)
@@ -243,9 +243,9 @@ namespace netlist
virtual ~logic_family_desc_t() noexcept = default;
- virtual poolptr<devices::nld_base_d_to_a_proxy> create_d_a_proxy(netlist_state_t &anetlist, const pstring &name,
+ virtual pool_owned_ptr<devices::nld_base_d_to_a_proxy> create_d_a_proxy(netlist_state_t &anetlist, const pstring &name,
logic_output_t *proxied) const = 0;
- virtual poolptr<devices::nld_base_a_to_d_proxy> create_a_d_proxy(netlist_state_t &anetlist, const pstring &name,
+ virtual pool_owned_ptr<devices::nld_base_a_to_d_proxy> create_a_d_proxy(netlist_state_t &anetlist, const pstring &name,
logic_input_t *proxied) const = 0;
double fixed_V() const { return m_fixed_V; }
@@ -1187,7 +1187,7 @@ namespace netlist
const setup_t &setup() const;
template<class C, typename... Args>
- void register_sub(const pstring &name, poolptr<C> &dev, const Args&... args)
+ void register_sub(const pstring &name, pool_owned_ptr<C> &dev, const Args&... args)
{
//dev.reset(plib::palloc<C>(*this, name, args...));
dev = pool().make_poolptr<C>(*this, name, args...);
@@ -1275,10 +1275,10 @@ namespace netlist
{
public:
- using nets_collection_type = std::vector<poolptr<detail::net_t>>;
+ using nets_collection_type = std::vector<pool_owned_ptr<detail::net_t>>;
/* need to preserve order of device creation ... */
- using devices_collection_type = std::vector<std::pair<pstring, poolptr<core_device_t>>>;
+ using devices_collection_type = std::vector<std::pair<pstring, pool_owned_ptr<core_device_t>>>;
netlist_state_t(const pstring &aname,
plib::unique_ptr<callbacks_t> &&callbacks,
plib::unique_ptr<setup_t> &&setup);
@@ -1330,7 +1330,7 @@ namespace netlist
std::size_t find_net_id(const detail::net_t *net) const;
template <typename T>
- void register_net(poolptr<T> &&net) { m_nets.push_back(std::move(net)); }
+ void register_net(pool_owned_ptr<T> &&net) { m_nets.push_back(std::move(net)); }
template<class device_class>
inline std::vector<device_class *> get_device_list()
@@ -1346,7 +1346,7 @@ namespace netlist
}
template <typename T>
- void add_dev(const pstring &name, poolptr<T> &&dev)
+ void add_dev(const pstring &name, pool_owned_ptr<T> &&dev)
{
for (auto & d : m_devices)
if (d.first == name)
diff --git a/src/lib/netlist/nl_factory.cpp b/src/lib/netlist/nl_factory.cpp
index c9d5ea7e29f..1f0ac35c6c4 100644
--- a/src/lib/netlist/nl_factory.cpp
+++ b/src/lib/netlist/nl_factory.cpp
@@ -76,7 +76,7 @@ namespace netlist { namespace factory
// factory_lib_entry_t: factory class to wrap macro based chips/elements
// -----------------------------------------------------------------------------
- poolptr<device_t> library_element_t::Create(netlist_state_t &anetlist, const pstring &name)
+ pool_owned_ptr<device_t> library_element_t::Create(netlist_state_t &anetlist, const pstring &name)
{
return pool().make_poolptr<NETLIB_NAME(wrapper)>(anetlist, name);
}
diff --git a/src/lib/netlist/nl_factory.h b/src/lib/netlist/nl_factory.h
index 23cfe522f8a..271bf72bf90 100644
--- a/src/lib/netlist/nl_factory.h
+++ b/src/lib/netlist/nl_factory.h
@@ -55,7 +55,7 @@ namespace factory {
COPYASSIGNMOVE(element_t, default)
- virtual poolptr<device_t> Create(netlist_state_t &anetlist, const pstring &name) = 0;
+ virtual pool_owned_ptr<device_t> Create(netlist_state_t &anetlist, const pstring &name) = 0;
virtual void macro_actions(nlparse_t &nparser, const pstring &name)
{
plib::unused_var(nparser);
@@ -85,7 +85,7 @@ namespace factory {
const pstring &def_param, const pstring &sourcefile)
: element_t(name, classname, def_param, sourcefile) { }
- poolptr<device_t> Create(netlist_state_t &anetlist, const pstring &name) override
+ pool_owned_ptr<device_t> Create(netlist_state_t &anetlist, const pstring &name) override
{
return pool().make_poolptr<C>(anetlist, name);
}
@@ -147,7 +147,7 @@ namespace factory {
{
}
- poolptr<device_t> Create(netlist_state_t &anetlist, const pstring &name) override;
+ pool_owned_ptr<device_t> Create(netlist_state_t &anetlist, const pstring &name) override;
void macro_actions(nlparse_t &nparser, const pstring &name) override;
diff --git a/src/lib/netlist/nl_setup.cpp b/src/lib/netlist/nl_setup.cpp
index 3ac1b604bc4..5dc9a9d2516 100644
--- a/src/lib/netlist/nl_setup.cpp
+++ b/src/lib/netlist/nl_setup.cpp
@@ -935,17 +935,17 @@ class logic_family_std_proxy_t : public logic_family_desc_t
{
public:
logic_family_std_proxy_t() = default;
- poolptr<devices::nld_base_d_to_a_proxy> create_d_a_proxy(netlist_state_t &anetlist,
+ pool_owned_ptr<devices::nld_base_d_to_a_proxy> create_d_a_proxy(netlist_state_t &anetlist,
const pstring &name, logic_output_t *proxied) const override;
- poolptr<devices::nld_base_a_to_d_proxy> create_a_d_proxy(netlist_state_t &anetlist, const pstring &name, logic_input_t *proxied) const override;
+ pool_owned_ptr<devices::nld_base_a_to_d_proxy> create_a_d_proxy(netlist_state_t &anetlist, const pstring &name, logic_input_t *proxied) const override;
};
-poolptr<devices::nld_base_d_to_a_proxy> logic_family_std_proxy_t::create_d_a_proxy(netlist_state_t &anetlist,
+pool_owned_ptr<devices::nld_base_d_to_a_proxy> logic_family_std_proxy_t::create_d_a_proxy(netlist_state_t &anetlist,
const pstring &name, logic_output_t *proxied) const
{
return pool().make_poolptr<devices::nld_d_to_a_proxy>(anetlist, name, proxied);
}
-poolptr<devices::nld_base_a_to_d_proxy> logic_family_std_proxy_t::create_a_d_proxy(netlist_state_t &anetlist, const pstring &name, logic_input_t *proxied) const
+pool_owned_ptr<devices::nld_base_a_to_d_proxy> logic_family_std_proxy_t::create_a_d_proxy(netlist_state_t &anetlist, const pstring &name, logic_input_t *proxied) const
{
return pool().make_poolptr<devices::nld_a_to_d_proxy>(anetlist, name, proxied);
}
@@ -1010,7 +1010,7 @@ void setup_t::delete_empty_nets()
{
netlist().nets().erase(
std::remove_if(netlist().nets().begin(), netlist().nets().end(),
- [](poolptr<detail::net_t> &x)
+ [](pool_owned_ptr<detail::net_t> &x)
{
if (x->num_cons() == 0)
{
@@ -1038,7 +1038,7 @@ void setup_t::prepare_to_run()
if ( factory().is_class<devices::NETLIB_NAME(solver)>(e.second)
|| factory().is_class<devices::NETLIB_NAME(netlistparams)>(e.second))
{
- m_netlist.nlstate().add_dev(e.first, poolptr<device_t>(e.second->Create(netlist(), e.first)));
+ m_netlist.nlstate().add_dev(e.first, pool_owned_ptr<device_t>(e.second->Create(netlist(), e.first)));
}
}
@@ -1055,7 +1055,7 @@ void setup_t::prepare_to_run()
if ( !factory().is_class<devices::NETLIB_NAME(solver)>(e.second)
&& !factory().is_class<devices::NETLIB_NAME(netlistparams)>(e.second))
{
- auto dev = poolptr<device_t>(e.second->Create(netlist(), e.first));
+ auto dev = pool_owned_ptr<device_t>(e.second->Create(netlist(), e.first));
m_netlist.nlstate().add_dev(dev->name(), std::move(dev));
}
}
diff --git a/src/lib/netlist/nltypes.h b/src/lib/netlist/nltypes.h
index 1ddc29adfae..9abe8beebef 100644
--- a/src/lib/netlist/nltypes.h
+++ b/src/lib/netlist/nltypes.h
@@ -84,18 +84,18 @@ namespace netlist
#if (USE_MEMPOOL)
using nlmempool = plib::mempool;
#else
- using nlmempool = plib::mempool_default;
+ using nlmempool = plib::aligned_arena;
#endif
/*! Owned pointer type for pooled allocations.
*
*/
template <typename T>
- using poolptr = nlmempool::poolptr<T>;
+ using pool_owned_ptr = nlmempool::owned_pool_ptr<T>;
inline nlmempool &pool()
{
- static nlmempool static_pool(655360, 16);
+ static nlmempool static_pool;
return static_pool;
}
diff --git a/src/lib/netlist/plib/palloc.h b/src/lib/netlist/plib/palloc.h
index d7b00262f7f..f10fd548817 100644
--- a/src/lib/netlist/plib/palloc.h
+++ b/src/lib/netlist/plib/palloc.h
@@ -17,6 +17,7 @@
#include <memory>
#include <utility>
#include <vector>
+#include <type_traits>
#if defined(_WIN32) || defined(_WIN64) || defined(_MSC_VER)
#include <malloc.h>
@@ -25,127 +26,65 @@
namespace plib {
//============================================================
- // Memory allocation
+ // Standard arena_deleter
//============================================================
-#if (USE_ALIGNED_ALLOCATION)
- static inline void *paligned_alloc( size_t alignment, size_t size )
+ template <typename P, typename T>
+ struct arena_deleter
{
-#if defined(_WIN32) || defined(_WIN64) || defined(_MSC_VER)
- return _aligned_malloc(size, alignment);
-#elif defined(__APPLE__)
- void* p;
- if (::posix_memalign(&p, alignment, size) != 0) {
- p = nullptr;
+ //using arena_storage_type = P *;
+ using arena_storage_type = typename std::conditional<P::is_stateless, P, P *>::type;
+ template <typename X, typename Y = void>
+ typename std::enable_if<!X::is_stateless, X&>::type getref(X *x) { return *x;}
+ template <typename X, typename Y = void *>
+ typename std::enable_if<std::remove_pointer<X>::type::is_stateless, X&>::type
+ getref(X &x, Y y = nullptr)
+ {
+ unused_var(y);
+ return x;
}
- return p;
-#else
- return aligned_alloc(alignment, size);
-#endif
- }
-
- static inline void pfree( void *ptr )
- {
- // NOLINTNEXTLINE(cppcoreguidelines-no-malloc)
- free(ptr);
- }
-
-#else
- static inline void *paligned_alloc( size_t alignment, size_t size )
- {
- unused_var(alignment);
- return ::operator new(size);
- }
-
- static inline void pfree( void *ptr )
- {
- ::operator delete(ptr);
- }
-#endif
-
- template <typename T, std::size_t ALIGN>
- /*inline */ C14CONSTEXPR T *assume_aligned_ptr(T *p) noexcept
- {
- static_assert(ALIGN >= alignof(T), "Alignment must be greater or equal to alignof(T)");
- static_assert(is_pow2(ALIGN), "Alignment must be a power of 2");
- //auto t = reinterpret_cast<std::uintptr_t>(p);
- //if (t & (ALIGN-1))
- // printf("alignment error!");
-#if (USE_ALIGNED_HINTS)
- return reinterpret_cast<T *>(__builtin_assume_aligned(p, ALIGN));
-#else
- return p;
-#endif
- }
-
- template <typename T, std::size_t ALIGN>
- constexpr const T *assume_aligned_ptr(const T *p) noexcept
- {
- static_assert(ALIGN >= alignof(T), "Alignment must be greater or equal to alignof(T)");
- static_assert(is_pow2(ALIGN), "Alignment must be a power of 2");
-#if (USE_ALIGNED_HINTS)
- return reinterpret_cast<const T *>(__builtin_assume_aligned(p, ALIGN));
-#else
- return p;
-#endif
- }
-
- template<typename T, typename... Args>
- inline T *pnew(Args&&... args)
- {
- auto *p = paligned_alloc(alignof(T), sizeof(T));
- return new(p) T(std::forward<Args>(args)...);
- }
- template<typename T>
- inline void pdelete(T *ptr)
- {
- ptr->~T();
- pfree(ptr);
- }
+ constexpr arena_deleter(arena_storage_type a = arena_storage_type()) noexcept
+ : m_a(a) { }
- template<typename T>
- inline T* pnew_array(const std::size_t num)
- {
- return new T[num]();
- }
-
- template<typename T>
- inline void pdelete_array(T *ptr)
- {
- delete [] ptr;
- }
-
- template <typename T>
- struct pdefault_deleter
- {
- constexpr pdefault_deleter() noexcept = default;
-
- template<typename U, typename = typename
+ template<typename PU, typename U, typename = typename
std::enable_if<std::is_convertible< U*, T*>::value>::type>
- pdefault_deleter(const pdefault_deleter<U>&) noexcept { }
+ arena_deleter(const arena_deleter<PU, U> &rhs) noexcept : m_a(rhs.m_a) { }
- void operator()(T *p) const
+ void operator()(T *p) //const
{
- pdelete(p);
+ /* call destructor */
+ p->~T();
+ getref(m_a).deallocate(p);
}
+ //private:
+ arena_storage_type m_a;
};
- template <typename SC, typename D = pdefault_deleter<SC>>
+ //============================================================
+ // owned_ptr: smart pointer with ownership information
+ //============================================================
+
+ template <typename SC, typename D>
class owned_ptr
{
public:
+
+ using pointer = SC *;
+ using element_type = SC;
+ using deleter_type = D;
+
owned_ptr()
- : m_ptr(nullptr), m_is_owned(true) { }
+ : m_ptr(nullptr), m_deleter(), m_is_owned(true) { }
template <typename, typename>
friend class owned_ptr;
- owned_ptr(SC *p, bool owned) noexcept
+ owned_ptr(pointer p, bool owned) noexcept
: m_ptr(p), m_deleter(), m_is_owned(owned)
{ }
- owned_ptr(SC *p, bool owned, D deleter) noexcept
+ owned_ptr(pointer p, bool owned, D deleter) noexcept
: m_ptr(p), m_deleter(deleter), m_is_owned(owned)
{ }
@@ -168,10 +107,10 @@ namespace plib {
}
owned_ptr(owned_ptr &&r) noexcept
+ : m_ptr(r.m_ptr)
+ , m_deleter(r.m_deleter)
+ , m_is_owned(r.m_is_owned)
{
- m_is_owned = r.m_is_owned;
- m_ptr = r.m_ptr;
- m_deleter = r.m_deleter;
r.m_is_owned = false;
r.m_ptr = nullptr;
}
@@ -183,7 +122,7 @@ namespace plib {
m_deleter(m_ptr);
m_is_owned = r.m_is_owned;
m_ptr = r.m_ptr;
- m_deleter = r.m_deleter;
+ m_deleter = std::move(r.m_deleter);
r.m_is_owned = false;
r.m_ptr = nullptr;
return *this;
@@ -191,10 +130,10 @@ namespace plib {
template<typename DC, typename DC_D>
owned_ptr(owned_ptr<DC, DC_D> &&r) noexcept
+ : m_ptr(static_cast<pointer >(r.get()))
+ , m_deleter(r.m_deleter)
+ , m_is_owned(r.is_owned())
{
- m_ptr = static_cast<SC *>(r.get());
- m_is_owned = r.is_owned();
- m_deleter = r.m_deleter;
r.release();
}
@@ -208,9 +147,9 @@ namespace plib {
m_is_owned = false;
m_ptr = nullptr;
}
- SC * release()
+ pointer release()
{
- SC *tmp = m_ptr;
+ pointer tmp = m_ptr;
m_is_owned = false;
m_ptr = nullptr;
return tmp;
@@ -218,98 +157,217 @@ namespace plib {
bool is_owned() const { return m_is_owned; }
- SC * operator ->() const { return m_ptr; }
- SC & operator *() const { return *m_ptr; }
- SC * get() const { return m_ptr; }
+ pointer operator ->() const noexcept { return m_ptr; }
+ typename std::add_lvalue_reference<element_type>::type operator *() const noexcept { return *m_ptr; }
+ pointer get() const noexcept { return m_ptr; }
+
+ deleter_type& get_deleter() noexcept { return m_deleter; }
+ const deleter_type& get_deleter() const noexcept { return m_deleter; }
+
private:
- SC *m_ptr;
+ pointer m_ptr;
D m_deleter;
bool m_is_owned;
};
- template <typename T>
- using unique_ptr = std::unique_ptr<T, pdefault_deleter<T>>;
-
- template<typename T, typename... Args>
- plib::unique_ptr<T> make_unique(Args&&... args)
- {
- return plib::unique_ptr<T>(pnew<T>(std::forward<Args>(args)...));
- }
-
- template<typename T, typename... Args>
- static owned_ptr<T> make_owned(Args&&... args)
- {
- owned_ptr<T> a(pnew<T>(std::forward<Args>(args)...), true);
- return std::move(a);
- }
-
//============================================================
- // Aligned allocator for use with containers
+ // Arena allocator for use with containers
//============================================================
- template <class T, std::size_t ALIGN = alignof(T)>
- class aligned_allocator
+ template <class ARENA, class T, std::size_t ALIGN = alignof(T)>
+ class arena_allocator
{
public:
using value_type = T;
static constexpr const std::size_t align_size = ALIGN;
+ using arena_type = ARENA;
static_assert(align_size >= alignof(T) && (align_size % alignof(T)) == 0,
"ALIGN must be greater than alignof(T) and a multiple");
- aligned_allocator() noexcept = default;
- ~aligned_allocator() noexcept = default;
+ arena_allocator() noexcept
+ : m_a(arena_type::instance())
+ { }
+
+ ~arena_allocator() noexcept = default;
- aligned_allocator(const aligned_allocator&) noexcept = default;
- aligned_allocator& operator=(const aligned_allocator&) noexcept = delete;
+ arena_allocator(const arena_allocator &rhs) noexcept : m_a(rhs.m_a) { printf("copy called\n"); }//= default;
+ arena_allocator& operator=(const arena_allocator&) noexcept = delete;
- aligned_allocator(aligned_allocator&&) noexcept = default;
- aligned_allocator& operator=(aligned_allocator&&) = delete;
+ arena_allocator(arena_allocator&&) noexcept = default;
+ arena_allocator& operator=(arena_allocator&&) = delete;
+
+ arena_allocator(arena_type & a) noexcept : m_a(a)
+ {
+ }
template <class U>
- aligned_allocator(const aligned_allocator<U, ALIGN>& rhs) noexcept
+ arena_allocator(const arena_allocator<ARENA, U, ALIGN>& rhs) noexcept
+ : m_a(rhs.m_a)
{
- unused_var(rhs);
}
template <class U> struct rebind
{
- using other = aligned_allocator<U, ALIGN>;
+ using other = arena_allocator<ARENA, U, ALIGN>;
};
T* allocate(std::size_t n)
{
- return reinterpret_cast<T *>(paligned_alloc(ALIGN, sizeof(T) * n));
+ return reinterpret_cast<T *>(m_a.allocate(ALIGN, sizeof(T) * n));
}
void deallocate(T* p, std::size_t n) noexcept
{
unused_var(n);
- pfree(p);
+ m_a.deallocate(p);
}
- template <class T1, std::size_t A1, class U, std::size_t A2>
- friend bool operator==(const aligned_allocator<T1, A1>& lhs,
- const aligned_allocator<U, A2>& rhs) noexcept;
+ template <class AR1, class T1, std::size_t A1, class AR2, class T2, std::size_t A2>
+ friend bool operator==(const arena_allocator<AR1, T1, A1>& lhs,
+ const arena_allocator<AR2, T2, A2>& rhs) noexcept;
- template <class U, std::size_t A> friend class aligned_allocator;
+ template <class AU, class U, std::size_t A> friend class arena_allocator;
+ private:
+ arena_type &m_a;
};
- template <class T1, std::size_t A1, class U, std::size_t A2>
- /*friend*/ inline bool operator==(const aligned_allocator<T1, A1>& lhs,
- const aligned_allocator<U, A2>& rhs) noexcept
+ template <class AR1, class T1, std::size_t A1, class AR2, class T2, std::size_t A2>
+ inline bool operator==(const arena_allocator<AR1, T1, A1>& lhs,
+ const arena_allocator<AR2, T2, A2>& rhs) noexcept
{
- unused_var(lhs, rhs);
- return A1 == A2;
+ return A1 == A2 && rhs.m_a == lhs.m_a;
}
- template <class T1, std::size_t A1, class U, std::size_t A2>
- /*friend*/ inline bool operator!=(const aligned_allocator<T1, A1>& lhs,
- const aligned_allocator<U, A2>& rhs) noexcept
+ template <class AR1, class T1, std::size_t A1, class AR2, class T2, std::size_t A2>
+ inline bool operator!=(const arena_allocator<AR1, T1, A1>& lhs,
+ const arena_allocator<AR2, T2, A2>& rhs) noexcept
{
return !(lhs == rhs);
}
//============================================================
+ // Memory allocation
+ //============================================================
+
+ struct aligned_arena
+ {
+ static constexpr const bool is_stateless = true;
+ template <class T, std::size_t ALIGN = alignof(T)>
+ using allocator_type = arena_allocator<aligned_arena, T, ALIGN>;
+
+ template <typename T>
+ using owned_pool_ptr = plib::owned_ptr<T, arena_deleter<aligned_arena, T>>;
+
+ static inline aligned_arena &instance()
+ {
+ static aligned_arena s_arena;
+ return s_arena;
+ }
+
+ static inline void *allocate( size_t alignment, size_t size )
+ {
+ #if (USE_ALIGNED_ALLOCATION)
+ #if defined(_WIN32) || defined(_WIN64) || defined(_MSC_VER)
+ return _aligned_malloc(size, alignment);
+ #elif defined(__APPLE__)
+ void* p;
+ if (::posix_memalign(&p, alignment, size) != 0) {
+ p = nullptr;
+ }
+ return p;
+ #else
+ return aligned_alloc(alignment, size);
+ #endif
+ #else
+ unused_var(alignment);
+ return ::operator new(size);
+ #endif
+ }
+
+ static inline void deallocate( void *ptr )
+ {
+ #if (USE_ALIGNED_ALLOCATION)
+ // NOLINTNEXTLINE(cppcoreguidelines-no-malloc)
+ free(ptr);
+ #else
+ ::operator delete(ptr);
+ #endif
+ }
+
+ template<typename T, typename... Args>
+ owned_pool_ptr<T> make_poolptr(Args&&... args)
+ {
+ auto *mem = allocate(alignof(T), sizeof(T));
+ return owned_pool_ptr<T>(new (mem) T(std::forward<Args>(args)...), true, arena_deleter<aligned_arena, T>(*this));
+ }
+
+ };
+
+ template <typename T, std::size_t ALIGN>
+ /*inline */ C14CONSTEXPR T *assume_aligned_ptr(T *p) noexcept
+ {
+ static_assert(ALIGN >= alignof(T), "Alignment must be greater or equal to alignof(T)");
+ static_assert(is_pow2(ALIGN), "Alignment must be a power of 2");
+ //auto t = reinterpret_cast<std::uintptr_t>(p);
+ //if (t & (ALIGN-1))
+ // printf("alignment error!");
+#if (USE_ALIGNED_HINTS)
+ return reinterpret_cast<T *>(__builtin_assume_aligned(p, ALIGN));
+#else
+ return p;
+#endif
+ }
+
+ template <typename T, std::size_t ALIGN>
+ constexpr const T *assume_aligned_ptr(const T *p) noexcept
+ {
+ static_assert(ALIGN >= alignof(T), "Alignment must be greater or equal to alignof(T)");
+ static_assert(is_pow2(ALIGN), "Alignment must be a power of 2");
+#if (USE_ALIGNED_HINTS)
+ return reinterpret_cast<const T *>(__builtin_assume_aligned(p, ALIGN));
+#else
+ return p;
+#endif
+ }
+
+ // FIXME: remove
+ template<typename T, typename... Args>
+ inline T *pnew(Args&&... args)
+ {
+ auto *p = aligned_arena::allocate(alignof(T), sizeof(T));
+ return new(p) T(std::forward<Args>(args)...);
+ }
+
+ template<typename T>
+ inline void pdelete(T *ptr)
+ {
+ ptr->~T();
+ aligned_arena::deallocate(ptr);
+ }
+
+
+ template <typename T>
+ using unique_ptr = std::unique_ptr<T, arena_deleter<aligned_arena, T>>;
+
+ template<typename T, typename... Args>
+ plib::unique_ptr<T> make_unique(Args&&... args)
+ {
+ return plib::unique_ptr<T>(pnew<T>(std::forward<Args>(args)...));
+ }
+
+#if 0
+ template<typename T, typename... Args>
+ static owned_ptr<T> make_owned(Args&&... args)
+ {
+ return owned_ptr<T>(pnew<T>(std::forward<Args>(args)...), true);
+ }
+#endif
+
+
+ template <class T, std::size_t ALIGN = alignof(T)>
+ using aligned_allocator = aligned_arena::allocator_type<T, ALIGN>;
+
+ //============================================================
// traits to determine alignment size and stride size
// from types supporting alignment
//============================================================
@@ -321,14 +379,7 @@ namespace plib {
{
static constexpr const std::size_t align_size = alignof(std::max_align_t);
static constexpr const std::size_t value_size = sizeof(typename T::value_type);
-#if 0
- static constexpr const std::size_t stride_size =
- ((value_size % align_size) == 0 ? 1 //T is a multiple of align_size
- : ((align_size % value_size) != 0 ? align_size // align_size is not a multiple of T
- : align_size / value_size));
-#else
static constexpr const std::size_t stride_size = lcm(align_size, value_size) / value_size;
-#endif
};
template <typename T>
@@ -336,14 +387,7 @@ namespace plib {
{
static constexpr const std::size_t align_size = T::align_size;
static constexpr const std::size_t value_size = sizeof(typename T::value_type);
-#if 0
- static constexpr const std::size_t stride_size =
- ((value_size % align_size) == 0 ? 1 //T is a multiple of align_size
- : ((align_size % value_size) != 0 ? align_size // align_size is not a multiple of T
- : align_size / value_size));
-#else
static constexpr const std::size_t stride_size = lcm(align_size, value_size) / value_size;
-#endif
};
//============================================================
diff --git a/src/lib/netlist/plib/pconfig.h b/src/lib/netlist/plib/pconfig.h
index c521f24e5f8..6616669f619 100644
--- a/src/lib/netlist/plib/pconfig.h
+++ b/src/lib/netlist/plib/pconfig.h
@@ -38,7 +38,7 @@
*/
#ifndef USE_ALIGNED_OPTIMIZATIONS
-#define USE_ALIGNED_OPTIMIZATIONS (0)
+#define USE_ALIGNED_OPTIMIZATIONS (1)
#endif
#define USE_ALIGNED_ALLOCATION (USE_ALIGNED_OPTIMIZATIONS)
diff --git a/src/lib/netlist/plib/pdynlib.cpp b/src/lib/netlist/plib/pdynlib.cpp
index 91e1b5cf73a..0d32bead51d 100644
--- a/src/lib/netlist/plib/pdynlib.cpp
+++ b/src/lib/netlist/plib/pdynlib.cpp
@@ -25,7 +25,7 @@ CHAR *astring_from_utf8(const char *utf8string)
// convert UTF-16 to "ANSI code page" string
char_count = WideCharToMultiByte(CP_ACP, 0, wstring, -1, nullptr, 0, nullptr, nullptr);
- result = pnew_array<CHAR>(char_count);
+ result = new CHAR[char_count];
if (result != nullptr)
WideCharToMultiByte(CP_ACP, 0, wstring, -1, result, char_count, nullptr, nullptr);
@@ -39,7 +39,7 @@ WCHAR *wstring_from_utf8(const char *utf8string)
// convert MAME string (UTF-8) to UTF-16
char_count = MultiByteToWideChar(CP_UTF8, 0, utf8string, -1, nullptr, 0);
- result = pnew_array<WCHAR>(char_count);
+ result = new WCHAR[char_count];
if (result != nullptr)
MultiByteToWideChar(CP_UTF8, 0, utf8string, -1, result, char_count);
@@ -72,7 +72,7 @@ dynlib::dynlib(const pstring &libname)
m_isLoaded = true;
//else
// fprintf(stderr, "win: library <%s> not found!\n", libname.c_str());
- pdelete_array(buffer);
+ delete [] buffer;
#elif defined(EMSCRIPTEN)
//no-op
#else
@@ -106,7 +106,7 @@ dynlib::dynlib(const pstring &path, const pstring &libname)
{
//printf("win: library <%s> not found!\n", libname.c_str());
}
- pdelete_array(buffer);
+ delete [] buffer;
#elif defined(EMSCRIPTEN)
//no-op
#else
diff --git a/src/lib/netlist/plib/pmatrix2d.h b/src/lib/netlist/plib/pmatrix2d.h
index 52228548cbf..eab533688d7 100644
--- a/src/lib/netlist/plib/pmatrix2d.h
+++ b/src/lib/netlist/plib/pmatrix2d.h
@@ -22,21 +22,22 @@ namespace plib
{
- template<typename T, typename A = std::allocator<T>>
+ template<typename T, typename A = aligned_allocator<T>>
class pmatrix2d
{
public:
using value_type = T;
+ using allocator_type = A;
static constexpr const std::size_t align_size = align_traits<A>::align_size;
static constexpr const std::size_t stride_size = align_traits<A>::stride_size;
pmatrix2d()
- : m_N(0), m_M(0), m_stride(8)
+ : m_N(0), m_M(0), m_stride(8), m_v()
{
}
pmatrix2d(std::size_t N, std::size_t M)
- : m_N(N), m_M(M)
+ : m_N(N), m_M(M), m_v()
{
m_stride = ((M + stride_size-1) / stride_size) * stride_size;
m_v.resize(N * m_stride);
diff --git a/src/lib/netlist/plib/pmempool.h b/src/lib/netlist/plib/pmempool.h
index 00e78b09fb6..5449595c86c 100644
--- a/src/lib/netlist/plib/pmempool.h
+++ b/src/lib/netlist/plib/pmempool.h
@@ -23,21 +23,6 @@
namespace plib {
- template <typename P, typename T>
- struct pool_deleter
- {
- constexpr pool_deleter() noexcept = default;
-
- template<typename PU, typename U, typename = typename
- std::enable_if<std::is_convertible< U*, T*>::value>::type>
- pool_deleter(const pool_deleter<PU, U>&) noexcept { }
-
- void operator()(T *p) const
- {
- P::free(p);
- }
- };
-
//============================================================
// Memory pool
//============================================================
@@ -100,8 +85,11 @@ namespace plib {
std::vector<block *> m_blocks;
public:
+ static constexpr const bool is_stateless = false;
+ template <class T, std::size_t ALIGN = alignof(T)>
+ using allocator_type = arena_allocator<mempool, T, ALIGN>;
- mempool(size_t min_alloc, size_t min_align)
+ mempool(size_t min_alloc = (1<<21), size_t min_align = 16)
: m_min_alloc(min_alloc), m_min_align(min_align)
{
}
@@ -122,10 +110,8 @@ namespace plib {
}
}
- template <std::size_t ALIGN>
- void *alloc(size_t size)
+ void *allocate(size_t align, size_t size)
{
- size_t align = ALIGN;
if (align < m_min_align)
align = m_min_align;
@@ -164,11 +150,8 @@ namespace plib {
}
}
- template <typename T>
- static void free(T *ptr)
+ static void deallocate(void *ptr)
{
- /* call destructor */
- ptr->~T();
auto it = sinfo().find(ptr);
if (it == sinfo().end())
@@ -188,19 +171,18 @@ namespace plib {
}
template <typename T>
- using poolptr = plib::owned_ptr<T, pool_deleter<mempool, T>>;
+ using owned_pool_ptr = plib::owned_ptr<T, arena_deleter<mempool, T>>;
template<typename T, typename... Args>
- poolptr<T> make_poolptr(Args&&... args)
+ owned_pool_ptr<T> make_poolptr(Args&&... args)
{
- auto *mem = this->alloc<alignof(T)>(sizeof(T));
- auto *obj = new (mem) T(std::forward<Args>(args)...);
- poolptr<T> a(obj, true);
- return std::move(a);
+ auto *mem = this->allocate(alignof(T), sizeof(T));
+ return owned_pool_ptr<T>(new (mem) T(std::forward<Args>(args)...), true, arena_deleter<mempool, T>(this));
}
};
+#if 0
class mempool_default
{
private:
@@ -210,7 +192,11 @@ namespace plib {
public:
- mempool_default(size_t min_alloc, size_t min_align)
+ static constexpr const bool is_stateless = true;
+ template <class T, std::size_t ALIGN = alignof(T)>
+ using allocator_type = arena_allocator<mempool_default, T, ALIGN>;
+
+ mempool_default(size_t min_alloc = 16, size_t min_align = (1 << 21))
: m_min_alloc(min_alloc), m_min_align(min_align)
{
}
@@ -219,24 +205,22 @@ namespace plib {
~mempool_default() = default;
-#if 0
- void *alloc(size_t size)
+ void *allocate(size_t alignment, size_t size)
{
plib::unused_var(m_min_alloc); // -Wunused-private-field fires without
plib::unused_var(m_min_align);
+ plib::unused_var(alignment);
return ::operator new(size);
}
-#endif
- template <typename T>
- static void free(T *ptr)
+ static void deallocate(void *ptr)
{
- plib::pdelete(ptr);
+ ::operator delete(ptr);
}
template <typename T>
- using poolptr = plib::owned_ptr<T, pool_deleter<mempool_default, T>>;
+ using poolptr = plib::owned_ptr<T, arena_deleter<mempool_default, T>>;
template<typename T, typename... Args>
poolptr<T> make_poolptr(Args&&... args)
@@ -249,7 +233,7 @@ namespace plib {
return std::move(a);
}
};
-
+#endif
} // namespace plib
diff --git a/src/lib/netlist/plib/pstream.cpp b/src/lib/netlist/plib/pstream.cpp
index 8f80f317f98..a7acdaafb52 100644
--- a/src/lib/netlist/plib/pstream.cpp
+++ b/src/lib/netlist/plib/pstream.cpp
@@ -268,55 +268,25 @@ pimemstream::pos_type pimemstream::vtell() const
// -----------------------------------------------------------------------------
pomemstream::pomemstream()
-: postream(FLAG_SEEKABLE), m_pos(0), m_capacity(1024), m_size(0)
+: postream(FLAG_SEEKABLE), m_pos(0), m_mem(1024)
{
- m_mem = pnew_array<char>(m_capacity);
-}
-
-pomemstream::~pomemstream()
-{
- if (m_mem != nullptr)
- pdelete_array(m_mem);
+ m_mem.clear();
}
void pomemstream::vwrite(const value_type *buf, const pos_type n)
{
- if (m_pos + n >= m_capacity)
- {
- while (m_pos + n >= m_capacity)
- m_capacity *= 2;
- char *o = m_mem;
- m_mem = pnew_array<char>(m_capacity);
- if (m_mem == nullptr)
- {
- throw out_of_mem_e("pomemstream::vwrite");
- }
- std::copy(o, o + m_pos, m_mem);
- pdelete_array(o);
- }
+ if (m_pos + n >= m_mem.size())
+ m_mem.resize(m_pos + n);
- std::copy(buf, buf + n, m_mem + m_pos);
+ std::copy(buf, buf + n, &m_mem[0] + m_pos);
m_pos += n;
- m_size = std::max(m_pos, m_size);
}
void pomemstream::vseek(const pos_type n)
{
m_pos = n;
- m_size = std::max(m_pos, m_size);
- if (m_size >= m_capacity)
- {
- while (m_size >= m_capacity)
- m_capacity *= 2;
- char *o = m_mem;
- m_mem = pnew_array<char>(m_capacity);
- if (m_mem == nullptr)
- {
- throw out_of_mem_e("pomemstream::vseek");
- }
- std::copy(o, o + m_pos, m_mem);
- pdelete_array(o);
- }
+ if (m_pos>=m_mem.size())
+ m_mem.resize(m_pos);
}
pstream::pos_type pomemstream::vtell() const
diff --git a/src/lib/netlist/plib/pstream.h b/src/lib/netlist/plib/pstream.h
index ec15c0258c6..93497eb1423 100644
--- a/src/lib/netlist/plib/pstream.h
+++ b/src/lib/netlist/plib/pstream.h
@@ -179,18 +179,15 @@ public:
pomemstream(pomemstream &&src) noexcept
: postream(std::move(src))
, m_pos(src.m_pos)
- , m_capacity(src.m_capacity)
- , m_size(src.m_size)
- , m_mem(src.m_mem)
+ , m_mem(std::move(src.m_mem))
{
- src.m_mem = nullptr;
}
pomemstream &operator=(pomemstream &&src) = delete;
- ~pomemstream() override;
+ ~pomemstream() override = default;
- char *memory() const { return m_mem; }
- pos_type size() const { return m_size; }
+ const char *memory() const { return m_mem.data(); }
+ pos_type size() const { return m_mem.size(); }
protected:
/* write n bytes to stream */
@@ -200,9 +197,7 @@ protected:
private:
pos_type m_pos;
- pos_type m_capacity;
- pos_type m_size;
- char *m_mem;
+ std::vector<char> m_mem;
};
class postringstream : public postream
@@ -626,11 +621,10 @@ public:
{
std::size_t sz = 0;
read(sz);
- auto buf = plib::pnew_array<plib::string_info<pstring>::mem_t>(sz+1);
- m_strm.read(reinterpret_cast<pistream::value_type *>(buf), sz);
+ std::vector<plib::string_info<pstring>::mem_t> buf(sz+1);
+ m_strm.read(buf.data(), sz);
buf[sz] = 0;
- s = pstring(buf);
- plib::pdelete_array(buf);
+ s = pstring(buf.data());
}
template <typename T>
diff --git a/src/lib/netlist/plib/ptypes.h b/src/lib/netlist/plib/ptypes.h
index 7d3c064b35d..bda62099150 100644
--- a/src/lib/netlist/plib/ptypes.h
+++ b/src/lib/netlist/plib/ptypes.h
@@ -120,8 +120,8 @@ namespace plib
static_assert(std::is_integral<N>::value, "gcd: N must be an integer");
return m == 0 ? plib::abs(n)
- : n == 0 ? plib::abs(m)
- : gcd(n, m % n);
+ : n == 0 ? plib::abs(m)
+ : gcd(n, m % n);
}
template<typename M, typename N>
diff --git a/src/lib/netlist/prg/nltool.cpp b/src/lib/netlist/prg/nltool.cpp
index f9e25346493..784161a71a8 100644
--- a/src/lib/netlist/prg/nltool.cpp
+++ b/src/lib/netlist/prg/nltool.cpp
@@ -625,7 +625,7 @@ void tool_app_t::listdevices()
nt.setup().prepare_to_run();
- std::vector<netlist::poolptr<netlist::core_device_t>> devs;
+ std::vector<netlist::pool_owned_ptr<netlist::core_device_t>> devs;
for (auto & f : list)
{
diff --git a/src/lib/netlist/solver/nld_matrix_solver.h b/src/lib/netlist/solver/nld_matrix_solver.h
index a7473eb6315..f76660e1cb9 100644
--- a/src/lib/netlist/solver/nld_matrix_solver.h
+++ b/src/lib/netlist/solver/nld_matrix_solver.h
@@ -254,7 +254,7 @@ namespace devices
std::vector<plib::unique_ptr<terms_for_net_t>> m_terms;
std::vector<analog_net_t *> m_nets;
- std::vector<poolptr<proxied_analog_output_t>> m_inps;
+ std::vector<pool_owned_ptr<proxied_analog_output_t>> m_inps;
std::vector<plib::unique_ptr<terms_for_net_t>> m_rails_temp;
diff --git a/src/lib/netlist/solver/nld_solver.cpp b/src/lib/netlist/solver/nld_solver.cpp
index 9d7b8e7dbb2..4734cc3624d 100644
--- a/src/lib/netlist/solver/nld_solver.cpp
+++ b/src/lib/netlist/solver/nld_solver.cpp
@@ -111,13 +111,13 @@ namespace devices
}
template <class C>
- poolptr<matrix_solver_t> create_it(netlist_state_t &nl, pstring name, solver_parameters_t &params, std::size_t size)
+ pool_owned_ptr<matrix_solver_t> create_it(netlist_state_t &nl, pstring name, solver_parameters_t &params, std::size_t size)
{
return pool().make_poolptr<C>(nl, name, &params, size);
}
template <typename FT, int SIZE>
- poolptr<matrix_solver_t> NETLIB_NAME(solver)::create_solver(std::size_t size, const pstring &solvername)
+ pool_owned_ptr<matrix_solver_t> NETLIB_NAME(solver)::create_solver(std::size_t size, const pstring &solvername)
{
if (m_method() == "SOR_MAT")
{
@@ -161,12 +161,12 @@ namespace devices
else
{
log().fatal(MF_1_UNKNOWN_SOLVER_TYPE, m_method());
- return poolptr<matrix_solver_t>();
+ return pool_owned_ptr<matrix_solver_t>();
}
}
template <typename FT, int SIZE>
- poolptr<matrix_solver_t> NETLIB_NAME(solver)::create_solver_x(std::size_t size, const pstring &solvername)
+ pool_owned_ptr<matrix_solver_t> NETLIB_NAME(solver)::create_solver_x(std::size_t size, const pstring &solvername)
{
if (SIZE > 0)
{
@@ -291,7 +291,7 @@ namespace devices
log().verbose("Found {1} net groups in {2} nets\n", splitter.groups.size(), state().nets().size());
for (auto & grp : splitter.groups)
{
- poolptr<matrix_solver_t> ms;
+ pool_owned_ptr<matrix_solver_t> ms;
std::size_t net_count = grp.size();
pstring sname = plib::pfmt("Solver_{1}")(m_mat_solvers.size());
diff --git a/src/lib/netlist/solver/nld_solver.h b/src/lib/netlist/solver/nld_solver.h
index 190ae9a9ab5..c9ec967a72a 100644
--- a/src/lib/netlist/solver/nld_solver.h
+++ b/src/lib/netlist/solver/nld_solver.h
@@ -102,17 +102,17 @@ namespace devices
param_logic_t m_log_stats;
- std::vector<poolptr<matrix_solver_t>> m_mat_solvers;
+ std::vector<pool_owned_ptr<matrix_solver_t>> m_mat_solvers;
std::vector<matrix_solver_t *> m_mat_solvers_all;
std::vector<matrix_solver_t *> m_mat_solvers_timestepping;
solver_parameters_t m_params;
template <typename FT, int SIZE>
- poolptr<matrix_solver_t> create_solver(std::size_t size, const pstring &solvername);
+ pool_owned_ptr<matrix_solver_t> create_solver(std::size_t size, const pstring &solvername);
template <typename FT, int SIZE>
- poolptr<matrix_solver_t> create_solver_x(std::size_t size, const pstring &solvername);
+ pool_owned_ptr<matrix_solver_t> create_solver_x(std::size_t size, const pstring &solvername);
};
} //namespace devices