Subversion Repositories an-fpga-implementation-of-low-latency-noc-based-mpsoc

#ifndef _SYNFUL_WRAPPER_H
	#define  _SYNFUL_WRAPPER_H
 
 
#include <iostream>
 
#include "synful/synful.h"
 
bool synful_SSExit;
int  synful_random_seed=53432145;
int  synful_packets_left = 0;
int  synful_flitw =4;
 
extern queue_t** synful_inject;
       queue_t** synful_traverse;
 
 
 
 
 
void synful_init(char * fname, bool ss_exit, int seed,unsigned int max_clk, unsigned int max_pck){
	//std::cout << "Initiating synful with: " << fname << "random seed:" << seed << std::endl;
    synful_model_init(fname, ss_exit,seed,max_clk, max_pck, traffic_model_mapping );
 
 	synful_inject   = (queue_t**) malloc( NE * sizeof(queue_t*) );
 	synful_traverse = (queue_t**) malloc( NE * sizeof(queue_t*) );
 
 	if(synful_inject == NULL || synful_traverse == NULL ) {
		printf( "ERROR: malloc fail queues\n" );
		exit(0);
	}
	for(int i = 0; i <  NE; ++i ) {
		synful_inject[i]     = queue_new();
		synful_traverse[i]   = queue_new();
	}
}
 
 
void synful_final_report(){
	int i;
 
	if(verbosity==1) 	printf("\e[?25h");//To re-enable the cursor:
	printf("\nSynful simulation results-------------------\n"
			"\tSimulation clock cycles: %llu\n"
	,synful_cycle);
	print_statistic_new (synful_cycle);
}
 
 
 
void synful_eval( ){
	int i;
	unsigned int pronoc_src_id,pronoc_dst_id;
 
	if((reset==reset_active_high) || (count_en==0))	return;
 
	if((( synful_cycle > sim_end_clk_num) || (total_sent_pck_num>= end_sim_pck_num )) && synful_packets_left==0 )  simulation_done=1;
 
	// Reset packets remaining check
	synful_packets_left = 0;
 
	synful_run_one_cycle ();
 
 
	// Inject where possible (max one per node)
	for( i = 0; i < NE; ++i ) {
		synful_packets_left |= !queue_empty( synful_inject[i] );
 
		//TODO define sent vc policy
		int sent_vc = 0;
 
		if(pck_inj[i]->pck_injct_in_pck_wr){
			//the wr_pck should be asserted only for single cycle
			pck_inj[i]->pck_injct_in_pck_wr  	   = 0;
			continue;
		}
 
		pck_inj[i]->pck_injct_in_pck_wr  	   = 0;
		if((pck_inj[i]->pck_injct_out_ready & (0x1<<sent_vc)) == 0){
			//This pck injector is not ready yet
			continue;
		}
 
		pronoc_pck_t* temp_node = (pronoc_pck_t*) queue_peek_front( synful_inject[i] );
		if( temp_node != NULL ) {
			if(verbosity>1) {
				printf( "Inject: %llu ", synful_cycle );
				synful_print_packet( temp_node );
			}
			temp_node = (pronoc_pck_t*) queue_pop_front( synful_inject[i] );
 
			pronoc_dst_id =  traffic_model_mapping[temp_node->dest];
			queue_push( synful_traverse[pronoc_dst_id], temp_node, synful_cycle );
			int flit_num =  temp_node->packetSize / synful_flitw ;
			if (flit_num*synful_flitw !=temp_node->packetSize) flit_num++;
			if (flit_num < pck_inj[i]->min_pck_size) flit_num = pck_inj[i]->min_pck_size;
 
			if(IS_SELF_LOOP_EN ==0){
				if(pronoc_dst_id == i ){
					 fprintf(stderr,"ERROR: ProNoC is not configured with self-loop enable and Netrace aims to inject\n a "
							 "packet with identical source and destination address. Enable the SELF_LOOP parameter\n"
							 "in ProNoC and rebuild the simulation model\n");
					 exit(1);
				}
			}
 
			unsigned int sent_class =0;
			long int ptr_addr = reinterpret_cast<long int> (temp_node);
			pck_inj[i]->pck_injct_in_data         = ptr_addr;
			pck_inj[i]->pck_injct_in_size         = flit_num;
			pck_inj[i]->pck_injct_in_endp_addr    = endp_addr_encoder(pronoc_dst_id);
			pck_inj[i]->pck_injct_in_class_num    = sent_class;
			pck_inj[i]->pck_injct_in_init_weight  = 1;
			pck_inj[i]->pck_injct_in_vc           = 0x1<<sent_vc;
			pck_inj[i]->pck_injct_in_pck_wr  	   = 1;
			total_sent_pck_num++;
 
			#if (C>1)
				sent_stat[i][sent_class].pck_num ++;
				sent_stat[i][sent_class].flit_num +=flit_num;
			#else
				sent_stat[i].pck_num ++;
				sent_stat[i].flit_num +=flit_num;
			#endif
		}//temp!=NULL
	}//inject
 
 
 
	// Step all network components, Eject where possible
	for( i = 0; i < NE; ++i ) {
		synful_packets_left |= !queue_empty( synful_traverse[i] );
		//check which pck injector got a packet
		if(pck_inj[i]->pck_injct_out_pck_wr==0) continue;
		//we have got a packet
		//printf( "data=%lx\n",pck_inj[i]->pck_injct_out_data);
 
		pronoc_pck_t* temp_node = (pronoc_pck_t*)  pck_inj[i]->pck_injct_out_data;
		if( temp_node != NULL ) {
			if(verbosity>1) {
				printf( "Eject: %llu ", synful_cycle );
				synful_print_packet(temp_node);
			}
			//send it to synful
			synful_Eject (temp_node);
 
			// remove from traverse
 
			queue_remove( synful_traverse[i], temp_node );
			unsigned long long int    clk_num_h2t= (synful_cycle - temp_node->cycle);
			unsigned int    clk_num_h2h= clk_num_h2t - pck_inj[i]->pck_injct_out_h2t_delay;
			/*
				printf("clk_num_h2t (%llu) h2t_delay(%u)\n", clk_num_h2t , pck_inj[i]->pck_injct_out_h2t_delay);
				if(clk_num_h2t < pck_inj[i]->pck_injct_out_h2t_delay){
					fprintf(stderr, "ERROR:clk_num_h2t (%llu) is smaller than  injector h2t_delay(%u)\n", clk_num_h2t , pck_inj[i]->pck_injct_out_h2t_delay);
					exit(1);
				}
			*/
			pronoc_src_id=traffic_model_mapping[temp_node->source];
			update_statistic_at_ejection (
					i,//	core_num
					clk_num_h2h, // clk_num_h2h,
					(unsigned int) clk_num_h2t, // clk_num_h2t,
					pck_inj[i]->pck_injct_out_distance, //    distance,
					pck_inj[i]->pck_injct_out_class_num,//  	class_num,
					pronoc_src_id, //temp_node->source
					pck_inj[i]->pck_injct_out_size
			);
 
				free( temp_node );
 
		}//emp_node != NULL
	}//for
 
	synful_cycle++;
 
	//std::cout << synful_cycle << std::endl;
 
}
 
 
 
 
 
void synful_negedge_event( ){
	int i;
	clk = 0;
	topology_connect_all_nodes ();
	//connect_clk_reset_start_all();
	sim_eval_all();
}
 
void synful_posedge_event(){
	unsigned int i;
	clk = 1;       // Toggle clock
	update_all_router_stat();
	synful_eval();
	//connect_clk_reset_start_all();
	sim_eval_all();
	//print total sent packet each 1024 clock cycles
	if(verbosity==1) if(synful_cycle&0x3FF) printf("\rTotal sent packet: %9d", total_sent_pck_num);
}
 
 
 
 
 
#endif