CMSC216 Final Exam Review Exercise

 1: // star_search_commented.c: more information commenting on the
 2: // progression of the computation.
 3: 
 4: #include "star.h"
 5: 
 6: int main(int argc, char *argv[]){
 7:   if(argc < 3){
 8:     printf("usage: %s <star_class> <filename>\n",argv[0]);
 9:     return 1;
10:   }
11: 
12:   char *star_class = argv[1];
13:   char *star_file = argv[2];
14:   
15:   // find size of the data
16:   //
17:   // Use a child process that exec() the "stat" command line utility
18:   // get the size of the data file in bytes; uses I/O redirection to
19:   // channel output into a file which will be parsed by the parent
20:   // process.
21:   int pid = fork();
22: 
23:   if(pid == 0){                                     // CHILD CODE ONLY
24:     int outfd = open("statout.txt", O_WRONLY|O_TRUNC|O_CREAT, S_IRUSR|S_IWUSR);
25:     if(outfd == -1){
26:       perror("open() failed");
27:       exit(1);
28:     }
29:     int ret = dup2(outfd, STDOUT_FILENO);           // redirect output into the file
30:     if(ret == -1){
31:       perror("dup2() failed");
32:       exit(1);
33:     }
34:     char *argv[] = {"stat", star_file, NULL};       // exec the stat command
35:     execvp(argv[0], argv);                          // child will exit here or
36:     perror("exec() failed");                        // on a fail, bail out
37:     exit(EXIT_FAILURE);
38:   }
39: 
40:   int status;                                       // PARENT CODE ONLY
41:   int ret = waitpid(pid, &status, 0);               // wait until child is finished
42:   if( !WIFEXITED(status) || WEXITSTATUS(status)!=0 ){
43:     printf("Couldn't get the size of %s\n",star_file);
44:     return EXIT_FAILURE;
45:   }
46:   
47:   // get size
48:   //
49:   // extract the size in bytes of star_file from the text output of
50:   // stat; it's on the 2nd line after the word "Size:"
51:   FILE *statfile = fopen("statout.txt","r");        // open the output file the child created
52:   char buf[128], *res;
53:   res = fgets(buf, 128, statfile);                  // skip the first line
54:   res = fgets(buf, 128, statfile);                  // get the next line which will be "    Size: <bytes> ..."
55:   if(res == NULL){
56:     printf("I/O Failed\n");
57:     fclose(statfile);
58:     return EXIT_FAILURE;
59:   }
60:   int size;
61:   sscanf(buf, " Size: %d", &size);                  // get the size data from this line
62:   fclose(statfile);                                 // done with file
63:   printf("%d bytes in file %s\n",size,star_file);   // report bytes for ease of debugging
64: 
65:   // get stars
66:   //
67:   // open and process the main stars file until the end of the file;
68:   // use the size in bytes obtained above to terminate the input loop
69:   int starfd = open(star_file, O_RDONLY);           // open original file which contains the star data
70:   if(starfd == -1){
71:     perror("open() on starfile failed");
72:     return EXIT_FAILURE;
73:   }
74:   int total_bytes = 0;                              // total bytes procesed from the file
75:   int hits = 0;                                     // number of planets matching the star_type requested
76:   star_t cur_star;                                  // current star read from file
77:   while(total_bytes < size){
78:     int nbytes = read(starfd, &cur_star, sizeof(star_t));
79:     if( strcmp(cur_star.star_class, star_class)==0 ){ // check for a matching star_type
80:       printf("| %20s | %8s | %12.4f |\n",
81:              cur_star.name, cur_star.star_class, cur_star.dist);
82:       hits++;
83:     }
84:     total_bytes += nbytes;                          // tack on the total bytes as progress is made
85:   }
86:   close(starfd);
87:   printf("%d stars matched\n",hits);
88:   return 0;
89: }

 1: // star_search_stat.c: demonstrate use of the stat() system call to
 2: // easily get the size of the input file.
 3: 
 4: #include "star.h"
 5: 
 6: int main(int argc, char *argv[]){
 7:   if(argc < 3){
 8:     printf("usage: %s <star_class> <filename>\n",argv[0]);
 9:     return 1;
10:   }
11: 
12:   char *star_class = argv[1];
13:   char *star_file = argv[2];
14:   
15:   // find size of the data
16:   //
17:   // Use a call to stat() to get the size of the star_file in bytes
18:   struct stat statbuf;
19:   int ret = stat(star_file, &statbuf);
20:   if(ret == -1){
21:     perror("stat() failed");
22:     return EXIT_FAILURE;
23:   }
24:   int size = statbuf.st_size;
25:   printf("%d bytes in file %s\n",size,star_file);   // report bytes for ease of debugging
26: 
27:   // get stars
28:   //
29:   // open and process the main stars file until the end of the file;
30:   // use the size in bytes obtained above to terminate the input loop
31:   int starfd = open(star_file, O_RDONLY);           // open original file which contains the star data
32:   if(starfd == -1){
33:     perror("open() on starfile failed");
34:     return EXIT_FAILURE;
35:   }
36:   int total_bytes = 0;                              // total bytes procesed from the file
37:   int hits = 0;                                     // number of planets matching the star_type requested
38:   star_t cur_star;                                  // current star read from file
39:   while(total_bytes < size){
40:     int nbytes = read(starfd, &cur_star, sizeof(star_t));
41:     if( strcmp(cur_star.star_class, star_class)==0 ){ // check for a matching star_type
42:       printf("| %20s | %8s | %12.4f |\n",
43:              cur_star.name, cur_star.star_class, cur_star.dist);
44:       hits++;
45:     }
46:     total_bytes += nbytes;                          // tack on the total bytes as progress is made
47:   }
48:   close(starfd);
49:   printf("%d stars matched\n",hits);
50:   return 0;
51: }

 1: // star_search_read0.c: demonstrate use of return value from read() to
 2: // simplify the input loop.
 3: 
 4: #include "star.h"
 5: 
 6: int main(int argc, char *argv[]){
 7:   if(argc < 3){
 8:     printf("usage: %s <star_class> <filename>\n",argv[0]);
 9:     return 1;
10:   }
11: 
12:   char *star_class = argv[1];
13:   char *star_file = argv[2];
14:   
15:   // get stars
16:   //
17:   // open and process the main stars file until the end of the file;
18:   // use the size in bytes obtained above to terminate the input loop
19:   //
20:   // use the return value from read() to terminate the loop
21:   int starfd = open(star_file, O_RDONLY);           // open original file which contains the star data
22:   if(starfd == -1){
23:     perror("open() on starfile failed");
24:     return EXIT_FAILURE;
25:   }
26:   int hits = 0;                                     // number of planets matching the star_type requested
27:   star_t cur_star;                                  // current star read from file
28:   while(1){
29:     int nbytes = read(starfd, &cur_star, sizeof(star_t));
30:     if(nbytes == 0){
31:       break;
32:     }
33:     if( strcmp(cur_star.star_class, star_class)==0 ){ // check for a matching star_type
34:       printf("| %20s | %8s | %12.4f |\n",
35:              cur_star.name, cur_star.star_class, cur_star.dist);
36:       hits++;
37:     }
38:   }
39:   close(starfd);
40:   printf("%d stars matched\n",hits);
41:   return 0;
42: }

 1: // star_search_mmap.c: demonstrate use of the mmap() to memory map the
 2: // data file and access it scontents.
 3: 
 4: #include "star.h"
 5: 
 6: int main(int argc, char *argv[]){
 7:   if(argc < 3){
 8:     printf("usage: %s <star_class> <filename>\n",argv[0]);
 9:     return 1;
10:   }
11: 
12:   char *star_class = argv[1];
13:   char *star_file = argv[2];
14:   
15:   int starfd = open(star_file, O_RDONLY);           // open file which contains the star data
16:   struct stat statbuf;
17:   int ret = fstat(starfd, &statbuf);                // use fstat() to get info on an already-open fd
18:   if(ret == -1){
19:     perror("fstat() failed");
20:     return EXIT_FAILURE;
21:   }
22:   int size = statbuf.st_size;
23:   star_t *stars = mmap(NULL,                        // OS assigns virtual address
24:                        size,                        // map whole file
25:                        PROT_READ, MAP_SHARED,       // only reading file contents, could change perms later
26:                        starfd, 0);                  // map the open file starting at offset 0
27: 
28:   int nstars = size / sizeof(star_t);               // calculate number of star_t structs in the file
29:   int hits = 0;                                     // number of planets matching the star_type requested
30:   for(int i=0; i<nstars; i++){
31:     if( strcmp(stars[i].star_class, star_class)==0 ){ // check for a matching star_type
32:       printf("| %20s | %8s | %12.4f |\n",
33:              stars[i].name, stars[i].star_class, stars[i].dist);
34:       hits++;
35:     }
36:   }
37: 
38:   munmap(stars, size);
39:   close(starfd);
40:   printf("%d stars matched\n",hits);
41:   return 0;
42: }