コード例 #1
0
        public std.vector <detail.core_terminal_t> core_terms(detail.net_t net)  //std::vector<detail::core_terminal_t *> &core_terms(const detail::net_t &net) noexcept
        {
            if (m_core_terms[net] == default)
            {
                m_core_terms[net] = new std.vector <detail.core_terminal_t>();
            }

            return(m_core_terms[net]);
        }
コード例 #2
0
 int get_net_idx(detail.net_t net)
 {
     for (UInt32 k = 0; k < m_nets.size(); k++)
     {
         if (m_nets[k] == net)
         {
             return((int)k);
         }
     }
     return(-1);
 }
コード例 #3
0
        // FIXME: only used by queue_t save state

        public size_t find_net_id(detail.net_t net)
        {
            for (size_t i = 0; i < m_nets.size(); i++)
            {
                if (m_nets[i] == net)
                {
                    return(i);
                }
            }

            return(size_t.MaxValue);  //return std::numeric_limits<std::size_t>::max();
        }
コード例 #4
0
        //template <class R>
        public void qremove(detail.net_t elem)  //void qremove(const R &elem) noexcept
        {
#if !NL_USE_QUEUE_STATS
            m_queue.remove <bool_const_false>(elem);
#else
            if (!m_use_stats)
            {
                m_queue.remove <false>(elem);
            }
            else
            {
                m_queue.remove <true>(elem);
            }
#endif
        }
コード例 #5
0
 //template <typename T>
 public void register_net(detail.net_t net)
 {
     m_nets.push_back(net);
 }                                                                      //void register_net(device_arena::owned_ptr<T> &&net) { m_nets.push_back(std::move(net)); }
コード例 #6
0
        //void enable_stats(bool val) noexcept { m_use_stats = val; }


        //template <bool KEEP_STATS>
        void process_queue_stats(bool KEEP_STATS, netlist_time_ext delta)  //void process_queue_stats(netlist_time_ext delta) noexcept;
        {
            netlist_time_ext stop = m_time + delta;

            qpush(new queue_t_entry_t(stop, null));

            if (m_mainclock == null)
            {
                m_time = m_queue.top().exec_time();
                detail.net_t obj = m_queue.top().object_();
                m_queue.pop();

                while (obj != null)
                {
                    obj.update_devs(KEEP_STATS);

                    //throw new emu_unimplemented();
#if false
                    if (KEEP_STATS)
                    {
                        m_perf_out_processed.inc();
                    }
#endif

                    queue_t_entry_t top = m_queue.top();
                    m_time = top.exec_time();
                    obj    = top.object_();
                    m_queue.pop();
                }
            }
            else
            {
                logic_net_t      mc_net  = m_mainclock.m_Q.net();
                netlist_time     inc     = m_mainclock.m_inc;
                netlist_time_ext mc_time = mc_net.next_scheduled_time();

                do
                {
                    queue_t_entry_t top = m_queue.top();
                    while (top.exec_time() > mc_time)
                    {
                        m_time = mc_time;
                        mc_net.toggle_new_Q();
                        mc_net.update_devs(KEEP_STATS);
                        top      = m_queue.top();
                        mc_time += inc;
                    }

                    m_time = top.exec_time();
                    detail.net_t obj = top.object_();
                    m_queue.pop();
                    if (!!(obj == null))
                    {
                        break;
                    }

                    obj.update_devs(KEEP_STATS);

                    //throw new emu_unimplemented();
#if false
                    if (KEEP_STATS)
                    {
                        m_perf_out_processed.inc();
                    }
#endif
                } while (true);

                mc_net.set_next_scheduled_time(mc_time);
            }
        }