mirror of
https://github.com/holub/mame
synced 2025-06-09 22:33:00 +03:00
Netlist now compiles with
-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:
parent
a24fd3408a
commit
b1a72a3e9f
@ -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)
|
||||
|
@ -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);
|
||||
|
||||
|
||||
|
@ -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);
|
||||
|
@ -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)
|
||||
|
@ -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.
|
||||
*
|
||||
*/
|
||||
|
||||
|
@ -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);
|
||||
|
@ -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()));
|
||||
|
@ -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);
|
||||
|
@ -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, "-")
|
||||
|
@ -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)
|
||||
|
@ -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)
|
||||
|
@ -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)
|
||||
|
@ -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);
|
||||
|
||||
|
@ -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);
|
||||
|
@ -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));
|
||||
}
|
||||
|
@ -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()
|
||||
|
@ -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)
|
||||
|
||||
|
@ -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;
|
||||
|
@ -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)
|
||||
{
|
||||
}
|
||||
|
@ -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();
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -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
|
||||
//============================================================
|
||||
|
@ -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)
|
||||
|
@ -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
|
||||
|
@ -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);
|
||||
}
|
||||
|
||||
|
@ -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) {}
|
||||
|
@ -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++;
|
||||
|
@ -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 ¶m, const pstring &value);
|
||||
void register_param(const pstring ¶m, const double value);
|
||||
|
||||
|
@ -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);
|
||||
|
@ -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)
|
||||
|
@ -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
|
||||
//============================================================
|
||||
|
@ -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]);
|
||||
|
||||
|
@ -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
|
||||
|
@ -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);
|
||||
}
|
||||
|
@ -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:
|
||||
|
@ -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]];
|
||||
}
|
||||
|
@ -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]);
|
||||
}
|
||||
|
@ -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] */
|
||||
|
@ -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];
|
||||
}
|
||||
|
||||
|
@ -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++)
|
||||
|
@ -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));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -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;
|
||||
|
@ -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++;
|
||||
}
|
||||
|
@ -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();
|
||||
|
Loading…
Reference in New Issue
Block a user