random_bcet_wcet_sw.h

#ifndef random_bcet_wcet_sw_MODULE_ALGORITHMS_FILE_H
#define random_bcet_wcet_sw_MODULE_ALGORITHMS_FILE_H

#include "user_parameters.h"

#include "user_algorithm_interface.h"
#include <time.h>       /* time */

My_Simulation_states current_time_state;

/*****************************************************************************/
/**************************  BEGIN USER SPACE ********************************/

template<int Ni, int No>
void random_bcet_wcet_sw(User_algorithm_interface<Ni, No> &user_algo_interface) {
        // Sw Default behavior
        srand ((unsigned int)sc_time_stamp().to_double());      
        user_algo_interface.get_logfile() << sc_time_stamp() << "init srand" << endl;
        
        

        while(true) {

                /*******************************************************************************/
                /****                    MANDATORY PART (EXCEPT DISPLAY)                    ****/

                
                

                /* WAIT FOR START ALGORITHM EVENT : Only for Dynamic tasks */
                user_algo_interface.get_logfile() << sc_time_stamp() << ": " << user_algo_interface.get_name() << " Beginning of loop" << endl;
                current_time_state = tasks_execution_time;
                user_algo_interface.b_execution_requested();
                

                
                user_algo_interface.get_logfile() << sc_time_stamp() << ": " << user_algo_interface.get_name() << " Execution requested" << endl;
                
                /* TRACE : The algorithm is idle in order to have an accurate trace */
                user_algo_interface.set_algorithm_idle();

                /* WAIT FOR NEXT PERIOD to begin to start algorithm execution. For non-periodic modules, function returns right away */
                user_algo_interface.wait_until_next_period();
                


                
#ifdef GENERATE_LOG_FILE
                user_algo_interface.get_logfile() << sc_time_stamp() << ": " << user_algo_interface.get_name() << " New period started" << endl;
#endif
                user_algo_interface.set_algorithm_waiting();

                /**** BEGINNING OF DATA RECEPTION SEGMENT ****/


                                
                user_algo_interface.b_all_data_received();

                user_algo_interface.set_algorithm_running();

                /**** END OF DATA RECEPTION SEGMENT ****/

                /**** BEGINNING OF USER ALGORITHM ****/

                
                sc_time my_WCET=(user_algo_interface.get_WCET())*(CPU_FREQUENCIES_STEPS[0]/CPU_FREQUENCIES_STEPS[global_operating_point]);  
                sc_time my_BCET=(user_algo_interface.get_BCET())*(CPU_FREQUENCIES_STEPS[0]/CPU_FREQUENCIES_STEPS[global_operating_point]);  
                
                int *data;
                data = user_algo_interface.get_data_in_ptr(0);
                if ((data[0]>>16)==0)
                        current_time_state = BCET;
                if ((data[0]>>16)==1)
                        current_time_state = WCET;
                if ((data[0]>>16)==2)
                        current_time_state = BCET;
                if ((data[0]>>16)>2)
                        current_time_state = RANDOM;
                        
                user_algo_interface.get_logfile() << sc_time_stamp() << ": " << user_algo_interface.get_name() << " DATA : " << (data[0]>>16) << endl;

                
                double random = rand()%101;

                double random_result =(random/100.0)*(my_WCET.to_seconds()-my_BCET.to_seconds());

                sc_time random_execution_time = my_BCET;

//              if (user_algo_interface.is_algorithm_execution_mode(RANDOM_EXECUTION_TIME) == true)

                if (current_time_state == RANDOM)               
                        random_execution_time = my_BCET + sc_time(random_result, SC_SEC);

                if (current_time_state == BCET)
                        random_execution_time = my_BCET;
                        
                if (current_time_state == WCET)
                        random_execution_time = my_WCET;

                        
                
                user_algo_interface.get_logfile() << sc_time_stamp() << ": " << user_algo_interface.get_name() << " Execution times : " << random_execution_time.to_seconds()*1000 << " ms : " << endl;
                
                
                // Preemption points
                for(int i = 0; i < user_algo_interface.get_nb_preemption_points(); i++) {
                        user_algo_interface.compute(random_execution_time/(user_algo_interface.get_nb_preemption_points() + 1));

                        user_algo_interface.preemption_point();
                        user_algo_interface.set_algorithm_running();

                }

                // Wait for the last execution segment (after last preemption point)
                user_algo_interface.compute(random_execution_time/(user_algo_interface.get_nb_preemption_points() + 1));
#ifdef GENERATE_LOG_FILE
                user_algo_interface.get_logfile() << sc_time_stamp() << ": " << user_algo_interface.get_name() << " User algorithm ended" << endl;
#endif






                /**** END OF USER ALGORITHM ****/


                // Check that all data issued from previous algorithm execution has been processed and sent
                user_algo_interface.b_all_data_sent();

                // When all data is sent, indicate that a new sequence starts now
                // MUST BE DONE ONLY AFTER VERIFYING THAT ALL PREVIOUS DATA HAVE BEEN SENT
                user_algo_interface.start_new_transaction_sequence();

                // Find a channel that is not transient and has updated data
                int channel_id = 0;
                while(user_algo_interface.is_channel_transient(channel_id) || !user_algo_interface.nb_data_received(channel_id)) channel_id++;

                // Copy data
                int data_in_length = 0;
                int data_out_length = 0;
                for(int i = 0; i < No; i++) {
                        data_in_length = user_algo_interface.get_data_in_length(channel_id);
                        data_out_length = user_algo_interface.get_data_out_length(i);

                        if(data_out_length <= data_in_length) {
                                memcpy(user_algo_interface.get_data_out_ptr(i), user_algo_interface.get_data_in_ptr(channel_id), data_out_length);
                        } else {
                                memcpy(user_algo_interface.get_data_out_ptr(i), user_algo_interface.get_data_in_ptr(channel_id), data_in_length);
                                for(int j = data_in_length; j < data_out_length; j+=4) user_algo_interface.get_data_out_ptr(i)[j/4] = 0;
                        }
                        
                        user_algo_interface.set_address_out(i, user_algo_interface.get_address_in(channel_id));
                }

                // Release input sockets (we won't need their data anymore) for they are used by preceding modules again
                user_algo_interface.release_all_input_sockets();

                // Notify RZ to continue processing
                user_algo_interface.end_of_algorithm();

                // Send data to all sockets
                user_algo_interface.nb_send_all_data();


                // Wait for the event notifying a possible change in the user algorithm thread
                user_algo_interface.wait_for_update_user_algorithm();

                user_algo_interface.get_logfile() << sc_time_stamp() << ": " << user_algo_interface.get_name() << " Update user algorithm event received" << endl;

                if(user_algo_interface.kill_user_algorithm()) {
#ifdef GENERATE_LOG_FILE
                        user_algo_interface.get_logfile() << user_algo_interface.get_name() << " User algorithm thread has to be killed!" << endl;
#endif
                        return;
                }
        }

}

/**************************  END USER SPACE ********************************/
/***************************************************************************/

#endif