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

Netlist now compiles with

Browse Source 
-std=c++98 -Wall -Wpedantic -Wextra -Wno-long-long -Wno-variadic-macros
and
-std=c++11 -Wall -Wpedantic -Wextra
[Couriersud]
This commit is contained in:
couriersud 2015-06-28 23:23:56 +02:00
parent a24fd3408a
commit b1a72a3e9f
43 changed files with 308 additions and 282 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
nl_examples/kidniki.c
View File

@ -3,16 +3,17 @@
#include "netlist/devices/nld_system.h"
#include "netlist/analog/nld_bjt.h"
#define USE_FRONTIERS 1
#define USE_FIXED_STV 1
#define USE_FRONTIERS 0
#define USE_FIXED_STV 0
NETLIST_START(dummy)
SOLVER(Solver, 12000)
PARAM(Solver.ACCURACY, 1e-8)
PARAM(Solver.ACCURACY, 1e-7)
PARAM(Solver.NR_LOOPS, 300)
PARAM(Solver.GS_LOOPS, 3)
PARAM(Solver.GS_LOOPS, 23)
//PARAM(Solver.GS_THRESHOLD, 99) // Force Gaussian elimination here
PARAM(Solver.SOR_FACTOR, 1.05)
PARAM(Solver.ITERATIVE, "GMRES")
#if 0
//PARAM(Solver.SOR_FACTOR, 1)
PARAM(Solver.DYNAMIC_TS, 1)

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

@ -74,7 +74,7 @@ private:
};
#define MEMREGION_SOURCE(_name) \
setup.register_source(palloc(netlist_source_memregion_t, _name));
setup.register_source(palloc(netlist_source_memregion_t(_name)));
#define NETDEV_ANALOG_CALLBACK_MEMBER(_name) \
void _name(const double data, const attotime &time)
@ -642,7 +642,7 @@ public:
register_output("Q", m_Q);
register_input("FB", m_feedback);
connect(m_feedback, m_Q);
connect_late(m_feedback, m_Q);
m_inc = netlist::netlist_time::from_nsec(1);

12
src/emu/netlist/analog/nld_bjt.c
View File

@ -83,10 +83,10 @@ NETLIB_START(QBJT_switch)
register_terminal("_B1", m_BC_dummy.m_P);
register_terminal("_C1", m_BC_dummy.m_N);
connect(m_RB.m_N, m_RC.m_N);
connect_late(m_RB.m_N, m_RC.m_N);
connect(m_RB.m_P, m_BC_dummy.m_P);
connect(m_RC.m_P, m_BC_dummy.m_N);
connect_late(m_RB.m_P, m_BC_dummy.m_P);
connect_late(m_RC.m_P, m_BC_dummy.m_N);
save(NLNAME(m_state_on));
@ -185,9 +185,9 @@ NETLIB_START(QBJT_EB)
register_terminal("_E1", m_D_EC.m_P);
register_terminal("_C1", m_D_EC.m_N);
connect(m_D_EB.m_P, m_D_EC.m_P);
connect(m_D_EB.m_N, m_D_CB.m_N);
connect(m_D_CB.m_P, m_D_EC.m_N);
connect_late(m_D_EB.m_P, m_D_EC.m_P);
connect_late(m_D_EB.m_N, m_D_CB.m_N);
connect_late(m_D_CB.m_P, m_D_EC.m_N);
m_gD_BE.save("m_D_BE", *this);
m_gD_BC.save("m_D_BC", *this);

9
src/emu/netlist/analog/nld_fourterm.c
View File

@ -43,8 +43,8 @@ void NETLIB_NAME(VCCS)::start_internal(const nl_double def_RI)
m_ON.m_otherterm = &m_IP;
m_ON1.m_otherterm = &m_IN;
connect(m_OP, m_OP1);
connect(m_ON, m_ON1);
connect_late(m_OP, m_OP1);
connect_late(m_ON, m_ON1);
}
NETLIB_RESET(VCCS)
@ -70,7 +70,6 @@ NETLIB_UPDATE_PARAM(VCCS)
NETLIB_UPDATE(VCCS)
{
/* only called if connected to a rail net ==> notify the solver to recalculate */
/* Big FIXME ... */
if (!m_IP.net().isRailNet())
m_IP.schedule_solve();
else if (!m_IN.net().isRailNet())
@ -122,8 +121,8 @@ NETLIB_START(VCVS)
m_OP2.m_otherterm = &m_ON2;
m_ON2.m_otherterm = &m_OP2;
connect(m_OP2, m_OP1);
connect(m_ON2, m_ON1);
connect_late(m_OP2, m_OP1);
connect_late(m_ON2, m_ON1);
}
NETLIB_RESET(VCVS)

4
src/emu/netlist/analog/nld_fourterm.h
View File

@ -99,9 +99,7 @@ protected:
*
* RI = 1
*
* FIXME: This needs extremely high levels of accuracy to work
* With the current default of 1mv we can only measure
* currents of 1mA.
* This needs high levels of accuracy to work with 1 Ohm RI.
*
*/

2
src/emu/netlist/analog/nld_switches.c
View File

@ -65,7 +65,7 @@ NETLIB_START(switch2)
register_param("POS", m_POS, 0);
connect(m_R[0].m_N, m_R[1].m_N);
connect_late(m_R[0].m_N, m_R[1].m_N);
register_subalias("1", m_R[0].m_P);
register_subalias("2", m_R[1].m_P);

12
src/emu/netlist/analog/nld_twoterm.c
View File

@ -119,10 +119,6 @@ NETLIB_UPDATE(R)
NETLIB_UPDATE_PARAM(R)
{
//printf("updating %s to %f\n", name().cstr(), m_R.Value());
// FIXME: Only attached nets should be brought up to current time
//netlist().solver()->update_to_current_time(); // bring up current time
update_dev();
if (m_R.Value() > 1e-9)
set_R(m_R.Value());
@ -143,7 +139,7 @@ NETLIB_START(POT)
register_subalias("2", m_R1.m_N);
register_subalias("3", m_R2.m_N);
connect(m_R2.m_P, m_R1.m_N);
connect_late(m_R2.m_P, m_R1.m_N);
register_param("R", m_R, 1.0 / netlist().gmin());
register_param("DIAL", m_Dial, 0.5);
@ -169,9 +165,6 @@ NETLIB_UPDATE_PARAM(POT)
if (m_DialIsLog.Value())
v = (nl_math::exp(v) - 1.0) / (nl_math::exp(1.0) - 1.0);
// FIXME: Only attached nets should be brought up to current time
//netlist().solver()->update_to_current_time(); // bring up current time
m_R1.update_dev();
m_R2.update_dev();
@ -217,9 +210,6 @@ NETLIB_UPDATE_PARAM(POT2)
if (m_Reverse.Value())
v = 1.0 - v;
// FIXME: Only attached nets should be brought up to current time
//netlist().solver()->update_to_current_time(); // bring up current time
m_R1.update_dev();
m_R1.set_R(std::max(m_R.Value() * v, netlist().gmin()));

8
src/emu/netlist/analog/nld_twoterm.h
View File

@ -217,8 +217,6 @@ public:
ATTR_HOT inline void update_diode(const nl_double nVd)
{
//FIXME: Optimize cutoff case
if (nVd < NL_FCONST(-5.0) * m_Vt)
{
m_Vd = nVd;
@ -227,16 +225,14 @@ public:
}
else if (nVd < m_Vcrit)
{
const nl_double eVDVt = nl_math::exp(nVd * m_VtInv);
m_Vd = nVd;
const nl_double eVDVt = nl_math::exp(m_Vd * m_VtInv);
m_Id = m_Is * (eVDVt - NL_FCONST(1.0));
m_G = m_Is * m_VtInv * eVDVt + m_gmin;
}
else
{
nl_double a = (nVd - m_Vd) * m_VtInv;
if (a < NL_FCONST(1e-12) - NL_FCONST(1.0)) a = NL_FCONST(1e-12) - NL_FCONST(1.0);
const nl_double a = std::max((nVd - m_Vd) * m_VtInv, NL_FCONST(1e-12) - NL_FCONST(1.0));
m_Vd = m_Vd + nl_math::e_log1p(a) * m_Vt;
const nl_double eVDVt = nl_math::exp(m_Vd * m_VtInv);

2
src/emu/netlist/devices/net_lib.c
View File

@ -50,7 +50,7 @@ void initialize_factory(factory_list_t &factory)
ENTRY(POT2, POT2, "R")
ENTRY(C, CAP, "C")
ENTRY(D, DIODE, "model")
ENTRY(VCVS, VCVS, "-") // FIXME: STD parameters ?
ENTRY(VCVS, VCVS, "-")
ENTRY(VCCS, VCCS, "-")
ENTRY(CCCS, CCCS, "-")
ENTRY(dummy_input, DUMMY_INPUT, "-")

16
src/emu/netlist/devices/nld_74123.c
View File

@ -38,11 +38,11 @@ NETLIB_START(74123)
register_param("K", m_K, 0.4);
register_param("RI", m_RI, 400.0); // around 250 for HC series, 400 on LS/TTL, estimated from datasheets
connect(m_RP_Q, m_RP.m_I);
connect(m_RN_Q, m_RN.m_I);
connect_late(m_RP_Q, m_RP.m_I);
connect_late(m_RN_Q, m_RN.m_I);
connect(m_RN.m_R.m_P, m_RP.m_R.m_N);
connect(m_CV, m_RN.m_R.m_P);
connect_late(m_RN.m_R.m_P, m_RP.m_R.m_N);
connect_late(m_CV, m_RN.m_R.m_P);
m_KP = 1.0 / (1.0 + exp(m_K.Value()));
@ -136,7 +136,7 @@ NETLIB_START(74123_dip)
register_subalias("6", m_2.m_RN.m_R.m_N);
register_subalias("7", m_2.m_RN.m_R.m_P);
register_subalias("8", m_1.m_RN.m_R.m_N);
connect(m_1.m_RN.m_R.m_N, m_2.m_RN.m_R.m_N);
connect_late(m_1.m_RN.m_R.m_N, m_2.m_RN.m_R.m_N);
register_subalias("9", m_2.m_A);
register_subalias("10", m_2.m_B);
@ -146,7 +146,7 @@ NETLIB_START(74123_dip)
register_subalias("14", m_1.m_RN.m_R.m_N);
register_subalias("15", m_1.m_RN.m_R.m_P);
register_subalias("16", m_1.m_RP.m_R.m_P);
connect(m_1.m_RP.m_R.m_P, m_2.m_RP.m_R.m_P);
connect_late(m_1.m_RP.m_R.m_P, m_2.m_RP.m_R.m_P);
}
NETLIB_UPDATE(74123_dip)
@ -178,7 +178,7 @@ NETLIB_START(9602_dip)
register_subalias("6", m_1.m_Q);
register_subalias("7", m_1.m_QQ);
register_subalias("8", m_1.m_RN.m_R.m_N);
connect(m_1.m_RN.m_R.m_N, m_2.m_RN.m_R.m_N);
connect_late(m_1.m_RN.m_R.m_N, m_2.m_RN.m_R.m_N);
register_subalias("9", m_2.m_QQ);
register_subalias("10", m_2.m_Q);
@ -188,7 +188,7 @@ NETLIB_START(9602_dip)
register_subalias("14", m_2.m_RN.m_R.m_P); // RC2
register_subalias("15", m_2.m_RN.m_R.m_N); // C2
register_subalias("16", m_1.m_RP.m_R.m_P);
connect(m_1.m_RP.m_R.m_P, m_2.m_RP.m_R.m_P);
connect_late(m_1.m_RP.m_R.m_P, m_2.m_RP.m_R.m_P);
}
NETLIB_UPDATE(9602_dip)

3
src/emu/netlist/devices/nld_7474.c
View File

@ -88,9 +88,6 @@ NETLIB_RESET(7474sub)
m_CLK.set_state(logic_t::STATE_INP_LH);
m_nextD = 0;
/* FIXME: required by pong doubles - need a mechanism to set this from netlist */
//m_Q.initial(1);
//m_QQ.initial(1);
}
NETLIB_START(7474_dip)

4
src/emu/netlist/devices/nld_7493.c
View File

@ -27,8 +27,8 @@ NETLIB_START(7493)
register_subalias("QC", C.m_Q);
register_subalias("QD", D.m_Q);
connect(C.m_I, B.m_Q);
connect(D.m_I, C.m_Q);
connect_late(C.m_I, B.m_Q);
connect_late(D.m_I, C.m_Q);
}
NETLIB_RESET(7493)

12
src/emu/netlist/devices/nld_74ls629.c
View File

@ -49,7 +49,7 @@ NETLIB_START(SN74LS629clk)
register_input("FB", m_FB);
register_output("Y", m_Y);
connect(m_FB, m_Y);
connect_late(m_FB, m_Y);
reset();
@ -89,9 +89,9 @@ NETLIB_START(SN74LS629)
register_input("FC", m_FC);
register_subalias("GND", m_R_FC.m_N);
connect(m_FC, m_R_FC.m_P);
connect(m_RNG, m_R_RNG.m_P);
connect(m_R_FC.m_N, m_R_RNG.m_N);
connect_late(m_FC, m_R_FC.m_P);
connect_late(m_RNG, m_R_RNG.m_P);
connect_late(m_R_FC.m_N, m_R_RNG.m_N);
register_subalias("Y", m_clock.m_Y);
register_param("CAP", m_CAP, 1e-6);
@ -143,7 +143,7 @@ NETLIB_UPDATE(SN74LS629)
freq += k9 * v_rng * v_freq_3;
freq += k10 * v_rng * v_freq_4;
freq *= NL_FCONST(0.1e-6) / m_CAP.Value();
freq *= NL_FCONST(0.1e-6) / m_CAP;
// FIXME: we need a possibility to remove entries from queue ...
// or an exact model ...
@ -189,7 +189,7 @@ NETLIB_START(SN74LS629_dip)
register_subalias("8", m_1.m_R_FC.m_N);
register_subalias("9", m_1.m_R_FC.m_N);
connect(m_1.m_R_FC.m_N, m_2.m_R_FC.m_N);
connect_late(m_1.m_R_FC.m_N, m_2.m_R_FC.m_N);
register_subalias("10", m_2.m_clock.m_Y);

7
src/emu/netlist/devices/nld_ne555.c
View File

@ -42,9 +42,9 @@ NETLIB_START(NE555)
register_subalias("DISCH", m_RDIS.m_P); // Pin 7
register_subalias("VCC", m_R1.m_P); // Pin 8
connect(m_R1.m_N, m_R2.m_P);
connect(m_R2.m_N, m_R3.m_P);
connect(m_RDIS.m_N, m_R3.m_N);
connect_late(m_R1.m_N, m_R2.m_P);
connect_late(m_R2.m_N, m_R3.m_P);
connect_late(m_RDIS.m_N, m_R3.m_N);
save(NLNAME(m_last_out));
save(NLNAME(m_ff));
@ -68,7 +68,6 @@ NETLIB_RESET(NE555)
NETLIB_UPDATE(NE555)
{
// FIXME: assumes GND is connected to 0V.
// FIXME: Hookup RESET!
nl_double vt = clamp(TERMANALOG(m_R2.m_P), 0.7, 1.4);
bool bthresh = (INPANALOG(m_THRES) > vt);

6
src/emu/netlist/devices/nld_system.c
View File

@ -44,7 +44,7 @@ NETLIB_START(clock)
register_param("FREQ", m_freq, 7159000.0 * 5.0);
m_inc = netlist_time::from_hz(m_freq.Value()*2);
connect(m_feedback, m_Q);
connect_late(m_feedback, m_Q);
}
NETLIB_RESET(clock)
@ -75,7 +75,7 @@ NETLIB_START(extclock)
register_param("OFFSET", m_offset, 0.0);
m_inc[0] = netlist_time::from_hz(m_freq.Value()*2);
connect(m_feedback, m_Q);
connect_late(m_feedback, m_Q);
{
netlist_time base = netlist_time::from_hz(m_freq.Value()*2);
pstring_list_t pat(m_pattern.Value(),",");
@ -202,7 +202,7 @@ void nld_d_to_a_proxy::start()
register_output("_Q", m_Q);
register_subalias("Q", m_RV.m_P);
connect(m_RV.m_N, m_Q);
connect_direct(m_RV.m_N, m_Q);
save(NLNAME(m_last_state));
}

4
src/emu/netlist/devices/nld_system.h
View File

@ -230,12 +230,12 @@ protected:
register_input("_I", m_I);
register_terminal("I",m_RIN.m_P);
register_terminal("G",m_RIN.m_N);
connect(m_I, m_RIN.m_P);
connect_late(m_I, m_RIN.m_P);
register_output("_Q", m_Q);
register_terminal("_OP",m_ROUT.m_P);
register_terminal("Q",m_ROUT.m_N);
connect(m_Q, m_ROUT.m_P);
connect_late(m_Q, m_ROUT.m_P);
}
void reset()

2
src/emu/netlist/devices/nld_truthtable.c
View File

@ -240,7 +240,7 @@ void truthtable_desc_t::setup(const pstring_list_t &truthtable, UINT32 disabled_
#define ENTRYX(_n,_m,_h) case (_n * 1000 + _m * 10 + _h): \
{ typedef netlist_factory_truthtable_t<_n,_m,_h> xtype; \
return palloc(xtype,name,classname,def_param); } break
return palloc(xtype(name,classname,def_param)); } break
#define ENTRYY(_n,_m) ENTRYX(_n,_m,0); ENTRYX(_n,_m,1)

12
src/emu/netlist/devices/nld_truthtable.h
View File

@ -158,7 +158,7 @@ public:
if (idx>=0)
{
//printf("connecting %s %d\n", out[i].cstr(), idx);
connect(m_Q[i], m_I[idx]);
connect_late(m_Q[i], m_I[idx]);
// disable ignore for this inputs altogether.
// FIXME: This shouldn't be necessary
disabled_ignore |= (1<<idx);
@ -269,13 +269,15 @@ public:
*/
if (m_NI < 2)
return;
if (has_state == 0)
else if (has_state == 0)
{
if (--m_active == 0)
{
for (unsigned i = 0; i< m_NI; i++)
m_I[i].inactivate();
m_ign = (1<<m_NI)-1;
}
}
}
logic_input_t m_I[m_NI];
@ -293,7 +295,7 @@ private:
class netlist_base_factory_truthtable_t : public base_factory_t
{
NETLIST_PREVENT_COPYING(netlist_base_factory_truthtable_t)
P_PREVENT_COPYING(netlist_base_factory_truthtable_t)
public:
netlist_base_factory_truthtable_t(const pstring &name, const pstring &classname,
const pstring &def_param)
@ -314,7 +316,7 @@ public:
template<unsigned m_NI, unsigned m_NO, int has_state>
class netlist_factory_truthtable_t : public netlist_base_factory_truthtable_t
{
NETLIST_PREVENT_COPYING(netlist_factory_truthtable_t)
P_PREVENT_COPYING(netlist_factory_truthtable_t)
public:
netlist_factory_truthtable_t(const pstring &name, const pstring &classname,
const pstring &def_param)
@ -323,7 +325,7 @@ public:
device_t *Create()
{
typedef nld_truthtable_t<m_NI, m_NO, has_state> tt_type;
device_t *r = palloc(tt_type, &m_ttbl, m_desc);
device_t *r = palloc(tt_type(&m_ttbl, m_desc));
r->set_logic_family(m_family);
//r->init(setup, name);
return r;

49
src/emu/netlist/nl_base.c
View File

@ -59,7 +59,7 @@ public:
}
virtual devices::nld_base_d_to_a_proxy *create_d_a_proxy(logic_output_t *proxied) const
{
return palloc(devices::nld_d_to_a_proxy, proxied);
return palloc(devices::nld_d_to_a_proxy(proxied));
}
};
@ -80,7 +80,7 @@ public:
}
virtual devices::nld_base_d_to_a_proxy *create_d_a_proxy(logic_output_t *proxied) const
{
return palloc(devices::nld_d_to_a_proxy , proxied);
return palloc(devices::nld_d_to_a_proxy(proxied));
}
};
@ -93,7 +93,7 @@ public:
logic_family_std_proxy_t() { }
virtual devices::nld_base_d_to_a_proxy *create_d_a_proxy(logic_output_t *proxied) const
{
return palloc(devices::nld_d_to_a_proxy , proxied);
return palloc(devices::nld_d_to_a_proxy(proxied));
}
};
@ -104,7 +104,6 @@ logic_family_desc_t *logic_family_desc_t::from_model(const pstring &model)
if (setup_t::model_value_str(model, "TYPE", "") == "CD4000")
return netlist_family_CD4000;
/* FIXME: Memory leak */
logic_family_std_proxy_t *ret = palloc(logic_family_std_proxy_t);
ret->m_low_thresh_V = setup_t::model_value(model, "IVL", 0.8);
@ -138,7 +137,7 @@ void queue_t::register_state(pstate_manager_t &manager, const pstring &module)
NL_VERBOSE_OUT(("register_state\n"));
manager.save_item(m_qsize, this, module + "." + "qsize");
manager.save_item(&m_times[0], this, module + "." + "times", m_times.size());
manager.save_item(&(m_names[0][0]), this, module + "." + "names", m_names.size() * 64);
manager.save_item(&(m_names[0].m_buf[0]), this, module + "." + "names", m_names.size() * sizeof(names_t));
}
void queue_t::on_pre_save()
@ -152,8 +151,8 @@ void queue_t::on_pre_save()
pstring p = this->listptr()[i].object()->name();
int n = p.len();
n = std::min(63, n);
std::strncpy(&(m_names[i][0]), p, n);
m_names[i][n] = 0;
std::strncpy(m_names[i].m_buf, p, n);
m_names[i].m_buf[n] = 0;
}
}
@ -164,7 +163,7 @@ void queue_t::on_post_load()
NL_VERBOSE_OUT(("current time %f qsize %d\n", netlist().time().as_double(), m_qsize));
for (int i = 0; i < m_qsize; i++ )
{
net_t *n = netlist().find_net(&(m_names[i][0]));
net_t *n = netlist().find_net(m_names[i].m_buf);
//NL_VERBOSE_OUT(("Got %s ==> %p\n", qtemp[i].m_name, n));
//NL_VERBOSE_OUT(("schedule time %f (%f)\n", n->time().as_double(), netlist_time::from_raw(m_times[i]).as_double()));
this->push(queue_t::entry_t(netlist_time::from_raw(m_times[i]), n));
@ -203,18 +202,18 @@ ATTR_COLD const pstring &object_t::name() const
// netlist_owned_object_t
// ----------------------------------------------------------------------------------------
ATTR_COLD owned_object_t::owned_object_t(const type_t atype,
ATTR_COLD device_object_t::device_object_t(const type_t atype,
const family_t afamily)
: object_t(atype, afamily)
, m_netdev(NULL)
, m_device(NULL)
{
}
ATTR_COLD void owned_object_t::init_object(core_device_t &dev,
ATTR_COLD void device_object_t::init_object(core_device_t &dev,
const pstring &aname)
{
object_t::init_object(dev.netlist(), aname);
m_netdev = &dev;
m_device = &dev;
}
// ----------------------------------------------------------------------------------------
@ -571,7 +570,6 @@ ATTR_COLD void device_t::register_output(const pstring &name, logic_output_t &po
ATTR_COLD void device_t::register_output(const pstring &name, analog_output_t &port)
{
//port.set_logic_family(this->logic_family());
setup().register_object(*this, name, port);
}
@ -584,14 +582,18 @@ ATTR_COLD void device_t::register_input(const pstring &name, logic_input_t &inp)
ATTR_COLD void device_t::register_input(const pstring &name, analog_input_t &inp)
{
//inp.set_logic_family(this->logic_family());
setup().register_object(*this, name, inp);
m_terminals.add(inp.name());
}
ATTR_COLD void device_t::connect(core_terminal_t &t1, core_terminal_t &t2)
ATTR_COLD void device_t::connect_late(core_terminal_t &t1, core_terminal_t &t2)
{
//printf("device %s: connect %s to %s\n", name().cstr(), t1.name().cstr(), t2.name().cstr());
setup().register_link_fqn(t1.name(), t2.name());
}
ATTR_COLD void device_t::connect_direct(core_terminal_t &t1, core_terminal_t &t2)
{
/* FIXME: These should really first be collected like NET_C connects */
if (!setup().connect(t1, t2))
netlist().error("Error connecting %s to %s\n", t1.name().cstr(), t2.name().cstr());
}
@ -652,7 +654,7 @@ ATTR_HOT void net_t::inc_active(core_terminal_t &term)
{
if (netlist().use_deactivate())
{
railterminal().netdev().inc_active();
railterminal().device().inc_active();
//m_cur_Q = m_new_Q;
}
if (m_in_queue == 0)
@ -679,7 +681,7 @@ ATTR_HOT void net_t::dec_active(core_terminal_t &term)
nl_assert(m_active >= 0);
m_list_active.remove(term);
if (m_active == 0 && netlist().use_deactivate())
railterminal().netdev().dec_active();
railterminal().device().dec_active();
}
ATTR_COLD void net_t::register_railterminal(core_terminal_t &mr)
@ -721,7 +723,7 @@ ATTR_HOT /* inline */ void core_terminal_t::update_dev(const UINT32 mask)
inc_stat(netdev().stat_call_count);
if ((state() & mask) != 0)
{
netdev().update_dev();
device().update_dev();
}
}
@ -808,7 +810,7 @@ ATTR_COLD void net_t::move_connections(net_t *dest_net)
core_terminal_t *p = m_core_terms[i];
dest_net->register_con(*p);
}
m_core_terms.clear(); // FIXME: othernet needs to be free'd from memory
m_core_terms.clear();
m_active = 0;
}
@ -923,7 +925,7 @@ ATTR_COLD void analog_net_t::process_net(list_t *groups, int &cur_group)
// ----------------------------------------------------------------------------------------
ATTR_COLD core_terminal_t::core_terminal_t(const type_t atype, const family_t afamily)
: owned_object_t(atype, afamily)
: device_object_t(atype, afamily)
, plinkedlist_element_t<core_terminal_t>()
, m_net(NULL)
, m_state(STATE_NONEX)
@ -1033,8 +1035,7 @@ ATTR_COLD void analog_output_t::init_object(core_device_t &dev, const pstring &a
ATTR_COLD void analog_output_t::initial(const nl_double val)
{
// FIXME: Really necessary?
net().as_analog().m_cur_Analog = val * NL_FCONST(0.99);
net().as_analog().m_cur_Analog = val;
}
// ----------------------------------------------------------------------------------------
@ -1042,7 +1043,7 @@ ATTR_COLD void analog_output_t::initial(const nl_double val)
// ----------------------------------------------------------------------------------------
ATTR_COLD param_t::param_t(const param_type_t atype)
: owned_object_t(PARAM, ANALOG)
: device_object_t(PARAM, ANALOG)
, m_param_type(atype)
{
}

60
src/emu/netlist/nl_base.h
View File

@ -360,7 +360,7 @@ namespace netlist
class object_t
{
NETLIST_PREVENT_COPYING(object_t)
P_PREVENT_COPYING(object_t)
public:
enum type_t {
TERMINAL = 0,
@ -434,26 +434,27 @@ namespace netlist
// netlist_owned_object_t
// -----------------------------------------------------------------------------
class owned_object_t : public object_t
class device_object_t : public object_t
{
NETLIST_PREVENT_COPYING(owned_object_t)
P_PREVENT_COPYING(device_object_t)
public:
ATTR_COLD owned_object_t(const type_t atype, const family_t afamily);
ATTR_COLD device_object_t(const type_t atype, const family_t afamily);
ATTR_COLD void init_object(core_device_t &dev, const pstring &aname);
ATTR_HOT core_device_t &netdev() const { return *m_netdev; }
core_device_t &device() const { return *m_device; }
private:
core_device_t * m_netdev;
core_device_t * m_device;
};
// -----------------------------------------------------------------------------
// netlist_core_terminal_t
// -----------------------------------------------------------------------------
class core_terminal_t : public owned_object_t, public plinkedlist_element_t<core_terminal_t>
class core_terminal_t : public device_object_t, public plinkedlist_element_t<core_terminal_t>
{
NETLIST_PREVENT_COPYING(core_terminal_t)
P_PREVENT_COPYING(core_terminal_t)
public:
typedef plist_t<core_terminal_t *> list_t;
@ -496,7 +497,7 @@ namespace netlist
virtual void save_register()
{
save(NLNAME(m_state));
owned_object_t::save_register();
device_object_t::save_register();
}
private:
@ -506,7 +507,7 @@ namespace netlist
class terminal_t : public core_terminal_t
{
NETLIST_PREVENT_COPYING(terminal_t)
P_PREVENT_COPYING(terminal_t)
public:
typedef plist_t<terminal_t *> list_t;
@ -657,7 +658,7 @@ namespace netlist
class net_t : public object_t
{
NETLIST_PREVENT_COPYING(net_t)
P_PREVENT_COPYING(net_t)
public:
typedef plist_t<net_t *> list_t;
@ -737,7 +738,7 @@ namespace netlist
class logic_net_t : public net_t
{
NETLIST_PREVENT_COPYING(logic_net_t)
P_PREVENT_COPYING(logic_net_t)
public:
typedef plist_t<logic_net_t *> list_t;
@ -797,7 +798,7 @@ namespace netlist
class analog_net_t : public net_t
{
NETLIST_PREVENT_COPYING(analog_net_t)
P_PREVENT_COPYING(analog_net_t)
public:
typedef plist_t<analog_net_t *> list_t;
@ -842,7 +843,7 @@ namespace netlist
class logic_output_t : public logic_t
{
NETLIST_PREVENT_COPYING(logic_output_t)
P_PREVENT_COPYING(logic_output_t)
public:
ATTR_COLD logic_output_t();
@ -866,7 +867,7 @@ namespace netlist
class analog_output_t : public netlist_analog_t
{
NETLIST_PREVENT_COPYING(analog_output_t)
P_PREVENT_COPYING(analog_output_t)
public:
ATTR_COLD analog_output_t();
@ -891,9 +892,9 @@ namespace netlist
// net_param_t
// -----------------------------------------------------------------------------
class param_t : public owned_object_t
class param_t : public device_object_t
{
NETLIST_PREVENT_COPYING(param_t)
P_PREVENT_COPYING(param_t)
public:
enum param_type_t {
@ -919,7 +920,7 @@ namespace netlist
template <class C, param_t::param_type_t T>
class param_template_t : public param_t
{
NETLIST_PREVENT_COPYING(param_template_t)
P_PREVENT_COPYING(param_template_t)
public:
ATTR_COLD param_template_t()
: param_t(T)
@ -952,14 +953,14 @@ namespace netlist
class param_logic_t : public param_int_t
{
NETLIST_PREVENT_COPYING(param_logic_t)
P_PREVENT_COPYING(param_logic_t)
public:
ATTR_COLD param_logic_t() : param_int_t() { };
};
class param_model_t : public param_template_t<pstring, param_t::MODEL>
{
NETLIST_PREVENT_COPYING(param_model_t)
P_PREVENT_COPYING(param_model_t)
public:
ATTR_COLD param_model_t() : param_template_t<pstring, param_t::MODEL>() { }
@ -970,12 +971,12 @@ namespace netlist
};
// -----------------------------------------------------------------------------
// net_device_t
// core_device_t
// -----------------------------------------------------------------------------
class core_device_t : public object_t, public logic_family_t
{
NETLIST_PREVENT_COPYING(core_device_t)
P_PREVENT_COPYING(core_device_t)
public:
typedef plist_t<core_device_t *> list_t;
@ -1064,10 +1065,13 @@ namespace netlist
#endif
};
// -----------------------------------------------------------------------------
// device_t
// -----------------------------------------------------------------------------
class device_t : public core_device_t
{
NETLIST_PREVENT_COPYING(device_t)
P_PREVENT_COPYING(device_t)
public:
ATTR_COLD device_t();
@ -1087,7 +1091,8 @@ namespace netlist
ATTR_COLD void register_input(const pstring &name, analog_input_t &in);
ATTR_COLD void register_input(const pstring &name, logic_input_t &in);
ATTR_COLD void connect(core_terminal_t &t1, core_terminal_t &t2);
ATTR_COLD void connect_late(core_terminal_t &t1, core_terminal_t &t2);
ATTR_COLD void connect_direct(core_terminal_t &t1, core_terminal_t &t2);
plist_t<pstring> m_terminals;
@ -1124,9 +1129,10 @@ namespace netlist
void on_post_load();
private:
struct names_t { char m_buf[64]; };
int m_qsize;
parray_t<netlist_time::INTERNALTYPE> m_times;
parray_t<char[64]> m_names;
parray_t<names_t> m_names;
};
// -----------------------------------------------------------------------------
@ -1136,7 +1142,7 @@ namespace netlist
class netlist_t : public object_t, public pstate_manager_t
{
NETLIST_PREVENT_COPYING(netlist_t)
P_PREVENT_COPYING(netlist_t)
public:
netlist_t();
@ -1273,7 +1279,7 @@ namespace netlist
if (m_param != param)
{
m_param = param;
netdev().update_param();
device().update_param();
}
}

6
src/emu/netlist/nl_config.h
View File

@ -136,12 +136,6 @@
#define HAS_OPENMP (0)
#endif
// prevent implicit copying
#define NETLIST_PREVENT_COPYING(_name) \
private: \
_name(const _name &); \
_name &operator=(const _name &);
//============================================================
// Performance tracking
//============================================================

6
src/emu/netlist/nl_factory.h
View File

@ -22,7 +22,7 @@ namespace netlist
class base_factory_t
{
NETLIST_PREVENT_COPYING(base_factory_t)
P_PREVENT_COPYING(base_factory_t)
public:
ATTR_COLD base_factory_t(const pstring &name, const pstring &classname,
const pstring &def_param)
@ -48,7 +48,7 @@ namespace netlist
template <class C>
class factory_t : public base_factory_t
{
NETLIST_PREVENT_COPYING(factory_t)
P_PREVENT_COPYING(factory_t)
public:
ATTR_COLD factory_t(const pstring &name, const pstring &classname,
const pstring &def_param)
@ -74,7 +74,7 @@ namespace netlist
ATTR_COLD void register_device(const pstring &name, const pstring &classname,
const pstring &def_param)
{
m_list.add(palloc(factory_t< _C >, name, classname, def_param));
m_list.add(palloc(factory_t< _C >(name, classname, def_param)));
}
ATTR_COLD void register_device(base_factory_t *factory)

2
src/emu/netlist/nl_lists.h
View File

@ -22,7 +22,7 @@ namespace netlist
template <class _Element, class _Time>
class timed_queue
{
NETLIST_PREVENT_COPYING(timed_queue)
P_PREVENT_COPYING(timed_queue)
public:
class entry_t

12
src/emu/netlist/nl_parser.c
View File

@ -288,12 +288,20 @@ void parser_t::net_c()
void parser_t::netdev_param()
{
pstring param;
nl_double val;
param = get_identifier();
require_token(m_tok_comma);
val = eval_param(get_token());
token_t tok = get_token();
if (tok.is_type(STRING))
{
NL_VERBOSE_OUT(("Parser: Param: %s %s\n", param.cstr(), tok.str().cstr()));
m_setup.register_param(param, tok.str());
}
else
{
nl_double val = eval_param(tok);
NL_VERBOSE_OUT(("Parser: Param: %s %f\n", param.cstr(), val));
m_setup.register_param(param, val);
}
require_token(m_tok_param_right);
}

2
src/emu/netlist/nl_parser.h
View File

@ -16,7 +16,7 @@ namespace netlist
{
class parser_t : public ptokenizer
{
NETLIST_PREVENT_COPYING(parser_t)
P_PREVENT_COPYING(parser_t)
public:
parser_t(setup_t &setup)
: ptokenizer(), m_setup(setup), m_buf(NULL) {}

15
src/emu/netlist/nl_setup.c
View File

@ -288,13 +288,16 @@ void setup_t::register_link_arr(const pstring &terms)
}
void setup_t::register_link(const pstring &sin, const pstring &sout)
void setup_t::register_link_fqn(const pstring &sin, const pstring &sout)
{
link_t temp = link_t(build_fqn(sin), build_fqn(sout));
link_t temp = link_t(sin, sout);
NL_VERBOSE_OUT(("link %s <== %s\n", sin.cstr(), sout.cstr()));
m_links.add(temp);
//if (!(m_links.add(sin + "." + sout, temp, false)==TMERR_NONE))
// fatalerror("Error adding link %s<==%s to link list\n", sin.cstr(), sout.cstr());
}
void setup_t::register_link(const pstring &sin, const pstring &sout)
{
register_link_fqn(build_fqn(sin), build_fqn(sout));
}
void setup_t::remove_connections(const pstring pin)
@ -479,7 +482,7 @@ void setup_t::connect_input_output(core_terminal_t &in, core_terminal_t &out)
if (out.isFamily(terminal_t::ANALOG) && in.isFamily(terminal_t::LOGIC))
{
logic_input_t &incast = dynamic_cast<logic_input_t &>(in);
devices::nld_a_to_d_proxy *proxy = palloc(devices::nld_a_to_d_proxy, &incast);
devices::nld_a_to_d_proxy *proxy = palloc(devices::nld_a_to_d_proxy(&incast));
incast.set_proxy(proxy);
pstring x = pstring::sprintf("proxy_ad_%s_%d", in.name().cstr(), m_proxy_cnt);
m_proxy_cnt++;
@ -518,7 +521,7 @@ void setup_t::connect_terminal_input(terminal_t &term, core_terminal_t &inp)
{
logic_input_t &incast = dynamic_cast<logic_input_t &>(inp);
NL_VERBOSE_OUT(("connect_terminal_input: connecting proxy\n"));
devices::nld_a_to_d_proxy *proxy = palloc(devices::nld_a_to_d_proxy, &incast);
devices::nld_a_to_d_proxy *proxy = palloc(devices::nld_a_to_d_proxy(&incast));
incast.set_proxy(proxy);
pstring x = pstring::sprintf("proxy_ad_%s_%d", inp.name().cstr(), m_proxy_cnt);
m_proxy_cnt++;

7
src/emu/netlist/nl_setup.h
View File

@ -58,7 +58,7 @@ ATTR_COLD void NETLIST_NAME(_name)(netlist::setup_t &setup)
#define NETLIST_END() }
#define LOCAL_SOURCE(_name) \
setup.register_source(palloc(netlist::source_proc_t, # _name, &NETLIST_NAME(_name)));
setup.register_source(palloc(netlist::source_proc_t(# _name, &NETLIST_NAME(_name))));
#define INCLUDE(_name) \
setup.include(# _name);
@ -80,7 +80,7 @@ namespace netlist
class setup_t
{
NETLIST_PREVENT_COPYING(setup_t)
P_PREVENT_COPYING(setup_t)
public:
// ----------------------------------------------------------------------------------------
@ -148,8 +148,11 @@ namespace netlist
void register_model(const pstring &model);
void register_alias(const pstring &alias, const pstring &out);
void register_alias_nofqn(const pstring &alias, const pstring &out);
void register_link_arr(const pstring &terms);
void register_link_fqn(const pstring &sin, const pstring &sout);
void register_link(const pstring &sin, const pstring &sout);
void register_param(const pstring &param, const pstring &value);
void register_param(const pstring &param, const double value);

24
src/emu/netlist/plib/palloc.c
View File

@ -6,11 +6,35 @@
*/
#include "pconfig.h"
#include "palloc.h"
#if (PSTANDALONE)
#include <stdlib.h>
#include <xmmintrin.h>
class pmemory_pool
{
public:
pmemory_pool() {}
};
static pmemory_pool sppool;
pmemory_pool *ppool = &sppool;
void* operator new(std::size_t size, pmemory_pool *pool) throw (std::bad_alloc)
{
//printf("here new\n");
return palloc_raw(size);;
}
void operator delete(void *ptr, pmemory_pool *pool)
{
//printf("here delete\n");
if (ptr != NULL)
pfree_raw(ptr);
}
void *palloc_raw(const size_t size)
{
return _mm_malloc(size, 64);

82
src/emu/netlist/plib/palloc.h
View File

@ -8,6 +8,8 @@
#ifndef PALLOC_H_
#define PALLOC_H_
#include <cstdio>
#include "pconfig.h"
//============================================================
@ -28,81 +30,71 @@
#define ATTR_ALIGN
#endif
class pmemory_pool;
extern pmemory_pool *ppool;
void *palloc_raw(const size_t size);
void pfree_raw(void *p);
template<typename T>
inline T *palloc_t()
{
void *p = palloc_raw(sizeof(T));
return new (p) T();
}
void* operator new(std::size_t size, pmemory_pool *pool) throw (std::bad_alloc);
template<typename T, typename P1>
inline T *palloc_t(P1 p1)
{
void *p = palloc_raw(sizeof(T));
return new (p) T(p1);
}
template<typename T, typename P1, typename P2>
inline T *palloc_t(P1 p1, P2 p2)
{
void *p = palloc_raw(sizeof(T));
return new (p) T(p1, p2);
}
template<typename T, typename P1, typename P2, typename P3>
inline T *palloc_t(P1 p1, P2 p2, P3 p3)
{
void *p = palloc_raw(sizeof(T));
return new (p) T(p1, p2, p3);
}
template<typename T, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7>
inline T *palloc_t(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7)
{
void *p = palloc_raw(sizeof(T));
return new (p) T(p1, p2, p3, p4, p5, p6, p7);
}
void operator delete(void *ptr, pmemory_pool *pool);
template<typename T>
inline void pfree_t(T *p)
{
p->~T();
pfree_raw(p);
//delete p;
}
template <typename T>
inline T *palloc_array_t(size_t N)
{
return new T[N];
//printf("here palloc_array %d\n", (unsigned) N);
char *buf = reinterpret_cast<char *>(palloc_raw(N * sizeof(T) + 64*2));
size_t *s = reinterpret_cast<size_t *>(buf);
*s = N;
buf += 64;
T *p = reinterpret_cast<T *>(buf);
for (size_t i = 0; i < N; i++)
new(reinterpret_cast<void *>(&p[i])) T();
return p;
}
template <typename T>
inline void pfree_array_t(T *p)
{
delete[] p;
char *buf = reinterpret_cast<char *>(p);
buf -= 64;
size_t *s = reinterpret_cast<size_t *>(buf);
size_t N = *s;
//printf("here pfree_array %d\n", (unsigned) N);
while (N > 0)
{
p->~T();
p++;
N--;
}
pfree_raw(s);
}
#if 1
#define palloc(T, ...) palloc_t<T>(__VA_ARGS__)
#define palloc(T) new(ppool) T
#define pfree(_ptr) pfree_t(_ptr)
#else
#define palloc(T, ...) new T(__VA_ARGS__)
#define pfree(_ptr) delete(_ptr)
#endif
#if 1
#define palloc_array(T, N) palloc_array_t<T>(N)
#define pfree_array(_ptr) pfree_array_t(_ptr)
#else
#define palloc_array(T, N) new T[N]
#define pfree_array(_ptr) delete[] _ptr
#endif
#else
#include "corealloc.h"
#define ATTR_ALIGN
#include "corealloc.h"
#define palloc(T, ...) global_alloc(T(__VA_ARGS__))
#define palloc(T) global_alloc(T)
#define pfree(_ptr) global_free(_ptr)
#define palloc_array(T, N) global_alloc_array(T, N)

12
src/emu/netlist/plib/pconfig.h
View File

@ -27,6 +27,18 @@
#include <cstddef>
#endif
//============================================================
// Standard defines
//============================================================
// prevent implicit copying
#define P_PREVENT_COPYING(_name) \
private: \
_name(const _name &); \
_name &operator=(const _name &);
//============================================================
// Compiling standalone
//============================================================

10
src/emu/netlist/plib/plists.h
View File

@ -313,10 +313,12 @@ private:
if (cnt > new_capacity)
cnt = new_capacity;
for (_ListClass *ps = m_list; ps < m_list + cnt; ps++, pd++)
*pd = *ps;
if (m_list != NULL)
{
for (_ListClass *ps = m_list; ps < m_list + cnt; ps++, pd++)
*pd = *ps;
this->dealloc(m_list);
}
m_list = m_new;
m_count = cnt;
}
@ -604,9 +606,9 @@ public:
template<typename Class>
static inline void psort_list(Class &sl)
{
for(int i = 0; i < (int) sl.size() - 1; i++)
for(unsigned i = 0; i < sl.size(); i++)
{
for(int j = i + 1; j < sl.size(); j++)
for(unsigned j = i + 1; j < sl.size(); j++)
if(sl[i] > sl[j])
std::swap(sl[i], sl[j]);

8
src/emu/netlist/plib/pparser.h
View File

@ -9,12 +9,12 @@
#define PPARSER_H_
#include "pconfig.h"
#include "../nl_config.h" // FIXME
#include "../nl_util.h"
#include "pstring.h"
#include "plists.h"
class ptokenizer
{
NETLIST_PREVENT_COPYING(ptokenizer)
P_PREVENT_COPYING(ptokenizer)
public:
virtual ~ptokenizer() {}
@ -146,7 +146,7 @@ private:
class ppreprocessor
{
NETLIST_PREVENT_COPYING(ppreprocessor)
P_PREVENT_COPYING(ppreprocessor)
public:
struct define_t

4
src/emu/netlist/plib/pstate.c
View File

@ -33,7 +33,7 @@ ATTR_COLD void pstate_manager_t::save_state_ptr(const pstring &stname, const pst
"DT_FLOAT"
};
pstate_entry_t *p = palloc(pstate_entry_t, stname, dt, owner, size, count, ptr, is_ptr);
pstate_entry_t *p = palloc(pstate_entry_t(stname, dt, owner, size, count, ptr, is_ptr));
m_save.add(p);
}
@ -71,7 +71,7 @@ template<> ATTR_COLD void pstate_manager_t::save_item(pstate_callback_t &state,
{
//save_state_ptr(stname, DT_CUSTOM, 0, 1, &state);
pstate_callback_t *state_p = &state;
pstate_entry_t *p = palloc(pstate_entry_t, stname, owner, state_p);
pstate_entry_t *p = palloc(pstate_entry_t(stname, owner, state_p));
m_save.add(p);
state.register_state(*this, stname);
}

21
src/emu/netlist/plib/pstate.h
View File

@ -24,9 +24,9 @@
template<typename C> ATTR_COLD void obj::save(C &state, const pstring &stname) \
{ manager->save_item(state, this, module + "." + stname); } \
template<typename C, std::size_t N> ATTR_COLD void obj::save(C (&state)[N], const pstring &stname) \
{ manager->save_state_ptr(module + "." + stname, nl_datatype<C>::type, this, sizeof(state[0]), N, &(state[0]), false); } \
{ manager->save_state_ptr(module + "." + stname, pstate_datatype<C>::type, this, sizeof(state[0]), N, &(state[0]), false); } \
template<typename C> ATTR_COLD void obj::save(C *state, const pstring &stname, const int count) \
{ manager->save_state_ptr(module + "." + stname, nl_datatype<C>::type, this, sizeof(C), count, state, false); }
{ manager->save_state_ptr(module + "." + stname, pstate_datatype<C>::type, this, sizeof(C), count, state, false); }
enum pstate_data_type_e {
NOT_SUPPORTED,
@ -40,13 +40,13 @@ enum pstate_data_type_e {
DT_FLOAT
};
template<typename _ItemType> struct nl_datatype
template<typename _ItemType> struct pstate_datatype
{
static const pstate_data_type_e type = pstate_data_type_e(NOT_SUPPORTED);
static const bool is_ptr = false;
};
template<typename _ItemType> struct nl_datatype<_ItemType *>
template<typename _ItemType> struct pstate_datatype<_ItemType *>
{
static const pstate_data_type_e type = pstate_data_type_e(NOT_SUPPORTED);
static const bool is_ptr = true;
@ -55,8 +55,8 @@ template<typename _ItemType> struct nl_datatype<_ItemType *>
//template<typename _ItemType> struct type_checker<_ItemType*> { static const bool is_atom = false; static const bool is_pointer = true; };
#define NETLIST_SAVE_TYPE(TYPE, TYPEDESC) \
template<> struct nl_datatype<TYPE>{ static const pstate_data_type_e type = pstate_data_type_e(TYPEDESC); static const bool is_ptr = false;}; \
template<> struct nl_datatype<TYPE *>{ static const pstate_data_type_e type = pstate_data_type_e(TYPEDESC); static const bool is_ptr = true;}
template<> struct pstate_datatype<TYPE>{ static const pstate_data_type_e type = pstate_data_type_e(TYPEDESC); static const bool is_ptr = false;}; \
template<> struct pstate_datatype<TYPE *>{ static const pstate_data_type_e type = pstate_data_type_e(TYPEDESC); static const bool is_ptr = true;}
NETLIST_SAVE_TYPE(char, DT_INT8);
NETLIST_SAVE_TYPE(double, DT_DOUBLE);
@ -128,26 +128,25 @@ public:
template<typename C> ATTR_COLD void save_item(C &state, const void *owner, const pstring &stname)
{
save_state_ptr(stname, nl_datatype<C>::type, owner, sizeof(C), 1, &state, nl_datatype<C>::is_ptr);
save_state_ptr(stname, pstate_datatype<C>::type, owner, sizeof(C), 1, &state, pstate_datatype<C>::is_ptr);
}
template<typename C, std::size_t N> ATTR_COLD void save_item(C (&state)[N], const void *owner, const pstring &stname)
{
save_state_ptr(stname, nl_datatype<C>::type, owner, sizeof(state[0]), N, &(state[0]), false);
save_state_ptr(stname, pstate_datatype<C>::type, owner, sizeof(state[0]), N, &(state[0]), false);
}
template<typename C> ATTR_COLD void save_item(C *state, const void *owner, const pstring &stname, const int count)
{
save_state_ptr(stname, nl_datatype<C>::type, owner, sizeof(C), count, state, false);
save_state_ptr(stname, pstate_datatype<C>::type, owner, sizeof(C), count, state, false);
}
ATTR_COLD void pre_save();
ATTR_COLD void post_load();
ATTR_COLD void remove_save_items(const void *owner);
inline const pstate_entry_t::list_t &save_list() const { return m_save; }
const pstate_entry_t::list_t &save_list() const { return m_save; }
// FIXME: should be protected
ATTR_COLD void save_state_ptr(const pstring &stname, const pstate_data_type_e, const void *owner, const int size, const int count, void *ptr, bool is_ptr);
protected:

2
src/emu/netlist/solver/mat_cr.h
View File

@ -124,7 +124,7 @@ struct mat_cr_t
double tmp = 0.0;
const unsigned j1 = diag[im1] + 1;
const unsigned j2 = ia[im1+1];
for (int j = j1; j < j2; j++ )
for (unsigned j = j1; j < j2; j++ )
tmp += LU[j] * r[ja[j]];
r[im1] = (r[im1] - tmp) / LU[diag[im1]];
}

12
src/emu/netlist/solver/nld_ms_direct.h
View File

@ -228,7 +228,7 @@ ATTR_COLD void matrix_solver_direct_t<m_N, _storage_N>::vsetup(analog_net_t::lis
else
{
t->m_nzrd = m_terms[k-1]->m_nzrd;
int j=0;
unsigned j=0;
while(j < t->m_nzrd.size())
{
if (t->m_nzrd[j] < k + 1)
@ -242,7 +242,7 @@ ATTR_COLD void matrix_solver_direct_t<m_N, _storage_N>::vsetup(analog_net_t::lis
{
for (unsigned i = 0; i < t->m_railstart; i++)
{
if (!t->m_nzrd.contains(other[i]) && other[i] >= k + 1)
if (!t->m_nzrd.contains(other[i]) && other[i] >= (int) (k + 1))
t->m_nzrd.add(other[i]);
if (!t->m_nz.contains(other[i]))
t->m_nz.add(other[i]);
@ -373,7 +373,7 @@ ATTR_HOT void matrix_solver_direct_t<m_N, _storage_N>::LE_solve()
/* FIXME: Singular matrix? */
const nl_double f = 1.0 / m_A[i][i];
const double * RESTRICT s = &m_A[i][0];
const int *p = m_terms[i]->m_nzrd.data();
const unsigned *p = m_terms[i]->m_nzrd.data();
const unsigned e = m_terms[i]->m_nzrd.size();
/* Eliminate column i from row j */
@ -430,7 +430,7 @@ ATTR_HOT void matrix_solver_direct_t<m_N, _storage_N>::LE_back_subst(
tmp += A[k] * xp[k];
#else
const double * RESTRICT A = &m_A[j][0];
const int *p = m_terms[j]->m_nzrd.data();
const unsigned *p = m_terms[j]->m_nzrd.data();
const unsigned e = m_terms[j]->m_nzrd.size();
for (unsigned k = 0; k < e; k++)
@ -447,9 +447,9 @@ ATTR_HOT void matrix_solver_direct_t<m_N, _storage_N>::LE_back_subst(
}
#if 0
printf("Solution:\n");
for (int i = 0; i < N(); i++)
for (unsigned i = 0; i < N(); i++)
{
for (int k = 0; k < N(); k++)
for (unsigned k = 0; k < N(); k++)
printf("%f ", m_A[i][k]);
printf("| %f = %f \n", x[i], m_RHS[i]);
}

42
src/emu/netlist/solver/nld_ms_gmres.h
View File

@ -32,24 +32,24 @@ public:
, m_use_more_precise_stop_condition(false)
, m_accuracy_mult(1.0)
{
int mr=this->N(); /* FIXME: maximum iterations locked in here */
unsigned mr=this->N(); /* FIXME: maximum iterations locked in here */
for (int i = 0; i < mr; i++)
m_ht[i] = new double[mr + 1];
for (unsigned i = 0; i < mr + 1; i++)
m_ht[i] = new double[mr];
for (int i = 0; i < this->N(); i++)
for (unsigned i = 0; i < this->N(); i++)
m_v[i] = new double[_storage_N];
}
virtual ~matrix_solver_GMRES_t()
{
int mr=this->N(); /* FIXME: maximum iterations locked in here */
unsigned mr=this->N(); /* FIXME: maximum iterations locked in here */
for (int i = 0; i < mr; i++)
for (unsigned i = 0; i < mr + 1; i++)
delete[] m_ht[i];
for (int i = 0; i < this->N(); i++)
for (unsigned i = 0; i < this->N(); i++)
delete[] m_v[i];
}
@ -74,7 +74,7 @@ private:
double m_c[_storage_N + 1]; /* mr + 1 */
double m_g[_storage_N + 1]; /* mr + 1 */
double * RESTRICT m_ht[_storage_N]; /* mr, (mr + 1) */
double * RESTRICT m_ht[_storage_N + 1]; /* (mr + 1), mr */
double m_s[_storage_N]; /* mr + 1 */
double * RESTRICT m_v[_storage_N + 1]; /*(mr + 1), n */
//double m_y[_storage_N]; /* mr + 1 */
@ -91,8 +91,8 @@ void matrix_solver_GMRES_t<m_N, _storage_N>::vsetup(analog_net_t::list_t &nets)
{
matrix_solver_direct_t<m_N, _storage_N>::vsetup(nets);
int nz = 0;
const int iN = this->N();
unsigned nz = 0;
const unsigned iN = this->N();
for (unsigned k=0; k<iN; k++)
{
@ -109,10 +109,10 @@ void matrix_solver_GMRES_t<m_N, _storage_N>::vsetup(analog_net_t::list_t &nets)
/* build pointers into the compressed row format matrix for each terminal */
for (int j=0; j< this->m_terms[k]->m_railstart;j++)
for (unsigned j=0; j< this->m_terms[k]->m_railstart;j++)
{
for (int i = mat.ia[k]; i<nz; i++)
if (this->m_terms[k]->net_other()[j] == mat.ja[i])
for (unsigned i = mat.ia[k]; i<nz; i++)
if (this->m_terms[k]->net_other()[j] == (int) mat.ja[i])
{
m_term_cr[k].add(i);
break;
@ -135,7 +135,7 @@ ATTR_HOT nl_double matrix_solver_GMRES_t<m_N, _storage_N>::vsolve()
template <unsigned m_N, unsigned _storage_N>
ATTR_HOT inline int matrix_solver_GMRES_t<m_N, _storage_N>::vsolve_non_dynamic(const bool newton_raphson)
{
const int iN = this->N();
const unsigned iN = this->N();
/* ideally, we could get an estimate for the spectral radius of
* Inv(D - L) * U
@ -150,16 +150,16 @@ ATTR_HOT inline int matrix_solver_GMRES_t<m_N, _storage_N>::vsolve_non_dynamic(c
ATTR_ALIGN nl_double new_V[_storage_N];
ATTR_ALIGN nl_double l_V[_storage_N];
for (int i=0, e=mat.nz_num; i<e; i++)
for (unsigned i=0, e=mat.nz_num; i<e; i++)
m_A[i] = 0.0;
for (int k = 0; k < iN; k++)
for (unsigned k = 0; k < iN; k++)
{
nl_double gtot_t = 0.0;
nl_double RHS_t = 0.0;
const int term_count = this->m_terms[k]->count();
const int railstart = this->m_terms[k]->m_railstart;
const unsigned term_count = this->m_terms[k]->count();
const unsigned railstart = this->m_terms[k]->m_railstart;
const nl_double * const RESTRICT gt = this->m_terms[k]->gt();
const nl_double * const RESTRICT go = this->m_terms[k]->go();
const nl_double * const RESTRICT Idr = this->m_terms[k]->Idr();
@ -190,7 +190,7 @@ ATTR_HOT inline int matrix_solver_GMRES_t<m_N, _storage_N>::vsolve_non_dynamic(c
const nl_double accuracy = this->m_params.m_accuracy;
#if 1
int mr = std::min(iN-1,(int) sqrt(iN));
int mr = std::min((int) iN-1,(int) sqrt(iN));
mr = std::min(mr, this->m_params.m_gs_loops);
int iter = 4;
int gsl = solve_ilu_gmres(new_V, RHS, iter, mr, accuracy);
@ -228,7 +228,7 @@ ATTR_HOT inline int matrix_solver_GMRES_t<m_N, _storage_N>::vsolve_non_dynamic(c
}
else
{
for (int k = 0; k < iN; k++)
for (unsigned k = 0; k < iN; k++)
this->m_nets[k]->m_cur_Analog = new_V[k];
return 1;
}
@ -378,7 +378,7 @@ int matrix_solver_GMRES_t<m_N, _storage_N>::solve_ilu_gmres (double * RESTRICT x
/* didn't converge within accuracy */
last_k = mr - 1;
double m_y[_storage_N];
double m_y[_storage_N + 1];
/* Solve the system H * y = g */
/* x += m_v[j] * m_y[j] */

20
src/emu/netlist/solver/nld_ms_sor.h
View File

@ -63,7 +63,7 @@ ATTR_HOT nl_double matrix_solver_SOR_t<m_N, _storage_N>::vsolve()
template <unsigned m_N, unsigned _storage_N>
ATTR_HOT inline int matrix_solver_SOR_t<m_N, _storage_N>::vsolve_non_dynamic(const bool newton_raphson)
{
const int iN = this->N();
const unsigned iN = this->N();
bool resched = false;
int resched_cnt = 0;
@ -82,13 +82,13 @@ ATTR_HOT inline int matrix_solver_SOR_t<m_N, _storage_N>::vsolve_non_dynamic(con
ATTR_ALIGN nl_double RHS[_storage_N];
ATTR_ALIGN nl_double new_V[_storage_N];
for (int k = 0; k < iN; k++)
for (unsigned k = 0; k < iN; k++)
{
nl_double gtot_t = 0.0;
nl_double gabs_t = 0.0;
nl_double RHS_t = 0.0;
const int term_count = this->m_terms[k]->count();
const unsigned term_count = this->m_terms[k]->count();
const nl_double * const RESTRICT gt = this->m_terms[k]->gt();
const nl_double * const RESTRICT go = this->m_terms[k]->go();
const nl_double * const RESTRICT Idr = this->m_terms[k]->Idr();
@ -102,14 +102,14 @@ ATTR_HOT inline int matrix_solver_SOR_t<m_N, _storage_N>::vsolve_non_dynamic(con
RHS_t = RHS_t + Idr[i];
}
for (int i = this->m_terms[k]->m_railstart; i < term_count; i++)
for (unsigned i = this->m_terms[k]->m_railstart; i < term_count; i++)
RHS_t = RHS_t + go[i] * *other_cur_analog[i];
RHS[k] = RHS_t;
if (USE_GABS)
{
for (int i = 0; i < term_count; i++)
for (unsigned i = 0; i < term_count; i++)
gabs_t = gabs_t + nl_math::abs(go[i]);
gabs_t *= NL_FCONST(0.5); // derived by try and error
@ -144,14 +144,14 @@ ATTR_HOT inline int matrix_solver_SOR_t<m_N, _storage_N>::vsolve_non_dynamic(con
do {
resched = false;
double err = 0;
for (int k = 0; k < iN; k++)
for (unsigned k = 0; k < iN; k++)
{
const int * RESTRICT net_other = this->m_terms[k]->net_other();
const int railstart = this->m_terms[k]->m_railstart;
const unsigned railstart = this->m_terms[k]->m_railstart;
const nl_double * RESTRICT go = this->m_terms[k]->go();
nl_double Idrive = 0.0;
for (int i = 0; i < railstart; i++)
for (unsigned i = 0; i < railstart; i++)
Idrive = Idrive + go[i] * new_V[net_other[i]];
const nl_double new_val = new_V[k] * one_m_w[k] + (Idrive + RHS[k]) * w[k];
@ -179,12 +179,12 @@ ATTR_HOT inline int matrix_solver_SOR_t<m_N, _storage_N>::vsolve_non_dynamic(con
if (interleaved_dynamic_updates)
{
for (int k = 0; k < iN; k++)
for (unsigned k = 0; k < iN; k++)
this->m_nets[k]->m_cur_Analog += 1.0 * (new_V[k] - this->m_nets[k]->m_cur_Analog);
}
else
{
for (int k = 0; k < iN; k++)
for (unsigned k = 0; k < iN; k++)
this->m_nets[k]->m_cur_Analog = new_V[k];
}

6
src/emu/netlist/solver/nld_ms_sor_mat.h
View File

@ -188,19 +188,19 @@ ATTR_HOT inline int matrix_solver_SOR_mat_t<m_N, _storage_N>::vsolve_non_dynamic
}
#endif
for (int k = 0; k < iN; k++)
for (unsigned k = 0; k < iN; k++)
new_v[k] = this->m_nets[k]->m_cur_Analog;
do {
resched = false;
nl_double cerr = 0.0;
for (int k = 0; k < iN; k++)
for (unsigned k = 0; k < iN; k++)
{
nl_double Idrive = 0;
const double * RESTRICT A = &this->m_A[k][0];
const int *p = this->m_terms[k]->m_nz.data();
const unsigned *p = this->m_terms[k]->m_nz.data();
const unsigned e = this->m_terms[k]->m_nz.size();
for (unsigned i = 0; i < e; i++)

29
src/emu/netlist/solver/nld_solver.c
View File

@ -126,19 +126,19 @@ ATTR_COLD void matrix_solver_t::setup(analog_net_t::list_t &nets)
switch (p->type())
{
case terminal_t::TERMINAL:
switch (p->netdev().family())
switch (p->device().family())
{
case device_t::CAPACITOR:
if (!m_step_devices.contains(&p->netdev()))
m_step_devices.add(&p->netdev());
if (!m_step_devices.contains(&p->device()))
m_step_devices.add(&p->device());
break;
case device_t::BJT_EB:
case device_t::DIODE:
//case device_t::VCVS:
case device_t::BJT_SWITCH:
NL_VERBOSE_OUT(("found BJT/Diode\n"));
if (!m_dynamic_devices.contains(&p->netdev()))
m_dynamic_devices.add(&p->netdev());
if (!m_dynamic_devices.contains(&p->device()))
m_dynamic_devices.add(&p->device());
break;
default:
break;
@ -202,7 +202,7 @@ ATTR_COLD void matrix_solver_t::start()
{
register_output("Q_sync", m_Q_sync);
register_input("FB_sync", m_fb_sync);
connect(m_fb_sync, m_Q_sync);
connect_direct(m_fb_sync, m_Q_sync);
save(NLNAME(m_last_step));
save(NLNAME(m_cur_ts));
@ -279,8 +279,7 @@ ATTR_HOT nl_double matrix_solver_t::solve()
// We are already up to date. Avoid oscillations.
// FIXME: Make this a parameter!
//if (delta < netlist_time::from_nsec(1)) // 20000
if (delta < netlist_time::from_nsec(20000)) // 20000
if (delta < netlist_time::from_nsec(1)) // 20000
return -1.0;
/* update all terminals for new time step */
@ -346,7 +345,7 @@ NETLIB_START(solver)
// internal staff
register_input("FB_step", m_fb_step);
connect(m_fb_step, m_Q_step);
connect_late(m_fb_step, m_Q_step);
}
@ -425,9 +424,9 @@ template <int m_N, int _storage_N>
matrix_solver_t * NETLIB_NAME(solver)::create_solver(int size, const bool use_specific)
{
if (use_specific && m_N == 1)
return palloc(matrix_solver_direct1_t, &m_params);
return palloc(matrix_solver_direct1_t(&m_params));
else if (use_specific && m_N == 2)
return palloc(matrix_solver_direct2_t, &m_params);
return palloc(matrix_solver_direct2_t(&m_params));
else
{
if (size >= m_gs_threshold)
@ -435,17 +434,17 @@ matrix_solver_t * NETLIB_NAME(solver)::create_solver(int size, const bool use_sp
if (pstring("SOR_MAT").equals(m_iterative_solver))
{
typedef matrix_solver_SOR_mat_t<m_N,_storage_N> solver_mat;
return palloc(solver_mat, &m_params, size);
return palloc(solver_mat(&m_params, size));
}
else if (pstring("SOR").equals(m_iterative_solver))
{
typedef matrix_solver_SOR_t<m_N,_storage_N> solver_GS;
return palloc(solver_GS, &m_params, size);
return palloc(solver_GS(&m_params, size));
}
else if (pstring("GMRES").equals(m_iterative_solver))
{
typedef matrix_solver_GMRES_t<m_N,_storage_N> solver_GMRES;
return palloc(solver_GMRES, &m_params, size);
return palloc(solver_GMRES(&m_params, size));
}
else
{
@ -456,7 +455,7 @@ matrix_solver_t * NETLIB_NAME(solver)::create_solver(int size, const bool use_sp
else
{
typedef matrix_solver_direct_t<m_N,_storage_N> solver_D;
return palloc(solver_D, &m_params, size);
return palloc(solver_D(&m_params, size));
}
}
}

6
src/emu/netlist/solver/nld_solver.h
View File

@ -52,7 +52,7 @@ struct solver_parameters_t
class terms_t
{
NETLIST_PREVENT_COPYING(terms_t)
P_PREVENT_COPYING(terms_t)
public:
ATTR_COLD terms_t() : m_railstart(0)
@ -83,8 +83,8 @@ class terms_t
unsigned m_railstart;
plist_t<int> m_nzrd; /* non zero right of the diagonal for elimination */
plist_t<int> m_nz; /* all non zero for multiplication */
plist_t<unsigned> m_nzrd; /* non zero right of the diagonal for elimination */
plist_t<unsigned> m_nz; /* all non zero for multiplication */
private:
plist_t<terminal_t *> m_term;
plist_t<int> m_net_other;

19
src/emu/netlist/tools/nl_convert.c
View File

@ -7,18 +7,19 @@
#include <algorithm>
#include <cstdio>
#include <cmath>
#include "nl_convert.h"
template<typename Class>
static plist_t<int> bubble(const pnamedlist_t<Class *> &sl)
{
plist_t<int> ret(sl.size());
for (int i=0; i<sl.size(); i++)
for (unsigned i=0; i<sl.size(); i++)
ret[i] = i;
for(int i=0; i < sl.size()-1;i++)
for(unsigned i=0; i < sl.size(); i++)
{
for(int j=i+1; j < sl.size(); j++)
for(unsigned j=i+1; j < sl.size(); j++)
{
if(sl[ret[i]]->name() > sl[ret[j]]->name())
{
@ -44,7 +45,7 @@ void nl_convert_base_t::out(const char *format, ...)
void nl_convert_base_t::add_pin_alias(const pstring &devname, const pstring &name, const pstring &alias)
{
m_pins.add(palloc(pin_alias_t, devname + "." + name, devname + "." + alias), false);
m_pins.add(palloc(pin_alias_t(devname + "." + name, devname + "." + alias)), false);
}
void nl_convert_base_t::add_ext_alias(const pstring &alias)
@ -54,15 +55,15 @@ void nl_convert_base_t::add_ext_alias(const pstring &alias)
void nl_convert_base_t::add_device(const pstring &atype, const pstring &aname, const pstring &amodel)
{
m_devs.add(palloc(dev_t, atype, aname, amodel), false);
m_devs.add(palloc(dev_t(atype, aname, amodel)), false);
}
void nl_convert_base_t::add_device(const pstring &atype, const pstring &aname, double aval)
{
m_devs.add(palloc(dev_t, atype, aname, aval), false);
m_devs.add(palloc(dev_t(atype, aname, aval)), false);
}
void nl_convert_base_t::add_device(const pstring &atype, const pstring &aname)
{
m_devs.add(palloc(dev_t, atype, aname), false);
m_devs.add(palloc(dev_t(atype, aname)), false);
}
void nl_convert_base_t::add_term(pstring netname, pstring termname)
@ -70,7 +71,7 @@ void nl_convert_base_t::add_term(pstring netname, pstring termname)
net_t * net = m_nets.find_by_name(netname);
if (net == NULL)
{
net = palloc(net_t, netname);
net = palloc(net_t(netname));
m_nets.add(net, false);
}
@ -136,7 +137,7 @@ const pstring nl_convert_base_t::get_nl_val(const double val)
int i = 0;
while (m_units[i].m_unit != "-" )
{
if (m_units[i].m_mult <= nl_math::abs(val))
if (m_units[i].m_mult <= std::abs(val))
break;
i++;
}

6
src/tools/nltool.c
View File

@ -183,7 +183,7 @@ public:
void init()
{
m_setup = palloc(netlist::setup_t, this);
m_setup = palloc(netlist::setup_t(this));
this->init_object(*this, "netlist");
m_setup->init();
}
@ -192,7 +192,7 @@ public:
{
// read the netlist ...
m_setup->register_source(palloc(netlist::netlist_source_mem_t, buffer));
m_setup->register_source(palloc(netlist::netlist_source_mem_t(buffer)));
m_setup->include(name);
log_setup();
@ -292,7 +292,7 @@ static void listdevices()
nt.init();
const netlist::factory_list_t::list_t &list = nt.setup().factory().list();
nt.setup().register_source(palloc(netlist::source_proc_t, "dummy", &netlist_dummy));
nt.setup().register_source(palloc(netlist::source_proc_t("dummy", &netlist_dummy)));
nt.setup().include("dummy");
nt.setup().start_devices();