Changeset 342af53 for benchmark

Timestamp:

Jan 14, 2021, 12:23:14 PM (4 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

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

Children:

8e4aa05

Parents:

4468a70 (diff), ec19b21 (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

Files:

• creation/node_cor.js (modified) (1 diff)
• ctxswitch/node_cor.js (modified) (1 diff)
• io/http/Makefile.am (modified) (1 diff)
• io/http/main.cfa (modified) (7 diffs)
• io/http/options.cfa (modified) (2 diffs)
• io/http/options.hfa (modified) (1 diff)
• io/http/protocol.cfa (modified) (8 diffs)
• io/http/protocol.hfa (modified) (2 diffs)
• io/http/worker.cfa (modified) (6 diffs)
• io/http/worker.hfa (modified) (1 diff)
• io/readv.cfa (modified) (1 diff)
• vector/glm_vec2.cc (added)
• vector/vec2_notemplates.cfa (added)
• vector/vec2_templates.cfa (added)

benchmark/creation/node_cor.js

@@ -6 +6 @@
 function * coroutine() { yield }
 
-for ( var i = 0; i < times; i += 1 ) { // warm jit
+for ( var i = 0; i < times; i += 1 ) { // warm JIT
         cor = coroutine()
 }

benchmark/ctxswitch/node_cor.js

@@ -11 +11 @@
 cor = coroutine()
 
-for ( var i = 0; i < times; i += 1 ) { // warm git
+for ( var i = 0; i < times; i += 1 ) { // warm JIT
         cor.next();
 }

benchmark/io/http/Makefile.am

@@ -29 +29 @@
 EXTRA_PROGRAMS = httpforall .dummy_hack
 
+CLEANFILES = httpforall
+
 nodist_httpforall_SOURCES = \
         filecache.cfa \

benchmark/io/http/main.cfa

@@ -46 +46 @@
 }
 
+extern void init_protocol(void);
+extern void deinit_protocol(void);
+
 //=============================================================================================
 // Main
@@ -61 +64 @@
         //===================
         // Open Socket
-        printf("Listening on port %d\n", options.socket.port);
+        printf("%ld : Listening on port %d\n", getpid(), options.socket.port);
         int server_fd = socket(AF_INET, SOCK_STREAM, 0);
         if(server_fd < 0) {
@@ -79 +82 @@
                 ret = bind( server_fd, (struct sockaddr *)&address, sizeof(address) );
                 if(ret < 0) {
-                        if(errno == 98) {
+                        if(errno == EADDRINUSE) {
                                 if(waited == 0) {
                                         printf("Waiting for port\n");
@@ -109 +112 @@
                 options.clopts.instance = &cl;
 
+
                 int pipe_cnt = options.clopts.nworkers * 2;
                 int pipe_off;
@@ -124 +128 @@
                 {
                         ServerProc procs[options.clopts.nprocs];
+
+                        init_protocol();
                         {
                                 Worker workers[options.clopts.nworkers];
@@ -151 +157 @@
                                         printf("Shutting Down\n");
                                 }
+
+                                for(i; options.clopts.nworkers) {
+                                        printf("Cancelling %p\n", (void*)workers[i].cancel.target);
+                                        workers[i].done = true;
+                                        cancel(workers[i].cancel);
+                                }
+
+                                printf("Shutting down socket\n");
+                                int ret = shutdown( server_fd, SHUT_RD );
+                                if( ret < 0 ) { abort( "shutdown error: (%d) %s\n", (int)errno, strerror(errno) ); }
+
+                                //===================
+                                // Close Socket
+                                printf("Closing Socket\n");
+                                ret = close( server_fd );
+                                if(ret < 0) {
+                                        abort( "close socket error: (%d) %s\n", (int)errno, strerror(errno) );
+                                }
                         }
                         printf("Workers Closed\n");
+
+                        deinit_protocol();
                 }
 
@@ -162 +188 @@
                 }
                 free(fds);
-        }
 
-        //===================
-        // Close Socket
-        printf("Closing Socket\n");
-        ret = close( server_fd );
-        if(ret < 0) {
-                abort( "close socket error: (%d) %s\n", (int)errno, strerror(errno) );
         }
 

benchmark/io/http/options.cfa

@@ -12 +12 @@
 #include <parseargs.hfa>
 
+#include <string.h>
+
 Options options @= {
+        false, // log
+
         { // file_cache
                 0,     // open_flags;
@@ -48 +52 @@
                 {'p', "port",           "Port the server will listen on", options.socket.port},
                 {'c', "cpus",           "Number of processors to use", options.clopts.nprocs},
+                {'L', "log",            "Enable logs", options.log, parse_settrue},
                 {'t', "threads",        "Number of worker threads to use", options.clopts.nworkers},
                 {'b', "accept-backlog", "Maximum number of pending accepts", options.socket.backlog},

benchmark/io/http/options.hfa

@@ -8 +8 @@
 
 struct Options {
+        bool log;
+
         struct {
                 int open_flags;

benchmark/io/http/protocol.cfa

@@ -18 +18 @@
 #include "options.hfa"
 
+const char * volatile date = 0p;
+
 const char * http_msgs[] = {
-        "HTTP/1.1 200 OK\nContent-Type: text/plain\nContent-Length: %zu\n\n",
-        "HTTP/1.1 400 Bad Request\nContent-Type: text/plain\nContent-Length: 0\n\n",
-        "HTTP/1.1 404 Not Found\nContent-Type: text/plain\nContent-Length: 0\n\n",
-        "HTTP/1.1 413 Payload Too Large\nContent-Type: text/plain\nContent-Length: 0\n\n",
-        "HTTP/1.1 414 URI Too Long\nContent-Type: text/plain\nContent-Length: 0\n\n",
+        "HTTP/1.1 200 OK\nServer: HttoForall\nDate: %s \nContent-Type: text/plain\nContent-Length: %zu \n\n",
+        "HTTP/1.1 400 Bad Request\nServer: HttoForall\nDate: %s \nContent-Type: text/plain\nContent-Length: 0 \n\n",
+        "HTTP/1.1 404 Not Found\nServer: HttoForall\nDate: %s \nContent-Type: text/plain\nContent-Length: 0 \n\n",
+        "HTTP/1.1 413 Payload Too Large\nServer: HttoForall\nDate: %s \nContent-Type: text/plain\nContent-Length: 0 \n\n",
+        "HTTP/1.1 414 URI Too Long\nServer: HttoForall\nDate: %s \nContent-Type: text/plain\nContent-Length: 0 \n\n",
 };
 
@@ -45 +47 @@
         while(len > 0) {
                 // Call write
-                int ret = write(fd, it, len);
+                int ret = cfa_write(fd, it, len, 0, -1`s, 0p, 0p);
+                // int ret = write(fd, it, len);
                 if( ret < 0 ) { if( errno != EAGAIN && errno != EWOULDBLOCK) abort( "'answer error' error: (%d) %s\n", (int)errno, strerror(errno) ); }
 
@@ -63 +66 @@
 int answer_header( int fd, size_t size ) {
         const char * fmt = http_msgs[OK200];
-        int len = 100;
+        int len = 200;
         char buffer[len];
-        len = snprintf(buffer, len, fmt, size);
+        len = snprintf(buffer, len, fmt, date, size);
         return answer( fd, buffer, len );
 }
 
-[HttpCode code, bool closed, * const char file, size_t len] http_read(int fd, []char buffer, size_t len) {
+int answer_plain( int fd, char buffer[], size_t size ) {
+        int ret = answer_header(fd, size);
+        if( ret < 0 ) return ret;
+        return answer(fd, buffer, size);
+}
+
+int answer_empty( int fd ) {
+        return answer_header(fd, 0);
+}
+
+
+[HttpCode code, bool closed, * const char file, size_t len] http_read(int fd, []char buffer, size_t len, io_cancellation * cancel) {
         char * it = buffer;
         size_t count = len - 1;
@@ -75 +89 @@
         READ:
         for() {
-                int ret = cfa_read(fd, (void*)it, count, 0, -1`s, 0p, 0p);
+                int ret = cfa_read(fd, (void*)it, count, 0, -1`s, cancel, 0p);
+                // int ret = read(fd, (void*)it, count);
                 if(ret == 0 ) return [OK200, true, 0, 0];
                 if(ret < 0 ) {
                         if( errno == EAGAIN || errno == EWOULDBLOCK) continue READ;
+                        // if( errno == EINVAL ) return [E400, true, 0, 0];
                         abort( "read error: (%d) %s\n", (int)errno, strerror(errno) );
                 }
@@ -92 +108 @@
         }
 
-        printf("%.*s\n", rlen, buffer);
+        if( options.log ) printf("%.*s\n", rlen, buffer);
 
         it = buffer;
@@ -104 +120 @@
 
 void sendfile( int pipe[2], int fd, int ans_fd, size_t count ) {
+        unsigned sflags = SPLICE_F_MOVE; // | SPLICE_F_MORE;
         off_t offset = 0;
         ssize_t ret;
         SPLICE1: while(count > 0) {
-                ret = cfa_splice(ans_fd, &offset, pipe[1], 0p, count, SPLICE_F_MOVE | SPLICE_F_MORE, 0, -1`s, 0p, 0p);
+                ret = cfa_splice(ans_fd, &offset, pipe[1], 0p, count, sflags, 0, -1`s, 0p, 0p);
+                // ret = splice(ans_fd, &offset, pipe[1], 0p, count, sflags);
                 if( ret < 0 ) {
                         if( errno != EAGAIN && errno != EWOULDBLOCK) continue SPLICE1;
@@ -117 +135 @@
                 size_t in_pipe = ret;
                 SPLICE2: while(in_pipe > 0) {
-                        ret = cfa_splice(pipe[0], 0p, fd, 0p, in_pipe, SPLICE_F_MOVE | SPLICE_F_MORE, 0, -1`s, 0p, 0p);
+                        ret = cfa_splice(pipe[0], 0p, fd, 0p, in_pipe, sflags, 0, -1`s, 0p, 0p);
+                        // ret = splice(pipe[0], 0p, fd, 0p, in_pipe, sflags);
                         if( ret < 0 ) {
                                 if( errno != EAGAIN && errno != EWOULDBLOCK) continue SPLICE2;
@@ -127 +146 @@
         }
 }
+
+//=============================================================================================
+
+#include <clock.hfa>
+#include <time.hfa>
+#include <thread.hfa>
+
+struct date_buffer {
+        char buff[100];
+};
+
+thread DateFormater {
+        int idx;
+        date_buffer buffers[2];
+};
+
+void ?{}( DateFormater & this ) {
+        ((thread&)this){ "Server Date Thread", *options.clopts.instance };
+        this.idx = 0;
+        memset( this.buffers[0].buff, 0, sizeof(this.buffers[0]) );
+        memset( this.buffers[1].buff, 0, sizeof(this.buffers[1]) );
+}
+
+void main(DateFormater & this) {
+        LOOP: for() {
+                waitfor( ^?{} : this) {
+                        break LOOP;
+                }
+                or else {}
+
+                Time now = getTimeNsec();
+
+                strftime( this.buffers[this.idx].buff, 100, "%a, %d %b %Y %H:%M:%S %Z", now );
+
+                char * next = this.buffers[this.idx].buff;
+                __atomic_exchange_n((char * volatile *)&date, next, __ATOMIC_SEQ_CST);
+                this.idx = (this.idx + 1) % 2;
+
+                sleep(1`s);
+        }
+}
+
+//=============================================================================================
+DateFormater * the_date_formatter;
+
+void init_protocol(void) {
+        the_date_formatter = alloc();
+        (*the_date_formatter){};
+}
+
+void deinit_protocol(void) {
+        ^(*the_date_formatter){};
+        free( the_date_formatter );
+}

benchmark/io/http/protocol.hfa

@@ -1 +1 @@
 #pragma once
+
+struct io_cancellation;
 
 enum HttpCode {
@@ -14 +16 @@
 int answer_error( int fd, HttpCode code );
 int answer_header( int fd, size_t size );
+int answer_plain( int fd, char buffer [], size_t size );
+int answer_empty( int fd );
 
-[HttpCode code, bool closed, * const char file, size_t len] http_read(int fd, []char buffer, size_t len);
+[HttpCode code, bool closed, * const char file, size_t len] http_read(int fd, []char buffer, size_t len, io_cancellation *);
 
 void sendfile( int pipe[2], int fd, int ans_fd, size_t count );

benchmark/io/http/worker.cfa

@@ -19 +19 @@
         this.pipe[0] = -1;
         this.pipe[1] = -1;
+        this.done = false;
+}
+
+extern "C" {
+extern int accept4(int sockfd, struct sockaddr *addr, socklen_t *addrlen, int flags);
 }
 
@@ -28 +33 @@
         CONNECTION:
         for() {
-                int fd = cfa_accept4( this.[sockfd, addr, addrlen, flags], 0, -1`s, 0p, 0p );
+                if( options.log ) printf("=== Accepting connection ===\n");
+                int fd = cfa_accept4( this.[sockfd, addr, addrlen, flags], 0, -1`s, &this.cancel, 0p );
+                // int fd = accept4( this.[sockfd, addr, addrlen, flags] );
                 if(fd < 0) {
                         if( errno == ECONNABORTED ) break;
+                        if( errno == EINVAL && this.done ) break;
                         abort( "accept error: (%d) %s\n", (int)errno, strerror(errno) );
                 }
 
-                printf("New connection %d, waiting for requests\n", fd);
+                if( options.log ) printf("=== New connection %d, waiting for requests ===\n", fd);
                 REQUEST:
                 for() {
@@ -45 +53 @@
                         size_t len = options.socket.buflen;
                         char buffer[len];
-                        printf("Reading request\n");
-                        [code, closed, file, name_size] = http_read(fd, buffer, len);
+                        if( options.log ) printf("=== Reading request ===\n");
+                        [code, closed, file, name_size] = http_read(fd, buffer, len, &this.cancel);
 
                         // if we are done, break out of the loop
                         if( closed ) {
-                                printf("Connection closed\n");
+                                if( options.log ) printf("=== Connection closed ===\n");
+                                close(fd);
                                 continue CONNECTION;
                         }
@@ -56 +65 @@
                         // If this wasn't a request retrun 400
                         if( code != OK200 ) {
-                                printf("Invalid Request : %d\n", code_val(code));
+                                printf("=== Invalid Request : %d ===\n", code_val(code));
                                 answer_error(fd, code);
                                 continue REQUEST;
                         }
 
-                        printf("Request for file %.*s\n", (int)name_size, file);
+                        if(0 == strncmp(file, "plaintext", min(name_size, sizeof("plaintext") ))) {
+                                if( options.log ) printf("=== Request for /plaintext ===\n");
+
+                                char text[] = "Hello, World!\n";
+
+                                // Send the header
+                                answer_plain(fd, text, sizeof(text));
+
+                                if( options.log ) printf("=== Answer sent ===\n");
+                                continue REQUEST;
+                        }
+
+                        if(0 == strncmp(file, "ping", min(name_size, sizeof("ping") ))) {
+                                if( options.log ) printf("=== Request for /ping ===\n");
+
+                                // Send the header
+                                answer_empty(fd);
+
+                                if( options.log ) printf("=== Answer sent ===\n");
+                                continue REQUEST;
+                        }
+
+                        if( options.log ) printf("=== Request for file %.*s ===\n", (int)name_size, file);
 
                         // Get the fd from the file cache
@@ -70 +101 @@
                         // If we can't find the file, return 404
                         if( ans_fd < 0 ) {
-                                printf("File Not Found\n");
+                                printf("=== File Not Found ===\n");
                                 answer_error(fd, E404);
                                 continue REQUEST;
@@ -81 +112 @@
                         sendfile( this.pipe, fd, ans_fd, count);
 
-                        printf("File sent\n");
+                        if( options.log ) printf("=== Answer sent ===\n");
                 }
         }

benchmark/io/http/worker.hfa

@@ -17 +17 @@
         socklen_t * addrlen;
         int flags;
+        io_cancellation cancel;
+        volatile bool done;
 };
 void ?{}( Worker & this);

benchmark/io/readv.cfa

@@ -96 +96 @@
 
         char **left;
-        parse_args( opt, opt_cnt, "[OPTIONS]...\ncforall yield benchmark", left );
+        parse_args( opt, opt_cnt, "[OPTIONS]...\ncforall readv benchmark", left );
 
         if(kpollcp || odirect) {
                 if( (buflen % 512) != 0 ) {
                         fprintf(stderr, "Buffer length must be a multiple of 512 when using O_DIRECT, was %lu\n\n", buflen);
-                        print_args_usage(opt, opt_cnt, "[OPTIONS]...\ncforall yield benchmark", true);
+                        print_args_usage(opt, opt_cnt, "[OPTIONS]...\ncforall readv benchmark", true);
                 }
         }