Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-10-06 17:08:28 +03:00
Code Issues Actions 3 Packages Projects Releases Wiki Activity

netlist: remove locked-in context from sources. (nw)

Browse Source
This commit is contained in:
couriersud 2019-02-17 23:52:05 +01:00
parent 11c3b63c41
commit 17d784d83b
9 changed files with 86 additions and 61 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
src/devices/machine/netlist.cpp
View File

@ -213,22 +213,26 @@ private:
class netlist_source_memregion_t : public netlist::source_t class netlist_source_memregion_t : public netlist::source_t
{ {
public: public:
netlist_source_memregion_t(netlist::nlparse_t &setup, pstring name) netlist_source_memregion_t(device_t &dev, pstring name)
: netlist::source_t(setup), m_name(name) : netlist::source_t(), m_dev(dev), m_name(name)
{ {
} }
virtual std::unique_ptr<plib::pistream> stream(const pstring &name) override; virtual std::unique_ptr<plib::pistream> stream(const pstring &name) override;
private: private:
device_t &m_dev;
pstring m_name; pstring m_name;
}; };
class netlist_data_memregions_t : public netlist::source_t class netlist_data_memregions_t : public netlist::source_t
{ {
public: public:
netlist_data_memregions_t(netlist::setup_t &setup); netlist_data_memregions_t(device_t &dev);
virtual std::unique_ptr<plib::pistream> stream(const pstring &name) override; virtual std::unique_ptr<plib::pistream> stream(const pstring &name) override;
private:
device_t &m_dev;
}; };
@ -238,18 +242,20 @@ public:
std::unique_ptr<plib::pistream> netlist_source_memregion_t::stream(const pstring &name) std::unique_ptr<plib::pistream> netlist_source_memregion_t::stream(const pstring &name)
{ {
memory_region *mem = static_cast<netlist_mame_device::netlist_mame_t &>(setup().setup().exec()).machine().root_device().memregion(m_name.c_str()); //memory_region *mem = static_cast<netlist_mame_device::netlist_mame_t &>(setup().setup().exec()).machine().root_device().memregion(m_name.c_str());
memory_region *mem = m_dev.machine().root_device().memregion(m_name.c_str());
return plib::make_unique<plib::pimemstream>(mem->base(), mem->bytes()); return plib::make_unique<plib::pimemstream>(mem->base(), mem->bytes());
} }
netlist_data_memregions_t::netlist_data_memregions_t(netlist::setup_t &setup) netlist_data_memregions_t::netlist_data_memregions_t(device_t &dev)
: netlist::source_t(setup, netlist::source_t::DATA) : netlist::source_t(netlist::source_t::DATA), m_dev(dev)
{ {
} }
std::unique_ptr<plib::pistream> netlist_data_memregions_t::stream(const pstring &name) std::unique_ptr<plib::pistream> netlist_data_memregions_t::stream(const pstring &name)
{ {
memory_region *mem = static_cast<netlist_mame_device::netlist_mame_t &>(setup().setup().exec()).parent().memregion(name.c_str()); //memory_region *mem = static_cast<netlist_mame_device::netlist_mame_t &>(setup().setup().exec()).parent().memregion(name.c_str());
memory_region *mem = m_dev.memregion(name.c_str());
if (mem != nullptr) if (mem != nullptr)
{ {
return plib::make_unique<plib::pimemstream>(mem->base(), mem->bytes()); return plib::make_unique<plib::pimemstream>(mem->base(), mem->bytes());
@ -454,9 +460,9 @@ netlist::setup_t &netlist_mame_device::setup()
return m_netlist->nlstate().setup(); return m_netlist->nlstate().setup();
} }
void netlist_mame_device::register_memregion_source(netlist::nlparse_t &setup, const char *name) void netlist_mame_device::register_memregion_source(netlist::nlparse_t &setup, device_t &dev, const char *name)
{ {
setup.register_source(plib::make_unique<netlist_source_memregion_t>(setup, pstring(name))); setup.register_source(plib::make_unique<netlist_source_memregion_t>(dev, pstring(name)));
} }
void netlist_mame_analog_input_device::write(const double val) void netlist_mame_analog_input_device::write(const double val)
@ -826,12 +832,6 @@ netlist_mame_device::~netlist_mame_device()
LOGDEVCALLS("~netlist_mame_device\n"); LOGDEVCALLS("~netlist_mame_device\n");
} }
void netlist_mame_device::set_constructor(void (*setup_func)(netlist::nlparse_t &))
{
if (LOG_DEV_CALLS) logerror("set_constructor\n");
m_setup_func = setup_func;
}
void netlist_mame_device::device_config_complete() void netlist_mame_device::device_config_complete()
{ {
LOGDEVCALLS("device_config_complete %s\n", this->mconfig().gamedrv().name); LOGDEVCALLS("device_config_complete %s\n", this->mconfig().gamedrv().name);
@ -867,7 +867,7 @@ void netlist_mame_device::device_start()
} }
/* add default data provider for roms */ /* add default data provider for roms */
setup().register_source(plib::make_unique<netlist_data_memregions_t>(setup())); setup().register_source(plib::make_unique<netlist_data_memregions_t>(*this));
m_setup_func(setup()); m_setup_func(setup());

25
src/devices/machine/netlist.h
View File

@ -11,6 +11,8 @@
#ifndef MAME_MACHINE_NETLIST_H #ifndef MAME_MACHINE_NETLIST_H
#define MAME_MACHINE_NETLIST_H #define MAME_MACHINE_NETLIST_H
#include <functional>
#include "netlist/nl_time.h" #include "netlist/nl_time.h"
#include "netlist/netlist_types.h" #include "netlist/netlist_types.h"
@ -32,6 +34,9 @@ namespace netlist {
#define MCFG_NETLIST_SETUP(_setup) \ #define MCFG_NETLIST_SETUP(_setup) \
downcast<netlist_mame_device &>(*device).set_constructor(NETLIST_NAME(_setup)); downcast<netlist_mame_device &>(*device).set_constructor(NETLIST_NAME(_setup));
#define MCFG_NETLIST_SETUP_MEMBER(_obj, _setup) \
downcast<netlist_mame_device &>(*device).set_constructor(_obj, _setup);
#define MCFG_NETLIST_ANALOG_INPUT(_basetag, _tag, _name) \ #define MCFG_NETLIST_ANALOG_INPUT(_basetag, _tag, _name) \
MCFG_DEVICE_ADD(_basetag ":" _tag, NETLIST_ANALOG_INPUT, 0) \ MCFG_DEVICE_ADD(_basetag ":" _tag, NETLIST_ANALOG_INPUT, 0) \
downcast<netlist_mame_analog_input_device &>(*device).set_name(_name); downcast<netlist_mame_analog_input_device &>(*device).set_name(_name);
@ -80,9 +85,10 @@ namespace netlist {
#define NETLIST_ANALOG_PORT_CHANGED(_base, _tag) \ #define NETLIST_ANALOG_PORT_CHANGED(_base, _tag) \
PORT_CHANGED_MEMBER(_base ":" _tag, netlist_mame_analog_input_device, input_changed, 0) PORT_CHANGED_MEMBER(_base ":" _tag, netlist_mame_analog_input_device, input_changed, 0)
/* This macro can only be called from device member */
#define MEMREGION_SOURCE(_name) \ #define MEMREGION_SOURCE(_name) \
netlist_mame_device::register_memregion_source(setup, _name); netlist_mame_device::register_memregion_source(setup, *this, _name);
#define NETDEV_ANALOG_CALLBACK_MEMBER(_name) \ #define NETDEV_ANALOG_CALLBACK_MEMBER(_name) \
void _name(const double data, const attotime &time) void _name(const double data, const attotime &time)
@ -102,11 +108,22 @@ public:
class netlist_mame_t; class netlist_mame_t;
class netlist_mame_callbacks_t; class netlist_mame_callbacks_t;
using func_type = std::function<void(netlist::nlparse_t &)>;
// construction/destruction // construction/destruction
netlist_mame_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock); netlist_mame_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
virtual ~netlist_mame_device(); virtual ~netlist_mame_device();
void set_constructor(void (*setup_func)(netlist::nlparse_t &)); void set_constructor(void (*setup_func)(netlist::nlparse_t &))
{
m_setup_func = func_type(setup_func);
}
template <typename T, typename F>
void set_constructor(T *obj, F && f)
{
m_setup_func = std::move(std::bind(std::forward<F>(f), obj, std::placeholders::_1));
}
ATTR_HOT inline netlist::setup_t &setup(); ATTR_HOT inline netlist::setup_t &setup();
ATTR_HOT inline netlist_mame_t &netlist() { return *m_netlist; } ATTR_HOT inline netlist_mame_t &netlist() { return *m_netlist; }
@ -114,7 +131,7 @@ public:
ATTR_HOT void update_icount(netlist::netlist_time time); ATTR_HOT void update_icount(netlist::netlist_time time);
ATTR_HOT void check_mame_abort_slice(); ATTR_HOT void check_mame_abort_slice();
static void register_memregion_source(netlist::nlparse_t &setup, const char *name); static void register_memregion_source(netlist::nlparse_t &setup, device_t &dev, const char *name);
int m_icount; int m_icount;
@ -145,7 +162,7 @@ private:
netlist::poolptr<netlist_mame_t> m_netlist; netlist::poolptr<netlist_mame_t> m_netlist;
void (*m_setup_func)(netlist::nlparse_t &); func_type m_setup_func;
}; };
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------

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

@ -237,13 +237,13 @@ detail::terminal_type detail::core_terminal_t::type() const
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
netlist_t::netlist_t(const pstring &aname, std::unique_ptr<callbacks_t> callbacks) netlist_t::netlist_t(const pstring &aname, std::unique_ptr<callbacks_t> callbacks)
: m_time(netlist_time::zero()) : m_state(plib::make_unique<netlist_state_t>(aname,
, m_mainclock(nullptr)
, m_state(plib::make_unique<netlist_state_t>(aname,
std::move(callbacks), std::move(callbacks),
plib::make_unique<setup_t>(*this))) // FIXME, ugly but needed to have netlist_state_t constructed first plib::make_unique<setup_t>(*this))) // FIXME, ugly but needed to have netlist_state_t constructed first
, m_queue(*m_state)
, m_solver(nullptr) , m_solver(nullptr)
, m_time(netlist_time::zero())
, m_mainclock(nullptr)
, m_queue(*m_state)
{ {
devices::initialize_factory(nlstate().setup().factory()); devices::initialize_factory(nlstate().setup().factory());
NETLIST_NAME(base)(nlstate().setup()); NETLIST_NAME(base)(nlstate().setup());

9
src/lib/netlist/nl_base.h
View File

@ -1453,19 +1453,16 @@ namespace netlist
void print_stats() const; void print_stats() const;
private: private:
std::unique_ptr<netlist_state_t> m_state;
devices::NETLIB_NAME(solver) * m_solver;
/* mostly rw */ /* mostly rw */
PALIGNAS_CACHELINE() PALIGNAS_CACHELINE()
netlist_time m_time; netlist_time m_time;
PALIGNAS_CACHELINE()
devices::NETLIB_NAME(mainclock) * m_mainclock; devices::NETLIB_NAME(mainclock) * m_mainclock;
PALIGNAS_CACHELINE()
std::unique_ptr<netlist_state_t> m_state;
PALIGNAS_CACHELINE()
detail::queue_t m_queue; detail::queue_t m_queue;
devices::NETLIB_NAME(solver) * m_solver;
// performance // performance
nperftime_t<NL_KEEP_STATISTICS> m_stat_mainloop; nperftime_t<NL_KEEP_STATISTICS> m_stat_mainloop;
nperfcount_t<NL_KEEP_STATISTICS> m_perf_out_processed; nperfcount_t<NL_KEEP_STATISTICS> m_perf_out_processed;

4
src/lib/netlist/nl_lists.h
View File

@ -37,6 +37,7 @@ namespace netlist
void lock() noexcept{ while (m_lock.test_and_set(std::memory_order_acquire)) { } } void lock() noexcept{ while (m_lock.test_and_set(std::memory_order_acquire)) { } }
void unlock() noexcept { m_lock.clear(std::memory_order_release); } void unlock() noexcept { m_lock.clear(std::memory_order_release); }
private: private:
PALIGNAS_CACHELINE()
std::atomic_flag m_lock = ATOMIC_FLAG_INIT; std::atomic_flag m_lock = ATOMIC_FLAG_INIT;
}; };
@ -96,7 +97,7 @@ namespace netlist
/* Use TS = true for a threadsafe queue */ /* Use TS = true for a threadsafe queue */
template <class T, bool TS, bool KEEPSTAT, class QueueOp = typename T::QueueOp> template <class T, bool TS, bool KEEPSTAT, class QueueOp = typename T::QueueOp>
class PALIGNAS_CACHELINE() timed_queue_linear : plib::nocopyassignmove class timed_queue_linear : plib::nocopyassignmove
{ {
public: public:
@ -192,6 +193,7 @@ namespace netlist
using lock_guard_type = std::lock_guard<mutex_type>; using lock_guard_type = std::lock_guard<mutex_type>;
mutex_type m_lock; mutex_type m_lock;
PALIGNAS_CACHELINE()
T * m_end; T * m_end;
std::vector<T> m_list; std::vector<T> m_list;

10
src/lib/netlist/nl_setup.cpp
View File

@ -101,7 +101,7 @@ namespace netlist
{ {
for (auto &source : m_sources) for (auto &source : m_sources)
{ {
if (source->parse(netlist_name)) if (source->parse(*this, netlist_name))
return; return;
} }
log().fatal(MF_1_NOT_FOUND_IN_SOURCE_COLLECTION, netlist_name); log().fatal(MF_1_NOT_FOUND_IN_SOURCE_COLLECTION, netlist_name);
@ -1136,13 +1136,13 @@ void setup_t::prepare_to_run()
// base sources // base sources
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
bool source_t::parse(const pstring &name) bool source_t::parse(nlparse_t &setup, const pstring &name)
{ {
if (m_type != SOURCE) if (m_type != SOURCE)
return false; return false;
else else
{ {
return m_setup.parse_stream(stream(name), name); return setup.parse_stream(stream(name), name);
} }
} }
@ -1164,11 +1164,11 @@ std::unique_ptr<plib::pistream> source_file_t::stream(const pstring &name)
return plib::make_unique<plib::pifilestream>(m_filename); return plib::make_unique<plib::pifilestream>(m_filename);
} }
bool source_proc_t::parse(const pstring &name) bool source_proc_t::parse(nlparse_t &setup, const pstring &name)
{ {
if (name == m_setup_func_name) if (name == m_setup_func_name)
{ {
m_setup_func(setup()); m_setup_func(setup);
return true; return true;
} }
else else

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

@ -67,7 +67,7 @@ void NETLIST_NAME(name)(netlist::nlparse_t &setup) \
#define NETLIST_END() } #define NETLIST_END() }
#define LOCAL_SOURCE(name) \ #define LOCAL_SOURCE(name) \
setup.register_source(plib::make_unique<netlist::source_proc_t>(setup, # name, &NETLIST_NAME(name))); setup.register_source(plib::make_unique<netlist::source_proc_t>(# name, &NETLIST_NAME(name)));
#define LOCAL_LIB_ENTRY(name) \ #define LOCAL_LIB_ENTRY(name) \
LOCAL_SOURCE(name) \ LOCAL_SOURCE(name) \
@ -182,24 +182,22 @@ namespace netlist
using list_t = std::vector<std::unique_ptr<source_t>>; using list_t = std::vector<std::unique_ptr<source_t>>;
source_t(nlparse_t &setup, const type_t type = SOURCE) source_t(const type_t type = SOURCE)
: m_setup(setup) : m_type(type)
, m_type(type)
{} {}
COPYASSIGNMOVE(source_t, delete) COPYASSIGNMOVE(source_t, delete)
virtual ~source_t() noexcept = default; virtual ~source_t() noexcept = default;
virtual bool parse(const pstring &name); virtual bool parse(nlparse_t &setup, const pstring &name);
nlparse_t &setup() { return m_setup; }
type_t type() const { return m_type; } type_t type() const { return m_type; }
protected: protected:
virtual std::unique_ptr<plib::pistream> stream(const pstring &name) = 0; virtual std::unique_ptr<plib::pistream> stream(const pstring &name) = 0;
private: private:
nlparse_t &m_setup;
const type_t m_type; const type_t m_type;
}; };
@ -400,8 +398,8 @@ namespace netlist
{ {
public: public:
source_string_t(setup_t &setup, const pstring &source) source_string_t(const pstring &source)
: source_t(setup), m_str(source) : source_t(), m_str(source)
{ {
} }
@ -416,8 +414,8 @@ namespace netlist
{ {
public: public:
source_file_t(setup_t &setup, const pstring &filename) source_file_t(const pstring &filename)
: source_t(setup), m_filename(filename) : source_t(), m_filename(filename)
{ {
} }
@ -431,8 +429,8 @@ namespace netlist
class source_mem_t : public source_t class source_mem_t : public source_t
{ {
public: public:
source_mem_t(setup_t &setup, const char *mem) source_mem_t(const char *mem)
: source_t(setup), m_str(mem) : source_t(), m_str(mem)
{ {
} }
@ -446,14 +444,14 @@ namespace netlist
class source_proc_t : public source_t class source_proc_t : public source_t
{ {
public: public:
source_proc_t(nlparse_t &setup, pstring name, void (*setup_func)(nlparse_t &)) source_proc_t(pstring name, void (*setup_func)(nlparse_t &))
: source_t(setup), : source_t(),
m_setup_func(setup_func), m_setup_func(setup_func),
m_setup_func_name(name) m_setup_func_name(name)
{ {
} }
bool parse(const pstring &name) override; bool parse(nlparse_t &setup, const pstring &name) override;
protected: protected:
std::unique_ptr<plib::pistream> stream(const pstring &name) override; std::unique_ptr<plib::pistream> stream(const pstring &name) override;

15
src/lib/netlist/prg/nltool.cpp
View File

@ -120,9 +120,8 @@ NETLIST_END()
class netlist_data_folder_t : public netlist::source_t class netlist_data_folder_t : public netlist::source_t
{ {
public: public:
netlist_data_folder_t(netlist::setup_t &setup, netlist_data_folder_t(pstring folder)
pstring folder) : netlist::source_t(netlist::source_t::DATA)
: netlist::source_t(setup, netlist::source_t::DATA)
, m_folder(folder) , m_folder(folder)
{ {
} }
@ -189,9 +188,9 @@ public:
setup().add_define(d); setup().add_define(d);
for (auto & r : roms) for (auto & r : roms)
setup().register_source(plib::make_unique<netlist_data_folder_t>(setup(), r)); setup().register_source(plib::make_unique<netlist_data_folder_t>(r));
setup().register_source(plib::make_unique<netlist::source_file_t>(setup(), filename)); setup().register_source(plib::make_unique<netlist::source_file_t>(filename));
setup().include(name); setup().include(name);
create_dynamic_logs(logs); create_dynamic_logs(logs);
@ -524,7 +523,7 @@ void tool_app_t::create_header()
nt.log().verbose.set_enabled(false); nt.log().verbose.set_enabled(false);
nt.log().warning.set_enabled(false); nt.log().warning.set_enabled(false);
nt.setup().register_source(plib::make_unique<netlist::source_proc_t>(nt.setup(), "dummy", &netlist_dummy)); nt.setup().register_source(plib::make_unique<netlist::source_proc_t>("dummy", &netlist_dummy));
nt.setup().include("dummy"); nt.setup().include("dummy");
pout("// license:GPL-2.0+\n"); pout("// license:GPL-2.0+\n");
@ -568,7 +567,7 @@ void tool_app_t::create_docheader()
nt.log().verbose.set_enabled(false); nt.log().verbose.set_enabled(false);
nt.log().warning.set_enabled(false); nt.log().warning.set_enabled(false);
nt.setup().register_source(plib::make_unique<netlist::source_proc_t>(nt.setup(), "dummy", &netlist_dummy)); nt.setup().register_source(plib::make_unique<netlist::source_proc_t>("dummy", &netlist_dummy));
nt.setup().include("dummy"); nt.setup().include("dummy");
std::vector<pstring> devs; std::vector<pstring> devs;
@ -620,7 +619,7 @@ void tool_app_t::listdevices()
netlist::factory::list_t &list = nt.setup().factory(); netlist::factory::list_t &list = nt.setup().factory();
nt.setup().register_source(plib::make_unique<netlist::source_proc_t>(nt.setup(), "dummy", &netlist_dummy)); nt.setup().register_source(plib::make_unique<netlist::source_proc_t>("dummy", &netlist_dummy));
nt.setup().include("dummy"); nt.setup().include("dummy");

14
src/mame/drivers/pong.cpp
View File

@ -184,6 +184,15 @@ public:
void pongd(machine_config &config); void pongd(machine_config &config);
void pong(machine_config &config); void pong(machine_config &config);
void pongf(machine_config &config); void pongf(machine_config &config);
NETLIST_START(pong)
MEMREGION_SOURCE("maincpu")
PARAM(NETLIST.USE_DEACTIVATE, 1)
INCLUDE(pong_schematics)
NETLIST_END()
protected: protected:
// driver_device overrides // driver_device overrides
@ -260,6 +269,7 @@ private:
}; };
#if 0
static NETLIST_START(pong) static NETLIST_START(pong)
MEMREGION_SOURCE("maincpu") MEMREGION_SOURCE("maincpu")
@ -267,6 +277,7 @@ static NETLIST_START(pong)
INCLUDE(pong_schematics) INCLUDE(pong_schematics)
NETLIST_END() NETLIST_END()
#endif
INPUT_CHANGED_MEMBER(pong_state::input_changed) INPUT_CHANGED_MEMBER(pong_state::input_changed)
{ {
@ -379,7 +390,8 @@ MACHINE_CONFIG_START(pong_state::pong)
/* basic machine hardware */ /* basic machine hardware */
MCFG_DEVICE_ADD("maincpu", NETLIST_CPU, NETLIST_CLOCK) MCFG_DEVICE_ADD("maincpu", NETLIST_CPU, NETLIST_CLOCK)
MCFG_NETLIST_SETUP(pong) //MCFG_NETLIST_SETUP(pong)
MCFG_NETLIST_SETUP_MEMBER(this, &pong_state::NETLIST_NAME(pong))
MCFG_NETLIST_ANALOG_INPUT("maincpu", "vr0", "ic_b9_R.R") MCFG_NETLIST_ANALOG_INPUT("maincpu", "vr0", "ic_b9_R.R")
MCFG_NETLIST_ANALOG_MULT_OFFSET(1.0 / 100.0 * RES_K(50), RES_K(56) ) MCFG_NETLIST_ANALOG_MULT_OFFSET(1.0 / 100.0 * RES_K(50), RES_K(56) )