ATTR_COLD void netlist_base_t::start()
{
/* find the main clock and solver ... */
NL_VERBOSE_OUT(("Searching for mainclock and solver ...\n"));
m_mainclock = get_single_device<NETLIB_NAME(mainclock)>("mainclock");
m_solver = get_single_device<NETLIB_NAME(solver)>("solver");
m_gnd = get_single_device<NETLIB_NAME(gnd)>("gnd");
m_params = get_single_device<NETLIB_NAME(netlistparams)>("parameter");
/* make sure the solver and parameters are started first! */
if (m_solver != NULL)
m_solver->start_dev();
if (m_params != NULL)
{
m_params->start_dev();
}
m_use_deactivate = (m_params->m_use_deactivate.Value() ? true : false);
NL_VERBOSE_OUT(("Initializing devices ...\n"));
for (netlist_device_t * const * entry = m_devices.first(); entry != NULL; entry = m_devices.next(entry))
{
netlist_device_t *dev = *entry;
if (dev != m_solver && dev != m_params)
dev->start_dev();
}
}
ATTR_HOT ATTR_ALIGN void netlist_base_t::process_queue(const netlist_time delta)
{
m_stop = m_time + delta;
if (m_mainclock == NULL)
{
while ( (m_time < m_stop) && (m_queue.is_not_empty()))
{
const netlist_queue_t::entry_t &e = m_queue.pop();
m_time = e.time();
e.object()->update_devs();
add_to_stat(m_perf_out_processed, 1);
if (FATAL_ERROR_AFTER_NS)
if (time() > NLTIME_FROM_NS(FATAL_ERROR_AFTER_NS))
error("Stopped");
}
if (m_queue.is_empty())
m_time = m_stop;
} else {
netlist_net_t &mcQ = m_mainclock->m_Q.net();
const netlist_time inc = m_mainclock->m_inc;
while (m_time < m_stop)
{
if (m_queue.is_not_empty())
{
while (m_queue.peek().time() > mcQ.time())
{
m_time = mcQ.time();
NETLIB_NAME(mainclock)::mc_update(mcQ, m_time + inc);
}
const netlist_queue_t::entry_t &e = m_queue.pop();
m_time = e.time();
e.object()->update_devs();
} else {
m_time = mcQ.time();
NETLIB_NAME(mainclock)::mc_update(mcQ, m_time + inc);
}
if (FATAL_ERROR_AFTER_NS)
if (time() > NLTIME_FROM_NS(FATAL_ERROR_AFTER_NS))
error("Stopped");
add_to_stat(m_perf_out_processed, 1);
}
}
}
ATTR_HOT ATTR_ALIGN void netlist_base_t::process_queue(const netlist_time &delta)
{
m_stop = m_time + delta;
if (m_mainclock == NULL)
{
while ( (m_time < m_stop) && (m_queue.is_not_empty()))
{
const netlist_queue_t::entry_t e = *m_queue.pop();
m_time = e.exec_time();
e.object()->update_devs();
add_to_stat(m_perf_out_processed, 1);
}
if (m_queue.is_empty())
m_time = m_stop;
} else {
netlist_logic_net_t &mc_net = m_mainclock->m_Q.net().as_logic();
const netlist_time inc = m_mainclock->m_inc;
netlist_time mc_time = mc_net.time();
while (m_time < m_stop)
{
if (m_queue.is_not_empty())
{
while (m_queue.peek()->exec_time() > mc_time)
{
m_time = mc_time;
mc_time += inc;
NETLIB_NAME(mainclock)::mc_update(mc_net);
}
const netlist_queue_t::entry_t e = *m_queue.pop();
m_time = e.exec_time();
e.object()->update_devs();
} else {
m_time = mc_time;
mc_time += inc;
NETLIB_NAME(mainclock)::mc_update(mc_net);
}
add_to_stat(m_perf_out_processed, 1);
}
mc_net.set_time(mc_time);
}
}
ATTR_COLD void netlist_base_t::start()
{
/* find the main clock and solver ... */
m_mainclock = get_single_device<NETLIB_NAME(mainclock)>("mainclock");
m_solver = get_single_device<NETLIB_NAME(solver)>("solver");
m_gnd = get_single_device<NETLIB_NAME(gnd)>("gnd");
NL_VERBOSE_OUT(("Initializing devices ...\n"));
for (tagmap_devices_t::entry_t *entry = m_devices.first(); entry != NULL; entry = m_devices.next(entry))
{
netlist_device_t *dev = entry->object();
dev->start_dev();
}
}
m_nets.reset();
pstring::resetmem();
}
ATTR_COLD netlist_net_t *netlist_base_t::find_net(const pstring &name)
{
for (netlist_net_t::list_t::entry_t *p = m_nets.first(); p != NULL; p = m_nets.next(p))
{
if (p->object()->name() == name)
return p->object();
}
return NULL;
}
ATTR_COLD void netlist_base_t::set_mainclock_dev(NETLIB_NAME(mainclock) *dev)
{
m_mainclock = dev;
}
ATTR_COLD void netlist_base_t::set_solver_dev(NETLIB_NAME(solver) *dev)
{
m_solver = dev;
}
ATTR_COLD void netlist_base_t::reset()
{
m_time_ps = netlist_time::zero;
m_rem = 0;
m_queue.clear();
if (m_mainclock != NULL)
/*
* nld_solver.c
*
*/
#include "nld_solver.h"
#include "nld_twoterm.h"
// ----------------------------------------------------------------------------------------
// netlist_matrix_solver
// ----------------------------------------------------------------------------------------
#define SOLVER_VERBOSE_OUT(x) do {} while (0)
//#define SOLVER_VERBOSE_OUT(x) printf x
ATTR_COLD void netlist_matrix_solver_t::setup(netlist_net_t::list_t &nets, NETLIB_NAME(solver) &aowner)
{
m_owner = &aowner;
for (netlist_net_t::list_t::entry_t *pn = nets.first(); pn != NULL; pn = nets.next(pn))
{
NL_VERBOSE_OUT(("setting up net\n"));
m_nets.add(pn->object());
pn->object()->m_solver = this;
for (netlist_core_terminal_t *p = pn->object()->m_head; p != NULL; p = p->m_update_list_next)
{
switch (p->type())
{
case netlist_terminal_t::TERMINAL:
switch (p->netdev().family())
