Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-10-09 01:39:48 +03:00
Code Issues Actions 18 Packages Projects Releases Wiki Activity

No whatsnew: Moved device setup out of constructor (again).

Browse Source 
This wasn't a good idea because some more advanced stuff like virtual function address caching doesn't work in constructors.
This commit is contained in:
Couriersud 2013-10-28 18:37:04 +00:00
parent 707cc76fd1
commit 15b51ba1c8
4 changed files with 265 additions and 164 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

74
src/emu/machine/net_lib.c
View File

@ -47,7 +47,7 @@
#include "net_lib.h" #include "net_lib.h"
NETLIB_CONSTRUCTOR(netdev_logic_input) NETLIB_START(netdev_logic_input)
{ {
register_output("Q", m_Q); register_output("Q", m_Q);
} }
@ -56,7 +56,7 @@ NETLIB_UPDATE(netdev_logic_input)
{ {
} }
NETLIB_CONSTRUCTOR(netdev_analog_input) NETLIB_START(netdev_analog_input)
{ {
register_output("Q", m_Q); register_output("Q", m_Q);
} }
@ -65,17 +65,17 @@ NETLIB_UPDATE(netdev_analog_input)
{ {
} }
NETLIB_CONSTRUCTOR(netdev_log) NETLIB_START(netdev_log)
{ {
register_input("I", m_I); register_input("I", m_I);
} }
NETLIB_UPDATE(netdev_log) NETLIB_UPDATE(netdev_log)
{ {
printf("%s: %d %d\n", name(), (UINT32) (netlist().time().as_raw() / 1000000), INPLOGIC(m_I)); printf("%s: %d %d\n", name(), (UINT32) (netlist()->time().as_raw() / 1000000), INPLOGIC(m_I));
} }
NETLIB_CONSTRUCTOR(netdev_clock) NETLIB_START(netdev_clock)
{ {
register_output("Q", m_Q); register_output("Q", m_Q);
//register_input("FB", m_feedback); //register_input("FB", m_feedback);
@ -98,7 +98,7 @@ NETLIB_UPDATE(netdev_clock)
OUTLOGIC(m_Q, !m_Q.new_Q(), m_inc ); OUTLOGIC(m_Q, !m_Q.new_Q(), m_inc );
} }
NETLIB_CONSTRUCTOR(nicMultiSwitch) NETLIB_START(nicMultiSwitch)
{ {
static const char *sIN[8] = { "i1", "i2", "i3", "i4", "i5", "i6", "i7", "i8" }; static const char *sIN[8] = { "i1", "i2", "i3", "i4", "i5", "i6", "i7", "i8" };
int i; int i;
@ -130,7 +130,7 @@ NETLIB_UPDATE_PARAM(nicMultiSwitch)
update(); update();
} }
NETLIB_CONSTRUCTOR(nicMixer8) NETLIB_START(nicMixer8)
{ {
static const char *sI[8] = { "I1", "I2", "I3", "I4", "I5", "I6", "I7", "I8" }; static const char *sI[8] = { "I1", "I2", "I3", "I4", "I5", "I6", "I7", "I8" };
static const char *sR[8] = { "R1", "R2", "R3", "R4", "R5", "R6", "R7", "R8" }; static const char *sR[8] = { "R1", "R2", "R3", "R4", "R5", "R6", "R7", "R8" };
@ -176,7 +176,7 @@ NETLIB_UPDATE_PARAM(nicMixer8)
NETLIB_CONSTRUCTOR(nicRSFF) NETLIB_START(nicRSFF)
{ {
register_input("S", m_S); register_input("S", m_S);
register_input("R", m_R); register_input("R", m_R);
@ -201,7 +201,7 @@ NETLIB_UPDATE(nicRSFF)
} }
NETLIB_CONSTRUCTOR(nicNE555N_MSTABLE) NETLIB_START(nicNE555N_MSTABLE)
{ {
register_input("TRIG", m_trigger); register_input("TRIG", m_trigger);
register_input("CV", m_CV); register_input("CV", m_CV);
@ -284,7 +284,7 @@ NETLIB_UPDATE(nicNE555N_MSTABLE)
m_last = out; m_last = out;
} }
NETLIB_CONSTRUCTOR(nic7404) NETLIB_START(nic7404)
{ {
register_input("I1", m_I); register_input("I1", m_I);
register_output("Q", m_Q); register_output("Q", m_Q);
@ -298,7 +298,7 @@ NETLIB_UPDATE(nic7404)
OUTLOGIC(m_Q, t, delay[t]); OUTLOGIC(m_Q, t, delay[t]);
} }
NETLIB_CONSTRUCTOR(nic7486) NETLIB_START(nic7486)
{ {
register_input("I1", m_I0); register_input("I1", m_I0);
register_input("I2", m_I1); register_input("I2", m_I1);
@ -312,9 +312,10 @@ NETLIB_UPDATE(nic7486)
OUTLOGIC(m_Q, t, delay[t]); OUTLOGIC(m_Q, t, delay[t]);
} }
NETLIB_CONSTRUCTOR(nic7448) NETLIB_START(nic7448)
, sub(setup, "sub")
{ {
register_sub(sub, "sub");
sub.m_state = 0; sub.m_state = 0;
register_input(sub, "A0", sub.m_A0); register_input(sub, "A0", sub.m_A0);
@ -410,7 +411,7 @@ const UINT8 nic7448_sub::tab7448[16][7] =
{ 0, 0, 0, 0, 0, 0, 0 }, /* 15 */ { 0, 0, 0, 0, 0, 0, 0 }, /* 15 */
}; };
NETLIB_CONSTRUCTOR(nic7450) NETLIB_START(nic7450)
{ {
register_input("I1", m_I0); register_input("I1", m_I0);
register_input("I2", m_I1); register_input("I2", m_I1);
@ -498,10 +499,10 @@ NETLIB_UPDATE(nic7474)
} }
} }
NETLIB_CONSTRUCTOR(nic7474) NETLIB_START(nic7474)
, sub(setup, "sub")
{ {
register_sub(sub, "sub");
register_input(sub, "CLK", sub.m_clk, net_input_t::INP_STATE_LH); register_input(sub, "CLK", sub.m_clk, net_input_t::INP_STATE_LH);
register_input("D", m_D); register_input("D", m_D);
register_input("CLRQ", m_clrQ); register_input("CLRQ", m_clrQ);
@ -514,7 +515,7 @@ NETLIB_CONSTRUCTOR(nic7474)
sub.m_QQ.initial(0); sub.m_QQ.initial(0);
} }
NETLIB_CONSTRUCTOR(nic7483) NETLIB_START(nic7483)
{ {
m_lastr = 0; m_lastr = 0;
@ -553,7 +554,7 @@ NETLIB_UPDATE(nic7483)
} }
} }
NETLIB_CONSTRUCTOR(nic7490) NETLIB_START(nic7490)
{ {
m_cnt = 0; m_cnt = 0;
@ -606,12 +607,13 @@ NETLIB_FUNC_VOID(nic7490, update_outputs, (void))
} }
#endif #endif
#if !USE_OLD7493 #if !USE_OLD7493
NETLIB_CONSTRUCTOR(nic7493) NETLIB_START(nic7493)
, A(setup, "A")
, B(setup, "B")
, C(setup, "C")
, D(setup, "D")
{ {
register_sub(A, "A");
register_sub(B, "B");
register_sub(C, "C");
register_sub(D, "D");
register_input(A, "CLKA", A.m_I, net_input_t::INP_STATE_HL); register_input(A, "CLKA", A.m_I, net_input_t::INP_STATE_HL);
register_input(B, "CLKB", B.m_I, net_input_t::INP_STATE_HL); register_input(B, "CLKB", B.m_I, net_input_t::INP_STATE_HL);
register_input("R1", m_R1); register_input("R1", m_R1);
@ -659,7 +661,7 @@ NETLIB_UPDATE(nic7493)
} }
#else #else
NETLIB_CONSTRUCTOR(nic7493) NETLIB_START(nic7493)
{ {
m_cnt = 0; m_cnt = 0;
@ -739,9 +741,10 @@ NETLIB_FUNC_VOID(nic7493, update_outputs, (void))
} }
#endif #endif
NETLIB_CONSTRUCTOR(nic74107A) NETLIB_START(nic74107A)
, sub(setup, "sub")
{ {
register_sub(sub, "sub");
register_input(sub, "CLK", sub.m_clk, net_input_t::INP_STATE_HL); register_input(sub, "CLK", sub.m_clk, net_input_t::INP_STATE_HL);
register_input("J", m_J); register_input("J", m_J);
register_input("K", m_K); register_input("K", m_K);
@ -816,7 +819,7 @@ NETLIB_UPDATE(nic74107A)
// sub.m_clk.activate_hl(); // sub.m_clk.activate_hl();
} }
NETLIB_CONSTRUCTOR(nic74153) NETLIB_START(nic74153)
{ {
register_input("A1", m_I[0]); register_input("A1", m_I[0]);
register_input("A2", m_I[1]); register_input("A2", m_I[1]);
@ -844,9 +847,10 @@ NETLIB_UPDATE(nic74153)
} }
} }
NETLIB_CONSTRUCTOR(nic9316) NETLIB_START(nic9316)
, sub(setup, "sub")
{ {
register_sub(sub, "sub");
sub.m_cnt = 0; sub.m_cnt = 0;
sub.m_loadq = 1; sub.m_loadq = 1;
sub.m_ent = 1; sub.m_ent = 1;
@ -1006,7 +1010,11 @@ net_device_t *net_create_device_by_classname(const char *classname, netlist_setu
while (p != NULL) while (p != NULL)
{ {
if (strcmp((*p)->classname(), classname) == 0) if (strcmp((*p)->classname(), classname) == 0)
return (*p)->Create(setup, icname); {
net_device_t *ret = (*p)->Create();
ret->setup(setup, icname);
return ret;
}
p++; p++;
} }
fatalerror("Class %s required for IC %s not found!\n", classname, icname); fatalerror("Class %s required for IC %s not found!\n", classname, icname);
@ -1019,7 +1027,11 @@ net_device_t *net_create_device_by_name(const char *name, netlist_setup_t &setup
while (p != NULL) while (p != NULL)
{ {
if (strcmp((*p)->name(), name) == 0) if (strcmp((*p)->name(), name) == 0)
return (*p)->Create(setup, icname); {
net_device_t *ret = (*p)->Create();
ret->setup(setup, icname);
return ret;
}
p++; p++;
} }
fatalerror("Class %s required for IC %s not found!\n", name, icname); fatalerror("Class %s required for IC %s not found!\n", name, icname);

4
src/emu/machine/net_lib.h
View File

@ -383,8 +383,8 @@ NETLIB_DEVICE(nic74107A,
class nic74107 : public nic74107A class nic74107 : public nic74107A
{ {
public: public:
nic74107(netlist_setup_t &setup, const char *name) nic74107()
: nic74107A(setup, name) {} : nic74107A() {}
}; };

144
src/emu/machine/netlist.c
View File

@ -322,6 +322,40 @@ ATTR_HOT ATTR_ALIGN void netlist_timed_queue::push(const entry_t &e)
} }
} }
// ----------------------------------------------------------------------------------------
// netdev_mainclock
// ----------------------------------------------------------------------------------------
ATTR_HOT inline void netdev_mainclock::mc_update(net_output_t &Q, const netlist_time &curtime)
{
Q.m_new_Q = !Q.m_new_Q;
Q.set_time(curtime);
Q.update_devs();
}
ATTR_COLD NETLIB_START(netdev_mainclock)
{
register_output("Q", m_Q);
//register_input("FB", m_feedback);
register_param("FREQ", m_freq, 7159000.0 * 5);
m_inc = netlist_time::from_hz(m_freq.Value()*2);
}
ATTR_HOT NETLIB_UPDATE_PARAM(netdev_mainclock)
{
m_inc = netlist_time::from_hz(m_freq.Value()*2);
}
ATTR_HOT NETLIB_UPDATE(netdev_mainclock)
{
// this is only called during setup ...
m_Q.m_new_Q = !m_Q.m_new_Q;
m_Q.set_time(m_netlist->time() + m_inc);
}
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
// netdev_a_to_d // netdev_a_to_d
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
@ -329,12 +363,20 @@ ATTR_HOT ATTR_ALIGN void netlist_timed_queue::push(const entry_t &e)
class netdev_a_to_d_proxy : public net_device_t class netdev_a_to_d_proxy : public net_device_t
{ {
public: public:
netdev_a_to_d_proxy(netlist_setup_t &setup, const char *name, net_input_t &in_proxied) netdev_a_to_d_proxy(net_input_t &in_proxied)
: net_device_t(setup, name) : net_device_t()
{ {
assert(in_proxied.object_type(SIGNAL_MASK) == SIGNAL_DIGITAL); assert(in_proxied.object_type(SIGNAL_MASK) == SIGNAL_DIGITAL);
m_I.m_high_thresh_V = in_proxied.m_high_thresh_V; m_I.m_high_thresh_V = in_proxied.m_high_thresh_V;
m_I.m_low_thresh_V = in_proxied.m_low_thresh_V; m_I.m_low_thresh_V = in_proxied.m_low_thresh_V;
}
analog_input_t m_I;
ttl_output_t m_Q;
protected:
void start()
{
m_I.init_input(this); m_I.init_input(this);
m_Q.init_terminal(this); m_Q.init_terminal(this);
@ -349,8 +391,6 @@ public:
OUTLOGIC(m_Q, 0, NLTIME_FROM_NS(1)); OUTLOGIC(m_Q, 0, NLTIME_FROM_NS(1));
} }
analog_input_t m_I;
ttl_output_t m_Q;
}; };
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
@ -360,12 +400,20 @@ public:
class netdev_d_to_a_proxy : public net_device_t class netdev_d_to_a_proxy : public net_device_t
{ {
public: public:
netdev_d_to_a_proxy(netlist_setup_t &setup, const char *name, net_output_t &out_proxied) netdev_d_to_a_proxy(net_output_t &out_proxied)
: net_device_t(setup, name) : net_device_t()
{ {
assert(out_proxied.object_type(SIGNAL_MASK) == SIGNAL_DIGITAL);
m_low_V = out_proxied.m_low_V; m_low_V = out_proxied.m_low_V;
m_high_V = out_proxied.m_high_V; m_high_V = out_proxied.m_high_V;
assert(out_proxied.object_type(SIGNAL_MASK) == SIGNAL_DIGITAL); }
ttl_input_t m_I;
analog_output_t m_Q;
protected:
void start()
{
m_I.init_input(this); m_I.init_input(this);
m_Q.init_terminal(this); m_Q.init_terminal(this);
m_Q.initial(0); m_Q.initial(0);
@ -376,9 +424,6 @@ public:
OUTANALOG(m_Q, INPLOGIC(m_I) ? m_high_V : m_low_V, NLTIME_FROM_NS(1)); OUTANALOG(m_Q, INPLOGIC(m_I) ? m_high_V : m_low_V, NLTIME_FROM_NS(1));
} }
ttl_input_t m_I;
analog_output_t m_Q;
private: private:
double m_low_V; double m_low_V;
double m_high_V; double m_high_V;
@ -388,7 +433,7 @@ private:
// netdev_const // netdev_const
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
NETLIB_CONSTRUCTOR(netdev_ttl_const) NETLIB_START(netdev_ttl_const)
{ {
register_output("Q", m_Q); register_output("Q", m_Q);
register_param("CONST", m_const, 0.0); register_param("CONST", m_const, 0.0);
@ -403,7 +448,7 @@ NETLIB_UPDATE_PARAM(netdev_ttl_const)
OUTLOGIC(m_Q, m_const.ValueInt(), NLTIME_IMMEDIATE); OUTLOGIC(m_Q, m_const.ValueInt(), NLTIME_IMMEDIATE);
} }
NETLIB_CONSTRUCTOR(netdev_analog_const) NETLIB_START(netdev_analog_const)
{ {
register_output("Q", m_Q); register_output("Q", m_Q);
register_param("CONST", m_const, 0.0); register_param("CONST", m_const, 0.0);
@ -496,6 +541,9 @@ ATTR_HOT ATTR_ALIGN void netlist_base_t::process_list(INT32 &atime)
atime = 0; atime = 0;
} }
} else { } else {
net_output_t &mcQ = m_mainclock->m_Q;
const netlist_time inc = m_mainclock->m_inc;
while (atime > 0) while (atime > 0)
{ {
if (m_queue.is_not_empty()) if (m_queue.is_not_empty())
@ -504,8 +552,7 @@ ATTR_HOT ATTR_ALIGN void netlist_base_t::process_list(INT32 &atime)
{ {
update_time(m_mainclock->m_Q.time(), atime); update_time(m_mainclock->m_Q.time(), atime);
m_mainclock->update(); netdev_mainclock::mc_update(mcQ, time() + inc);
m_mainclock->m_Q.update_devs();
} }
const queue_t::entry_t &e = m_queue.pop(); const queue_t::entry_t &e = m_queue.pop();
@ -517,8 +564,7 @@ ATTR_HOT ATTR_ALIGN void netlist_base_t::process_list(INT32 &atime)
} else { } else {
update_time(m_mainclock->m_Q.time(), atime); update_time(m_mainclock->m_Q.time(), atime);
m_mainclock->update(); netdev_mainclock::mc_update(mcQ, time() + inc);
m_mainclock->m_Q.update_devs();
} }
if (FATAL_ERROR_AFTER_NS) if (FATAL_ERROR_AFTER_NS)
if (time() > NLTIME_FROM_NS(FATAL_ERROR_AFTER_NS)) if (time() > NLTIME_FROM_NS(FATAL_ERROR_AFTER_NS))
@ -721,8 +767,9 @@ void netlist_setup_t::resolve_inputs(void)
if (out.object_type(net_output_t::SIGNAL_MASK) == net_output_t::SIGNAL_ANALOG if (out.object_type(net_output_t::SIGNAL_MASK) == net_output_t::SIGNAL_ANALOG
&& in->object_type(net_output_t::SIGNAL_MASK) == net_output_t::SIGNAL_DIGITAL) && in->object_type(net_output_t::SIGNAL_MASK) == net_output_t::SIGNAL_DIGITAL)
{ {
netdev_a_to_d_proxy *proxy = new netdev_a_to_d_proxy(*this, "abc", *in); netdev_a_to_d_proxy *proxy = new netdev_a_to_d_proxy(*in);
proxy->setup(*this, "abc");
in->set_output(proxy->m_Q); in->set_output(proxy->m_Q);
proxy->m_Q.register_con(*in); proxy->m_Q.register_con(*in);
proxy->m_I.set_output(out); proxy->m_I.set_output(out);
@ -733,8 +780,9 @@ void netlist_setup_t::resolve_inputs(void)
&& in->object_type(net_output_t::SIGNAL_MASK) == net_output_t::SIGNAL_ANALOG) && in->object_type(net_output_t::SIGNAL_MASK) == net_output_t::SIGNAL_ANALOG)
{ {
//printf("here 1\n"); //printf("here 1\n");
netdev_d_to_a_proxy *proxy = new netdev_d_to_a_proxy(*this, "abc", out); netdev_d_to_a_proxy *proxy = new netdev_d_to_a_proxy(out);
proxy->setup(*this, "abc");
in->set_output(proxy->m_Q); in->set_output(proxy->m_Q);
proxy->m_Q.register_con(*in); proxy->m_Q.register_con(*in);
proxy->m_I.set_output(out); proxy->m_I.set_output(out);
@ -768,7 +816,7 @@ void netlist_setup_t::resolve_inputs(void)
for (tagmap_devices_t::entry_t *entry = m_devices.first(); entry != NULL; entry = m_devices.next(entry)) for (tagmap_devices_t::entry_t *entry = m_devices.first(); entry != NULL; entry = m_devices.next(entry))
{ {
net_device_t *dev = entry->object(); net_device_t *dev = entry->object();
dev->update(); dev->update_dev();
} }
#else #else
@ -824,13 +872,36 @@ void netlist_setup_t::print_stats()
// net_core_device_t // net_core_device_t
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
net_core_device_t::net_core_device_t(netlist_setup_t &setup, const char *name) net_core_device_t::net_core_device_t()
: net_object_t(DEVICE) : net_object_t(DEVICE)
, m_netlist(setup.netlist())
, m_name(name)
{ {
} }
ATTR_COLD void net_core_device_t::setup(netlist_setup_t &setup, const char *name)
{
m_netlist = &setup.netlist();
m_name = name;
#if USE_DELEGATES
#if USE_PMFDELEGATES
void (net_core_device_t::* pFunc)() = &net_core_device_t::update;
static_update = reinterpret_cast<net_update_delegate>((this->*pFunc));
#else
static_update = net_update_delegate(&net_core_device_t::update, "update", this);
// get the pointer to the member function
#endif
#endif
}
ATTR_COLD void net_device_t::setup(netlist_setup_t &setup, const char *name)
{
net_core_device_t::setup(setup, name);
m_setup = &setup;
start();
}
net_core_device_t::~net_core_device_t() net_core_device_t::~net_core_device_t()
{ {
} }
@ -854,9 +925,8 @@ ATTR_HOT ATTR_ALIGN const net_sig_t net_core_device_t::INPLOGIC_PASSIVE(logic_in
return ret; return ret;
} }
net_device_t::net_device_t(netlist_setup_t &setup, const char *name) net_device_t::net_device_t()
: net_core_device_t(setup, name), : net_core_device_t(),
m_setup(setup),
m_variable_input_count(false) m_variable_input_count(false)
{ {
} }
@ -865,19 +935,24 @@ net_device_t::~net_device_t()
{ {
} }
ATTR_COLD void net_device_t::register_sub(net_core_device_t &dev, const char *name)
{
dev.setup(*m_setup, name);
}
void net_device_t::register_output(net_core_device_t &dev, const char *name, net_output_t &port) void net_device_t::register_output(net_core_device_t &dev, const char *name, net_output_t &port)
{ {
m_setup.register_output(*this, dev, name, port); m_setup->register_output(*this, dev, name, port);
} }
void net_device_t::register_output(const char *name, net_output_t &port) void net_device_t::register_output(const char *name, net_output_t &port)
{ {
m_setup.register_output(*this,*this,name, port); m_setup->register_output(*this,*this,name, port);
} }
void net_device_t::register_input(net_core_device_t &dev, const char *name, net_input_t &inp, net_input_t::net_input_state type) void net_device_t::register_input(net_core_device_t &dev, const char *name, net_input_t &inp, net_input_t::net_input_state type)
{ {
m_setup.register_input(*this, dev, name, inp, type); m_setup->register_input(*this, dev, name, inp, type);
} }
void net_device_t::register_input(const char *name, net_input_t &inp, net_input_t::net_input_state type) void net_device_t::register_input(const char *name, net_input_t &inp, net_input_t::net_input_state type)
@ -902,7 +977,7 @@ void net_device_t::register_param(net_core_device_t &dev, const char *name, net_
{ {
param.set_netdev(dev); param.set_netdev(dev);
param.initial(initialVal); param.initial(initialVal);
m_setup.register_param(name, &param); m_setup->register_param(name, &param);
} }
void net_device_t::register_param(const char *name, net_param_t &param, double initialVal) void net_device_t::register_param(const char *name, net_param_t &param, double initialVal)
@ -917,7 +992,7 @@ void net_device_t::register_param(const char *name, net_param_t &param, double i
ATTR_COLD void net_terminal_t::init_terminal(net_core_device_t *dev) ATTR_COLD void net_terminal_t::init_terminal(net_core_device_t *dev)
{ {
m_netdev = dev; m_netdev = dev;
m_netlist = &dev->netlist(); m_netlist = dev->netlist();
} }
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
@ -928,9 +1003,6 @@ ATTR_COLD void net_input_t::init_input(net_core_device_t *dev, net_input_state a
{ {
init_terminal(dev); init_terminal(dev);
m_state = astate; m_state = astate;
#if USE_DELEGATES
h = net_update_delegate(&net_core_device_t::update, "update", dev);
#endif
} }
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
@ -958,11 +1030,7 @@ ATTR_HOT inline void net_output_t::update_dev(const net_input_t *inp, const UINT
ATTR_UNUSED net_core_device_t *netdev = inp->netdev(); ATTR_UNUSED net_core_device_t *netdev = inp->netdev();
begin_timing(netdev->total_time); begin_timing(netdev->total_time);
inc_stat(netdev->stat_count); inc_stat(netdev->stat_count);
#if USE_DELEGATES netdev->update_dev();
inp->h();
#else
netdev->update();
#endif
end_timing(netdev()->total_time); end_timing(netdev()->total_time);
} }
} }

207
src/emu/machine/netlist.h
View File

@ -55,7 +55,14 @@
// SETUP // SETUP
//============================================================ //============================================================
#define USE_DELEGATES (1) #define USE_DELEGATES (0)
/*
* The next options needs -Wno-pmf-conversions to compile and gcc
* This is intended for non-mame usage.
*
*/
#define USE_PMFDELEGATES (0)
// Next if enabled adds 20% performance ... but is not guaranteed to be absolutely timing correct. // Next if enabled adds 20% performance ... but is not guaranteed to be absolutely timing correct.
#define USE_DEACTIVE_DEVICE (0) #define USE_DEACTIVE_DEVICE (0)
@ -127,9 +134,9 @@ ATTR_COLD void NETLIST_NAME(_name)(netlist_setup_t &netlist) \
//============================================================ //============================================================
#define NETLIB_UPDATE(_chip) ATTR_HOT ATTR_ALIGN void _chip :: update(void) #define NETLIB_UPDATE(_chip) ATTR_HOT ATTR_ALIGN void _chip :: update(void)
//#define NETLIB_START(_chip) ATTR_COLD _chip :: _chip (netlist_setup_t &setup, const char *name) #define NETLIB_START(_chip) ATTR_COLD void _chip :: start(void)
#define NETLIB_CONSTRUCTOR(_chip) ATTR_COLD _chip :: _chip (netlist_setup_t &setup, const char *name) \ //#define NETLIB_CONSTRUCTOR(_chip) ATTR_COLD _chip :: _chip (netlist_setup_t &setup, const char *name)
: net_device_t(setup, name) // : net_device_t(setup, name)
#define NETLIB_UPDATE_PARAM(_chip) ATTR_HOT ATTR_ALIGN void _chip :: update_param(void) #define NETLIB_UPDATE_PARAM(_chip) ATTR_HOT ATTR_ALIGN void _chip :: update_param(void)
#define NETLIB_FUNC_VOID(_chip, _name, _params) ATTR_HOT ATTR_ALIGN inline void _chip :: _name _params #define NETLIB_FUNC_VOID(_chip, _name, _params) ATTR_HOT ATTR_ALIGN inline void _chip :: _name _params
@ -138,17 +145,19 @@ ATTR_COLD void NETLIST_NAME(_name)(netlist_setup_t &netlist) \
class _name : public net_signal_t<_num_input, _check, _invert> \ class _name : public net_signal_t<_num_input, _check, _invert> \
{ \ { \
public: \ public: \
_name (netlist_setup_t &setup, const char *name) \ _name () \
: net_signal_t<_num_input, _check, _invert>(setup, name) { } \ : net_signal_t<_num_input, _check, _invert>() { } \
}; };
#define NETLIB_DEVICE(_name, _priv) \ #define NETLIB_DEVICE(_name, _priv) \
class _name : public net_device_t \ class _name : public net_device_t \
{ \ { \
public: \ public: \
_name (netlist_setup_t &setup, const char *name); \ _name () \
ATTR_HOT void update(); \ : net_device_t() { } \
protected: \ protected: \
ATTR_HOT void update(); \
ATTR_HOT void start(); \
_priv \ _priv \
} }
@ -156,11 +165,11 @@ ATTR_COLD void NETLIST_NAME(_name)(netlist_setup_t &netlist) \
class _name : public net_core_device_t \ class _name : public net_core_device_t \
{ \ { \
public: \ public: \
_name (netlist_setup_t &setup, const char *name) \ _name () \
: net_core_device_t(setup, name) \ : net_core_device_t() \
{ } \ { } \
ATTR_HOT void update(); \
/*protected:*/ \ /*protected:*/ \
ATTR_HOT void update(); \
_priv \ _priv \
} }
@ -168,9 +177,11 @@ ATTR_COLD void NETLIST_NAME(_name)(netlist_setup_t &netlist) \
class _name : public net_device_t \ class _name : public net_device_t \
{ \ { \
public: \ public: \
_name (netlist_setup_t &setup, const char *name); \ _name () \
: net_device_t() { } \
ATTR_HOT void update_param(); \ ATTR_HOT void update_param(); \
ATTR_HOT void update(); \ ATTR_HOT void update(); \
ATTR_HOT void start(); \
/* protected: */ \ /* protected: */ \
_priv \ _priv \
} }
@ -189,10 +200,15 @@ ATTR_COLD void NETLIST_NAME(_name)(netlist_setup_t &netlist) \
// Type definitions // Type definitions
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
class net_core_device_t;
#if USE_DELEGATES #if USE_DELEGATES
#if USE_PMFDELEGATES
typedef void (*net_update_delegate)(net_core_device_t *);
#else
typedef delegate<void ()> net_update_delegate; typedef delegate<void ()> net_update_delegate;
#endif #endif
#endif
typedef UINT8 net_sig_t; typedef UINT8 net_sig_t;
@ -472,10 +488,6 @@ public:
double m_low_thresh_V; double m_low_thresh_V;
double m_high_thresh_V; double m_high_thresh_V;
#if USE_DELEGATES
net_update_delegate h;
#endif
private: private:
net_input_state m_state; net_input_state m_state;
net_output_t * RESTRICT m_output; net_output_t * RESTRICT m_output;
@ -541,12 +553,9 @@ public:
ATTR_HOT inline const net_sig_t last_Q() const { return m_last_Q; } ATTR_HOT inline const net_sig_t last_Q() const { return m_last_Q; }
ATTR_HOT inline const net_sig_t new_Q() const { return m_new_Q; } ATTR_HOT inline const net_sig_t new_Q() const { return m_new_Q; }
//ATTR_HOT inline net_sig_t *Q_ptr() { return &m_Q; }
//ATTR_HOT inline net_sig_t *new_Q_ptr() { return &m_new_Q; }
ATTR_COLD void register_con(net_input_t &inp); ATTR_COLD void register_con(net_input_t &inp);
ATTR_HOT void update_devs(); ATTR_HOT inline void update_devs();
ATTR_HOT inline void inc_active(); ATTR_HOT inline void inc_active();
ATTR_HOT inline void dec_active(); ATTR_HOT inline void dec_active();
@ -583,6 +592,7 @@ protected:
double m_Q_analog; double m_Q_analog;
double m_new_Q_analog; double m_new_Q_analog;
UINT32 m_num_cons;
private: private:
ATTR_HOT void update_dev(const net_input_t *inp, const UINT32 mask); ATTR_HOT void update_dev(const net_input_t *inp, const UINT32 mask);
@ -592,7 +602,6 @@ private:
UINT32 m_in_queue; /* 0: not in queue, 1: in queue, 2: last was taken */ UINT32 m_in_queue; /* 0: not in queue, 1: in queue, 2: last was taken */
UINT32 m_num_cons;
net_input_t *m_cons[OUTPUT_MAX_CONNECTIONS]; net_input_t *m_cons[OUTPUT_MAX_CONNECTIONS];
}; };
@ -616,7 +625,8 @@ public:
if (EXPECTED(newQ != m_new_Q)) if (EXPECTED(newQ != m_new_Q))
{ {
m_new_Q = newQ; m_new_Q = newQ;
push_to_queue(delay); if (m_num_cons)
push_to_queue(delay);
} }
} }
@ -665,18 +675,31 @@ class net_core_device_t : public net_object_t
{ {
public: public:
net_core_device_t(netlist_setup_t &setup, const char *name); net_core_device_t();
virtual ~net_core_device_t(); virtual ~net_core_device_t();
ATTR_COLD virtual void setup(netlist_setup_t &setup, const char *name);
ATTR_COLD const char *name() const { return m_name; } ATTR_COLD const char *name() const { return m_name; }
ATTR_HOT virtual void update_param() {} ATTR_HOT virtual void update_param() {}
ATTR_HOT virtual void update() { }
ATTR_HOT const net_sig_t INPLOGIC_PASSIVE(logic_input_t &inp); ATTR_HOT const net_sig_t INPLOGIC_PASSIVE(logic_input_t &inp);
ATTR_HOT inline void update_dev()
{
#if USE_DELEGATES
#if USE_PMFDELEGATES
static_update(this);
#else
static_update();
#endif
#else
update();
#endif
}
ATTR_HOT inline const net_sig_t INPLOGIC(const logic_input_t &inp) const ATTR_HOT inline const net_sig_t INPLOGIC(const logic_input_t &inp) const
{ {
assert(inp.state() != net_input_t::INP_STATE_PASSIVE); assert(inp.state() != net_input_t::INP_STATE_PASSIVE);
@ -705,7 +728,7 @@ public:
out.set_Q(val, delay); out.set_Q(val, delay);
} }
ATTR_HOT inline netlist_base_t &netlist() const { return m_netlist; } ATTR_HOT inline netlist_base_t *netlist() const { return m_netlist; }
ATTR_HOT virtual void inc_active() { } ATTR_HOT virtual void inc_active() { }
@ -715,15 +738,19 @@ public:
osd_ticks_t total_time; osd_ticks_t total_time;
INT32 stat_count; INT32 stat_count;
#if USE_DELEGATES
net_update_delegate static_update;
#endif
protected: protected:
netlist_base_t &m_netlist; ATTR_HOT virtual void update() { }
ATTR_HOT virtual void start() { }
netlist_base_t *m_netlist;
private: private:
#if USE_DELEGATES
net_update_delegate h;
#endif
const char *m_name; const char *m_name;
}; };
@ -732,16 +759,18 @@ class net_device_t : public net_core_device_t
{ {
public: public:
net_device_t(netlist_setup_t &setup, const char *name); net_device_t();
virtual ~net_device_t(); virtual ~net_device_t();
virtual void update() { } ATTR_COLD void setup(netlist_setup_t &setup, const char *name);
ATTR_COLD const netlist_setup_t &setup() const { return m_setup; } ATTR_COLD const netlist_setup_t *setup() const { return m_setup; }
ATTR_COLD bool variable_input_count() { return m_variable_input_count; } ATTR_COLD bool variable_input_count() { return m_variable_input_count; }
ATTR_COLD void register_sub(net_core_device_t &dev, const char *name);
ATTR_COLD void register_output(const char *name, net_output_t &out); ATTR_COLD void register_output(const char *name, net_output_t &out);
ATTR_COLD void register_output(net_core_device_t &dev, const char *name, net_output_t &out); ATTR_COLD void register_output(net_core_device_t &dev, const char *name, net_output_t &out);
@ -755,10 +784,13 @@ public:
protected: protected:
virtual void update() { }
ATTR_HOT virtual void start() { }
ATTR_COLD void register_param(const char *sname, net_param_t &param, const double initialVal = 0.0); ATTR_COLD void register_param(const char *sname, net_param_t &param, const double initialVal = 0.0);
ATTR_COLD void register_param(net_core_device_t &dev, const char *sname, net_param_t &param, const double initialVal = 0.0); ATTR_COLD void register_param(net_core_device_t &dev, const char *sname, net_param_t &param, const double initialVal = 0.0);
netlist_setup_t &m_setup; netlist_setup_t *m_setup;
bool m_variable_input_count; bool m_variable_input_count;
private: private:
@ -794,8 +826,10 @@ template <int _numdev>
class net_signal_base_t : public net_device_t class net_signal_base_t : public net_device_t
{ {
public: public:
net_signal_base_t(netlist_setup_t &setup, const char *name) net_signal_base_t()
: net_device_t(setup, name), m_active(1) : net_device_t(), m_active(1) { }
ATTR_COLD void start()
{ {
const char *sIN[8] = { "I1", "I2", "I3", "I4", "I5", "I6", "I7", "I8" }; const char *sIN[8] = { "I1", "I2", "I3", "I4", "I5", "I6", "I7", "I8" };
@ -839,8 +873,10 @@ template <int _numdev, UINT8 _check, UINT8 _invert>
class net_signal_t : public net_device_t class net_signal_t : public net_device_t
{ {
public: public:
net_signal_t(netlist_setup_t &setup, const char *name) net_signal_t()
: net_device_t(setup, name), m_active(1) : net_device_t(), m_active(1) { }
ATTR_COLD void start()
{ {
const char *sIN[8] = { "I1", "I2", "I3", "I4", "I5", "I6", "I7", "I8" }; const char *sIN[8] = { "I1", "I2", "I3", "I4", "I5", "I6", "I7", "I8" };
@ -908,39 +944,41 @@ template <UINT8 _check, UINT8 _invert>
class xx_net_signal_t: public net_device_t class xx_net_signal_t: public net_device_t
{ {
public: public:
xx_net_signal_t(netlist_setup_t &setup, const char *name) xx_net_signal_t()
: net_device_t(setup, name), m_active(1) : net_device_t(), m_active(1) { }
{
const char *sIN[2] = { "I1", "I2" };
register_output("Q", m_Q); ATTR_COLD void start()
for (int i=0; i < 2; i++) {
const char *sIN[2] = { "I1", "I2" };
register_output("Q", m_Q);
for (int i=0; i < 2; i++)
{
register_input(sIN[i], m_i[i], net_input_t::INP_STATE_ACTIVE);
}
m_Q.initial(1);
}
#if (USE_DEACTIVE_DEVICE)
ATTR_HOT void inc_active()
{
if (m_active == 0)
{ {
register_input(sIN[i], m_i[i], net_input_t::INP_STATE_ACTIVE); update();
} }
m_Q.initial(1); m_active++;
} }
#if (USE_DEACTIVE_DEVICE) ATTR_HOT void dec_active()
ATTR_HOT void inc_active() {
m_active--;
if (m_active == 0)
{ {
if (m_active == 0) m_i[0].inactivate();
{ m_i[1].inactivate();
update();
}
m_active++;
} }
}
ATTR_HOT void dec_active() #endif
{
m_active--;
if (m_active == 0)
{
m_i[0].inactivate();
m_i[1].inactivate();
}
}
#endif
ATTR_HOT ATTR_ALIGN void update() ATTR_HOT ATTR_ALIGN void update()
@ -977,8 +1015,8 @@ template <UINT8 _check, UINT8 _invert>
class net_signal_t<2, _check, _invert> : public xx_net_signal_t<_check, _invert> class net_signal_t<2, _check, _invert> : public xx_net_signal_t<_check, _invert>
{ {
public: public:
net_signal_t(netlist_setup_t &setup, const char *name) net_signal_t()
: xx_net_signal_t<_check, _invert>(setup, name) { } : xx_net_signal_t<_check, _invert>() { }
}; };
// The following did not improve performance // The following did not improve performance
@ -1149,29 +1187,10 @@ NETLIB_DEVICE_WITH_PARAMS(netdev_mainclock,
net_param_t m_freq; net_param_t m_freq;
netlist_time m_inc; netlist_time m_inc;
ATTR_HOT inline static void mc_update(net_output_t &Q, const netlist_time &curtime);
); );
inline NETLIB_CONSTRUCTOR(netdev_mainclock)
{
register_output("Q", m_Q);
//register_input("FB", m_feedback);
register_param("FREQ", m_freq, 7159000.0 * 5);
m_inc = netlist_time::from_hz(m_freq.Value()*2);
}
inline NETLIB_UPDATE_PARAM(netdev_mainclock)
{
m_inc = netlist_time::from_hz(m_freq.Value()*2);
}
inline NETLIB_UPDATE(netdev_mainclock)
{
m_Q.m_new_Q = !m_Q.m_new_Q;
m_Q.set_time(m_netlist.time() + m_inc);
}
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
// netdev_callback // netdev_callback
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
@ -1179,8 +1198,10 @@ inline NETLIB_UPDATE(netdev_mainclock)
class netdev_analog_callback : public net_device_t class netdev_analog_callback : public net_device_t
{ {
public: public:
netdev_analog_callback(netlist_setup_t &setup, const char *name) netdev_analog_callback()
: net_device_t(setup, name) : net_device_t() { }
ATTR_COLD void start()
{ {
register_input("IN", m_in); register_input("IN", m_in);
} }
@ -1329,7 +1350,7 @@ ATTR_HOT inline const double analog_input_t::Q_Analog() const
ATTR_HOT inline const bool analog_input_t::is_highz() const ATTR_HOT inline const bool analog_input_t::is_highz() const
{ {
return output()->Q_Analog() == NETLIST_HIGHIMP_V; return (output()->Q_Analog() == NETLIST_HIGHIMP_V);
} }
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
@ -1340,7 +1361,7 @@ class net_device_t_base_factory
{ {
public: public:
virtual ~net_device_t_base_factory() {} virtual ~net_device_t_base_factory() {}
virtual net_device_t *Create(netlist_setup_t &setup, const char *name) const = 0; virtual net_device_t *Create() const = 0;
const char *name() const { return m_name; } const char *name() const { return m_name; }
const char *classname() const { return m_classname; } const char *classname() const { return m_classname; }
@ -1354,9 +1375,9 @@ class net_device_t_factory : public net_device_t_base_factory
{ {
public: public:
net_device_t_factory(const char *name, const char *classname) { m_name = name; m_classname = classname; } net_device_t_factory(const char *name, const char *classname) { m_name = name; m_classname = classname; }
net_device_t *Create(netlist_setup_t &setup, const char *name) const net_device_t *Create() const
{ {
net_device_t *r = global_alloc_clear(C(setup, name)); net_device_t *r = global_alloc_clear(C());
//r->init(setup, name); //r->init(setup, name);
return r; return r;
} }