Changeset 7d94bfe3

Timestamp:

Jul 20, 2020, 3:52:38 PM (3 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

ADT, arm-eh, enum, forall-pointer-decay, jacob/cs343-translation, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

124c1b7, 92850ef

Parents:

ffa48a8 (diff), 3f1d9b5 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Location:

benchmark/io/http

Files:

• filecache.cfa (modified) (5 diffs)
• main.cfa (modified) (8 diffs)
• options.cfa (added)
• options.hfa (modified) (1 diff)
• parseargs.cfa (modified) (6 diffs)
• protocol.cfa (modified) (2 diffs)
• protocol.hfa (modified) (1 diff)
• worker.cfa (modified) (6 diffs)

benchmark/io/http/filecache.cfa

@@ -82 +82 @@
 
 [int fd, size_t size] get_file( * const char file, size_t len ) {
-        uint32_t idx = murmur3_32( (const uint8_t *)file, len, options.hash_seed ) % file_cache.size;
+        uint32_t idx = murmur3_32( (const uint8_t *)file, len, options.file_cache.hash_seed ) % file_cache.size;
 
         for(int i = 0;; i++) {
@@ -99 +99 @@
 
 int put_file( cache_line & entry ) {
-        uint32_t idx = murmur3_32( (const uint8_t *)entry.file, strlen(entry.file), options.hash_seed ) % file_cache.size;
+        uint32_t idx = murmur3_32( (const uint8_t *)entry.file, strlen(entry.file), options.file_cache.hash_seed ) % file_cache.size;
 
         int i = 0;
@@ -136 +136 @@
                 raw[idx].file = strdup(fpath+2);
                 raw[idx].size = sb->st_size;
-                if( !options.file_cache_list ) {
-                        raw[idx].fd = open( fpath, options.open_flags );
+                if( !options.file_cache.list ) {
+                        raw[idx].fd = open( fpath, options.file_cache.open_flags );
                         if(raw[idx].fd < 0) {
                                 abort( "open file error: (%d) %s\n", (int)errno, strerror(errno) );
@@ -154 +154 @@
         }
 
-        if(options.file_cache_list) {
+        // Step 2 create the cache
+        file_cache.size = options.file_cache.size > 0 ? options.file_cache.size : fsize;
+        if( file_cache.size < fcount ) {
+                abort("File Cache too small\n");
+        }
+
+        file_cache.entries = anew(file_cache.size);
+
+        // Step 3 fill the cache
+        int conflicts = 0;
+        for(i; fcount) {
+                conflicts += put_file( raw[i] );
+        }
+        printf("Filled cache from path \"%s\" with %zu files\n", path, fcount);
+        if( conflicts > 0 ) {
+                printf("Found %d conflicts (seed: %u)\n", conflicts, options.file_cache.hash_seed);
+                #if defined(REJECT_CONFLICTS)
+                        abort("Conflicts found in the cache");
+                #endif
+        }
+
+        if(options.file_cache.list) {
                 printf("Listing files and exiting\n");
                 for(i; fcount) {
@@ -163 +184 @@
                 }
                 free(raw);
+                adelete(file_cache.size, file_cache.entries);
                 exit(0);
-        }
-
-        // Step 2 create the cache
-        file_cache.size = options.file_cache_size > 0 ? options.file_cache_size : fsize;
-        if( file_cache.size < fcount ) {
-                abort("File Cache too small\n");
-        }
-
-        file_cache.entries = anew(fsize);
-
-        // Step 3 fill the cache
-        int conflicts = 0;
-        for(i; fcount) {
-                printf("Added file %s\n", raw[i].file);
-                conflicts += put_file( raw[i] );
-        }
-        printf("Filled cache from path \"%s\" with %zu files\n", path, fcount);
-        if( conflicts > 0 ) {
-                printf("Found %d conflicts (seed: %u)\n", conflicts, options.hash_seed);
-                #if defined(REJECT_CONFLICTS)
-                        abort("Conflicts found in the cache");
-                #endif
         }
 

benchmark/io/http/main.cfa

@@ -17 +17 @@
 #include "filecache.hfa"
 #include "options.hfa"
-#include "parseargs.hfa"
 #include "worker.hfa"
 
@@ -23 +22 @@
 // Globals
 //=============================================================================================
-Options options @= {
-        0,     //   open_flags;
-        42u,   //       hash_seed;
-        0,     //   file_cache_size;
-        false, //       file_cache_list;
-        false, //       procstats;
-        false, //       viewhalts;
-        0      //       the_cluster;
-};
-
 channel & wait_connect;
 
@@ -40 +29 @@
 
 void ?{}( ServerProc & this ) {
-        /* paranoid */ assert( options.the_cluster != 0p );
-        (this.self){ "Benchmark Processor", *options.the_cluster };
+        /* paranoid */ assert( options.clopts.instance != 0p );
+        (this.self){ "Benchmark Processor", *options.clopts.instance };
 
         #if !defined(__CFA_NO_STATISTICS__)
-                if( options.procstats ) {
-                        print_stats_at_exit( this.self, options.the_cluster->print_stats );
+                if( options.clopts.procstats ) {
+                        print_stats_at_exit( this.self, options.clopts.instance->print_stats );
                 }
-                if( options.viewhalts ) {
+                if( options.clopts.viewhalts ) {
                         print_halts( this.self );
                 }
@@ -57 +46 @@
 //============================================================================================='
 int main( int argc, char * argv[] ) {
-        int port      = 8080;
-        int backlog   = 10;
-        int nprocs    = 1;
-        int nworkers  = 1;
-        int cl_flags  = 0;
-        int chan_size = 10;
-        const char * path = ".";
         //===================
         // Parse args
-        static cfa_option opt[] = {
-                {'p', "port", "Port the server will listen on", port},
-                {'c', "cpus", "Number of processors to use", nprocs},
-                {'t', "threads", "Number of worker threads to use", nworkers},
-                {'b', "accept-backlog", "Maximum number of pending accepts", backlog},
-                {'B', "channel-size", "Maximum number of accepted connection pending", chan_size},
-                {'S', "seed", "seed to use for hashing", options.hash_seed },
-                {'C', "cache-size", "Size of the cache to use, if set to small, will uses closes power of 2", options.file_cache_size },
-                {'l', "list-files", "List the files in the specified path and exit", options.file_cache_list, parse_settrue }
-
-        };
-        int opt_cnt = sizeof(opt) / sizeof(cfa_option);
-
-        char **left;
-      parse_args( argc, argv, opt, opt_cnt, "[OPTIONS]... [PATH]\ncforall http server", left );
-        if( left[0] != 0p ) {
-                path = left[0];
-                left++;
-        }
-        if( left[0] != 0p ) {
-                abort("Too many trailing arguments!\n");
-        }
-
+        const char * path = parse_options(argc, argv);
 
         //===================
@@ -97 +57 @@
         //===================
         // Open Socket
-        printf("Listening on port %d\n", port);
+        printf("Listening on port %d\n", options.socket.port);
         int server_fd = socket(AF_INET, SOCK_STREAM, 0);
         if(server_fd < 0) {
@@ -109 +69 @@
         address.sin_family = AF_INET;
         address.sin_addr.s_addr = htonl(INADDR_ANY);
-        address.sin_port = htons( port );
+        address.sin_port = htons( options.socket.port );
 
         ret = bind( server_fd, (struct sockaddr *)&address, sizeof(address) );
@@ -116 +76 @@
         }
 
-        ret = listen( server_fd, backlog );
+        ret = listen( server_fd, options.socket.backlog );
         if(ret < 0) {
                 abort( "listen error: (%d) %s\n", (int)errno, strerror(errno) );
@@ -124 +84 @@
         // Run Server Cluster
         {
-                cluster cl = { "Server Cluster", cl_flags };
+                cluster cl = { "Server Cluster", options.clopts.flags };
                 #if !defined(__CFA_NO_STATISTICS__)
                         print_stats_at_exit( cl, CFA_STATS_READY_Q | CFA_STATS_IO );
                 #endif
-                options.the_cluster = &cl;
+                options.clopts.instance = &cl;
 
-                channel chan = { chan_size };
+                channel chan = { options.clopts.chan_size };
                 &wait_connect = &chan;
 
                 {
-                        ServerProc procs[nprocs];
+                        ServerProc procs[options.clopts.nprocs];
                         {
-                                Worker workers[nworkers];
-                                printf("%d workers started on %d processors\n", nworkers, nprocs);
+                                Worker workers[options.clopts.nworkers];
+                                printf("%d workers started on %d processors\n", options.clopts.nworkers, options.clopts.nprocs);
                                 {
                                         Acceptor acceptor = { server_fd, (struct sockaddr *)&address, (socklen_t*)&addrlen, 0 };
+
+                                        char buffer[128];
+                                        while(!feof(stdin)) {
+                                                fgets(buffer, 128, stdin);
+                                        }
+
+                                        printf("Shutting Down\n");
                                 }
-                                printf("Shutting Down\n");
+                                printf("Acceptor Closed\n");
 
                                 // Clean-up the workers
-                                for(nworkers) {
+                                for(options.clopts.nworkers) {
                                         put( wait_connect, -1 );
                                 }
                         }
+                        printf("Workers Closed\n");
                 }
         }

benchmark/io/http/options.hfa

@@ -6 +6 @@
 
 struct Options {
-        int open_flags;
-        uint32_t hash_seed;
-        size_t file_cache_size;
-        bool file_cache_list;
-        bool procstats;
-        bool viewhalts;
-        cluster * the_cluster;
+        struct {
+                int open_flags;
+                uint32_t hash_seed;
+                size_t size;
+                bool list;
+                bool fixed_fds;
+        } file_cache;
+
+        struct {
+                int port;
+                int backlog;
+                int buflen;
+        } socket;
+
+        struct {
+                int nprocs;
+                int nworkers;
+                int flags;
+                int chan_size;
+                bool procstats;
+                bool viewhalts;
+                cluster * instance;
+        } clopts;
 };
 
 extern Options options;
+
+const char * parse_options( int argc, char * argv[] );

benchmark/io/http/parseargs.cfa

@@ -3 +3 @@
 // #include <stdio.h>
 // #include <stdlib.h>
+#include <errno.h>
 #include <string.h>
+#include <unistd.h>
 extern "C" {
         #include <getopt.h>
+        #include <sys/ioctl.h>
 
         struct FILE;
@@ -11 +14 @@
         extern FILE * stdout;
 
+        extern int fileno(FILE *stream);
+
         extern int fprintf ( FILE * stream, const char * format, ... );
 
         extern          long long int strtoll (const char* str, char** endptr, int base);
         extern unsigned long long int strtoull(const char* str, char** endptr, int base);
+}
+
+#include <common.hfa>
+#include <limits.hfa>
+
+void printopt(FILE * out, int width, int max, char sn, const char * ln, const char * help) {
+        int hwidth = max - (11 + width);
+        if(hwidth <= 0) hwidth = max;
+
+        fprintf(out, "  -%c, --%-*s   %.*s\n", sn, width, ln, hwidth, help);
+        for() {
+                help += min(strlen(help), hwidth);
+                if('\0' == *help) break;
+                fprintf(out, "%*s%.*s\n", width + 11, "", hwidth, help);
+        }
 }
 
@@ -27 +47 @@
         struct option optarr[opt_count + 2];
         int width = 0;
+        int max_width = 1_000_000;
         {
                 int idx = 0;
@@ -95 +116 @@
         }
 
-        USAGE:
+        USAGE:;
+        int outfd = fileno(out);
+        if(isatty(outfd)) {
+                struct winsize size;
+                int ret = ioctl(outfd, TIOCGWINSZ, &size);
+                if(ret < 0) abort( "ioctl error: (%d) %s\n", (int)errno, strerror(errno) );
+                max_width = size.ws_col;
+        }
+
         fprintf(out, "Usage:\n  %s %s\n", argv[0], usage);
 
         for(i; opt_count) {
-                fprintf(out, "  -%c, --%-*s   %s\n", options[i].short_name, width, options[i].long_name, options[i].help);
+                printopt(out, width, max_width, options[i].short_name, options[i].long_name, options[i].help);
         }
         fprintf(out, "  -%c, --%-*s   %s\n", 'h', width, "help", "print this help message");
@@ -138 +167 @@
         unsigned long long int r = strtoull(arg, &end, 10);
         if(*end != '\0') return false;
-#warning not checking max
+        if(r > (unsigned)MAX) return false;
 
         value = r;
@@ -148 +177 @@
         unsigned long long int r = strtoull(arg, &end, 10);
         if(*end != '\0') return false;
-#warning not checking max
+        if(r > (size_t)MAX) return false;
 
         value = r;

benchmark/io/http/protocol.cfa

@@ -25 +25 @@
 };
 
-_Static_assert( KNOWN_CODES == (sizeof(http_msgs) / sizeof(http_msgs[0])));
+_Static_assert( KNOWN_CODES == (sizeof(http_msgs ) / sizeof(http_msgs [0])));
+
+const int http_codes[] = {
+        200,
+        400,
+        404,
+        413,
+        414,
+};
+
+_Static_assert( KNOWN_CODES == (sizeof(http_codes) / sizeof(http_codes[0])));
+
+int code_val(HttpCode code) {
+        return http_codes[code];
+}
 
 static inline int answer( int fd, const char * it, int len) {
@@ -61 +75 @@
         for() {
                 int ret = cfa_read(fd, it, count);
+                if(ret == 0 ) return [OK200, true, 0p, 0];
                 if(ret < 0 ) {
-                        if( errno ) return [OK200, true, 0p, 0];
                         if( errno == EAGAIN || errno == EWOULDBLOCK) continue READ;
                         abort( "read error: (%d) %s\n", (int)errno, strerror(errno) );

benchmark/io/http/protocol.hfa

@@ -10 +10 @@
 };
 
+int code_val(HttpCode code);
+
 int answer_error( int fd, HttpCode code );
 int answer_header( int fd, size_t size );

benchmark/io/http/worker.cfa

@@ -26 +26 @@
 //=============================================================================================
 void ?{}( Worker & this ) {
-        ((thread&)this){ "Server Worker Thread", *options.the_cluster };
+        ((thread&)this){ "Server Worker Thread", *options.clopts.instance };
         int ret = pipe(this.pipe);
         if( ret < 0 ) { abort( "pipe error: (%d) %s\n", (int)errno, strerror(errno) ); }
@@ -33 +33 @@
 void main( Worker & this ) {
         CONNECTION:
-        while( int fd = take(wait_connect); fd >= 0) {
-            printf("New connection, waiting for requests\n");
+        for() {
+                int fd = take(wait_connect);
+                if (fd < 0) break;
+
+                printf("New connection %d, waiting for requests\n", fd);
                 REQUEST:
                 for() {
@@ -43 +46 @@
 
                         // Read the http request
-                        size_t len = 1024;
+                        size_t len = options.socket.buflen;
                         char buffer[len];
                         printf("Reading request\n");
@@ -56 +59 @@
                         // If this wasn't a request retrun 400
                         if( code != OK200 ) {
-                                printf("Invalid Request\n");
+                                printf("Invalid Request : %d\n", code_val(code));
                                 answer_error(fd, code);
                                 continue REQUEST;
                         }
 
-                        printf("Request for file %.*s\n", name_size, file);
+                        printf("Request for file %.*s\n", (int)name_size, file);
 
                         // Get the fd from the file cache
@@ -90 +93 @@
 //=============================================================================================
 void ?{}( Acceptor & this, int sockfd, struct sockaddr * addr, socklen_t * addrlen, int flags ) {
-        ((thread&)this){ "Acceptor Thread", *options.the_cluster };
+        ((thread&)this){ "Acceptor Thread", *options.clopts.instance };
         this.sockfd  = sockfd;
         this.addr    = addr;
@@ -105 +108 @@
                 }
 
-            printf("New connection accepted\n");
+                printf("New connection accepted\n");
                 put( wait_connect, ret );
-      }
+        }
 }