API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Dec 6th, 2019
130
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 18.88 KB | None | 0 0
raw download clone embed print report
  1. #include <stdio.h>
  2.  
  3. #include <stdlib.h>
  4.  
  5. #include "header.h"
  6.  
  7.  
  8.  
  9. //timelog function
  10.  
  11. char *timelog() {
  12. t = time(NULL);
  13. Time = *localtime(&t);
  14.  
  15. snprintf(timenow, sizeof(timenow), "\n%d:%d:%d ",Time.tm_hour, Time.tm_min, Time.tm_sec);
  16. return timenow;
  17. }
  18.  
  19.  
  20.  
  21. //code - init time - takeoff time
  22.  
  23. int create_departure(char *c, int i, int t) {
  24.  
  25.  
  26.  
  27. Lista_departure novo;
  28.  
  29. novo = (Lista_departure) malloc(sizeof(node_struct_departure));
  30.  
  31. novo->departure = malloc(sizeof(departure_struct));
  32.  
  33.  
  34.  
  35. if(novo!=NULL){
  36.  
  37. strcpy(novo->departure->flight_code, c);
  38.  
  39. novo->departure->initial_time = i;
  40.  
  41. novo->departure->takeoff_time = t;
  42.  
  43. }
  44.  
  45.  
  46.  
  47. sem_wait(&semafores->insert_queue);
  48.  
  49. departures = insert_departure(departures,novo);
  50.  
  51. sem_post(&semafores->insert_queue);
  52.  
  53.  
  54.  
  55. write_log_file("Departure introduzida na fila com sucesso!");
  56.  
  57. return 0;
  58.  
  59. }
  60.  
  61.  
  62.  
  63. //code - init time - time to runway - init fuel
  64.  
  65. int create_arrival(char *c, int i, int t, int f) {
  66.  
  67.  
  68.  
  69. Lista_arrival novo;
  70.  
  71. novo = (Lista_arrival) malloc(sizeof(node_struct_arrival));
  72.  
  73. novo->arrival = malloc(sizeof(arrival_struct));
  74.  
  75.  
  76.  
  77. if(novo!=NULL){
  78.  
  79. strcpy(novo->arrival->flight_code, c);
  80.  
  81. novo->arrival->initial_time = i;
  82.  
  83. novo->arrival->time_runway = t;
  84.  
  85. novo->arrival->initial_fuel = f;
  86.  
  87. }
  88.  
  89. sem_wait(&semafores->insert_queue);
  90.  
  91. arrivals = insert_arrival(arrivals, novo);
  92.  
  93. sem_post(&semafores->insert_queue);
  94.  
  95.  
  96.  
  97. write_log_file("Arrival introduzida na fila com sucesso!");
  98.  
  99. return 0;
  100.  
  101. }
  102.  
  103.  
  104.  
  105. Lista_departure insert_departure(Lista_departure departures, Lista_departure novo){
  106.  
  107. Lista_departure ant, act;
  108.  
  109.  
  110.  
  111. if(departures == NULL){
  112.  
  113. departures = novo;
  114.  
  115. novo->next = NULL;
  116.  
  117. return departures;
  118.  
  119. }
  120.  
  121.  
  122.  
  123. //(departures->departure->initial_time)>=(novo->departure->initial_time)
  124.  
  125. act = departures->next;
  126.  
  127. ant = departures;
  128.  
  129.  
  130.  
  131. while((act->next!=NULL) && (act->departure->initial_time)<=(novo->departure->initial_time)){
  132.  
  133. ant = ant->next;
  134.  
  135. act = act->next;
  136.  
  137. }
  138.  
  139.  
  140.  
  141. novo->next = act;
  142.  
  143. ant->next = novo;
  144.  
  145. return departures;
  146.  
  147. }
  148.  
  149.  
  150.  
  151. Lista_arrival insert_arrival(Lista_arrival arrivals, Lista_arrival novo){
  152.  
  153. Lista_arrival ant, act;
  154.  
  155.  
  156.  
  157. if(arrivals == NULL){
  158.  
  159. arrivals = novo;
  160.  
  161. novo->next = NULL;
  162.  
  163. return arrivals;
  164.  
  165. }
  166.  
  167.  
  168.  
  169. act = arrivals->next;
  170.  
  171. ant = arrivals;
  172.  
  173.  
  174.  
  175. while((act->next!=NULL) && (act->arrival->initial_time)<=(novo->arrival->initial_time)){
  176.  
  177. ant = ant->next;
  178.  
  179. act = act->next;
  180.  
  181. }
  182.  
  183.  
  184.  
  185. novo->next = act;
  186.  
  187. ant->next = novo;
  188.  
  189. return arrivals;
  190.  
  191. }
  192.  
  193.  
  194.  
  195. Lista_departure remove_departure(){
  196.  
  197. Lista_departure no;
  198.  
  199. Lista_departure removido;
  200.  
  201.  
  202.  
  203. removido = (Lista_departure) malloc(sizeof(node_struct_departure));
  204.  
  205. removido->departure = malloc(sizeof(departure_struct));
  206.  
  207.  
  208.  
  209. if(departures == NULL){
  210.  
  211. printf("Fila vazia.");
  212.  
  213. }else if(departures->next == NULL){
  214.  
  215. strcpy(removido->departure->flight_code,departures->departure->flight_code);
  216.  
  217. removido->departure->initial_time = departures->departure->initial_time;
  218.  
  219. removido->departure->takeoff_time = departures->departure->takeoff_time;
  220.  
  221. free(departures);
  222.  
  223. departures = NULL;
  224.  
  225. }else{
  226.  
  227. no = departures->next;
  228.  
  229. strcpy(removido->departure->flight_code,departures->departure->flight_code);
  230.  
  231. removido->departure->initial_time = departures->departure->initial_time;
  232.  
  233. removido->departure->takeoff_time = departures->departure->takeoff_time;
  234.  
  235. free(departures);
  236.  
  237. departures=no;
  238.  
  239. }
  240.  
  241. return removido;
  242.  
  243. }
  244.  
  245.  
  246.  
  247. void remove_arrival(){
  248.  
  249. Lista_arrival no;
  250.  
  251.  
  252.  
  253. if(arrivals == NULL){
  254.  
  255. printf("Fila vazia.");
  256.  
  257. }else if(arrivals->next == NULL){
  258.  
  259. free(arrivals);
  260.  
  261. arrivals = NULL;
  262.  
  263. }else{
  264.  
  265. no = arrivals->next;
  266.  
  267. free(arrivals);
  268.  
  269. arrivals = no;
  270.  
  271. }
  272.  
  273. }
  274.  
  275.  
  276.  
  277. void create_pipe(){
  278.  
  279. unlink(PIPE_NAME);
  280.  
  281. if ((mkfifo(PIPE_NAME, O_CREAT|O_EXCL|0600)<0) && (errno!=EEXIST)){
  282.  
  283. perror("Cannot create pipe. ");
  284.  
  285. exit(0);
  286.  
  287. }
  288.  
  289. write_log_file("Pipe created.");
  290.  
  291. }
  292.  
  293.  
  294.  
  295.  
  296.  
  297. void *workerthread_d(){
  298.  
  299. Lista_departure no = remove_departure();
  300.  
  301. message_struct_d message_d;
  302.  
  303.  
  304.  
  305. message_d.mtype = 3;
  306.  
  307. message_d.takeoff_time = no->departure->takeoff_time;
  308.  
  309. message_d.slot = 0;
  310.  
  311.  
  312.  
  313. if(msgsnd(mq_id,&message_d,sizeof(message_struct_d)-sizeof(long),0)!=0){
  314.  
  315. perror("Error - msgsnd() of mq");
  316.  
  317. }else{
  318.  
  319. printf("Enviado para message queue\n");
  320.  
  321. }
  322.  
  323.  
  324.  
  325. printf("A iniciar\n");
  326.  
  327. usleep(1000*5000);
  328.  
  329. printf("A terminar...\n");
  330.  
  331. pthread_exit(NULL);
  332.  
  333. }
  334.  
  335.  
  336.  
  337. void *workerthread_a(){
  338.  
  339. Lista_arrival no = remove_arrival();
  340.  
  341. message_struct_a message_a;
  342.  
  343.  
  344.  
  345. if(no->arrival->initial_fuel > 4+no->arrival->time_runway+running_config->L)
  346.  
  347. message_a.mtype =1;
  348.  
  349. else
  350.  
  351. message_a.mtype = 2;
  352.  
  353. message_a.initial_fuel = no->departure->initial_fuel;
  354.  
  355. message_a.time_runway = no->departure->time_runway;
  356.  
  357.  
  358.  
  359. message_a.slot = 0;
  360.  
  361.  
  362.  
  363. if(msgsnd(mq_id,&message_a,sizeof(message_struct_a)-sizeof(long),0)!=0){
  364.  
  365. perror("Error - msgsnd() of mq");
  366.  
  367. }else{
  368.  
  369. printf("Enviado para message queue\n");
  370.  
  371. }
  372.  
  373.  
  374.  
  375. printf("A iniciar\n");
  376.  
  377. usleep(1000*5000);
  378.  
  379. printf("A terminar...\n");
  380.  
  381. pthread_exit(NULL);
  382.  
  383. }
  384.  
  385.  
  386.  
  387.  
  388.  
  389. void *time_counter(){
  390.  
  391. while(1){
  392.  
  393. if((departures != NULL) && (departures->departure->initial_time) == mem->t){
  394.  
  395. pthread_create(&id_thread,NULL,workerthread_d,NULL);
  396.  
  397. }
  398.  
  399. if((arrivals != NULL) && (arrivals->arrival->initial_time) == mem->t){
  400.  
  401. pthread_create(&id_thread,NULL,workerthread_d,NULL);
  402.  
  403. }
  404.  
  405.  
  406.  
  407. usleep(1000*running_config->ut);
  408.  
  409. sem_wait(&semafores->mem);
  410.  
  411. mem->t++;
  412.  
  413. sem_post(&semafores->mem);
  414.  
  415. printf("Tempo %d\n",mem->t);
  416.  
  417.  
  418.  
  419. }
  420.  
  421. }
  422.  
  423.  
  424.  
  425. int init_shm_mem(){
  426.  
  427. if((mem_shmid= shmget(IPC_PRIVATE, sizeof(mem_struct*), IPC_CREAT|0700))<0){
  428.  
  429. perror("Error - shmget() of mem struct");
  430.  
  431. return -1;
  432.  
  433. }
  434.  
  435. if((mem = (mem_struct*) shmat(mem_shmid, NULL, 0)) == (mem_struct*)-1){
  436.  
  437. perror("Error - shmat() of mem struct");
  438.  
  439. return -1;
  440.  
  441. }
  442.  
  443. mem->t = 0;
  444.  
  445. return 0;
  446.  
  447. }
  448.  
  449.  
  450.  
  451. int init_shm_stats(){
  452.  
  453. if((stats_shmid = shmget(IPC_PRIVATE, sizeof(stats_struct*), IPC_CREAT|0700))<0){
  454.  
  455. perror("Error - shmget() of statistics struct");
  456.  
  457. return -1;
  458.  
  459. }
  460.  
  461. if((stats = (stats_struct*) shmat(stats_shmid, NULL, 0)) == (stats_struct*)-1){
  462.  
  463. perror("Error - shmat() of statistics struct");
  464.  
  465. return -1;
  466.  
  467. }
  468.  
  469.  
  470.  
  471. stats->n_voos_criados=0;
  472.  
  473. stats->n_voos_aterrados=0;
  474.  
  475. stats->t_aterrar=0.0;
  476.  
  477. stats->n_voos_descolados=0;
  478.  
  479. stats->t_descolados=0.0;
  480.  
  481. stats->n_holding_aterragem=0.0;
  482.  
  483. stats->n_holding_urgencia=0.0;
  484.  
  485. stats->n_voos_redirecionados=0;
  486.  
  487. stats->voos_rejeitados=0;
  488.  
  489.  
  490.  
  491. return 0;
  492.  
  493. }
  494.  
  495.  
  496.  
  497. //Create departure queue
  498.  
  499. int create_queue(){
  500.  
  501. if((mq_id = msgget(IPC_PRIVATE, IPC_CREAT|0700)) < 0) {
  502.  
  503. perror("Error - msgget()");
  504.  
  505. return -1;
  506.  
  507. }
  508.  
  509. else {
  510.  
  511. write_log_file("Message Queue created.");
  512.  
  513. }
  514.  
  515. return 0;
  516.  
  517. }
  518.  
  519.  
  520.  
  521. void close_named_pipe(){
  522.  
  523. close(fd);
  524.  
  525. unlink(PIPE_NAME);
  526.  
  527. }
  528.  
  529.  
  530.  
  531. //Init queues
  532.  
  533. int init_queues() {
  534.  
  535. departures = NULL;
  536.  
  537. arrivals = NULL;
  538.  
  539.  
  540.  
  541. d_ord = NULL;
  542.  
  543. a_ord = NULL;
  544.  
  545.  
  546.  
  547. write_log_file("Queues ready.");
  548.  
  549. return 0;
  550.  
  551. }
  552.  
  553.  
  554.  
  555. //Ficheiro LOG
  556.  
  557. int init_log_file() {
  558.  
  559. printf("Creating \"log.txt\"...\n");
  560.  
  561.  
  562.  
  563. if((flog = fopen(LOG_FILE_NAME, "a+")) == NULL){
  564.  
  565. perror("Error - fopen(\"log.txt\", \"a\")");
  566.  
  567. return -1;
  568.  
  569. }
  570.  
  571. write_log_file("File \"log.txt\" created successfully.");
  572.  
  573.  
  574.  
  575. return 0;
  576.  
  577. }
  578.  
  579.  
  580.  
  581. // Inicializar semáforos em memória partilhada
  582.  
  583. // Todos os semáforos declaram-se na struct respectiva e inicializam-se aqui
  584.  
  585. int init_shm_semafores() {
  586.  
  587. if((sem_shmid = shmget(IPC_PRIVATE, sizeof(sem_struct*), IPC_CREAT|0700))<0){
  588.  
  589. perror("Error - shmget() of semafores struct");
  590.  
  591. return -1;
  592.  
  593. }
  594.  
  595.  
  596.  
  597. if((semafores = (sem_struct*) shmat(sem_shmid, NULL, 0)) == (sem_struct*)-1){
  598.  
  599. perror("Error - shmat() of semafores struct");
  600.  
  601. return -1;
  602.  
  603. }
  604.  
  605.  
  606.  
  607. sem_init(&semafores->write_log, 1, 1);
  608.  
  609. sem_init(&semafores->insert_queue, 1, 1);
  610.  
  611. sem_init(&semafores->remove_queue, 1, 1);
  612.  
  613. sem_init(&semafores->mem,1,1);
  614.  
  615.  
  616.  
  617. return 0;
  618.  
  619. }
  620.  
  621.  
  622.  
  623.  
  624.  
  625. // Inicializar estutura de configuração de acordo com o ficheiro respectivo
  626.  
  627. int read_config(){
  628.  
  629.  
  630.  
  631. FILE *fp;
  632.  
  633. if(!(fp = fopen("config.txt","r"))) {
  634.  
  635. printf("Erro ao abrir o ficheiro config.txt!\n");
  636.  
  637. exit(0);
  638.  
  639. }
  640.  
  641.  
  642.  
  643. running_config = (config_struct*) malloc(sizeof(config_struct));
  644.  
  645.  
  646.  
  647. fscanf(fp,"%d",&running_config->ut);//unidade de tempo
  648.  
  649. fscanf(fp,"%d, %d",&running_config->T,&running_config->dt);//duracao descolagem, intervalo entre descolagem
  650.  
  651. fscanf(fp,"%d, %d",&running_config->L,&running_config->dl);//duracao aterragem, intervalo entre aterragens
  652.  
  653. fscanf(fp,"%d, %d",&running_config->Min,&running_config->Max); //holding duracao minima, holding duracao maxima
  654.  
  655. fscanf(fp,"%d",&running_config->D); //quantidade maxima partidas
  656.  
  657. fscanf(fp,"%d",&running_config->A); //quantidade maxima chegadas
  658.  
  659.  
  660.  
  661. //printf("%d\n",running_config->ut);
  662.  
  663. //printf("%d, %d\n",running_config->T,running_config->dt);
  664.  
  665. //printf("%d, %d\n",running_config->L,running_config->dl);
  666.  
  667. //printf("%d, %d\n",running_config->Min,running_config->Max);
  668.  
  669. //printf("%d\n",running_config->D);
  670.  
  671. //printf("%d\n",running_config->A);
  672.  
  673.  
  674.  
  675. write_log_file("Configuration file \"config.txt\" successfully loaded.");
  676.  
  677.  
  678.  
  679. return 0;
  680.  
  681. }
  682.  
  683.  
  684.  
  685. void delay(int number_of_seconds){
  686.  
  687. int milli_seconds = 1000 * number_of_seconds;
  688.  
  689.  
  690.  
  691. clock_t start_time = clock();
  692.  
  693. while(clock() < start_time + milli_seconds)
  694.  
  695. ;
  696.  
  697. }
  698.  
  699.  
  700.  
  701. void le_pipe(){
  702.  
  703. if((fd = open(PIPE_NAME, O_RDWR)) < 0) {
  704.  
  705. perror("Cannot open pipe for reading:\n");
  706.  
  707. exit(0);
  708.  
  709. }
  710.  
  711. else{
  712.  
  713. write_log_file("Open pipe for reading.");
  714.  
  715. }
  716.  
  717.  
  718.  
  719. char aux[BUFFER_SIZE];
  720.  
  721. char str[BUFFER_SIZE];
  722.  
  723. char all_str[50];
  724.  
  725. char flight_code[50];
  726.  
  727. int initial_time,takeoff_time, eta, fuel;
  728.  
  729.  
  730.  
  731. while(1){
  732.  
  733.  
  734.  
  735. read(fd, str, BUFFER_SIZE);
  736.  
  737. strcpy(all_str, str);
  738.  
  739. token = strtok(str," ");
  740.  
  741. if(strcmp(token,"DEPARTURE")==0){
  742.  
  743. token = strtok(NULL," ");
  744.  
  745. if(verifica_codigo(token)==0){
  746.  
  747. sprintf(aux, "WRONG COMMAND => %s", all_str);
  748.  
  749. write_log_file(aux);
  750.  
  751. strncpy(aux, "", sizeof(aux));
  752.  
  753. continue;
  754.  
  755. }
  756.  
  757. strcpy(flight_code, token);
  758.  
  759.  
  760.  
  761. token = strtok(NULL," ");
  762.  
  763. token = strtok(NULL," ");
  764.  
  765. if(verifica_inteiro(token)==0){
  766.  
  767. sprintf(aux, "WRONG COMMAND => %s", all_str);
  768.  
  769. write_log_file(aux);
  770.  
  771. strncpy(aux, "", sizeof(aux));
  772.  
  773. continue;
  774.  
  775. }
  776.  
  777. initial_time = atoi(token);
  778.  
  779.  
  780.  
  781. token = strtok(NULL," ");
  782.  
  783. token = strtok(NULL," ");
  784.  
  785. if(verifica_inteiro(token)==0){
  786.  
  787. sprintf(aux, "WRONG COMMAND => %s", all_str);
  788.  
  789. write_log_file(aux);
  790.  
  791. strncpy(aux, "", sizeof(aux));
  792.  
  793. continue;
  794.  
  795. }
  796.  
  797. takeoff_time = atoi(token);
  798.  
  799. sprintf(aux, "NEW COMMAND => %s", all_str);
  800.  
  801.  
  802.  
  803. write_log_file(aux);
  804.  
  805. strncpy(aux, "", sizeof(aux));
  806.  
  807.  
  808.  
  809. create_departure(flight_code, initial_time, takeoff_time);
  810.  
  811.  
  812.  
  813. }
  814.  
  815.  
  816.  
  817. else if(strcmp(token,"ARRIVAL")==0){
  818.  
  819. token = strtok(NULL," ");
  820.  
  821. if(verifica_codigo(token)==0){
  822.  
  823. sprintf(aux, "WRONG COMMAND => %s", all_str);
  824.  
  825. write_log_file(aux);
  826.  
  827. strncpy(aux, "", sizeof(aux));
  828.  
  829. continue;
  830.  
  831. }
  832.  
  833. strcpy(flight_code, token);
  834.  
  835.  
  836.  
  837. token = strtok(NULL," ");
  838.  
  839. token = strtok(NULL," ");
  840.  
  841. if(verifica_inteiro(token)==0){
  842.  
  843. sprintf(aux, "WRONG COMMAND => %s", all_str);
  844.  
  845. write_log_file(aux);
  846.  
  847. strncpy(aux, "", sizeof(aux));
  848.  
  849. continue;
  850.  
  851. }
  852.  
  853. initial_time = atoi(token);
  854.  
  855.  
  856.  
  857. token = strtok(NULL," ");
  858.  
  859. token = strtok(NULL," ");
  860.  
  861. if(verifica_inteiro(token)==0){
  862.  
  863. sprintf(aux, "WRONG COMMAND => %s", all_str);
  864.  
  865. write_log_file(aux);
  866.  
  867. strncpy(aux, "", sizeof(aux));
  868.  
  869. continue;
  870.  
  871. }
  872.  
  873. eta = atoi(token);
  874.  
  875.  
  876.  
  877. token = strtok(NULL," ");
  878.  
  879. token = strtok(NULL," ");
  880.  
  881. if(verifica_inteiro(token)==0){
  882.  
  883. sprintf(aux, "WRONG COMMAND => %s", all_str);
  884.  
  885. write_log_file(aux);
  886.  
  887. strncpy(aux, "", sizeof(aux));
  888.  
  889. continue;
  890.  
  891. }
  892.  
  893. fuel = atoi(token); //FUEL <eta nao da wrong command
  894.  
  895. if(fuel<eta){
  896.  
  897. sprintf(aux, "WRONG COMMAND => %s", all_str);
  898.  
  899. write_log_file(aux);
  900.  
  901. strncpy(aux, "", sizeof(aux));
  902.  
  903. continue;
  904.  
  905. }
  906.  
  907.  
  908.  
  909. sprintf(aux, "NEW COMMAND => %s", all_str);
  910.  
  911. write_log_file(aux);
  912.  
  913. strncpy(aux, "", sizeof(aux));
  914.  
  915.  
  916.  
  917. create_arrival(flight_code, initial_time, eta,fuel);
  918.  
  919.  
  920.  
  921. printf("Flitght Code: %s \n", flight_code);
  922.  
  923. printf("Initial Time: %d\n", initial_time);
  924.  
  925. printf("Time to runway: %d\n", eta);
  926.  
  927. printf("Initial Fuel: %d\n", fuel);
  928.  
  929. }
  930.  
  931.  
  932.  
  933. else{
  934.  
  935. sprintf(aux, "WRONG COMMAND => %s", all_str);
  936.  
  937. write_log_file(aux);
  938.  
  939. strncpy(aux, "", sizeof(aux));
  940.  
  941. }
  942.  
  943. }
  944.  
  945. }
  946.  
  947.  
  948.  
  949. int verifica_codigo(char *token1){
  950.  
  951. char token[50];
  952.  
  953. strcpy(token, token1);
  954.  
  955.  
  956.  
  957. if(token[0]=='T' && token[1]=='P'){
  958.  
  959. for(int i=2; i<strlen(token);i++){
  960.  
  961. if(!(isdigit(token[i])==0))
  962.  
  963. return 1;
  964.  
  965. }
  966.  
  967. }
  968.  
  969. return 0;
  970.  
  971. }
  972.  
  973.  
  974.  
  975. int verifica_inteiro(char* token1){
  976.  
  977. char token[50];
  978.  
  979. strcpy(token, token1);
  980.  
  981.  
  982.  
  983. for(int i=0; i<strlen(token);i++){
  984.  
  985. if(isdigit(token[i])==0)
  986.  
  987. return 0;
  988.  
  989. }
  990.  
  991. return 1;
  992.  
  993. }
  994.  
  995.  
  996.  
  997. void init(){
  998.  
  999. init_shm_semafores();
  1000.  
  1001. init_log_file();
  1002.  
  1003. read_config();
  1004.  
  1005. init_shm_stats();
  1006.  
  1007. init_shm_mem();
  1008.  
  1009. create_pipe();
  1010.  
  1011. create_queue();
  1012.  
  1013. init_queues();
  1014.  
  1015.  
  1016.  
  1017. write_log_file("PROGRAM STARTED.");
  1018.  
  1019. fflush(stdout);
  1020.  
  1021. }
  1022.  
  1023.  
  1024.  
  1025. void stats_shm_shutdown(){
  1026.  
  1027. if (shmdt(stats)==-1){ // detaching da memoria partilhada
  1028.  
  1029. perror("Error at detaching");
  1030.  
  1031. }
  1032.  
  1033. if (shmctl(stats_shmid, IPC_RMID, NULL)==-1) { //limpar memoria partilhada
  1034.  
  1035. perror("Error unmapping shared memory\n");
  1036.  
  1037. }
  1038.  
  1039. write_log_file("Shared memory for statistics cleaned");
  1040.  
  1041. }
  1042.  
  1043.  
  1044.  
  1045. void mq_shutdown(){
  1046.  
  1047. if(msgctl(mq_id, IPC_RMID, NULL)==-1) {
  1048.  
  1049. perror("Error destroying message queue\n");
  1050.  
  1051. }
  1052.  
  1053. write_log_file("Message queue for departure cleaned");
  1054.  
  1055. }
  1056.  
  1057.  
  1058.  
  1059.  
  1060.  
  1061. void mem_shm_shutdown(){
  1062.  
  1063. if (shmdt(mem)==-1){ // detaching da memoria partilhada
  1064.  
  1065. perror("Error at detaching");
  1066.  
  1067. }
  1068.  
  1069. if (shmctl(mem_shmid, IPC_RMID, NULL)==-1) { //limpar memoria partilhada
  1070.  
  1071. perror("Error unmapping shared memory\n");
  1072.  
  1073. }
  1074.  
  1075. write_log_file("Shared memory for mem cleaned");
  1076.  
  1077. }
  1078.  
  1079.  
  1080.  
  1081. void mutexes_shutdown(){
  1082.  
  1083. sem_destroy(&semafores->write_log);
  1084.  
  1085. sem_destroy(&semafores->insert_queue);
  1086.  
  1087. sem_destroy(&semafores->remove_queue);
  1088.  
  1089. sem_destroy(&semafores->mem);
  1090.  
  1091.  
  1092.  
  1093. write_log_file("Semafores cleaned");
  1094.  
  1095. }
  1096.  
  1097.  
  1098.  
  1099. void show_stats(){
  1100.  
  1101. //Escrever estatisticas - sigusr1
  1102.  
  1103. printf("\n\n-----|| ESTATISTICAS ||-----\n");
  1104.  
  1105. printf("Numero total de voos criados - %d\n", stats->n_voos_criados);
  1106.  
  1107. printf("Numero total de voos que aterraram - %d\n", stats->n_voos_aterrados);
  1108.  
  1109. printf("Tempo medio de espera para aterrar - %f\n", stats->t_aterrar);
  1110.  
  1111. printf("Numero total de voos que descolaram - %d\n", stats->n_voos_descolados);
  1112.  
  1113. printf("Tempo medio de espera para descolar - %f\n", stats->t_descolados);
  1114.  
  1115. printf("Numero medio de manobras de holding por voo de aterragem - %f\n", stats->n_holding_aterragem);
  1116.  
  1117. printf("Numero medio de manobras de holding por voo em estado de urgencia - %f\n", stats->n_holding_urgencia);
  1118.  
  1119. printf("Numero de voos redirecionados para outro aeroporto - %d\n", stats->n_voos_redirecionados);
  1120.  
  1121. printf("Voos rejeitados pela Torre de Controlo - %d\n", stats->voos_rejeitados);
  1122.  
  1123. }
  1124.  
  1125.  
  1126.  
  1127. void shutdown(int sig){
  1128.  
  1129. stats_shm_shutdown();
  1130.  
  1131. mem_shm_shutdown();
  1132.  
  1133. mq_shutdown();
  1134.  
  1135. close_named_pipe();
  1136.  
  1137.  
  1138.  
  1139. free(running_config);
  1140.  
  1141. fclose(flog);
  1142.  
  1143.  
  1144.  
  1145. mutexes_shutdown();
  1146.  
  1147. write_log_file("PROGRAM ENDED.");
  1148.  
  1149.  
  1150.  
  1151. printf("\n\n");
  1152.  
  1153. exit(0);
  1154.  
  1155. }
  1156.  
  1157.  
  1158.  
  1159. void write_log_file(char* str){
  1160.  
  1161. printf("%s%s",timelog(), str);
  1162.  
  1163. fflush(stdout);
  1164.  
  1165.  
  1166.  
  1167. sem_wait(&semafores->write_log);
  1168.  
  1169. fprintf(flog,"%s%s",timelog(), str);
  1170.  
  1171. fflush(flog);
  1172.  
  1173. sem_post(&semafores->write_log);
  1174.  
  1175. }
  1176.  
  1177.  
  1178.  
  1179. Departures_ord insert_departure_ord(message_struct_d departure){
  1180.  
  1181. Departures_ord novo;
  1182.  
  1183. novo = (Departures_ord) malloc(sizeof(node_struct_departure_ord));
  1184.  
  1185. novo->departure = malloc(sizeof(message_struct_d));
  1186.  
  1187.  
  1188.  
  1189. novo->departure->takeoff_time = departure.takeoff_time;
  1190.  
  1191.  
  1192.  
  1193. Departures_ord ant, act;
  1194.  
  1195.  
  1196.  
  1197. if(d_ord == NULL){
  1198.  
  1199. d_ord = novo;
  1200.  
  1201. novo->next = NULL;
  1202.  
  1203. return d_ord;
  1204.  
  1205. }
  1206.  
  1207.  
  1208.  
  1209. act = d_ord->next;
  1210.  
  1211. ant = d_ord;
  1212.  
  1213.  
  1214.  
  1215. while((act->next!=NULL) && (act->departure->takeoff_time)<=(novo->departure->takeoff_time)){
  1216.  
  1217. ant = ant->next;
  1218.  
  1219. act = act->next;
  1220.  
  1221. }
  1222.  
  1223.  
  1224.  
  1225. novo->next = act;
  1226.  
  1227. ant->next = novo;
  1228.  
  1229. return d_ord;
  1230.  
  1231. }
  1232.  
  1233.  
  1234.  
  1235. Arrivals_ord insert_arrival_ord(message_struct_a *arrival){
  1236.  
  1237. Arrivals_ord novo;
  1238.  
  1239. novo = (Arrivals_ord) malloc(sizeof(node_struct_arrival_ord));
  1240.  
  1241. novo->arrival = malloc(sizeof(message_struct_a));
  1242.  
  1243.  
  1244.  
  1245. novo->arrival = arrival;
  1246.  
  1247. Arrivals_ord ant, act;
  1248.  
  1249.  
  1250.  
  1251. if(a_ord == NULL){
  1252.  
  1253. a_ord = novo;
  1254.  
  1255. novo->next = NULL;
  1256.  
  1257. return a_ord;
  1258.  
  1259. }
  1260.  
  1261.  
  1262.  
  1263. while((act->next!=NULL) && (act->arrival->time_runway)<=(novo->arrival->time_runway)){
  1264.  
  1265. ant = ant->next;
  1266.  
  1267. act = act->next;
  1268.  
  1269. }
  1270.  
  1271.  
  1272.  
  1273. novo->next = act;
  1274.  
  1275. ant->next = novo;
  1276.  
  1277.  
  1278.  
  1279. return a_ord;
  1280.  
  1281. }
  1282.  
  1283.  
  1284.  
  1285. void *waiting_message_d(){
  1286.  
  1287. message_struct_d message_d;
  1288.  
  1289.  
  1290.  
  1291. while(1){
  1292.  
  1293. if(msgrcv(mq_id, &message_d, sizeof(message_struct_d)-sizeof(long), 3, 0) >0){
  1294.  
  1295.  
  1296.  
  1297. printf("ahahhhhhhhh %d\n",message_d.takeoff_time);
  1298.  
  1299. d_ord = insert_departure_ord(message_d);
  1300.  
  1301. }
  1302.  
  1303. }
  1304.  
  1305. }
  1306.  
  1307.  
  1308.  
  1309. void *waiting_message_a(){
  1310.  
  1311. message_a = (message_struct_a*) malloc(sizeof(message_struct_a));
  1312.  
  1313. while(1){
  1314.  
  1315. msgrcv(mq_id, &message_a, sizeof(message_a), -1, IPC_NOWAIT);
  1316.  
  1317. a_ord = insert_arrival_ord(message_a);
  1318.  
  1319. }
  1320.  
  1321. }
  1322.  
  1323.  
  1324.  
  1325. void torre_de_controlo(){
  1326.  
  1327. char res[100];
  1328.  
  1329. sprintf(res,"[%d] Torre de controlo ativa.",getpid());
  1330.  
  1331. write_log_file(res);
  1332.  
  1333.  
  1334.  
  1335. pthread_create(&thread_receive_d,NULL,waiting_message_d,NULL);
  1336.  
  1337. pthread_create(&thread_receive_a,NULL,waiting_message_a,NULL);
  1338.  
  1339. pthread_join(thread_receive_d,NULL);
  1340.  
  1341. pthread_join(thread_receive_a,NULL);
  1342.  
  1343.  
  1344.  
  1345. /*if(sizeof(mem->threads_departures)>running_config ->D){
  1346.  
  1347. sem_wait(&semafores->stats);
  1348.  
  1349. stats->voos_rejeitados++;
  1350.  
  1351. sem_post(&semafores->stats);
  1352.  
  1353. //terminar thread
  1354.  
  1355. write_log_file("Voo rejeitado. Numero maximo atingido.");
  1356.  
  1357. }*/
  1358.  
  1359. }
  1360.  
  1361.  
  1362.  
  1363. int main(){
  1364.  
  1365. signal(SIGINT, shutdown);
  1366.  
  1367. signal(SIGUSR1, show_stats);
  1368.  
  1369. init();
  1370.  
  1371.  
  1372.  
  1373. pid_t id = fork();
  1374.  
  1375. if(id == 0){
  1376.  
  1377. torre_de_controlo();
  1378.  
  1379. exit(0);
  1380.  
  1381. }
  1382.  
  1383. else if(id == -1){
  1384.  
  1385. write_log_file("Erro na criacao da torre de controlo.");
  1386.  
  1387. exit(0);
  1388.  
  1389. }
  1390.  
  1391. else{
  1392.  
  1393. pthread_create(&thread_time,NULL,time_counter,&id);
  1394.  
  1395. le_pipe();
  1396.  
  1397. exit(0);
  1398.  
  1399. }
  1400.  
  1401.  
  1402.  
  1403. return 0;
  1404.  
  1405. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!