void dispose(Macierz* m, MemoryManager* man){ int i; for(i=0;i<m->height;i++){ deallocation(m->tab[i],man); } deallocation(m,man); }
int main(int argc, const char * argv[]) { Node *node1 = initListItem(1); Node *node2 = initListItem(2); Node *node3 = initListItem(3); Node *node4 = initListItem(4); Node *node5 = initListItem(5); Node *newNode = initListItem(6); insertToTheEnd(node1, node2); insertToTheEnd(node1, node3); insertToTheEnd(node1, node4); insertToTheEnd(node1, node5); printf("All values in the list: "); listAll(node1); int valueUserInput; printf("Input the value to find:"); scanf("%d", &valueUserInput); Node *searchResult = searchValue(node1, valueUserInput); if (searchResult == NULL) { printf("%d is not found in this list!\n", valueUserInput); } else { printf("Search result %d found at %p\n", searchResult->value, searchResult); printf("%p\n", node2); } insertToTheEnd(node1, newNode); listAll(node1); removeListItem(node1, node2); listAll(node1); deallocation(node1); return 0; }
/** * \fn main (void) * \brief Configuration creation and deletion. * \return EXIT_SUCCESS status code: ok. * \return EXIT_FAILURE status code: error. */ int main (void){ // char *arge[] permet d'utiliser les redirections avec la fonction popen /* BOUCLES */ int i=0; /* CONFIGURATION */ int nbConfigurations = 0; ConfigurationName *tabConfigurations = NULL; int configurationChoisie = 0; int nb_circles = 0; char racinePython[ROOT_SIZE] = ""; MACaddress *tabMAC = NULL; char **counters_names = NULL; // Le nom de chaque compteurs est stocké dans un tableau de chaine de caractères /* MENU */ int choixMenu = 0; printf("Management of the plugwise configurations :\n"); printf("\n"); // MENU CONFIGURATIONS printf("What do you want to do?\n"); printf("1: Create a new configuration\n"); printf("2: Delete a configuration\n"); printf("Your choice: "); scanf("%d",&choixMenu); printf("\n"); if ((choixMenu != 1) && (choixMenu !=2)) { perror("Error : your choice is not possible !\n"); return EXIT_FAILURE; } // Because the source code was make for another program choixMenu++; /// CHOIX 1 : CREATION D'UNE NOUVELLE CONFIGURATION : if(choixMenu==2) { allocation_configurations_names(1, &tabConfigurations); write_static_data(choixMenu, 1, tabConfigurations, racinePython, &nb_circles); mac_adress_dynamic_allocation(nb_circles,&tabMAC); counters_names_dynamic_allocation(nb_circles,&counters_names); write_dynamic_data(choixMenu, nb_circles, tabMAC, counters_names); free(tabConfigurations); deallocation(nb_circles, &tabMAC, &counters_names); } /// CHOIX 2 : SUPPRIMER UNE CONFIGURATION : else { /// 1. On récupère le nombre et les noms des configurations nbConfigurations = nb_configurations(); allocation_configurations_names(nbConfigurations, &tabConfigurations); save_configurations_names(nbConfigurations, tabConfigurations); /// 2. On demande à l'utilisateur de choisir la configuration à supprimer configurationChoisie = configuration_choice(choixMenu, nbConfigurations, tabConfigurations); /// 3. On récupère les données de la configuration system("touch configurations.tmp"); i=1; while(i <= nbConfigurations){ if(i != configurationChoisie){ // Récupération des données static_data_recovery(choixMenu, i, tabConfigurations, racinePython,&nb_circles); mac_adress_dynamic_allocation(nb_circles,&tabMAC); counters_names_dynamic_allocation(nb_circles,&counters_names); dynamic_data_recovery(i, nb_circles, tabMAC, counters_names); // Permutation fichiers system("mv configurations.txt configurations.txt.tmp"); system("mv configurations.tmp configurations.txt"); // Ecriture des données write_static_data(choixMenu, i, tabConfigurations, racinePython, &nb_circles); write_dynamic_data(choixMenu, nb_circles, tabMAC, counters_names); system("mv configurations.txt configurations.tmp"); system("mv configurations.txt.tmp configurations.txt"); } i++; } /// 4. On libère la mémoire et renomme le fichier temporaire en configurations.txt free(tabConfigurations); deallocation(nb_circles, &tabMAC, &counters_names); system("rm configurations.txt"); system("mv configurations.tmp configurations.txt"); } return EXIT_SUCCESS; }
void ProcessEvent(unsigned int me, simtime_t now, int event_type, event_content_type *event_content, unsigned int size, void *ptr) { char *parameter, *value; channel *c; int w; event_content_type new_event_content; new_event_content.cell = -1; new_event_content.channel = -1; new_event_content.call_term_time = -1; simtime_t handoff_time; simtime_t timestamp = 0; lp_state_type *state; state = (lp_state_type*)ptr; if(state != NULL) { state->lvt = now; state->executed_events++; } switch(event_type) { case INIT: // Initialize the LP's state state = (lp_state_type *)malloc(sizeof(lp_state_type)); if (state == NULL) { printf("Out of memory!\n"); exit(EXIT_FAILURE); } SetState(state); bzero(state, sizeof(lp_state_type)); state->channel_counter = CHANNELS_PER_CELL; // Read runtime parameters if(IsParameterPresent(event_content, "pcs_statistics")) pcs_statistics = true; if(IsParameterPresent(event_content, "ta")) state->ref_ta = state->ta = GetParameterDouble(event_content, "ta"); else state->ref_ta = state->ta = TA; if(IsParameterPresent(event_content, "ta_duration")) state->ta_duration = GetParameterDouble(event_content, "ta_duration"); else state->ta_duration = TA_DURATION; if(IsParameterPresent(event_content, "ta_change")) state->ta_change = GetParameterDouble(event_content, "ta_change"); else state->ta_change = TA_CHANGE; if(IsParameterPresent(event_content, "channels_per_cell")) state->channels_per_cell = GetParameterInt(event_content, "channels_per_cell"); else state->channels_per_cell = CHANNELS_PER_CELL; if(IsParameterPresent(event_content, "complete_calls")) complete_calls = GetParameterInt(event_content, "complete_calls"); state->fading_recheck = IsParameterPresent(event_content, "fading_recheck"); state->variable_ta = IsParameterPresent(event_content, "variable_ta"); // Show current configuration, only once if(me == 0) { printf("CURRENT CONFIGURATION:\ncomplete calls: %d\nTA: %f\nta_duration: %f\nta_change: %f\nchannels_per_cell: %d\nfading_recheck: %d\nvariable_ta: %d\n", complete_calls, state->ta, state->ta_duration, state->ta_change, state->channels_per_cell, state->fading_recheck, state->variable_ta); fflush(stdout); } state->channel_counter = state->channels_per_cell; // Setup channel state state->channel_state = malloc(sizeof(unsigned int) * 2 * (CHANNELS_PER_CELL / BITS + 1)); for (w = 0; w < state->channel_counter / (sizeof(int) * 8) + 1; w++) state->channel_state[w] = 0; // Start the simulation timestamp = (simtime_t) (20 * Random()); ScheduleNewEvent(me, timestamp, START_CALL, NULL, 0); // If needed, start the first fading recheck // if (state->fading_recheck) { timestamp = (simtime_t) (FADING_RECHECK_FREQUENCY * Random()); ScheduleNewEvent(me, timestamp, FADING_RECHECK, NULL, 0); // } break; case START_CALL: state->arriving_calls++; if (state->channel_counter == 0) { state->blocked_on_setup++; } else { state->channel_counter--; new_event_content.channel = allocation(state); new_event_content.from = me; new_event_content.sent_at = now; // Determine call duration switch (DURATION_DISTRIBUTION) { case UNIFORM: new_event_content.call_term_time = now + (simtime_t)(state->ta_duration * Random()); break; case EXPONENTIAL: new_event_content.call_term_time = now + (simtime_t)(Expent(state->ta_duration)); break; default: new_event_content.call_term_time = now + (simtime_t) (5 * Random() ); } // Determine whether the call will be handed-off or not switch (CELL_CHANGE_DISTRIBUTION) { case UNIFORM: handoff_time = now + (simtime_t)((state->ta_change) * Random()); break; case EXPONENTIAL: handoff_time = now + (simtime_t)(Expent(state->ta_change)); break; default: handoff_time = now + (simtime_t)(5 * Random()); } if(new_event_content.call_term_time <= handoff_time) { ScheduleNewEvent(me, new_event_content.call_term_time, END_CALL, &new_event_content, sizeof(new_event_content)); } else { new_event_content.cell = FindReceiver(TOPOLOGY_HEXAGON); ScheduleNewEvent(me, handoff_time, HANDOFF_LEAVE, &new_event_content, sizeof(new_event_content)); } } if (state->variable_ta) state->ta = recompute_ta(state->ref_ta, now); // Determine the time at which a new call will be issued switch (DISTRIBUTION) { case UNIFORM: timestamp= now + (simtime_t)(state->ta * Random()); break; case EXPONENTIAL: timestamp= now + (simtime_t)(Expent(state->ta)); break; default: timestamp= now + (simtime_t) (5 * Random()); } ScheduleNewEvent(me, timestamp, START_CALL, NULL, 0); break; case END_CALL: state->channel_counter++; state->complete_calls++; deallocation(me, state, event_content->channel, event_content, now); break; case HANDOFF_LEAVE: state->channel_counter++; state->leaving_handoffs++; deallocation(me, state, event_content->channel, event_content, now); new_event_content.call_term_time = event_content->call_term_time; ScheduleNewEvent(event_content->cell, now, HANDOFF_RECV, &new_event_content, sizeof(new_event_content)); break; case HANDOFF_RECV: state->arriving_handoffs++; state->arriving_calls++; if (state->channel_counter == 0) state->blocked_on_handoff++; else { state->channel_counter--; new_event_content.channel = allocation(state); new_event_content.call_term_time = event_content->call_term_time; switch (CELL_CHANGE_DISTRIBUTION) { case UNIFORM: handoff_time = now + (simtime_t)((state->ta_change) * Random()); break; case EXPONENTIAL: handoff_time = now + (simtime_t)(Expent( state->ta_change )); break; default: handoff_time = now+ (simtime_t) (5 * Random()); } if(new_event_content.call_term_time < handoff_time ) { ScheduleNewEvent(me, new_event_content.call_term_time, END_CALL, &new_event_content, sizeof(new_event_content)); } else { new_event_content.cell = FindReceiver(TOPOLOGY_HEXAGON); ScheduleNewEvent(me, handoff_time, HANDOFF_LEAVE, &new_event_content, sizeof(new_event_content)); } } break; case FADING_RECHECK: /* if(state->check_fading) state->check_fading = false; else state->check_fading = true; */ fading_recheck(state); timestamp = now + (simtime_t) (FADING_RECHECK_FREQUENCY ); ScheduleNewEvent(me, timestamp, FADING_RECHECK, NULL, 0); break; default: fprintf(stdout, "PCS: Unknown event type! (me = %d - event type = %d)\n", me, event_type); abort(); } }
void ProcessEvent(unsigned int me, simtime_t now, int event_type, event_content_type *event_content, unsigned int size, void * ptr) { int w; event_content_type new_event_content; new_event_content.cell = -1; new_event_content.second_cell = -1; new_event_content.channel = -1; new_event_content.call_term_time = -1; simtime_t handoff_time; simtime_t timestamp=0; lp_state_type * pointer; pointer = (lp_state_type*)ptr; switch(event_type) { case INIT: pointer = (lp_state_type *)malloc(sizeof(lp_state_type)); if (pointer == NULL){ printf("ERROR in malloc!\n"); exit(EXIT_FAILURE); } SetState(pointer); // pointer->channels = NULL; pointer->contatore_canali = CHANNELS_PER_CELL; pointer->cont_chiamate_entranti = -1; pointer->cont_chiamate_complete = 0; pointer->cont_handoff_uscita = 0; pointer->cont_bloccate_in_partenza = 0; pointer->cont_bloccate_in_handoff = 0; pointer->handoffs_entranti = 0; // power_management = true; // variable_ta = true; // fading_recheck = true; // INIT is not considered as an event pointer->contatore_eventi = 0; // pointer->time = now; // Load the predefined values // variable_ta = true; complete_calls = COMPLETE_CALLS; ta = TA; ta_durata = TA_DURATA; ta_cambio = TA_CAMBIO; channels_per_cell = CHANNELS_PER_CELL; power_management = true; // Read runtime parameters char **arguments = (char **)event_content; for(w = 0; w < size; w += 2) { if(strcmp(arguments[w],"complete-calls") == 0) { complete_calls = parseInt(arguments[w + 1]); } else if(strcmp(arguments[w],"ta") == 0) { ta = parseDouble(arguments[w + 1]); } else if(strcmp(arguments[w],"ta-durata") == 0) { ta_durata = parseDouble(arguments[w + 1]); } else if(strcmp(arguments[w],"ta-cambio") == 0) { ta_cambio = parseDouble(arguments[w + 1]); } else if(strcmp(arguments[w],"channels-per-cell") == 0) { channels_per_cell = parseInt(arguments[w + 1]); } else if(strcmp(arguments[w],"complete-time") == 0) { complete_time = parseInt(arguments[w + 1]); } else if(strcmp(arguments[w],"no-power-management") == 0) { w -= 1; power_management = false; } else if(strcmp(arguments[w],"power-management") == 0) { w -= 1; power_management = true; } else if(strcmp(arguments[w],"variable-ta") == 0) { w -= 1; variable_ta = true; } else if(strcmp(arguments[w],"fading-recheck") == 0) { fading_recheck = true; } else if(strcmp(arguments[w],"complete-time") == 0) { complete_time = parseInt(arguments[w + 1]); } } ref_ta = ta; // Show current configuration, only once if(me == 0) { printf("CURRENT CONFIGURATION:\nCOMPLETE CALLS: %d\nTA: %f\nTA_DURATA: %f\nTA_CAMBIO: %f\nCHANNELS_PER_CELL: %d\nCOMPLETE_TIME: %d\n", complete_calls, ta, ta_durata, ta_cambio, channels_per_cell, complete_time); printf("POWER MANAGMENT: %d\nFADING RECHECK: %d\nVARIABLE TA: %d\n", power_management, fading_recheck, variable_ta); fflush(stdout); } pointer->contatore_canali = channels_per_cell; for (w = 0; w < pointer->contatore_canali / (sizeof(int) * 8) + 1; w++) pointer->channel_state[w] = 0; pointer->buff_topology = (_PCS_routing*)malloc(sizeof(_PCS_routing)); if(pointer->buff_topology == NULL){ printf("Chiamata a malloc errata sulla topologia della rete!\n"); exit(EXIT_FAILURE); } set_my_topology(me, pointer->buff_topology); timestamp = (simtime_t) (20 * Random()); ScheduleNewEvent(me, timestamp, START_CALL, NULL, 0); if (fading_recheck) { timestamp = now + (simtime_t) (FADING_RECHECK_FREQUENCY); ScheduleNewEvent(me, timestamp, FADING_RECHECK, NULL, 0); } break; case START_CALL: pointer->time = now; //make_copy(pointer->cont_chiamate_entranti, pointer->cont_chiamate_entranti+1); pointer->cont_chiamate_entranti++; //make_copy(pointer->contatore_eventi, pointer->contatore_eventi+1); pointer->contatore_eventi++; if (pointer->contatore_canali == 0) { //make_copy(pointer->cont_bloccate_in_partenza, pointer->cont_bloccate_in_partenza+1); pointer->cont_bloccate_in_partenza++; } else { pointer->contatore_canali--; //make_copy(pointer->contatore_canali, pointer->contatore_canali-1); #ifdef ACCURATE_SIMULATION new_event_content.channel = allocation(me, pointer); #endif // Determine call duration switch (DISTRIBUZIONE_DURATA) { case UNIFORME: new_event_content.call_term_time = now+ (simtime_t) (ta_durata * Random()); break; case ESPONENZIALE: new_event_content.call_term_time = now + (simtime_t)( Expent(ta_durata )); break; default: new_event_content.call_term_time = now+ (simtime_t) (5 * Random() ); } // Determine whether the call will be handed-off or not switch (DISTRIBUZIONE_CAMBIOCELLA) { case UNIFORME: handoff_time = now+ (simtime_t) ((ta_cambio) * Random() ); break; case ESPONENZIALE: handoff_time = now+ (simtime_t)( Expent( ta_cambio )); break; default: handoff_time = now+ (simtime_t) (5 * Random() ); } if( new_event_content.call_term_time <= handoff_time) { ScheduleNewEvent(me,new_event_content.call_term_time,END_CALL,&new_event_content,sizeof(new_event_content)); } else { new_event_content.cell = __FindReceiver(me,pointer); new_event_content.second_cell = -1; ScheduleNewEvent(me,handoff_time,HANDOFF_LEAVE,&new_event_content,sizeof(new_event_content)); // #ifdef PRE_SCHEDULING new_event_content.call_term_time = new_event_content.call_term_time; ScheduleNewEvent(new_event_content.cell,handoff_time,HANDOFF_RECV,&new_event_content,sizeof(new_event_content)); // #endif } } // if (pointer->contatore_canali == 0) if (variable_ta) ta = recompute_ta(ref_ta, now); // Determine the time at which the call will end switch (DISTRIBUZIONE) { case UNIFORME: timestamp= now+ (simtime_t) (ta * Random() ); break; case ESPONENZIALE: timestamp= now+ (simtime_t)( Expent( ta )); break; default: timestamp= now+ (simtime_t) (5 * Random()); } ScheduleNewEvent(me, timestamp, START_CALL, NULL, 0); break; case END_CALL: pointer->time = now; // make_copy(pointer->contatore_eventi, pointer->contatore_eventi+1); pointer->contatore_eventi++; //make_copy(pointer->contatore_canali, pointer->contatore_canali+1); pointer->contatore_canali++; //make_copy(pointer->cont_chiamate_complete, pointer->cont_chiamate_complete+1); pointer->cont_chiamate_complete++; #ifdef ACCURATE_SIMULATION deallocation(me, pointer, event_content->channel); #endif break; case HANDOFF_LEAVE: pointer->time = now; //make_copy(pointer->contatore_eventi, pointer->contatore_eventi+1); pointer->contatore_eventi++; //make_copy(pointer->contatore_canali, pointer->contatore_canali+1); pointer->contatore_canali++; //make_copy(pointer->cont_handoff_uscita, pointer->cont_handoff_uscita+1); pointer->cont_handoff_uscita++; #ifdef ACCURATE_SIMULATION deallocation(me, pointer, event_content->channel); #endif // #ifndef PRE_SCHEDULING // new_event_content.call_term_time = event_content->call_term_time + 0.00005; // ScheduleNewEvent(event_content->cell, now + 0.00003 , HANDOFF_RECV, &new_event_content, sizeof(new_event_content)); // #endif break; case HANDOFF_RECV: pointer->time = now; //handoff_counter++; //make_copy(pointer->handoffs_entranti, pointer->handoffs_entranti+1); pointer->handoffs_entranti++; //make_copy(pointer->cont_chiamate_entranti, pointer->cont_chiamate_entranti+1); //make_copy(pointer->contatore_eventi, pointer->contatore_eventi+1); pointer->contatore_eventi++; pointer->cont_chiamate_entranti++; if (pointer->contatore_canali == 0) //make_copy(pointer->cont_bloccate_in_handoff, pointer->cont_bloccate_in_handoff+1); pointer->cont_bloccate_in_handoff++; else { //make_copy(pointer->contatore_canali, pointer->contatore_canali-1); pointer->contatore_canali--; #ifdef ACCURATE_SIMULATION new_event_content.channel = allocation(me, pointer); #endif new_event_content.call_term_time = event_content->call_term_time; switch (DISTRIBUZIONE_CAMBIOCELLA) { case UNIFORME: handoff_time = now+ (simtime_t) ((ta_cambio) * Random()); break; case ESPONENZIALE: handoff_time = now+ (simtime_t)( Expent( ta_cambio )); break; default: handoff_time = now+ (simtime_t) (5 * Random()); } if (Random() < 0.5) handoff_time *= 10; if( new_event_content.call_term_time <= handoff_time ) { ScheduleNewEvent(me , new_event_content.call_term_time, END_CALL, &new_event_content, sizeof(new_event_content)); } else { new_event_content.cell = __FindReceiver(me,ptr); #ifdef NO_UNCERTAINTY new_event_content.second_cell = -1; #endif ScheduleNewEvent(me , new_event_content.call_term_time, HANDOFF_LEAVE, &new_event_content, sizeof(new_event_content)); } } break; case FADING_RECHECK: // pointer->time = now; if (pointer->check_fading == true) { //make_copy(pointer->check_fading, false); pointer->check_fading = false; } else { //make_copy(pointer->check_fading, true); pointer->check_fading = true; } timestamp = now + (simtime_t) (FADING_RECHECK_FREQUENCY); ScheduleNewEvent(me, timestamp, FADING_RECHECK, NULL, 0); break; default: fprintf(stderr, " pointer simulation: error - inconsistent event (me = %d - event type = %d)\n", me, event_type); break; } // switch(event->type) }
/** * \fn main (void) * \brief Configuration creation and deletion. * \return EXIT_SUCCESS status code: ok. * \return EXIT_FAILURE status code: error. */ int main (void){ /* BOUCLES */ int i=0; /* CONFIGURATION */ int nbConfigurations = 0; ConfigurationName *tabConfigurations = NULL; int chosenConfiguration = 0; int nb_circles = 0; char pythonRoot[ROOT_SIZE] = ""; MACaddress *tabMAC = NULL; char **counters_names = NULL; // the name of each counters is saved in a table of strings /* MENU */ int menuChoice = 0; printf("Management of the plugwise configurations :\n"); printf("\n"); // MENU CONFIGURATIONS printf("What do you want to do?\n"); printf("1: Create a new configuration\n"); printf("2: Delete a configuration\n"); printf("Your choice: "); scanf("%d",&menuChoice); printf("\n"); if ((menuChoice != 1) && (menuChoice !=2)) { perror("Error : your choice is not possible !\n"); return EXIT_FAILURE; } // Because the source code was made for another program (TO CHANGE) menuChoice++; /// <h2>CHOICE 1 : CREATION OF A NEW CONFIGURATION :</h2> if(menuChoice==2) { allocation_configurations_names(1, &tabConfigurations); write_static_data(menuChoice, 1, tabConfigurations, pythonRoot, &nb_circles); mac_adress_dynamic_allocation(nb_circles,&tabMAC); counters_names_dynamic_allocation(nb_circles,&counters_names); write_dynamic_data(menuChoice, nb_circles, tabMAC, counters_names); free(tabConfigurations); deallocation(nb_circles, &tabMAC, &counters_names); } /// <h2>CHOICE 2 : DELETE A CONFIGURATION:</h2> else { /// <h3>1. We save the number and the name of the configurations</h3> nbConfigurations = nb_configurations(); allocation_configurations_names(nbConfigurations, &tabConfigurations); save_configurations_names(nbConfigurations, tabConfigurations); /// <h3>2. We ask the user to chose the configuration to delete</h3> chosenConfiguration = configuration_choice(menuChoice, nbConfigurations, tabConfigurations); /// <h3>3. We save the configuration data</h3> system("touch configurations.tmp"); i=1; while(i <= nbConfigurations){ if(i != chosenConfiguration){ // Data recovery static_data_recovery(menuChoice, i, tabConfigurations, pythonRoot,&nb_circles); mac_adress_dynamic_allocation(nb_circles,&tabMAC); counters_names_dynamic_allocation(nb_circles,&counters_names); dynamic_data_recovery(i, nb_circles, tabMAC, counters_names); // Files permutation system("mv configurations.txt configurations.txt.tmp"); system("mv configurations.tmp configurations.txt"); // Data writing write_static_data(menuChoice, i, tabConfigurations, pythonRoot, &nb_circles); write_dynamic_data(menuChoice, nb_circles, tabMAC, counters_names); system("mv configurations.txt configurations.tmp"); system("mv configurations.txt.tmp configurations.txt"); } i++; } /// <h3>4. We release the memory and rename the temporary file in configurations.txt</h3> free(tabConfigurations); deallocation(nb_circles, &tabMAC, &counters_names); system("rm configurations.txt"); system("mv configurations.tmp configurations.txt"); } return EXIT_SUCCESS; }