Changeset 8e4aa05 for benchmark/io/http/protocol.cfa

Timestamp:

Mar 4, 2021, 7:40:25 PM (5 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:

77d601f

Parents:

342af53 (diff), a5040fe (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

File:

• benchmark/io/http/protocol.cfa (modified) (14 diffs)

benchmark/io/http/protocol.cfa

@@ -5 +5 @@
         #include <fcntl.h>
 }
+
+#include <fstream.hfa>
 #include <iofwd.hfa>
 
@@ -11 +13 @@
 extern "C" {
       int snprintf ( char * s, size_t n, const char * format, ... );
-        #include <linux/io_uring.h>
+        // #include <linux/io_uring.h>
 }
 #include <string.h>
@@ -18 +20 @@
 #include "options.hfa"
 
-const char * volatile date = 0p;
-
-const char * http_msgs[] = {
-        "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",
-};
+#define PLAINTEXT_1WRITE
+#define PLAINTEXT_NOCOPY
+
+struct https_msg_str {
+        char msg[512];
+        size_t len;
+};
+
+const https_msg_str * volatile http_msgs[KNOWN_CODES] = { 0 };
 
 _Static_assert( KNOWN_CODES == (sizeof(http_msgs ) / sizeof(http_msgs [0])));
 
-const int http_codes[] = {
+const int http_codes[KNOWN_CODES] = {
+        200,
         200,
         400,
         404,
+        405,
+        408,
         413,
         414,
@@ -47 +52 @@
         while(len > 0) {
                 // Call write
-                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) ); }
+                int ret = cfa_send(fd, it, len, 0, CFA_IO_LAZY);
+                if( ret < 0 ) {
+                        if( errno == ECONNRESET || errno == EPIPE ) return -ECONNRESET;
+                        if( errno == EAGAIN || errno == EWOULDBLOCK) return -EAGAIN;
+
+                        abort( "'answer error' error: (%d) %s\n", (int)errno, strerror(errno) );
+                }
 
                 // update it/len
@@ -61 +70 @@
         /* paranoid */ assert( code < KNOWN_CODES && code != OK200 );
         int idx = (int)code;
-        return answer( fd, http_msgs[idx], strlen( http_msgs[idx] ) );
+        return answer( fd, http_msgs[idx]->msg, http_msgs[idx]->len );
 }
 
 int answer_header( int fd, size_t size ) {
-        const char * fmt = http_msgs[OK200];
-        int len = 200;
-        char buffer[len];
-        len = snprintf(buffer, len, fmt, date, size);
+        char buffer[512];
+        char * it = buffer;
+        memcpy(it, http_msgs[OK200]->msg, http_msgs[OK200]->len);
+        it += http_msgs[OK200]->len;
+        int len = http_msgs[OK200]->len;
+        len += snprintf(it, 512 - len, "%d \n\n", size);
         return answer( fd, buffer, len );
 }
 
-int answer_plain( int fd, char buffer[], size_t size ) {
-        int ret = answer_header(fd, size);
+#if defined(PLAINTEXT_NOCOPY)
+int answer_plaintext( int fd ) {
+        return answer(fd, http_msgs[OK200_PlainText]->msg, http_msgs[OK200_PlainText]->len + 1); // +1 cause snprintf doesn't count nullterminator
+}
+#elif defined(PLAINTEXT_1WRITE)
+int answer_plaintext( int fd ) {
+        char text[] = "Hello, World!\n";
+        char buffer[512 + sizeof(text)];
+        char * it = buffer;
+        memcpy(it, http_msgs[OK200]->msg, http_msgs[OK200]->len);
+        it += http_msgs[OK200]->len;
+        int len = http_msgs[OK200]->len;
+        int r = snprintf(it, 512 - len, "%d \n\n", sizeof(text));
+        it += r;
+        len += r;
+        memcpy(it, text, sizeof(text));
+        return answer(fd, buffer, len + sizeof(text));
+}
+#else
+int answer_plaintext( int fd ) {
+        char text[] = "Hello, World!\n";
+        int ret = answer_header(fd, sizeof(text));
         if( ret < 0 ) return ret;
-        return answer(fd, buffer, size);
-}
+        return answer(fd, text, sizeof(text));
+}
+#endif
 
 int answer_empty( int fd ) {
@@ -83 +115 @@
 
 
-[HttpCode code, bool closed, * const char file, size_t len] http_read(int fd, []char buffer, size_t len, io_cancellation * cancel) {
+[HttpCode code, bool closed, * const char file, size_t len] http_read(int fd, []char buffer, size_t len) {
         char * it = buffer;
         size_t count = len - 1;
@@ -89 +121 @@
         READ:
         for() {
-                int ret = cfa_read(fd, (void*)it, count, 0, -1`s, cancel, 0p);
+                int ret = cfa_recv(fd, (void*)it, count, 0, CFA_IO_LAZY);
                 // 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];
+                        if( errno == ECONNRESET ) return [E408, true, 0, 0];
+                        if( errno == EPIPE ) return [E408, true, 0, 0];
                         abort( "read error: (%d) %s\n", (int)errno, strerror(errno) );
                 }
@@ -108 +141 @@
         }
 
-        if( options.log ) printf("%.*s\n", rlen, buffer);
+        if( options.log ) {
+                write(sout, buffer, rlen);
+                sout | nl;
+        }
 
         it = buffer;
@@ -119 +155 @@
 }
 
-void sendfile( int pipe[2], int fd, int ans_fd, size_t count ) {
+int 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, sflags, 0, -1`s, 0p, 0p);
-                // ret = splice(ans_fd, &offset, pipe[1], 0p, count, sflags);
+                ret = cfa_splice(ans_fd, &offset, pipe[1], 0p, count, sflags, CFA_IO_LAZY);
                 if( ret < 0 ) {
                         if( errno != EAGAIN && errno != EWOULDBLOCK) continue SPLICE1;
+                        if( errno == ECONNRESET ) return -ECONNRESET;
+                        if( errno == EPIPE ) return -EPIPE;
                         abort( "splice [0] error: (%d) %s\n", (int)errno, strerror(errno) );
                 }
@@ -135 +172 @@
                 size_t in_pipe = ret;
                 SPLICE2: while(in_pipe > 0) {
-                        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);
+                        ret = cfa_splice(pipe[0], 0p, fd, 0p, in_pipe, sflags, CFA_IO_LAZY);
                         if( ret < 0 ) {
                                 if( errno != EAGAIN && errno != EWOULDBLOCK) continue SPLICE2;
+                                if( errno == ECONNRESET ) return -ECONNRESET;
+                                if( errno == EPIPE ) return -EPIPE;
                                 abort( "splice [1] error: (%d) %s\n", (int)errno, strerror(errno) );
                         }
@@ -145 +183 @@
 
         }
+        return count;
 }
 
@@ -153 +192 @@
 #include <thread.hfa>
 
+const char * original_http_msgs[] = {
+        "HTTP/1.1 200 OK\nServer: HttoForall\nDate: %s \nContent-Type: text/plain\nContent-Length: ",
+        "HTTP/1.1 200 OK\nServer: HttoForall\nDate: %s \nContent-Type: text/plain\nContent-Length: 15\n\nHello, World!\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 405 Method Not Allowed\nServer: HttoForall\nDate: %s \nContent-Type: text/plain\nContent-Length: 0 \n\n",
+        "HTTP/1.1 408 Request Timeout\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",
+};
+
 struct date_buffer {
-        char buff[100];
+        https_msg_str strs[KNOWN_CODES];
 };
 
@@ -163 +213 @@
 
 void ?{}( DateFormater & this ) {
-        ((thread&)this){ "Server Date Thread", *options.clopts.instance };
+        ((thread&)this){ "Server Date Thread", *options.clopts.instance[0] };
         this.idx = 0;
-        memset( this.buffers[0].buff, 0, sizeof(this.buffers[0]) );
-        memset( this.buffers[1].buff, 0, sizeof(this.buffers[1]) );
+        memset( &this.buffers[0], 0, sizeof(this.buffers[0]) );
+        memset( &this.buffers[1], 0, sizeof(this.buffers[1]) );
 }
 
@@ -176 +226 @@
                 or else {}
 
+
+                char buff[100];
                 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);
+                strftime( buff, 100, "%a, %d %b %Y %H:%M:%S %Z", now );
+                sout | "Updated date to '" | buff | "'";
+
+                for(i; KNOWN_CODES) {
+                        size_t len = snprintf( this.buffers[this.idx].strs[i].msg, 512, original_http_msgs[i], buff );
+                        this.buffers[this.idx].strs[i].len = len;
+                }
+
+                for(i; KNOWN_CODES) {
+                        https_msg_str * next = &this.buffers[this.idx].strs[i];
+                        __atomic_exchange_n((https_msg_str * volatile *)&http_msgs[i], next, __ATOMIC_SEQ_CST);
+                }
                 this.idx = (this.idx + 1) % 2;
+
+                sout | "Date thread sleeping";
 
                 sleep(1`s);