void sc_simcontext::uvm_ml_quasi_static_start_of_simulation() {

    if( m_quasi_static_start_simulation_done || sim_status() != SC_SIM_OK ) {
        return;
    }

    m_execution_phase = phase_quasi_static_start_of_simulation;

    sc_cosim::do_ncsc_global_quasi_static_functions(ncsc_gf_phase_start_of_simulation);
    if (has_set_dpi_scope()) {
        sc_cosim::fpi().reset_dpi_export_scope(NULL);
        reset_dpi_scope();
    }
    m_port_registry->quasi_static_start_simulation();
    m_export_registry->quasi_static_start_simulation();
    m_prim_channel_registry->quasi_static_start_simulation();
    // m_module_registry->quasi_static_start_simulation();

    if (has_set_dpi_scope()) {
        sc_cosim::fpi().reset_dpi_export_scope(NULL);
        reset_dpi_scope();
    }

    m_quasi_static_start_simulation_done = true;
    m_ready_to_simulate = true;
    m_start_of_simulation_called = true;
    m_execution_phase = phase_unknown;

    // check for call(s) to sc_stop
    if( m_forced_stop ) {
        do_sc_stop_action();
        return;
    }
}
void
sc_simcontext::elaborate()
{
    if ( ! uvm_ml_sc_changes::sc_start_disabled ) { 
        if( m_elaboration_done || sim_status() != SC_SIM_OK ) {
            return;
        }

        m_port_registry->construction_done();
        m_export_registry->construction_done();
        m_prim_channel_registry->construction_done();
        m_module_registry->construction_done();
    
        // //////////////////
        // ML enabling additions START
        //

        if (!signal_end_of_elaboration()) {
            return;
        }
// 
// ML enabling additions END
// //////////////////
    }
}
void
sc_simcontext::simulate( const sc_time& duration )
{
    // UVM-ML-related
    if (! uvm_ml_sc_changes::sc_start_disabled ) { 
        ///
        initialize( true );

        if (sim_status() != SC_SIM_OK) {
            return;
        }


        do_simulate(duration);

    }

}
Beispiel #4
0
void
sc_simcontext::elaborate()
{
    if ( m_elaboration_done || sim_status() != SC_SIM_OK )
    {
        return;
    }

    m_port_registry->construction_done();
    m_export_registry->construction_done();
    m_prim_channel_registry->construction_done();
    m_module_registry->construction_done();

    // check for call(s) to sc_stop
    if ( m_forced_stop )
    {
        do_sc_stop_action();
        return;
    }

    // SIGNAL THAT ELABORATION IS DONE
    //
    // We set the switch before the calls in case someone creates a process
    // in an end_of_elaboration callback. We need the information to flag
    // the process as being dynamic.

    m_elaboration_done = true;

    m_port_registry->elaboration_done();
    m_export_registry->elaboration_done();
    m_prim_channel_registry->elaboration_done();
    m_module_registry->elaboration_done();
    sc_reset::reconcile_resets();

    // check for call(s) to sc_stop
    if ( m_forced_stop )
    {
        do_sc_stop_action();
        return;
    }
}
Beispiel #5
0
void ipc_pin_status(void* data)
{
	ALOGE("%s: test me!", __func__);
	pinStatus* pinSt = (pinStatus*)(data);
	int attempts = -1;
	switch(pinSt->status){
		case 0:
			DEBUG_I("%s : Correct password ", __func__);
			ril_request_complete(ril_data.tokens.pin_status, RIL_E_SUCCESS, &attempts, sizeof(attempts));
			return;
		case 1:
			DEBUG_I("%s : Wrong password ", __func__);
			attempts = pinSt->attempts;
			ril_request_complete(ril_data.tokens.pin_status, RIL_E_PASSWORD_INCORRECT, &attempts, sizeof(attempts));
			return;
		case 2:
			DEBUG_I("%s : Wrong password and no attempts left!", __func__);
			attempts = 0;
			ril_request_complete(ril_data.tokens.pin_status, RIL_E_PASSWORD_INCORRECT, &attempts, sizeof(attempts));
			sim_status(4);
			return;	
	}
}
Beispiel #6
0
void
sc_simcontext::simulate( const sc_time& duration )
{
    initialize( true );

    if (sim_status() != SC_SIM_OK)
    {
        return;
    }

    sc_time non_overflow_time =
        sc_time(~sc_dt::UINT64_ZERO, false) - m_curr_time;
    if ( duration > non_overflow_time )
    {
        SC_REPORT_ERROR(SC_ID_SIMULATION_TIME_OVERFLOW_, "");
        return;
    }
    else if ( duration < SC_ZERO_TIME )
    {
        SC_REPORT_ERROR(SC_ID_NEGATIVE_SIMULATION_TIME_,"");
    }
    m_in_simulator_control = true;

    sc_time until_t = m_curr_time + duration;

    m_until_event->cancel();  // to be on the safe side
    m_until_event->notify_internal( duration );

    sc_time t;

    // IF DURATION WAS ZERO WE ONLY CRUNCH:
    //
    // We duplicate the code so that we don't add the overhead of the
    // check to each loop in the do below.
    if ( duration == SC_ZERO_TIME )
    {
        m_runnable->toggle();
        crunch( true );
        if ( m_error ) return;
        if ( m_something_to_trace ) trace_cycle( /* delta cycle? */ false );
        if ( m_forced_stop )
            do_sc_stop_action();
        return;
    }


    // NON-ZERO DURATION: EXECUTE UP TO THAT TIME:
    do
    {
        m_runnable->toggle();

        crunch();
        if ( m_error )
        {
            m_in_simulator_control = false;
            return;
        }
        if ( m_something_to_trace )
        {
            trace_cycle( false );
        }
        // check for call(s) to sc_stop
        if ( m_forced_stop )
        {
            do_sc_stop_action();
            return;
        }

        do
        {
            t = next_time();

            // PROCESS TIMED NOTIFICATIONS

            do
            {
                sc_event_timed* et = m_timed_events->extract_top();
                sc_event* e = et->event();
                delete et;
                if ( e != 0 )
                {
                    e->trigger();
                }
            }
            while ( m_timed_events->size() &&
                    m_timed_events->top()->notify_time() == t );

        }
        while ( m_runnable->is_empty() && t != until_t );
        if ( t > m_curr_time ) m_curr_time = t;

    }
    while ( t != until_t );
    m_in_simulator_control = false;
}
Beispiel #7
0
void
sc_simcontext::prepare_to_simulate()
{
    sc_cthread_handle cthread_p; // Pointer to cthread process accessing.
    sc_method_handle  method_p;  // Pointer to method process accessing.
    sc_thread_handle  thread_p;  // Pointer to thread process accessing.

    if ( m_ready_to_simulate || sim_status() != SC_SIM_OK )
    {
        return;
    }

    // instantiate the coroutine package
#   if defined(WIN32)
    m_cor_pkg = new sc_cor_pkg_fiber( this );
#   else
#       if defined(SC_USE_PTHREADS)
    m_cor_pkg = new sc_cor_pkg_pthread( this );
#       else
    m_cor_pkg = new sc_cor_pkg_qt( this );
#       endif
#   endif
    m_cor = m_cor_pkg->get_main();

    // NOTIFY ALL OBJECTS THAT SIMULATION IS ABOUT TO START:

    m_port_registry->start_simulation();
    m_export_registry->start_simulation();
    m_prim_channel_registry->start_simulation();
    m_module_registry->start_simulation();
    m_start_of_simulation_called = true;

    // CHECK FOR CALL(S) TO sc_stop

    if ( m_forced_stop )
    {
        do_sc_stop_action();
        return;
    }

    // PREPARE ALL (C)THREAD PROCESSES FOR SIMULATION:

    for ( thread_p = m_process_table->thread_q_head();
            thread_p; thread_p = thread_p->next_exist() )
    {
        thread_p->prepare_for_simulation();
    }

    for ( cthread_p = m_process_table->cthread_q_head();
            cthread_p; cthread_p = cthread_p->next_exist() )
    {
        cthread_p->prepare_for_simulation();
    }

    m_ready_to_simulate = true;
    m_runnable->init();

    // update phase

    m_execution_phase = phase_update;
    m_prim_channel_registry->perform_update();
    m_execution_phase = phase_notify;

    int size;

    // make all method processes runnable

    for ( method_p = m_process_table->method_q_head();
            method_p; method_p = method_p->next_exist() )
    {
        if ( !method_p->dont_initialize() )
        {
            push_runnable_method_front( method_p );
        }
    }

    // make all thread processes runnable

    for ( thread_p = m_process_table->thread_q_head();
            thread_p; thread_p = thread_p->next_exist() )
    {
        if ( !thread_p->dont_initialize() )
        {
            push_runnable_thread_front( thread_p );
        }
    }


    // process delta notifications

    if ( ( size = m_delta_events.size() ) != 0 )
    {
        sc_event** l_delta_events = &m_delta_events[0];
        int i = size - 1;
        do
        {
            l_delta_events[i]->trigger();
        }
        while ( -- i >= 0 );
        m_delta_events.resize(0);
    }

    // used in 'simulate()'
    m_until_event = new sc_event;

    if ( m_runnable->is_empty() )
    {
        m_delta_count++;
    }
}