int main(int argc, char** argv) { StackDescription_t stkd ; Analysis_t analysis ; Output_t output ; ThermalData_t tdata ; // Checks if there are the all the arguments //////////////////////////////////////////////////////////////////////////// if (argc != 3) { fprintf(stderr, "Usage: \"%s file.stk smfile.txt\"\n", argv[0]) ; return EXIT_FAILURE ; } // Init StackDescription and parse the input file //////////////////////////////////////////////////////////////////////////// stack_description_init (&stkd) ; analysis_init (&analysis) ; output_init (&output) ; if (parse_stack_description_file (argv[1], &stkd, &analysis, &output) != 0) return EXIT_FAILURE ; // Init thermal data and fill it using the StackDescription //////////////////////////////////////////////////////////////////////////// thermal_data_init (&tdata) ; Error_t result = thermal_data_build (&tdata, &stkd.StackElements, stkd.Dimensions, &analysis) ; if (result != TDICE_SUCCESS) { stack_description_destroy (&stkd) ; output_destroy (&output) ; return EXIT_FAILURE ; } // Run the simulation and print the output //////////////////////////////////////////////////////////////////////////// system_matrix_print (tdata.SM_A, argv[2]) ; // free all data //////////////////////////////////////////////////////////////////////////// thermal_data_destroy (&tdata) ; stack_description_destroy (&stkd) ; output_destroy (&output) ; return EXIT_SUCCESS ; }
int main (int argc, char** argv) { StackDescription_t stkd ; Analysis_t analysis ; Output_t output ; ThermalData_t tdata ; Error_t error ; struct timespec t1,t2; struct timespec res; res.tv_sec=0; res.tv_nsec=0; Quantity_t server_port ; Socket_t server_socket, client_socket ; NetworkMessage_t request, reply , tmapReply; bool headers = false ; /* Checks if all arguments are there **************************************/ if (argc != 3) { fprintf (stderr, "Usage: \"%s file.stk server_port\n", argv[0]) ; return EXIT_FAILURE ; } server_port = atoi (argv[2]) ; /* Parses stack file (fills stack descrition and analysis) ****************/ fprintf (stdout, "Preparing stk data ... ") ; fflush (stdout) ; stack_description_init (&stkd) ; analysis_init (&analysis) ; output_init (&output) ; error = parse_stack_description_file (argv[1], &stkd, &analysis, &output) ; /* Initialise the compression related data ********************************/ Quantity_t nflpel_ = get_total_number_of_floorplan_elements (&stkd) ; float hist_table_d[nflpel_][HIST_TABLE_SIZE]; int tail_d[nflpel_]; for (unsigned int i = 0; i < nflpel_; i++) { tail_d[i] = 0; for (int j = 0; j < HIST_TABLE_SIZE; j++) hist_table_d[i][j] = -1.0; } for(int i=0;i<MAXRES;i++) for(int j=0;j<MAXROWS;j++) for(int k=0;k<MAXCOLS;k++) for(int l=0;l<HIST_TABLE_SIZE;l++) histTableMap[i][j][k][l] = -1.0; int compressionUsed; if (error != TDICE_SUCCESS) return EXIT_FAILURE ; if (analysis.AnalysisType != TDICE_ANALYSIS_TYPE_TRANSIENT) { fprintf (stderr, "only transient analysis!\n") ; goto wrong_analysis_error ; } fprintf (stdout, "done !\n") ; /* Prepares thermal data **************************************************/ fprintf (stdout, "Preparing thermal data ... ") ; fflush (stdout) ; thermal_data_init (&tdata) ; error = thermal_data_build (&tdata, &stkd.StackElements, stkd.Dimensions, &analysis) ; if (error != TDICE_SUCCESS) goto ftd_error ; fprintf (stdout, "done !\n") ; /* Creates socket *********************************************************/ fprintf (stdout, "Creating socket ... ") ; fflush (stdout) ; socket_init (&server_socket) ; error = open_server_socket (&server_socket, server_port) ; if (error != TDICE_SUCCESS) goto socket_error ; fprintf (stdout, "done !\n") ; /* Waits for a client to connect ******************************************/ fprintf (stdout, "Waiting for client ... ") ; fflush (stdout) ; socket_init (&client_socket) ; error = wait_for_client (&server_socket, &client_socket) ; if (error != TDICE_SUCCESS) goto wait_error ; fprintf (stdout, "done !\n") ; //float timeForTmap = 0.0; /* Runs the simlation *****************************************************/ do { network_message_init (&request) ; receive_message_from_socket (&client_socket, &request) ; switch (*request.Type) { /**********************************************************************/ case TDICE_COMPRESSION_USED : { extract_message_word (&request, &compressionUsed,0); break; } case TDICE_EXIT_SIMULATION : { network_message_destroy (&request) ; goto quit ; } /**********************************************************************/ case TDICE_RESET_THERMAL_STATE : { reset_thermal_state (&tdata, &analysis) ; break ; } /**********************************************************************/ case TDICE_TOTAL_NUMBER_OF_FLOORPLAN_ELEMENTS : { network_message_init (&reply) ; build_message_head (&reply, TDICE_TOTAL_NUMBER_OF_FLOORPLAN_ELEMENTS) ; Quantity_t nflpel = get_total_number_of_floorplan_elements (&stkd) ; insert_message_word (&reply, &nflpel) ; send_message_to_socket (&client_socket, &reply) ; network_message_destroy (&reply) ; break ; } /**********************************************************************/ case TDICE_INSERT_POWERS_AND_SIMULATE_SLOT : { Quantity_t nflpel, index ; PowersQueue_t queue ; powers_queue_init (&queue) ; extract_message_word (&request, &nflpel, 0) ; powers_queue_build (&queue, nflpel) ; if(compressionUsed) { unsigned int tmp[3]; int ret=-1; unsigned int compressedWord; float power=0.0; int readIndex=1; index=1; initTmp(tmp); extract_message_word (&request, &compressedWord,readIndex); while(index<=nflpel) { ret=getNextDecompressedWord(compressedWord,tmp,0); switch(ret) { case WI_DC: case WC_DC: switch(tmp[0]) { case 0: power=(int)hist_table_d[index-1][tmp[1]]+(hist_table_d[index-1][tmp[2]]-(int)hist_table_d[index-1][tmp[2]]); break; case 1: power=tmp[1]+(hist_table_d[index-1][tmp[2]]-(int)hist_table_d[index-1][tmp[2]]); hist_table_d[index-1][tail_d[index-1]]=power; tail_d[index-1]=(tail_d[index-1]+1)%HIST_TABLE_SIZE; break; case 2: power=(int)hist_table_d[index-1][tmp[1]]+((float)tmp[2])/(pow(10,DECIMAL_DIGITS)); hist_table_d[index-1][tail_d[index-1]]=power; tail_d[index-1]=(tail_d[index-1]+1)%HIST_TABLE_SIZE; break; case 3: power=tmp[1]+((float)tmp[2])/(pow(10,DECIMAL_DIGITS)); hist_table_d[index-1][tail_d[index-1]]=power; tail_d[index-1]=(tail_d[index-1]+1)%HIST_TABLE_SIZE; break; } put_into_powers_queue(&queue,power); index++; initTmp(tmp); if(ret==WC_DC) { readIndex++; extract_message_word (&request, &compressedWord,readIndex); } break; case WC_DI: readIndex++; extract_message_word (&request, &compressedWord,readIndex); break; default: break; } } ret=getNextDecompressedWord(compressedWord,tmp,1); } /* NO COMPRESSION *************************************/ else { for (index = 1, nflpel++ ; index != nflpel ; index++) { float power_value ; extract_message_word (&request, &power_value, index) ; put_into_powers_queue (&queue, power_value) ; } } error = insert_power_values (&tdata.PowerGrid, &queue) ; if (error != TDICE_SUCCESS) { fprintf (stderr, "error: insert power values\n") ; powers_queue_destroy (&queue) ; goto sim_error ; } powers_queue_destroy (&queue) ; network_message_init (&reply) ; build_message_head (&reply, TDICE_INSERT_POWERS_AND_SIMULATE_SLOT) ; SimResult_t result = emulate_slot (&tdata, stkd.Dimensions, &analysis) ; insert_message_word (&reply, &result) ; send_message_to_socket (&client_socket, &reply) ; network_message_destroy (&reply) ; if (result != TDICE_SLOT_DONE) { fprintf (stderr, "error %d: emulate slot\n", result) ; goto sim_error ; } break ; } /**********************************************************************/ case TDICE_SEND_OUTPUT : { OutputInstant_t instant ; OutputType_t type ; OutputQuantity_t quantity ; //clock_t Time; extract_message_word (&request, &instant, 0) ; extract_message_word (&request, &type, 1) ; extract_message_word (&request, &quantity, 2) ; network_message_init (&reply) ; build_message_head (&reply, TDICE_SEND_OUTPUT) ; float time = get_simulated_time (&analysis) ; Quantity_t n = get_number_of_inspection_points (&output, instant, type, quantity) ; insert_message_word (&reply, &time) ; insert_message_word (&reply, &n) ; if (n > 0) { error = fill_output_message (&output, stkd.Dimensions, tdata.Temperatures, tdata.PowerGrid.Sources, instant, type, quantity, &reply) ; if (error != TDICE_SUCCESS) { fprintf (stderr, "error: generate message content\n") ; network_message_destroy (&reply) ; goto sim_error ; } } if(type == TDICE_OUTPUT_TYPE_TMAP && compressionUsed) { //init histTableMap tailMap for compression //New packet tmapReply is being initialised / //clock_gettime (CLOCK_PROCESS_CPUTIME_ID, &t1); network_message_init (&tmapReply); build_message_head (&tmapReply, TDICE_SEND_OUTPUT); insert_message_word (&tmapReply, &time); insert_message_word (&tmapReply, &n); CellIndex_t nrows, ncols; int readIndex = 4; //get the no of rows and cols from reply packet extract_message_word (&reply, &nrows, 2); extract_message_word (&reply, &ncols, 3); //insert nrows and ncols into my packet insert_message_word (&tmapReply, &nrows); insert_message_word (&tmapReply, &ncols); int ret=-1, f1, f2; unsigned int compressedWord, i, j, k, l; unsigned int flag=0, intPart, decPart; unsigned int tmp[3]; float temper; for(i=0; i<n; i++) for(j=0; j<nrows; j++) for(k=0; k<ncols; k++) { f1 = -1;f2 = -1; extract_message_word (&reply, &temper, readIndex); readIndex++; unsigned int intPartTemper, decPartTemper; getParts (temper, &intPartTemper, &decPartTemper); for (l=0;l<HIST_TABLE_SIZE;l++) { if(histTableMap[i][j][k][l] != -1.0) { getParts (histTableMap[i][j][k][l], &intPart, &decPart); if(intPart == intPartTemper)f1 = l; float val=((float)decPart-decPartTemper); val=val/(float)pow(10,DECIMAL_DIGITS); val=abs (val); if(val <= TOLERANCE) f2=l; } } flag = getFlag (f1,f2); switch (flag) { case 1: histTableMap[i][j][k][tailMap[i][j][k]] = intPartTemper + (histTableMap[i][j][k][f2] - (int)histTableMap[i][j][k][f2]); tailMap[i][j][k] = (tailMap[i][j][k] + 1)%HIST_TABLE_SIZE; break; case 2: histTableMap[i][j][k][tailMap[i][j][k]] = (int)histTableMap[i][j][k][f1] + ((float)decPartTemper)/(pow(10,DECIMAL_DIGITS)); tailMap[i][j][k] = (tailMap[i][j][k] + 1)%HIST_TABLE_SIZE; break; case 3: histTableMap[i][j][k][tailMap[i][j][k]] = intPartTemper + ((float)decPartTemper)/(pow(10,DECIMAL_DIGITS)); tailMap[i][j][k] = (tailMap[i][j][k] + 1)%HIST_TABLE_SIZE; break; default: break; } getArgsInArray (f1, f2, flag, intPartTemper, decPartTemper, tmp); ret = getNextCompressedWord (tmp[1], tmp[2], flag, &compressedWord, !WRAP_UP); if(ret != WORD_INCOMPLETE) insert_message_word (&tmapReply, &compressedWord); } switch(ret) { case WORD_INCOMPLETE: case WORD_IN_TEMP: getNextCompressedWord (tmp[1], tmp[2], flag, &compressedWord, WRAP_UP); insert_message_word (&tmapReply, &compressedWord); break; default: break; } clock_gettime (CLOCK_PROCESS_CPUTIME_ID, &t1); send_message_to_socket (&client_socket, &tmapReply); clock_gettime (CLOCK_PROCESS_CPUTIME_ID, &t2); diff(t1,t2,&res); network_message_destroy (&reply); network_message_destroy (&tmapReply); } else { if(type == TDICE_OUTPUT_TYPE_TMAP) { //Time = clock(); clock_gettime (CLOCK_PROCESS_CPUTIME_ID, &t1); send_message_to_socket (&client_socket, &reply); //timeForTmap += ((double)clock() - Time) / CLOCKS_PER_SEC ; clock_gettime (CLOCK_PROCESS_CPUTIME_ID, &t2); diff(t1,t2,&res); } else send_message_to_socket (&client_socket, &reply) ; network_message_destroy (&reply) ; } break ; } /**********************************************************************/ case TDICE_PRINT_OUTPUT : { OutputInstant_t instant ; extract_message_word (&request, &instant, 0) ; if (headers == false) { Error_t error = generate_output_headers (&output, stkd.Dimensions, (String_t)"% ") ; if (error != TDICE_SUCCESS) { fprintf (stderr, "error in initializing output files \n "); goto sim_error ; } headers = true ; } generate_output (&output, stkd.Dimensions, tdata.Temperatures, tdata.PowerGrid.Sources, get_simulated_time (&analysis), instant) ; break ; } /**********************************************************************/ case TDICE_SIMULATE_SLOT : { network_message_init (&reply) ; build_message_head (&reply, TDICE_SIMULATE_SLOT) ; SimResult_t result = emulate_slot (&tdata, stkd.Dimensions, &analysis) ; insert_message_word (&reply, &result) ; send_message_to_socket (&client_socket, &reply) ; network_message_destroy (&reply) ; if (result == TDICE_END_OF_SIMULATION) { network_message_destroy (&request) ; goto quit ; } else if (result != TDICE_SLOT_DONE) { fprintf (stderr, "error %d: emulate slot\n", result) ; goto sim_error ; } break ; } /**********************************************************************/ case TDICE_SIMULATE_STEP : { network_message_init (&reply) ; build_message_head (&reply, TDICE_SIMULATE_STEP) ; SimResult_t result = emulate_step (&tdata, stkd.Dimensions, &analysis) ; insert_message_word (&reply, &result) ; send_message_to_socket (&client_socket, &reply) ; network_message_destroy (&reply) ; if (result == TDICE_END_OF_SIMULATION) { network_message_destroy (&request) ; goto quit ; } else if (result != TDICE_STEP_DONE && result != TDICE_SLOT_DONE) { fprintf (stderr, "error %d: emulate step\n", result) ; goto sim_error ; } break ; } /**********************************************************************/ default : fprintf (stderr, "ERROR :: received unknown message type") ; } network_message_destroy (&request) ; } while (1) ; /**************************************************************************/ quit : socket_close (&client_socket) ; socket_close (&server_socket) ; thermal_data_destroy (&tdata) ; stack_description_destroy (&stkd) ; output_destroy (&output) ; printf("Time taken %d sec %d nsec \n",(int)res.tv_sec,(int)res.tv_nsec); return EXIT_SUCCESS ; sim_error : network_message_destroy (&request) ; socket_close (&client_socket) ; wait_error : socket_close (&server_socket) ; socket_error : thermal_data_destroy (&tdata) ; ftd_error : wrong_analysis_error : stack_description_destroy (&stkd) ; output_destroy (&output) ; return EXIT_FAILURE ; }