Context Navigation

source: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/src/Parameters.cpp @ 138

Last change on this file since 138 was 138, checked in by rosiere, 14 years ago
1) add counters_t type for interface 2) fix in check load in load_store_unit 3) add parameters (but not yet implemented) 4) change environment and add script (distcc_env.sh ...) 5) add warning if an unser change rename flag with l.mtspr instruction 6) ...
Property svn:keywords set to `Id`
File size: 32.0 KB

Rev	Line
[78]	1	/*
	2	* $Id: Parameters.cpp 138 2010-05-12 17:34:01Z rosiere $
	3	*
	4	* [ Description ]
	5	*
	6	*/
	7
	8	#include "Behavioural/Core/Multi_Execute_loop/Execute_loop/include/Parameters.h"
[128]	9	#include "Behavioural/include/Allocation.h"
[88]	10	#include "Common/include/Max.h"
[78]	11
	12	namespace morpheo {
	13	namespace behavioural {
	14	namespace core {
	15	namespace multi_execute_loop {
	16	namespace execute_loop {
	17
	18
	19	#undef FUNCTION
	20	#define FUNCTION "Execute_loop::Parameters"
	21	Parameters::Parameters (uint32_t nb_read_unit ,
	22	uint32_t nb_functionnal_unit ,
	23	uint32_t nb_load_store_unit ,
	24	uint32_t nb_write_unit ,
	25
	26	uint32_t nb_context ,
	27	uint32_t nb_front_end ,
	28	uint32_t nb_ooo_engine ,
	29	uint32_t nb_packet ,
	30	uint32_t size_general_data ,
	31	uint32_t size_special_data ,
	32
[138]	33	uint32_t * nb_inst_read ,//[nb_read_unit]
[88]	34	uint32_t * size_read_queue ,//[nb_read_unit]
	35	uint32_t * size_reservation_station ,//[nb_read_unit]
	36	uint32_t * nb_inst_retire ,//[nb_read_unit]
	37
	38	uint32_t * nb_inst_functionnal_unit ,//[nb_functionnal_unit]
	39	execute_timing_t *** timing ,//[nb_functionnal_unit][nb_type][nb_operation]
	40	morpheo::behavioural::custom::custom_information_t (*get_custom_information) (void),
[78]	41
[88]	42	uint32_t * size_store_queue ,//[nb_load_store_unit]
	43	uint32_t * size_load_queue ,//[nb_load_store_unit]
	44	uint32_t * size_speculative_access_queue ,//[nb_load_store_unit]
[138]	45	uint32_t * nb_store_queue_bank ,//[nb_load_store_unit]
	46	uint32_t * nb_load_queue_bank ,//[nb_load_store_unit]
	47	uint32_t * nb_port_check ,//[nb_load_store_unit]
	48	Tspeculative_load_t * speculative_load ,//[nb_load_store_unit]
	49	Tpredictor_t * speculative_commit_predictor_scheme ,//[nb_load_store_unit]
	50	uint32_t ** lsu_pht_size_counter ,//[nb_load_store_unit][1]
	51	uint32_t ** lsu_pht_nb_counter ,//[nb_load_store_unit][1]
[88]	52	uint32_t * nb_bypass_memory ,//[nb_load_store_unit]
	53	uint32_t * nb_cache_port ,//[nb_load_store_unit]
	54	uint32_t * nb_inst_memory ,//[nb_load_store_unit]
[78]	55
[138]	56	uint32_t * nb_inst_write ,//[nb_write_unit]
[88]	57	uint32_t * size_write_queue ,//[nb_write_unit]
	58	uint32_t * size_execute_queue ,//[nb_write_unit]
	59	uint32_t * nb_bypass_write ,//[nb_write_unit]
[115]	60	multi_write_unit::write_unit::write_queue::Twrite_queue_scheme_t * write_queue_scheme,//[nb_write_unit]
[78]	61
	62	uint32_t nb_gpr_bank ,
	63	uint32_t nb_gpr_port_read_by_bank ,
	64	uint32_t nb_gpr_port_write_by_bank ,
	65	uint32_t nb_spr_bank ,
	66	uint32_t nb_spr_port_read_by_bank ,
	67	uint32_t nb_spr_port_write_by_bank ,
[88]	68	uint32_t * nb_general_register ,//[nb_ooo_engine]
	69	uint32_t * nb_special_register ,//[nb_ooo_engine]
[136]	70	// uint32_t * nb_inst_insert_rob ,//[nb_ooo_engine]
	71	// uint32_t * nb_inst_retire_rob ,//[nb_ooo_engine]
[78]	72
	73	Tpriority_t execution_unit_to_write_unit_priority ,
[88]	74	bool *** execution_unit_to_write_unit_table_routing,//[nb_execute_unit][nb_execute_unit_port][nb_write_unit]
	75	bool ** execution_unit_to_write_unit_table_thread ,//[nb_write_unit][nb_thread]
	76
	77	Tpriority_t read_unit_to_execution_unit_priority ,
	78	bool *** read_unit_to_execution_unit_table_routing ,//[nb_read_unit][nb_execute_unit][nb_execute_unit_port]
	79	bool ** read_unit_to_execution_unit_table_thread ,//[nb_execute_unit][nb_thread]
	80
	81	bool * is_load_store_unit ,//[nb_execute_unit]
	82	uint32_t * translate_num_execute_unit ,//[nb_execute_unit]
[120]	83
	84	bool * num_thread_valid ,//[nb_thread]
[88]	85
	86	bool is_toplevel
	87	)
[78]	88	{
	89	log_printf(FUNC,Execute_loop,FUNCTION,"Begin");
	90
[88]	91	_nb_read_unit = nb_read_unit ;
	92	_nb_functionnal_unit = nb_functionnal_unit ;
	93	_nb_load_store_unit = nb_load_store_unit ;
	94	_nb_write_unit = nb_write_unit ;
	95
	96	_nb_context = nb_context ;
	97	_nb_front_end = nb_front_end ;
	98	_nb_ooo_engine = nb_ooo_engine ;
	99	_nb_packet = nb_packet ;
	100
[138]	101	_nb_inst_read = nb_inst_read ;
[88]	102	_size_read_queue = size_read_queue ;
	103	_size_reservation_station = size_reservation_station ;
	104	_nb_inst_retire = nb_inst_retire ;
	105
	106	_nb_inst_functionnal_unit = nb_inst_functionnal_unit ;
	107	_timing = timing ;
	108	_get_custom_information = get_custom_information ;
	109
[138]	110	_nb_inst_write = nb_inst_write ;
[88]	111	_size_store_queue = size_store_queue ;
	112	_size_load_queue = size_load_queue ;
	113	_size_speculative_access_queue = size_speculative_access_queue ;
[138]	114	_nb_store_queue_bank = nb_store_queue_bank ;
	115	_nb_load_queue_bank = nb_load_queue_bank ;
[88]	116	_nb_port_check = nb_port_check ;
	117	_speculative_load = speculative_load ;
[138]	118	_speculative_commit_predictor_scheme = speculative_commit_predictor_scheme ;
	119	_lsu_pht_size_counter = lsu_pht_size_counter ;
	120	_lsu_pht_nb_counter = lsu_pht_nb_counter ;
[88]	121	_nb_bypass_memory = nb_bypass_memory ;
	122	_nb_cache_port = nb_cache_port ;
	123	_nb_inst_memory = nb_inst_memory ;
	124
	125	_size_write_queue = size_write_queue ;
	126	_size_execute_queue = size_execute_queue ;
	127	_nb_bypass_write = nb_bypass_write ;
[115]	128	_write_queue_scheme = write_queue_scheme ;
[88]	129
	130	_nb_gpr_bank = nb_gpr_bank ;
	131	_nb_gpr_port_read_by_bank = nb_gpr_port_read_by_bank ;
	132	_nb_gpr_port_write_by_bank = nb_gpr_port_write_by_bank ;
	133	_nb_spr_bank = nb_spr_bank ;
	134	_nb_spr_port_read_by_bank = nb_spr_port_read_by_bank ;
	135	_nb_spr_port_write_by_bank = nb_spr_port_write_by_bank ;
	136	_nb_general_register = nb_general_register ;
	137	_nb_special_register = nb_special_register ;
[136]	138	// _nb_inst_insert_rob = nb_inst_insert_rob ;
	139	// _nb_inst_retire_rob = nb_inst_retire_rob ;
[78]	140
	141	_execution_unit_to_write_unit_priority = execution_unit_to_write_unit_priority;
	142	_execution_unit_to_write_unit_table_routing = execution_unit_to_write_unit_table_routing;
	143	_execution_unit_to_write_unit_table_thread = execution_unit_to_write_unit_table_thread ;
	144
[88]	145	_read_unit_to_execution_unit_priority = read_unit_to_execution_unit_priority ;
[78]	146	_read_unit_to_execution_unit_table_routing = read_unit_to_execution_unit_table_routing ;
	147	_read_unit_to_execution_unit_table_thread = read_unit_to_execution_unit_table_thread ;
	148
[88]	149	_is_load_store_unit = is_load_store_unit ;
	150	_translate_num_execute_unit = translate_num_execute_unit;
[78]	151
[120]	152	_num_thread_valid = num_thread_valid;
	153
[88]	154	_nb_execute_unit = _nb_functionnal_unit + _nb_load_store_unit;
[78]	155
[136]	156
	157	_nb_thread = get_nb_thread(_nb_context,
	158	_nb_front_end,
	159	_nb_ooo_engine);
	160	_max_nb_inst_memory = max<uint32_t>(_nb_inst_memory,_nb_load_store_unit);
	161
[128]	162	ALLOC1(_nb_execute_unit_port ,uint32_t,_nb_execute_unit);
	163	ALLOC2(_read_unit_to_execution_unit_table_execute_type,bool ,_nb_execute_unit,_nb_type);
	164
[78]	165	for (uint32_t i=0; i<_nb_execute_unit; i++)
[128]	166	for (uint32_t j=0; j<_nb_type; j++)
	167	_read_unit_to_execution_unit_table_execute_type [i][j] = false;
[78]	168
	169	// Fill execute_type
	170	for (uint32_t i=0; i<_nb_execute_unit; i++)
[88]	171	// is load store
	172	if (is_load_store_unit [i])
	173	_read_unit_to_execution_unit_table_execute_type [i][TYPE_MEMORY] = true;
	174	else
	175	for (uint32_t j=0; j<_nb_type; j++)
	176	if (is_type_valid (j))
	177	for (uint32_t k=0; k<_nb_operation; k++)
	178	{
	179	uint32_t x = translate_num_execute_unit [i];
	180	if (timing[x][j][k]._latence > 0)
	181	{
[109]	182	log_printf(TRACE,Execute_loop,FUNCTION," * Execute unit '%d' (functional unit '%d') can execute type '%s'.",i,x,toString(j).c_str());
[88]	183	_read_unit_to_execution_unit_table_execute_type [i][j] = true;
	184	break; // find an operation
	185	}
	186	}
[78]	187
[109]	188	for (uint32_t i=0; i<_nb_load_store_unit; ++i)
	189	log_printf(TRACE,Execute_loop,FUNCTION," * Load_store_unit [%d] - nb_inst : %d",i,_nb_inst_memory [i]);
	190	for (uint32_t i=0; i<_nb_functionnal_unit; ++i)
	191	log_printf(TRACE,Execute_loop,FUNCTION," * Functionnal_unit [%d] - nb_inst : %d",i,_nb_inst_functionnal_unit [i]);
	192
	193
[78]	194	for (uint32_t i=0; i<_nb_execute_unit; i++)
[88]	195	{
	196	uint32_t x = translate_num_execute_unit [i];
	197
	198	if (_is_load_store_unit [i])
	199	_nb_execute_unit_port [i] = _nb_inst_memory [x];
	200	else
	201	_nb_execute_unit_port [i] = _nb_inst_functionnal_unit [x];
[109]	202
	203	log_printf(TRACE,Execute_loop,FUNCTION," * Execute unit [%d] (%d) - nb_inst : %d",i,x,_nb_execute_unit_port [i]);
[88]	204	}
[78]	205
	206	_nb_gpr_read = 2*_nb_read_unit;
	207	_nb_spr_read = 1*_nb_read_unit;
	208	_nb_gpr_write = 1*_nb_write_unit;
	209	_nb_spr_write = 1*_nb_write_unit;
	210
[88]	211	_max_nb_general_register = max<uint32_t>(nb_general_register,nb_ooo_engine);
	212	_max_nb_special_register = max<uint32_t>(nb_special_register,nb_ooo_engine);
[78]	213
[88]	214	_max_size_store_queue = max<uint32_t>(size_store_queue,nb_load_store_unit);
	215	_max_size_load_queue = max<uint32_t>(size_load_queue ,nb_load_store_unit);
[78]	216
[128]	217	ALLOC1(_set_read_unit_source_register_write ,std::set<uint32_t>,_nb_read_unit);
	218	ALLOC1(_set_read_unit_source_bypass_write ,std::set<uint32_t>,_nb_read_unit);
	219	ALLOC1(_set_read_unit_source_bypass_memory ,std::set<uint32_t>,_nb_read_unit);
[78]	220
[128]	221	ALLOC1(_read_unit_nb_register_write ,uint32_t ,_nb_read_unit);
	222	ALLOC1(_read_unit_nb_bypass_write ,uint32_t ,_nb_read_unit);
	223	ALLOC1(_read_unit_nb_bypass_memory ,uint32_t ,_nb_read_unit);
[78]	224
[128]	225	ALLOC3(_link_read_unit_with_load_store_unit ,bool ,_nb_read_unit,_nb_execute_unit,_max_nb_inst_memory);
	226	ALLOC2(_link_read_unit_with_write_unit ,bool ,_nb_read_unit,_nb_write_unit );
	227	ALLOC2(_link_read_unit_with_thread ,bool ,_nb_read_unit,_nb_thread );
	228
[78]	229	for (uint32_t i=0; i<_nb_read_unit; i++)
	230	{
	231	_read_unit_nb_register_write [i] = 0;
	232	_read_unit_nb_bypass_write [i] = 0;
	233	_read_unit_nb_bypass_memory [i] = 0;
	234
	235	for (uint32_t j=0; j<_nb_execute_unit; j++)
[128]	236	for (uint32_t k=0; k<_max_nb_inst_memory; k++)
	237	_link_read_unit_with_load_store_unit [i][j][k] = false;
[88]	238
[78]	239	for (uint32_t j=0; j<_nb_write_unit; j++)
	240	_link_read_unit_with_write_unit [i][j] = false;
	241	for (uint32_t j=0; j<_nb_thread; j++)
	242	_link_read_unit_with_thread [i][j] = false;
	243
	244	// fill link array
[88]	245	for (uint32_t x=0; x<_nb_execute_unit; x++)
	246	for (uint32_t y=0; y<_nb_execute_unit_port[x]; y++)
	247	{
	248	// Test if this read unit can send operation at this execute_unit
	249	if (_read_unit_to_execution_unit_table_routing [i][x][y])
	250	{
	251	if (_is_load_store_unit [x])
	252	{
	253	_link_read_unit_with_load_store_unit [i][x][y] = true;
	254	}
	255
	256	for (uint32_t k=0; k<_nb_thread; k++)
	257	{
	258	if (_read_unit_to_execution_unit_table_thread [x][k])
	259	{
	260	_link_read_unit_with_thread [i][k] = true;
	261	}
	262	}
	263	// Scearch associed write_unit
	264	for (uint32_t k=0; k<_nb_write_unit; k++)
	265	{
[109]	266	log_printf(TRACE,Execute_loop,FUNCTION," * Execution_unit_to_write_unit_table_routing [%d][%d][%d]",x,y,k);
	267
[88]	268	// Test if this execute_unit can send operation at this write_unit
	269	// Test if have not a previous link ! (a same read_unit can send operation à two execute_unit and each execute_unit send at the same write_unit)
	270	if (_execution_unit_to_write_unit_table_routing [x][y][k] and
	271	not _link_read_unit_with_write_unit [i][k])
	272	// if yes : this write_unit can have operation sended by this read_unit
	273	{
	274	_link_read_unit_with_write_unit [i][k] = true;
	275	}
	276	}
	277	}
	278	}
[78]	279	}
	280
	281	// Compute the gpr_write and spr_write port for the read_unit :
	282	// * Max : 2*nb_write_unit gpr_write_port.
	283	// * a specific read_unit and a specific write_unit can execute a null intersection of thread operation. Also it's unnecessarry to send the gpr_write at the read_unit.
	284
	285
[88]	286	// std::cout << "_link_......." << std::endl;
	287	// std::cout << "_link_read_unit_with_load_store_unit" << std::endl;
	288	// for (uint32_t i=0; i<_nb_read_unit; i++)
	289	// {
	290	// std::cout << "\t" << std::endl;
	291	// for (uint32_t j=0; j<_nb_execute_unit; j++)
	292	// for (uint32_t k=0; k<_nb_execute_unit_port[j]; k++)
	293	// std::cout << _link_read_unit_with_load_store_unit [i][j][k] << " ";
	294	// std::cout << std::endl;
	295	// }
	296	// std::cout << "_link_read_unit_with_write_unit" << std::endl;
	297	// for (uint32_t i=0; i<_nb_read_unit; i++)
	298	// {
	299	// std::cout << "\t" << std::endl;
	300	// for (uint32_t j=0; j<_nb_write_unit; j++)
	301	// std::cout << _link_read_unit_with_write_unit [i][j] << " ";
	302	// std::cout << std::endl;
	303	// }
	304	// std::cout << "_link_read_unit_with_thread" << std::endl;
	305	// for (uint32_t i=0; i<_nb_read_unit; i++)
	306	// {
	307	// std::cout << "\t" << std::endl;
	308	// for (uint32_t j=0; j<_nb_thread; j++)
	309	// std::cout << _link_read_unit_with_thread [i][j] << " ";
	310	// std::cout << std::endl;
	311	// }
[78]	312
[136]	313	// std::cout << "_set_......." << std::endl;
[78]	314
	315	for (uint32_t i=0; i<_nb_read_unit; i++)
	316	{
[88]	317	// std::cout << " * Read_unit[" << i << "]" << std::endl;
[78]	318	for (uint32_t j=0; j<_nb_write_unit; j++)
	319	{
[88]	320	// std::cout << " * Write_unit[" << j << "]" << std::endl;
[78]	321	// Test the thread executed on this write_unit
	322	for (uint32_t k=0; k<_nb_thread; k++)
	323	{
[136]	324	// std::cout << " * Thread[" << k << "]" << std::endl;
[78]	325	if ( (_execution_unit_to_write_unit_table_thread [j][k]) and
	326	(_link_read_unit_with_thread [i][k]))
	327	{
[88]	328	// std::cout << " * Find !!!!" << std::endl;
	329	// std::cout << " * Read_unit "+toString(i)+" must take the gpr_write with write_unit "+toString(j)+"." << std::endl;
[78]	330	_set_read_unit_source_register_write[i].insert(j);
	331	_read_unit_nb_register_write [i] ++;
	332
[88]	333	// std::cout << " * bypass_write : " << _nb_bypass_write [j] << std::endl;
	334	// std::cout << " * Read_unit "+toString(i)+" must take the bypass_write with write_unit "+toString(j)+"." << std::endl;
[78]	335	_set_read_unit_source_bypass_write [i].insert(j);
	336	_read_unit_nb_bypass_write [i] += _nb_bypass_write [j];
	337	break;
	338	}
	339	}
	340	}
	341	}
	342
	343	for (uint32_t i=0; i<_nb_read_unit; i++)
	344	{
[88]	345	// std::cout << " * Read_unit[" << i << "]" << std::endl;
[78]	346	for (uint32_t j=0; j<_nb_execute_unit; j++)
	347	{
[88]	348	uint32_t x = translate_num_execute_unit [j];
	349
	350	// std::cout << " * Execute_unit[" << j << "]" << std::endl;
[78]	351	// Test the thread executed on this execute_unit
	352	for (uint32_t k=0; k<_nb_thread; k++)
	353	{
[88]	354	// std::cout << " * Thread[" << k << "]" << std::endl;
[78]	355	if ((_read_unit_to_execution_unit_table_thread [j][k]) and
	356	(_link_read_unit_with_thread [i][k]) and
	357	(_is_load_store_unit [j]))
	358	{
[88]	359	// std::cout << " * Find !!!!" << std::endl;
	360	// std::cout << " * Bypass_memory !!!!" << std::endl;
	361	// std::cout << " * Read_unit "+toString(i)+" must take the bypass_memory with load_store_unit "+toString(j)+"." << std::endl;
[78]	362
	363	_set_read_unit_source_bypass_memory [i].insert(j);
[88]	364	_read_unit_nb_bypass_memory [i] += _nb_bypass_memory [x];
	365
	366	break; // loop on thread
[78]	367	}
	368	}
	369	}
	370	}
	371
[88]	372	uint32_t size_ooo_engine_id = log2(nb_ooo_engine );
	373	uint32_t size_general_register = log2(_max_nb_general_register);
	374	uint32_t size_special_register = log2(_max_nb_special_register);
	375
[78]	376	test();
	377
[88]	378	log_printf(TRACE,Execute_loop,FUNCTION,"Parameters : glue");
	379
	380	_param_glue = new morpheo::behavioural::core::multi_execute_loop::execute_loop::execute_loop_glue::Parameters
	381	(_nb_gpr_write ,
	382	_nb_spr_write ,
[136]	383	_nb_read_unit ,
[88]	384	size_ooo_engine_id ,
	385	size_general_register ,
	386	size_special_register ,
	387	size_general_data ,
	388	size_special_data );
	389
	390	log_printf(TRACE,Execute_loop,FUNCTION,"Parameters : read_unit");
	391
[78]	392	_param_read_unit = new morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_read_unit::read_unit::Parameters * [_nb_read_unit];
	393	for (uint32_t i=0; i<_nb_read_unit; i++)
	394	_param_read_unit [i] = new morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_read_unit::read_unit::Parameters
[138]	395	(_nb_inst_read [i],
	396	_size_read_queue [i],
[78]	397	_size_reservation_station [i],
	398	_nb_context ,
	399	_nb_front_end ,
	400	_nb_ooo_engine ,
	401	_nb_packet ,
[88]	402	size_general_data ,
	403	size_special_data ,
[78]	404	_max_nb_general_register ,
	405	_max_nb_special_register ,
	406	1*_read_unit_nb_register_write [i],
	407	1*_read_unit_nb_register_write [i],
	408	_max_size_store_queue ,
	409	_max_size_load_queue ,
	410	_nb_inst_retire [i],
	411	_read_unit_nb_bypass_write [i],
	412	_read_unit_nb_bypass_memory [i]);
	413
[88]	414	log_printf(TRACE,Execute_loop,FUNCTION,"Parameters : execute_unit");
	415
[78]	416	_param_functionnal_unit = new morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_execute_unit::execute_unit::functionnal_unit::Parameters * [_nb_functionnal_unit];
	417	_param_load_store_unit = new morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_execute_unit::execute_unit::load_store_unit::Parameters * [_nb_load_store_unit];
	418
	419	for (uint32_t i=0; i<_nb_execute_unit; i++)
[88]	420	{
	421	uint32_t x = _translate_num_execute_unit [i];
	422	if (_is_load_store_unit [i] == false)
[78]	423	_param_functionnal_unit [x] = new morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_execute_unit::execute_unit::functionnal_unit::Parameters
	424	(_nb_context ,
	425	_nb_front_end ,
	426	_nb_ooo_engine ,
	427	_nb_packet ,
[88]	428	size_general_data ,
[78]	429	_max_nb_general_register ,
[88]	430	size_special_data ,
[78]	431	_max_nb_special_register ,
	432	_max_size_store_queue ,
	433	_max_size_load_queue ,
[88]	434	_timing [x],
[78]	435	_get_custom_information );
[88]	436	else
	437	_param_load_store_unit [x] = new morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_execute_unit::execute_unit::load_store_unit::Parameters
[138]	438	(_size_store_queue [x],
	439	_size_load_queue [x],
	440	_size_speculative_access_queue [x],
	441
	442	_nb_store_queue_bank [x],
	443	_nb_load_queue_bank [x],
	444	_nb_port_check [x],
	445	_speculative_load [x],
	446	_speculative_commit_predictor_scheme [x],
	447	_lsu_pht_size_counter [x],
	448	_lsu_pht_nb_counter [x],
	449	_nb_bypass_memory [x],
	450	_nb_cache_port [x],
	451	_nb_inst_memory [x],
	452	_nb_context ,
	453	_nb_front_end ,
	454	_nb_ooo_engine ,
	455	_nb_packet ,
	456	size_general_data ,
	457	size_special_data ,
	458	_max_nb_special_register ,
	459	_max_nb_general_register ,
	460	_nb_thread ,
	461	_num_thread_valid );
[88]	462	}
[78]	463
[88]	464	log_printf(TRACE,Execute_loop,FUNCTION,"Parameters : write_unit");
	465
[78]	466	_param_write_unit = new morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_write_unit::write_unit::Parameters * [_nb_write_unit];
	467	for (uint32_t i=0; i<_nb_write_unit; i++)
	468	_param_write_unit [i] = new morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_write_unit::write_unit::Parameters
[138]	469	(_nb_inst_write [i],
	470	_size_write_queue [i],
[78]	471	_size_execute_queue [i],
	472	_nb_context ,
	473	_nb_front_end ,
	474	_nb_ooo_engine ,
	475	_nb_packet ,
[88]	476	size_general_data ,
[78]	477	_max_nb_general_register ,
[88]	478	size_special_data ,
[78]	479	_max_nb_special_register ,
[115]	480	_nb_bypass_write [i],
	481	_write_queue_scheme [i]);
[78]	482
[88]	483	log_printf(TRACE,Execute_loop,FUNCTION,"Parameters : read_unit_to_execution_unit");
	484
[78]	485	_param_read_unit_to_execution_unit = new morpheo::behavioural::core::multi_execute_loop::execute_loop::network::read_unit_to_execution_unit::Parameters
	486	(_nb_read_unit ,
[88]	487	_nb_inst_retire ,
[78]	488	_nb_execute_unit ,
[88]	489	_nb_execute_unit_port ,
[78]	490	_nb_context ,
	491	_nb_front_end ,
	492	_nb_ooo_engine ,
	493	_nb_packet ,
[88]	494	size_general_data ,
	495	size_special_data ,
[78]	496	_max_nb_general_register ,
	497	_max_nb_special_register ,
	498	_max_size_store_queue ,
	499	_max_size_load_queue ,
	500	_read_unit_to_execution_unit_priority ,
	501	_read_unit_to_execution_unit_table_routing ,
	502	_read_unit_to_execution_unit_table_execute_type,
[120]	503	_read_unit_to_execution_unit_table_thread ,
	504	_num_thread_valid);
[78]	505
[88]	506	log_printf(TRACE,Execute_loop,FUNCTION,"Parameters : execution_unit_to_write_unit");
	507
[78]	508	_param_execution_unit_to_write_unit = new morpheo::behavioural::core::multi_execute_loop::execute_loop::network::execution_unit_to_write_unit::Parameters
	509	(_nb_execute_unit ,
[88]	510	_nb_execute_unit_port ,
[78]	511	_nb_write_unit ,
	512	_nb_context ,
	513	_nb_front_end ,
	514	_nb_ooo_engine ,
	515	_nb_packet ,
[88]	516	size_general_data ,
	517	size_special_data ,
[78]	518	_max_nb_general_register ,
	519	_max_nb_special_register ,
	520	_execution_unit_to_write_unit_priority ,
	521	_execution_unit_to_write_unit_table_routing,
[120]	522	_execution_unit_to_write_unit_table_thread ,
	523	_num_thread_valid);
[78]	524
[88]	525	log_printf(TRACE,Execute_loop,FUNCTION,"Parameters : register_unit");
	526
[78]	527	_param_register_unit = new morpheo::behavioural::core::multi_execute_loop::execute_loop::register_unit::Parameters
	528	(_nb_ooo_engine ,
[88]	529	size_general_data ,
	530	size_special_data ,
[78]	531	_nb_gpr_read ,
	532	_nb_gpr_write ,
	533	_nb_gpr_bank ,
	534	_nb_gpr_port_read_by_bank ,
	535	_nb_gpr_port_write_by_bank ,
	536	_nb_spr_read ,
	537	_nb_spr_write ,
	538	_nb_spr_bank ,
	539	_nb_spr_port_read_by_bank ,
	540	_nb_spr_port_write_by_bank ,
	541	_nb_general_register ,
	542	_nb_special_register ,
[136]	543	_nb_read_unit // ,
	544	// _nb_inst_insert_rob ,
	545	// _nb_inst_retire_rob
	546	);
[78]	547
	548	_max_size_dcache_context_id = 0;
	549	_max_size_dcache_packet_id = 0;
	550
	551	for (uint32_t i=0; i<_nb_load_store_unit; i++)
	552	{
	553	if (_param_load_store_unit [i]->_size_dcache_context_id > _max_size_dcache_context_id) _max_size_dcache_context_id = _param_load_store_unit [i]->_size_dcache_context_id;
	554	if (_param_load_store_unit [i]->_size_dcache_packet_id > _max_size_dcache_packet_id) _max_size_dcache_packet_id = _param_load_store_unit [i]->_size_dcache_packet_id;
	555	}
	556
[117]	557	// log_printf(TRACE,Load_store_unit,FUNCTION,"kane : size_dcache_context_id : %d",_max_size_dcache_context_id );
	558	// log_printf(TRACE,Load_store_unit,FUNCTION,"kane : size_dcache_packet_id : %d",_max_size_dcache_packet_id );
[78]	559
[117]	560	_have_port_dcache_context_id = (_max_size_dcache_context_id>0);
[88]	561
[117]	562	// log_printf(TRACE,Load_store_unit,FUNCTION,"kane : have_port_dcache_context_id : %d",_have_port_dcache_context_id);
	563
[88]	564	if (is_toplevel)
	565	{
[97]	566	_size_instruction_address= size_general_data-2;
[88]	567	_size_context_id = log2(nb_context);
	568	_size_front_end_id = log2(nb_front_end);
	569	_size_ooo_engine_id = size_ooo_engine_id;
	570	_size_rob_ptr = log2(nb_packet);
	571	_size_general_data = size_general_data;
	572	_size_special_data = size_special_data;
	573	_size_general_register = size_general_register;
	574	_size_special_register = size_special_register;
	575
	576	_size_store_queue_ptr = log2(_max_size_store_queue);
	577	_size_load_queue_ptr = log2(_max_size_load_queue );
	578
	579	_have_port_context_id = _size_context_id > 0;
	580	_have_port_front_end_id = _size_front_end_id > 0;
	581	_have_port_ooo_engine_id = _size_ooo_engine_id > 0;
	582	_have_port_rob_ptr = _size_rob_ptr > 0;
	583	_have_port_load_queue_ptr= _size_load_queue_ptr > 0;
	584
	585	copy();
	586	}
	587
[78]	588	log_printf(FUNC,Execute_loop,FUNCTION,"End");
	589	};
	590
	591	// #undef FUNCTION
	592	// #define FUNCTION "Execute_loop::Parameters (copy)"
	593	// Parameters::Parameters (Parameters & param)
	594	// {
	595	// log_printf(FUNC,Execute_loop,FUNCTION,"Begin");
	596
	597	// test();
	598
	599	// log_printf(FUNC,Execute_loop,FUNCTION,"End");
	600	// };
	601
	602	#undef FUNCTION
	603	#define FUNCTION "Execute_loop::~Parameters"
[88]	604	Parameters::~Parameters (void)
[78]	605	{
	606	log_printf(FUNC,Execute_loop,FUNCTION,"Begin");
	607
[88]	608	delete _param_glue;
	609	for (uint32_t i=0; i<_nb_read_unit; i++)
[122]	610	delete _param_read_unit [i];
[78]	611	delete [] _param_read_unit;
[128]	612
[88]	613	for (uint32_t i=0; i<_nb_execute_unit; i++)
	614	{
	615	uint32_t x = _translate_num_execute_unit [i];
[128]	616
[88]	617	if (_is_load_store_unit [i] == false)
	618	delete _param_functionnal_unit [x];
	619	else
[128]	620	delete _param_load_store_unit [x];
[88]	621	}
[78]	622	delete [] _param_functionnal_unit;
	623	delete [] _param_load_store_unit;
[88]	624	for (uint32_t i=0; i<_nb_write_unit; i++)
[122]	625	delete _param_write_unit [i];
[78]	626	delete [] _param_write_unit;
	627	delete _param_read_unit_to_execution_unit;
	628	delete _param_execution_unit_to_write_unit;
	629	delete _param_register_unit;
	630
[128]	631	DELETE2(_link_read_unit_with_thread ,_nb_read_unit,_nb_thread );
	632	DELETE2(_link_read_unit_with_write_unit ,_nb_read_unit,_nb_write_unit );
	633	DELETE3(_link_read_unit_with_load_store_unit ,_nb_read_unit,_nb_execute_unit,_max_nb_inst_memory);
	634
	635	DELETE1(_read_unit_nb_bypass_memory ,_nb_read_unit);
	636	DELETE1(_read_unit_nb_bypass_write ,_nb_read_unit);
	637	DELETE1(_read_unit_nb_register_write ,_nb_read_unit);
	638
	639	DELETE1(_set_read_unit_source_bypass_memory ,_nb_read_unit);
	640	DELETE1(_set_read_unit_source_bypass_write ,_nb_read_unit);
	641	DELETE1(_set_read_unit_source_register_write ,_nb_read_unit);
	642
	643	DELETE2(_read_unit_to_execution_unit_table_execute_type,_nb_execute_unit,_nb_type);
	644	DELETE1(_nb_execute_unit_port ,_nb_execute_unit);
	645
[88]	646	log_printf(FUNC,Execute_loop,FUNCTION,"End");
	647	};
[78]	648
[88]	649
	650	#undef FUNCTION
	651	#define FUNCTION "Execute_loop::copy"
	652	void Parameters::copy (void)
	653	{
	654	log_printf(FUNC,Execute_loop,FUNCTION,"Begin");
	655
	656	COPY(_param_glue);
	657	for (uint32_t i=0; i<_nb_read_unit; i++)
	658	COPY(_param_read_unit [i]);
	659
	660	for (uint32_t i=0; i<_nb_execute_unit; i++)
	661	{
	662	uint32_t x = _translate_num_execute_unit [i];
	663
	664	if (_is_load_store_unit [i] == false)
	665	COPY(_param_functionnal_unit [x]);
	666	else
	667	COPY(_param_load_store_unit [x]);
	668	}
	669	for (uint32_t i=0; i<_nb_write_unit; i++)
	670	COPY(_param_write_unit [i]);
	671	COPY(_param_read_unit_to_execution_unit);
	672	COPY(_param_execution_unit_to_write_unit);
	673	COPY(_param_register_unit);
	674
[78]	675	log_printf(FUNC,Execute_loop,FUNCTION,"End");
	676	};
	677
	678	}; // end namespace execute_loop
	679	}; // end namespace multi_execute_loop
	680	}; // end namespace core
	681
	682	}; // end namespace behavioural
	683	}; // end namespace morpheo

Note: See TracBrowser for help on using the repository browser.

Download in other formats: