Changeset cc287800

benchmark/io/http/filecache.cfa

r949339b	rcc287800
185	185	sout \| "Filled cache from path \"" \| path \| "\" with" \| fcount \| "files";
186	186	if( conflicts > 0 ) {
187		sout \| "Found" \| conflicts \| "conflicts (seed: " \| options.file_cache.hash_seed \| ")";
	187	sout \| "Found" \| conflicts \| "conflicts (size: " \| file_cache.size \| ", seed: " \| options.file_cache.hash_seed \| ")";
188	188	#if defined(REJECT_CONFLICTS)
189	189	abort("Conflicts found in the cache");

benchmark/io/http/http_ring.cpp

-                      r949339b
+                      rcc287800
 // Get a fix reply based on the return code
 const char * http_msgs[] = {
         "HTTP/1.1 200 OK\r\nServer: HttoForall\r\nContent-Type: text/plain\r\nContent-Length: 15\r\nConnection: keep-alive\r\n\r\nHello, World!\r\n",
         "HTTP/1.1 400 Bad Request\r\nServer: HttoForall\r\nContent-Type: text/plain\r\nContent-Length: 0 \r\n\r\n",
         "HTTP/1.1 404 Not Found\r\nServer: HttoForall\r\nContent-Type: text/plain\r\nContent-Length: 0 \r\n\r\n",
         "HTTP/1.1 405 Method Not \r\nServer: HttoForall\r\nContent-Type: text/plain\r\nContent-Length: 0 \r\n\r\n",
         "HTTP/1.1 408 Request Timeout\r\nServer: HttoForall\r\nContent-Type: text/plain\r\nContent-Length: 0 \r\n\r\n",
         "HTTP/1.1 413 Payload Too Large\r\nServer: HttoForall\r\nContent-Type: text/plain\r\nContent-Length: 0 \r\n\r\n",
         "HTTP/1.1 414 URI Too Long\r\nServer: HttoForall\r\nContent-Type: text/plain\r\nContent-Length: 0 \r\n\r\n",
+        "HTTP/1.1 200 OK\r\nServer: HttpForall\r\nContent-Type: text/plain\r\nContent-Length: 15\r\nConnection: keep-alive\r\n\r\nHello, World!\r\n",
+        "HTTP/1.1 400 Bad Request\r\nServer: HttpForall\r\nContent-Type: text/plain\r\nContent-Length: 0 \r\n\r\n",
+        "HTTP/1.1 404 Not Found\r\nServer: HttpForall\r\nContent-Type: text/plain\r\nContent-Length: 0 \r\n\r\n",
+        "HTTP/1.1 405 Method Not \r\nServer: HttpForall\r\nContent-Type: text/plain\r\nContent-Length: 0 \r\n\r\n",
+        "HTTP/1.1 408 Request Timeout\r\nServer: HttpForall\r\nContent-Type: text/plain\r\nContent-Length: 0 \r\n\r\n",
+        "HTTP/1.1 413 Payload Too Large\r\nServer: HttpForall\r\nContent-Type: text/plain\r\nContent-Length: 0 \r\n\r\n",
+        "HTTP/1.1 414 URI Too Long\r\nServer: HttpForall\r\nContent-Type: text/plain\r\nContent-Length: 0 \r\n\r\n",
 };
 static_assert( KNOWN_CODES == (sizeof(http_msgs) / sizeof(http_msgs[0])) );

benchmark/io/http/main.cfa

r949339b	rcc287800
190	190	init_protocol();
191	191	{
192		Worker ~~workers[options.clopts.nworkers]~~;
	192	Worker * workers = anew(options.clopts.nworkers);
193	193	for(i; options.clopts.nworkers) {
194	194	// if( options.file_cache.fixed_fds ) {
…	…
212	212	}
213	213	sout \| nl;
	214	if(!options.interactive) park();
214	215	{
215	216	char buffer[128];
…	…
249	250
250	251	sout \| "Stopping connection threads..." \| nonl; flush( sout );
	252	adelete(workers);
251	253	}
252	254	sout \| "done";

benchmark/io/http/options.cfa

-                      r949339b
+                      rcc287800
         false, // log
         false, // stats
+        true, // interactive
+, // redirect
+, // redirect
         { // file_cache
 …
         // bool sqkpoll = false;
         // bool iokpoll = false;
         unsigned nentries = 16;
+        unsigned nentries = 0;
         bool isolate = false;
 …
                 {'\0', "isolate",        "Create one cluster per processor", isolate, parse_settrue},
                 {'\0', "log",            "Enable logs", options.log, parse_settrue},
+                {'\0', "sout",           "Redirect standard out to file", options.reopen_stdout},
+                {'\0', "serr",           "Redirect standard error to file", options.reopen_stderr},
                 {'\0', "stats",          "Enable statistics", options.stats, parse_settrue},
+                {'\0', "shell",          "Disable interactive mode", options.interactive, parse_setfalse},
                 {'\0', "accept-backlog", "Maximum number of pending accepts", options.socket.backlog},
                 {'\0', "request_len",    "Maximum number of bytes in the http request, requests with more data will be answered with Http Code 414", options.socket.buflen},
 …
         parse_args( argc, argv, opt, opt_cnt, "[OPTIONS]... [PATH]\ncforall http server", left );
         if( !is_pow2(nentries) ) {
+        if( nentries != 0 && !is_pow2(nentries) ) {
                 unsigned v = nentries;
                 v--;
 …
         options.file_cache.path = path;
+        if( options.reopen_stdout && options.reopen_stderr && 0 == strcmp(options.reopen_stdout, options.reopen_stderr) ) {
+                serr | "Redirect sout and serr to the same file is not supported";
+                exit(EXIT_FAILURE);
+        }
+        if( options.reopen_stdout ) {
+                sout | "redirecting sout to '" | options.reopen_stdout | "'";
+                FILE  * ret = freopen( options.reopen_stdout, "w", stdout);
+                if( ret == 0p ) {
+                        serr | "Failed to redirect sout to '" | options.reopen_stdout | "'";
+                        exit(EXIT_FAILURE);
+                }
+        }
+        if( options.reopen_stderr ) {
+                sout | "redirecting serr to '" | options.reopen_stderr | "'";
+                FILE  * ret = freopen( options.reopen_stderr, "w", stderr);
+                if( ret == 0p ) {
+                        serr | "Failed to redirect serr to '" | options.reopen_stderr | "'";
+                        exit(EXIT_FAILURE);
+                }
+        }
+}

benchmark/io/http/options.hfa

-                      r949339b
+                      rcc287800
         bool log;
         bool stats;
+        bool interactive;
+        const char * reopen_stdout;
+        const char * reopen_stderr;
         struct {

benchmark/io/http/protocol.cfa

-                      r949339b
+                      rcc287800
 #include <fstream.hfa>
 #include <iofwd.hfa>
+#include <io/types.hfa>
+#include <mutex_stmt.hfa>
 #include <assert.h>
 …
 #define PLAINTEXT_MEMCPY
 #define PLAINTEXT_NOCOPY
+#define LINKED_IO
 struct https_msg_str {
 …
+}
 static inline int answer( int fd, const char * it, int len) {
+static inline int answer( int fd, const char * it, int len ) {
         while(len > 0) {
                 // Call write
                 int ret = cfa_send(fd, it, len, 0, CFA_IO_LAZY);
                 if( ret < 0 ) {
                         if( errno == ECONNRESET || errno == EPIPE ) return -ECONNRESET;
+                        if( errno == ECONNRESET || errno == EPIPE ) { close(fd); return -ECONNRESET; }
                         if( errno == EAGAIN || errno == EWOULDBLOCK) return -EAGAIN;
 …
+}
+int answer_header( int fd, size_t size ) {
+        char buffer[512];
+        char * it = buffer;
+static int fill_header(char * it, size_t size) {
         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 len;
+}
+static int answer_header( int fd, size_t size ) {
+        char buffer[512];
+        int len = fill_header(buffer, 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) {
+        char * it = buffer;
+        size_t count = len - 1;
+        int rlen = 0;
+        READ:
+        for() {
+                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 == ECONNRESET ) return [E408, true, 0, 0];
+                        if( errno == EPIPE ) return [E408, true, 0, 0];
+                        abort( "read error: (%d) %s\n", (int)errno, strerror(errno) );
+                }
+                it[ret + 1] = '\0';
+                rlen += ret;
+                if( strstr( it, "\r\n\r\n" ) ) break;
+                it += ret;
+                count -= ret;
+                if( count < 1 ) return [E414, false, 0, 0];
+        }
+        if( options.log ) {
+                write(sout, buffer, rlen);
+                sout | nl;
+        }
+        it = buffer;
+        int ret = memcmp(it, "GET /", 5);
+        if( ret != 0 ) return [E400, false, 0, 0];
+        it += 5;
+        char * end = strstr( it, " " );
+        return [OK200, false, it, end - it];
+}
+int sendfile( int pipe[2], int fd, int ans_fd, size_t count ) {
+static 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;
 …
+}
+static void zero_sqe(struct io_uring_sqe * sqe) {
+        sqe->flags = 0;
+        sqe->ioprio = 0;
+        sqe->fd = 0;
+        sqe->off = 0;
+        sqe->addr = 0;
+        sqe->len = 0;
+        sqe->fsync_flags = 0;
+        sqe->__pad2[0] = 0;
+        sqe->__pad2[1] = 0;
+        sqe->__pad2[2] = 0;
+        sqe->fd = 0;
+        sqe->off = 0;
+        sqe->addr = 0;
+        sqe->len = 0;
+}
+enum FSM_STATE {
+        Initial,
+        Retry,
+        Error,
+        Done,
+};
+struct FSM_Result {
+        FSM_STATE state;
+        int error;
+};
+static inline void ?{}(FSM_Result & this) { this.state = Initial; this.error = 0; }
+static inline bool is_error(FSM_Result & this) { return Error == this.state; }
+static inline bool is_done(FSM_Result & this) { return Done == this.state; }
+static inline int error(FSM_Result & this, int error) {
+        this.error = error;
+        this.state = Error;
+        return error;
+}
+static inline int done(FSM_Result & this) {
+        this.state = Done;
+        return 0;
+}
+static inline int retry(FSM_Result & this) {
+        this.state = Retry;
+        return 0;
+}
+static inline int need(FSM_Result & this) {
+        switch(this.state) {
+                case Initial:
+                case Retry:
+                        return 1;
+                case Error:
+                        if(this.error == 0) mutex(serr) serr | "State marked error but code is 0";
+                case Done:
+                        return 0;
+        }
+}
+// Generator that handles sending the header
+generator header_g {
+        io_future_t f;
+        const char * next;
+        int fd; size_t len;
+        FSM_Result res;
+};
+static inline void ?{}(header_g & this, int fd, const char * it, size_t len ) {
+        this.next = it;
+        this.fd = fd;
+        this.len = len;
+}
+static inline void fill(header_g & this, struct io_uring_sqe * sqe) {
+        zero_sqe(sqe);
+        sqe->opcode = IORING_OP_SEND;
+        sqe->user_data = (uintptr_t)&this.f;
+        sqe->flags = IOSQE_IO_LINK;
+        sqe->fd = this.fd;
+        sqe->addr = (uintptr_t)this.next;
+        sqe->len = this.len;
+}
+static inline int error(header_g & this, int error) {
+        int ret = close(this.fd);
+        if( ret != 0 ) {
+                mutex(serr) serr | "Failed to close fd" | errno;
+        }
+        return error(this.res, error);
+}
+static inline int wait_and_process(header_g & this) {
+        wait(this.f);
+        // Did something crazy happen?
+        if(this.f.result > this.len) {
+                mutex(serr) serr | "HEADER sent too much!";
+                return error(this, -ERANGE);
+        }
+        // Something failed?
+        if(this.f.result < 0) {
+                int error = -this.f.result;
+                if( error == ECONNRESET ) return error(this, -ECONNRESET);
+                if( error == EPIPE ) return error(this, -EPIPE);
+                if( error == ECANCELED ) {
+                        mutex(serr) serr | "HEADER was cancelled, WTF!";
+                        return error(this, -ECONNRESET);
+                }
+                if( error == EAGAIN || error == EWOULDBLOCK) {
+                        mutex(serr) serr | "HEADER got eagain, WTF!";
+                        return error(this, -ECONNRESET);
+                }
+        }
+        // Done?
+        if(this.f.result == this.len) {
+                return done(this.res);
+        }
+        // It must be a Short read
+        this.len  -= this.f.result;
+        this.next += this.f.result;
+        reset(this.f);
+        return retry(this.res);
+}
+// Generator that handles splicing in a file
+struct splice_in_t {
+        io_future_t f;
+        int fd; int pipe; size_t len; off_t off;
+        FSM_Result res;
+};
+static inline void ?{}(splice_in_t & this, int fd, int pipe, size_t len) {
+        this.fd = fd;
+        this.pipe = pipe;
+        this.len = len;
+        this.off = 0;
+}
+static inline void fill(splice_in_t & this, struct io_uring_sqe * sqe) {
+        zero_sqe(sqe);
+        sqe->opcode = IORING_OP_SPLICE;
+        sqe->user_data = (uintptr_t)&this.f;
+        sqe->flags = 0;
+        sqe->splice_fd_in = this.fd;
+        sqe->splice_off_in = this.off;
+        sqe->fd = this.pipe;
+        sqe->off = (__u64)-1;
+        sqe->len = this.len;
+        sqe->splice_flags = SPLICE_F_MOVE;
+}
+static inline int wait_and_process(splice_in_t & this) {
+        wait(this.f);
+        // Did something crazy happen?
+        if(this.f.result > this.len) {
+                mutex(serr) serr | "SPLICE IN spliced too much!";
+                return error(this.res, -ERANGE);
+        }
+        // Something failed?
+        if(this.f.result < 0) {
+                int error = -this.f.result;
+                if( error == ECONNRESET ) return error(this.res, -ECONNRESET);
+                if( error == EPIPE ) return error(this.res, -EPIPE);
+                if( error == ECANCELED ) {
+                        mutex(serr) serr | "SPLICE IN was cancelled, WTF!";
+                        return error(this.res, -ECONNRESET);
+                }
+                if( error == EAGAIN || error == EWOULDBLOCK) {
+                        mutex(serr) serr | "SPLICE IN got eagain, WTF!";
+                        return error(this.res, -ECONNRESET);
+                }
+        }
+        // Done?
+        if(this.f.result == this.len) {
+                return done(this.res);
+        }
+        // It must be a Short read
+        this.len -= this.f.result;
+        this.off += this.f.result;
+        reset(this.f);
+        return retry(this.res);
+}
+generator splice_out_g {
+        io_future_t f;
+        int pipe; int fd; size_t len;
+        FSM_Result res;
+};
+static inline void ?{}(splice_out_g & this, int pipe, int fd, size_t len) {
+        this.pipe = pipe;
+        this.fd = fd;
+        this.len = len;
+}
+static inline void fill(splice_out_g & this, struct io_uring_sqe * sqe) {
+        zero_sqe(sqe);
+        sqe->opcode = IORING_OP_SPLICE;
+        sqe->user_data = (uintptr_t)&this.f;
+        sqe->flags = 0;
+        sqe->splice_fd_in = this.pipe;
+        sqe->splice_off_in = (__u64)-1;
+        sqe->fd = this.fd;
+        sqe->off = (__u64)-1;
+        sqe->len = this.len;
+        sqe->splice_flags = SPLICE_F_MOVE;
+}
+static inline int error(splice_out_g & this, int error) {
+        int ret = close(this.fd);
+        if( ret != 0 ) {
+                mutex(serr) serr | "Failed to close fd" | errno;
+        }
+        return error(this.res, error);
+}
+static inline void wait_and_process(splice_out_g & this) {
+        wait(this.f);
+        // Did something crazy happen?
+        if(this.f.result > this.len) {
+                mutex(serr) serr | "SPLICE OUT spliced too much!";
+                return error(this.res, -ERANGE);
+        }
+        // Something failed?
+        if(this.f.result < 0) {
+                int error = -this.f.result;
+                if( error == ECONNRESET ) return error(this, -ECONNRESET);
+                if( error == EPIPE ) return error(this, -EPIPE);
+                if( error == ECANCELED ) {
+                        this.f.result = 0;
+                        goto SHORT_WRITE;
+                }
+                if( error == EAGAIN || error == EWOULDBLOCK) {
+                        mutex(serr) serr | "SPLICE OUT got eagain, WTF!";
+                        return error(this, -ECONNRESET);
+                }
+        }
+        // Done?
+        if(this.f.result == this.len) {
+                return done(this.res);
+        }
+SHORT_WRITE:
+        // It must be a Short Write
+        this.len -= this.f.result;
+        reset(this.f);
+        return retry(this.res);
+}
+int answer_sendfile( int pipe[2], int fd, int ans_fd, size_t fsize ) {
+        #if defined(LINKED_IO)
+                char buffer[512];
+                int len = fill_header(buffer, fsize);
+                header_g header = { fd, buffer, len };
+                splice_in_t splice_in = { ans_fd, pipe[1], fsize };
+                splice_out_g splice_out = { pipe[0], fd, fsize };
+                RETRY_LOOP: for() {
+                        int have = need(header.res) + need(splice_in.res) + 1;
+                        int idx = 0;
+                        struct io_uring_sqe * sqes[3];
+                        __u32 idxs[3];
+                        struct $io_context * ctx = cfa_io_allocate(sqes, idxs, have);
+                        if(need(splice_in.res)) { fill(splice_in, sqes[idx++]); }
+                        if(need(   header.res)) { fill(header   , sqes[idx++]); }
+                        fill(splice_out, sqes[idx]);
+                        // Submit everything
+                        asm volatile("": : :"memory");
+                        cfa_io_submit( ctx, idxs, have, false );
+                        // wait for the results
+                        // Always wait for splice-in to complete as
+                        // we may need to kill the connection if it fails
+                        // If it already completed, this is a no-op
+                        wait_and_process(splice_in);
+                        if(is_error(splice_in.res)) {
+                                mutex(serr) serr | "SPLICE IN failed with" | splice_in.res.error;
+                                close(fd);
+                        }
+                        // Process the other 2
+                        wait_and_process(header);
+                        wait_and_process(splice_out);
+                        if(is_done(splice_out.res)) {
+                                break RETRY_LOOP;
+                        }
+                        // We need to wait for the completion if
+                        // - both completed
+                        // - the header failed
+                        // -
+                        if(  is_error(header.res)
+                          || is_error(splice_in.res)
+                          || is_error(splice_out.res)) {
+                                return -ECONNRESET;
+                        }
+                }
+                return len + fsize;
+        #else
+                int ret = answer_header(fd, fsize);
+                if( ret < 0 ) { close(fd); return ret; }
+                return sendfile(pipe, fd, ans_fd, fsize);
+        #endif
+}
+[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;
+        int rlen = 0;
+        READ:
+        for() {
+                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 == ECONNRESET ) { close(fd); return [E408, true, 0, 0]; }
+                        if( errno == EPIPE ) { close(fd); return [E408, true, 0, 0]; }
+                        abort( "read error: (%d) %s\n", (int)errno, strerror(errno) );
+                }
+                it[ret + 1] = '\0';
+                rlen += ret;
+                if( strstr( it, "\r\n\r\n" ) ) break;
+                it += ret;
+                count -= ret;
+                if( count < 1 ) return [E414, false, 0, 0];
+        }
+        if( options.log ) {
+                write(sout, buffer, rlen);
+                sout | nl;
+        }
+        it = buffer;
+        int ret = memcmp(it, "GET /", 5);
+        if( ret != 0 ) return [E400, false, 0, 0];
+        it += 5;
+        char * end = strstr( it, " " );
+        return [OK200, false, it, end - it];
+}
 //=============================================================================================
 …
 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\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",
+        "HTTP/1.1 200 OK\nServer: HttpForall\nDate: %s \nContent-Type: text/plain\nContent-Length: ",
+        "HTTP/1.1 200 OK\r\nServer: HttpForall\r\nDate\r\nConnection: keep-alive\r\nContent-Length: 15\r\nContent-Type: text/html: %s \r\n\r\nHello, World!\r\n",
+        "HTTP/1.1 400 Bad Request\nServer: HttpForall\nDate: %s \nContent-Type: text/plain\nContent-Length: 0 \n\n",
+        "HTTP/1.1 404 Not Found\nServer: HttpForall\nDate: %s \nContent-Type: text/plain\nContent-Length: 0 \n\n",
+        "HTTP/1.1 405 Method Not Allowed\nServer: HttpForall\nDate: %s \nContent-Type: text/plain\nContent-Length: 0 \n\n",
+        "HTTP/1.1 408 Request Timeout\nServer: HttpForall\nDate: %s \nContent-Type: text/plain\nContent-Length: 0 \n\n",
+        "HTTP/1.1 413 Payload Too Large\nServer: HttpForall\nDate: %s \nContent-Type: text/plain\nContent-Length: 0 \n\n",
+        "HTTP/1.1 414 URI Too Long\nServer: HttpForall\nDate: %s \nContent-Type: text/plain\nContent-Length: 0 \n\n",
 };
 …
                 Time now = timeHiRes();
                 strftime( buff, 100, "%a, %d %b %Y %H:%M:%S %Z", now );
                 sout | "Updated date to '" | buff | "'";
+                // if( options.log ) sout | "Updated date to '" | buff | "'";
                 for(i; KNOWN_CODES) {
 …
                 this.idx = (this.idx + 1) % 2;
                 sout | "Date thread sleeping";
+                // if( options.log ) sout | "Date thread sleeping";
                 sleep(1`s);

benchmark/io/http/protocol.hfa

-                      r949339b
+                      rcc287800
 int answer_error( int fd, HttpCode code );
-int answer_header( int fd, size_t size );
 int answer_plaintext( int fd );
 int answer_empty( int fd );
+int answer_sendfile( int pipe[2], int fd, int ans_fd, size_t count );
 [HttpCode code, bool closed, * const char file, size_t len] http_read(int fd, []char buffer, size_t len);
-int sendfile( int pipe[2], int fd, int ans_fd, size_t count );

benchmark/io/http/worker.cfa

-                      r949339b
+                      rcc287800
+                        }
-                        // Send the header
-                        int ret = answer_header(fd, count);
-                        if( ret == -ECONNRESET ) break REQUEST;
                         // Send the desired file
                         ret = sendfile( this.pipe, fd, ans_fd, count);
+                        int ret = answer_sendfile( this.pipe, fd, ans_fd, count);
                         if( ret == -ECONNRESET ) break REQUEST;
 …
                 if( options.log ) sout | "=== Connection closed ===";
-                close(fd);
                 continue CONNECTION;
+        }

doc/theses/mubeen_zulfiqar_MMath/allocator.tex

-                      r949339b
+                      rcc287800
 \end{itemize}
 The new features added to uHeapLmmm (incl. @malloc_size@ routine)
+The new features added to uHeapLmmm (incl. @malloc\_size@ routine)
 \CFA alloc interface with examples.
 \begin{itemize}
 \item
 …
 We added a few more features and routines to the allocator's C interface that can make the allocator more usable to the programmers. THese features will programmer more control on the dynamic memory allocation.
 \subsubsection void * aalloc( size_t dim, size_t elemSize )
+\subsubsection void * aalloc( size\_t dim, size\_t elemSize )
 aalloc is an extension of malloc. It allows programmer to allocate a dynamic array of objects without calculating the total size of array explicitly. The only alternate of this routine in the other allocators is calloc but calloc also fills the dynamic memory with 0 which makes it slower for a programmer who only wants to dynamically allocate an array of objects without filling it with 0.
 \paragraph{Usage}
 aalloc takes two parameters.
 \begin{itemize}
 \item
 …
 It returns address of dynamic object allocatoed on heap that can contain dim number of objects of the size elemSize. On failure, it returns NULL pointer.
 \subsubsection void * resize( void * oaddr, size_t size )
+\subsubsection void * resize( void * oaddr, size\_t size )
 resize is an extension of relloc. It allows programmer to reuse a cuurently allocated dynamic object with a new size requirement. Its alternate in the other allocators is realloc but relloc also copy the data in old object to the new object which makes it slower for the programmer who only wants to reuse an old dynamic object for a new size requirement but does not want to preserve the data in the old object to the new object.
 \paragraph{Usage}
 resize takes two parameters.
 \begin{itemize}
 \item
 …
 It returns an object that is of the size given but it does not preserve the data in the old object. On failure, it returns NULL pointer.
 \subsubsection void * resize( void * oaddr, size_t nalign, size_t size )
+\subsubsection void * resize( void * oaddr, size\_t nalign, size\_t size )
 This resize is an extension of the above resize (FIX ME: cite above resize). In addition to resizing the size of of an old object, it can also realign the old object to a new alignment requirement.
 \paragraph{Usage}
 This resize takes three parameters. It takes an additional parameter of nalign as compared to the above resize (FIX ME: cite above resize).
 \begin{itemize}
 \item
 …
 It returns an object with the size and alignment given in the parameters. On failure, it returns a NULL pointer.
 \subsubsection void * amemalign( size_t alignment, size_t dim, size_t elemSize )
+\subsubsection void * amemalign( size\_t alignment, size\_t dim, size\_t elemSize )
 amemalign is a hybrid of memalign and aalloc. It allows programmer to allocate an aligned dynamic array of objects without calculating the total size of the array explicitly. It frees the programmer from calculating the total size of the array.
 \paragraph{Usage}
 amemalign takes three parameters.
 \begin{itemize}
 \item
 …
 It returns a dynamic array of objects that has the capacity to contain dim number of objects of the size of elemSize. The returned dynamic array is aligned to the given alignment. On failure, it returns NULL pointer.
 \subsubsection void * cmemalign( size_t alignment, size_t dim, size_t elemSize )
+\subsubsection void * cmemalign( size\_t alignment, size\_t dim, size\_t elemSize )
 cmemalign is a hybrid of amemalign and calloc. It allows programmer to allocate an aligned dynamic array of objects that is 0 filled. The current way to do this in other allocators is to allocate an aligned object with memalign and then fill it with 0 explicitly. This routine provides both features of aligning and 0 filling, implicitly.
 \paragraph{Usage}
 cmemalign takes three parameters.
 \begin{itemize}
 \item
 …
 It returns a dynamic array of objects that has the capacity to contain dim number of objects of the size of elemSize. The returned dynamic array is aligned to the given alignment and is 0 filled. On failure, it returns NULL pointer.
+\subsubsection size_t malloc_alignment( void * addr )
+malloc_alignment returns the alignment of a currently allocated dynamic object. It allows the programmer in memory management and personal bookkeeping. It helps the programmer in verofying the alignment of a dynamic object especially in a scenerio similar to prudcer-consumer where a producer allocates a dynamic object and the consumer needs to assure that the dynamic object was allocated with the required alignment.
+\paragraph{Usage}
+malloc_alignment takes one parameters.
+\subsubsection size\_t malloc\_alignment( void * addr )
+malloc\_alignment returns the alignment of a currently allocated dynamic object. It allows the programmer in memory management and personal bookkeeping. It helps the programmer in verofying the alignment of a dynamic object especially in a scenerio similar to prudcer-consumer where a producer allocates a dynamic object and the consumer needs to assure that the dynamic object was allocated with the required alignment.
+\paragraph{Usage}
+malloc\_alignment takes one parameters.
 \begin{itemize}
 \item
 addr: the address of the currently allocated dynamic object.
 \end{itemize}
+malloc_alignment returns the alignment of the given dynamic object. On failure, it return the value of default alignment of the uHeapLmmm allocator.
+\subsubsection bool malloc_zero_fill( void * addr )
+malloc_zero_fill returns whether a currently allocated dynamic object was initially zero filled at the time of allocation. It allows the programmer in memory management and personal bookkeeping. It helps the programmer in verifying the zero filled property of a dynamic object especially in a scenerio similar to prudcer-consumer where a producer allocates a dynamic object and the consumer needs to assure that the dynamic object was zero filled at the time of allocation.
+\paragraph{Usage}
+malloc_zero_fill takes one parameters.
+malloc\_alignment returns the alignment of the given dynamic object. On failure, it return the value of default alignment of the uHeapLmmm allocator.
+\subsubsection bool malloc\_zero\_fill( void * addr )
+malloc\_zero\_fill returns whether a currently allocated dynamic object was initially zero filled at the time of allocation. It allows the programmer in memory management and personal bookkeeping. It helps the programmer in verifying the zero filled property of a dynamic object especially in a scenerio similar to prudcer-consumer where a producer allocates a dynamic object and the consumer needs to assure that the dynamic object was zero filled at the time of allocation.
+\paragraph{Usage}
+malloc\_zero\_fill takes one parameters.
 \begin{itemize}
 \item
 addr: the address of the currently allocated dynamic object.
 \end{itemize}
+malloc_zero_fill returns true if the dynamic object was initially zero filled and return false otherwise. On failure, it returns false.
+\subsubsection size_t malloc_size( void * addr )
+malloc_size returns the allocation size of a currently allocated dynamic object. It allows the programmer in memory management and personal bookkeeping. It helps the programmer in verofying the alignment of a dynamic object especially in a scenerio similar to prudcer-consumer where a producer allocates a dynamic object and the consumer needs to assure that the dynamic object was allocated with the required size. Its current alternate in the other allocators is malloc_usable_size. But, malloc_size is different from malloc_usable_size as malloc_usabe_size returns the total data capacity of dynamic object including the extra space at the end of the dynamic object. On the other hand, malloc_size returns the size that was given to the allocator at the allocation of the dynamic object. This size is updated when an object is realloced, resized, or passed through a similar allocator routine.
+\paragraph{Usage}
+malloc_size takes one parameters.
+malloc\_zero\_fill returns true if the dynamic object was initially zero filled and return false otherwise. On failure, it returns false.
+\subsubsection size\_t malloc\_size( void * addr )
+malloc\_size returns the allocation size of a currently allocated dynamic object. It allows the programmer in memory management and personal bookkeeping. It helps the programmer in verofying the alignment of a dynamic object especially in a scenerio similar to prudcer-consumer where a producer allocates a dynamic object and the consumer needs to assure that the dynamic object was allocated with the required size. Its current alternate in the other allocators is malloc\_usable\_size. But, malloc\_size is different from malloc\_usable\_size as malloc\_usabe\_size returns the total data capacity of dynamic object including the extra space at the end of the dynamic object. On the other hand, malloc\_size returns the size that was given to the allocator at the allocation of the dynamic object. This size is updated when an object is realloced, resized, or passed through a similar allocator routine.
+\paragraph{Usage}
+malloc\_size takes one parameters.
 \begin{itemize}
 \item
 addr: the address of the currently allocated dynamic object.
 \end{itemize}
 malloc_size returns the allocation size of the given dynamic object. On failure, it return zero.
 \subsubsection void * realloc( void * oaddr, size_t nalign, size_t size )
+malloc\_size returns the allocation size of the given dynamic object. On failure, it return zero.
+\subsubsection void * realloc( void * oaddr, size\_t nalign, size\_t size )
 This realloc is an extension of the default realloc (FIX ME: cite default realloc). In addition to reallocating an old object and preserving the data in old object, it can also realign the old object to a new alignment requirement.
 \paragraph{Usage}
 This realloc takes three parameters. It takes an additional parameter of nalign as compared to the default realloc.
 \begin{itemize}
 \item
 …
 It returns a dynamic object of the size of type T. On failure, it return NULL pointer.
 \subsubsection T * aalloc( size_t dim )
+\subsubsection T * aalloc( size\_t dim )
 This aalloc is a simplified polymorphic form of above aalloc (FIX ME: cite aalloc). It takes one parameter as compared to the above aalloc that takes two parameters.
 \paragraph{Usage}
 aalloc takes one parameters.
 \begin{itemize}
 \item
 …
 It returns a dynamic object that has the capacity to contain dim number of objects, each of the size of type T. On failure, it return NULL pointer.
 \subsubsection T * calloc( size_t dim )
+\subsubsection T * calloc( size\_t dim )
 This calloc is a simplified polymorphic form of defualt calloc (FIX ME: cite calloc). It takes one parameter as compared to the default calloc that takes two parameters.
 \paragraph{Usage}
 This calloc takes one parameter.
 \begin{itemize}
 \item
 …
 It returns a dynamic object that has the capacity to contain dim number of objects, each of the size of type T. On failure, it return NULL pointer.
 \subsubsection T * resize( T * ptr, size_t size )
+\subsubsection T * resize( T * ptr, size\_t size )
 This resize is a simplified polymorphic form of above resize (FIX ME: cite resize with alignment). It takes two parameters as compared to the above resize that takes three parameters. It frees the programmer from explicitly mentioning the alignment of the allocation as CFA provides gives allocator the liberty to get the alignment of the returned type.
 \paragraph{Usage}
 This resize takes two parameters.
 \begin{itemize}
 \item
 …
 It returns a dynamic object of the size given in paramters. The returned object is aligned to the alignemtn of type T. On failure, it return NULL pointer.
 \subsubsection T * realloc( T * ptr, size_t size )
+\subsubsection T * realloc( T * ptr, size\_t size )
 This realloc is a simplified polymorphic form of defualt realloc (FIX ME: cite realloc with align). It takes two parameters as compared to the above realloc that takes three parameters. It frees the programmer from explicitly mentioning the alignment of the allocation as CFA provides gives allocator the liberty to get the alignment of the returned type.
 \paragraph{Usage}
 This realloc takes two parameters.
 \begin{itemize}
 \item
 …
 It returns a dynamic object of the size given in paramters that preserves the data in the given object. The returned object is aligned to the alignemtn of type T. On failure, it return NULL pointer.
 \subsubsection T * memalign( size_t align )
+\subsubsection T * memalign( size\_t align )
 This memalign is a simplified polymorphic form of defualt memalign (FIX ME: cite memalign). It takes one parameters as compared to the default memalign that takes two parameters.
 \paragraph{Usage}
 memalign takes one parameters.
 \begin{itemize}
 \item
 …
 It returns a dynamic object of the size of type T that is aligned to given parameter align. On failure, it return NULL pointer.
 \subsubsection T * amemalign( size_t align, size_t dim )
+\subsubsection T * amemalign( size\_t align, size\_t dim )
 This amemalign is a simplified polymorphic form of above amemalign (FIX ME: cite amemalign). It takes two parameter as compared to the above amemalign that takes three parameters.
 \paragraph{Usage}
 amemalign takes two parameters.
 \begin{itemize}
 \item
 …
 It returns a dynamic object that has the capacity to contain dim number of objects, each of the size of type T. The returned object is aligned to the given parameter align. On failure, it return NULL pointer.
 \subsubsection T * cmemalign( size_t align, size_t dim  )
+\subsubsection T * cmemalign( size\_t align, size\_t dim  )
 This cmemalign is a simplified polymorphic form of above cmemalign (FIX ME: cite cmemalign). It takes two parameter as compared to the above cmemalign that takes three parameters.
 \paragraph{Usage}
 cmemalign takes two parameters.
 \begin{itemize}
 \item
 …
 It returns a dynamic object that has the capacity to contain dim number of objects, each of the size of type T. The returned object is aligned to the given parameter align and is zero filled. On failure, it return NULL pointer.
+\subsubsection T * aligned_alloc( size_t align )
+This aligned_alloc is a simplified polymorphic form of defualt aligned_alloc (FIX ME: cite aligned_alloc). It takes one parameter as compared to the default aligned_alloc that takes two parameters.
+\paragraph{Usage}
+This aligned_alloc takes one parameter.
+\subsubsection T * aligned\_alloc( size\_t align )
+This aligned\_alloc is a simplified polymorphic form of defualt aligned\_alloc (FIX ME: cite aligned\_alloc). It takes one parameter as compared to the default aligned\_alloc that takes two parameters.
+\paragraph{Usage}
+This aligned\_alloc takes one parameter.
 \begin{itemize}
 \item
 …
 It returns a dynamic object of the size of type T that is aligned to the given parameter. On failure, it return NULL pointer.
+\subsubsection int posix_memalign( T ** ptr, size_t align )
+This posix_memalign is a simplified polymorphic form of defualt posix_memalign (FIX ME: cite posix_memalign). It takes two parameters as compared to the default posix_memalign that takes three parameters.
+\paragraph{Usage}
+This posix_memalign takes two parameter.
+\subsubsection int posix\_memalign( T ** ptr, size\_t align )
+This posix\_memalign is a simplified polymorphic form of defualt posix\_memalign (FIX ME: cite posix\_memalign). It takes two parameters as compared to the default posix\_memalign that takes three parameters.
+\paragraph{Usage}
+This posix\_memalign takes two parameter.
 \begin{itemize}
 \item
 …
 align: required alignment of the dynamic object.
 \end{itemize}
 It stores address of the dynamic object of the size of type T in given parameter ptr. This object is aligned to the given parameter. On failure, it return NULL pointer.
 …
 It returns a dynamic object of the size that is calcutaed by rouding the size of type T. The returned object is also aligned to the page size. On failure, it return NULL pointer.
 \subsection{Alloc Interface}
+\subsection Alloc Interface
 In addition to improve allocator interface both for CFA and our standalone allocator uHeapLmmm in C. We also added a new alloc interface in CFA that increases usability of dynamic memory allocation.
 This interface helps programmers in three major ways.
 \begin{itemize}
 \item
 …
 This is the only parameter in the alloc routine that has a fixed-position and it is also the only parameter that does not use a backtick function. It has to be passed at the first position to alloc call in-case of an array allocation of objects of type T.
 It represents the required number of members in the array allocation as in CFA's aalloc (FIX ME: cite aalloc).
 This parameter should be of type size_t.
+This parameter should be of type size\_t.
 Example: int a = alloc( 5 )
 …
 \paragraph{Align}
 This parameter is position-free and uses a backtick routine align (`align). The parameter passed with `align should be of type size_t. If the alignment parameter is not a power of two or is less than the default alignment of the allocator (that can be found out using routine libAlign in CFA) then the passed alignment parameter will be rejected and the default alignment will be used.
+This parameter is position-free and uses a backtick routine align (`align). The parameter passed with `align should be of type size\_t. If the alignment parameter is not a power of two or is less than the default alignment of the allocator (that can be found out using routine libAlign in CFA) then the passed alignment parameter will be rejected and the default alignment will be used.
 Example: int b = alloc( 5 , 64`align )
 …
 This parameter is position-free and uses a backtick routine fill (`fill). In case of realloc, only the extra space after copying the data in the old object will be filled with given parameter.
 Three types of parameters can be passed using `fill.
 \begin{itemize}
 \item

doc/theses/mubeen_zulfiqar_MMath/background.tex

-                      r949339b
+                      rcc287800
 ====================
+\cite{Wasik08}
+\section{Background}
+% FIXME: cite wasik
+\cite{wasik.thesis}
+\subsection{Memory Allocation}
+With dynamic allocation being an important feature of C, there are many standalone memory allocators that have been designed for different purposes. For this thesis, we chose 7 of the most popular and widely used memory allocators.
+\paragraph{dlmalloc}
+dlmalloc (FIX ME: cite allocator) is a thread-safe allocator that is single threaded and single heap. dlmalloc maintains free-lists of different sizes to store freed dynamic memory. (FIX ME: cite wasik)
+\paragraph{hoard}
+Hoard (FIX ME: cite allocator) is a thread-safe allocator that is multi-threaded and using a heap layer framework. It has per-thred heaps that have thread-local free-lists, and a gloabl shared heap. (FIX ME: cite wasik)
+\paragraph{jemalloc}
+jemalloc (FIX ME: cite allocator) is a thread-safe allocator that uses multiple arenas. Each thread is assigned an arena. Each arena has chunks that contain contagious memory regions of same size. An arena has multiple chunks that contain regions of multiple sizes.
+\paragraph{ptmalloc}
+ptmalloc (FIX ME: cite allocator) is a modification of dlmalloc. It is a thread-safe multi-threaded memory allocator that uses multiple heaps. ptmalloc heap has similar design to dlmalloc's heap.
+\paragraph{rpmalloc}
+rpmalloc (FIX ME: cite allocator) is a thread-safe allocator that is multi-threaded and uses per-thread heap. Each heap has multiple size-classes and each size-calss contains memory regions of the relevant size.
+\paragraph{tbb malloc}
+tbb malloc (FIX ME: cite allocator) is a thread-safe allocator that is multi-threaded and uses private heap for each thread. Each private-heap has multiple bins of different sizes. Each bin contains free regions of the same size.
+\paragraph{tc malloc}
+tcmalloc (FIX ME: cite allocator) is a thread-safe allocator. It uses per-thread cache to store free objects that prevents contention on shared resources in multi-threaded application. A central free-list is used to refill per-thread cache when it gets empty.
+\subsection{Benchmarks}
+There are multiple benchmarks that are built individually and evaluate different aspects of a memory allocator. But, there is not standard set of benchamrks that can be used to evaluate multiple aspects of memory allocators.
+\paragraph{threadtest}
+(FIX ME: cite benchmark and hoard) Each thread repeatedly allocates and then deallocates 100,000 objects. Runtime of the benchmark evaluates its efficiency.
+\paragraph{shbench}
+(FIX ME: cite benchmark and hoard) Each thread allocates and randomly frees a number of random-sized objects. It is a stress test that also uses runtime to determine efficiency of the allocator.
+\paragraph{larson}
+(FIX ME: cite benchmark and hoard) Larson simulates a server environment. Multiple threads are created where each thread allocator and free a number of objects within a size range. Some objects are passed from threads to the child threads to free. It caluculates memory operations per second as an indicator of memory allocator's performance.

doc/theses/mubeen_zulfiqar_MMath/benchmarks.tex

r949339b	rcc287800
149	149	*** FIX ME: Insert a figure of above benchmark with description
150	150
151		\paragrpah{Relevant Knobs}
	151	\paragraph{Relevant Knobs}
152	152	*** FIX ME: Insert Relevant Knobs
153	153

doc/theses/mubeen_zulfiqar_MMath/intro.tex

-                      r949339b
+                      rcc287800
 \begin{itemize}
 \item
 aligned_alloc
+aligned\_alloc
 \item
 malloc_usable_size
+malloc\_usable\_size
 \item
 memalign
 \item
 posix_memalign
+posix\_memalign
 \item
 pvalloc
 …
 With the rise of concurrent applications, memory allocators should be able to fulfill dynamic memory requests from multiple threads in parallel without causing contention on shared resources. There needs to be a set of a standard benchmarks that can be used to evaluate an allocator's performance in different scenerios.
-\section{Background}
-\subsection{Memory Allocation}
-With dynamic allocation being an important feature of C, there are many standalone memory allocators that have been designed for different purposes. For this thesis, we chose 7 of the most popular and widely used memory allocators.
-\paragraph{dlmalloc}
-dlmalloc (FIX ME: cite allocator) is a thread-safe allocator that is single threaded and single heap. dlmalloc maintains free-lists of different sizes to store freed dynamic memory. (FIX ME: cite wasik)
-\paragraph{hoard}
-Hoard (FIX ME: cite allocator) is a thread-safe allocator that is multi-threaded and using a heap layer framework. It has per-thred heaps that have thread-local free-lists, and a gloabl shared heap. (FIX ME: cite wasik)
-\paragraph{jemalloc}
-jemalloc (FIX ME: cite allocator) is a thread-safe allocator that uses multiple arenas. Each thread is assigned an arena. Each arena has chunks that contain contagious memory regions of same size. An arena has multiple chunks that contain regions of multiple sizes.
-\paragraph{ptmalloc}
-ptmalloc (FIX ME: cite allocator) is a modification of dlmalloc. It is a thread-safe multi-threaded memory allocator that uses multiple heaps. ptmalloc heap has similar design to dlmalloc's heap.
-\paragraph{rpmalloc}
-rpmalloc (FIX ME: cite allocator) is a thread-safe allocator that is multi-threaded and uses per-thread heap. Each heap has multiple size-classes and each size-calss contains memory regions of the relevant size.
-\paragraph{tbb malloc}
-tbb malloc (FIX ME: cite allocator) is a thread-safe allocator that is multi-threaded and uses private heap for each thread. Each private-heap has multiple bins of different sizes. Each bin contains free regions of the same size.
-\paragraph{tc malloc}
-tcmalloc (FIX ME: cite allocator) is a thread-safe allocator. It uses per-thread cache to store free objects that prevents contention on shared resources in multi-threaded application. A central free-list is used to refill per-thread cache when it gets empty.
-\subsection{Benchmarks}
-There are multiple benchmarks that are built individually and evaluate different aspects of a memory allocator. But, there is not standard set of benchamrks that can be used to evaluate multiple aspects of memory allocators.
-\paragraph{threadtest}
-(FIX ME: cite benchmark and hoard) Each thread repeatedly allocates and then deallocates 100,000 objects. Runtime of the benchmark evaluates its efficiency.
-\paragraph{shbench}
-(FIX ME: cite benchmark and hoard) Each thread allocates and randomly frees a number of random-sized objects. It is a stress test that also uses runtime to determine efficiency of the allocator.
-\paragraph{larson}
-(FIX ME: cite benchmark and hoard) Larson simulates a server environment. Multiple threads are created where each thread allocator and free a number of objects within a size range. Some objects are passed from threads to the child threads to free. It caluculates memory operations per second as an indicator of memory allocator's performance.
 \section{Research Objectives}

doc/theses/mubeen_zulfiqar_MMath/performance.tex

-                      r949339b
+                      rcc287800
 tc               &             &  \\
 \end{tabularx}
+(FIX ME: complete table)
+%(FIX ME: complete table)
 \section{Experiment Environment}

doc/theses/mubeen_zulfiqar_MMath/uw-ethesis.bib

-                      r949339b
+                      rcc287800
         address =       "Reading, Massachusetts"
+}
+@article{wasik.thesis,
+    author        = "Ayelet Wasik",
+    title         = "Features of A Multi-Threaded Memory Alloator",
+    publisher     = "University of Waterloo",
+    year          = "2008"
+}

doc/theses/mubeen_zulfiqar_MMath/uw-ethesis.tex

-                      r949339b
+                      rcc287800
 \usepackage{graphicx}
 \usepackage{comment} % Removes large sections of the document.
+\usepackage{tabularx}
 % Hyperlinks make it very easy to navigate an electronic document.
 …
 % Tip: Putting each sentence on a new line is a way to simplify later editing.
 %----------------------------------------------------------------------
+\begin{sloppypar}
 \input{intro}
 \input{background}
 …
 \input{performance}
 \input{conclusion}
+\end{sloppypar}
 %----------------------------------------------------------------------

doc/user/user.tex

-                      r949339b
+                      rcc287800
 %% Created On       : Wed Apr  6 14:53:29 2016
 %% Last Modified By : Peter A. Buhr
 %% Last Modified On : Mon May 31 09:03:34 2021
 %% Update Count     : 5071
+%% Last Modified On : Sun Oct 10 12:45:00 2021
+%% Update Count     : 5095
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 …
 \CFA provides a fine-grained solution where a \Index{recursive lock} is acquired and released indirectly via a manipulator ©acquire© or instantiating an \Index{RAII} type specific for the kind of stream: ©osacquire©\index{ostream@©ostream©!osacquire@©osacquire©} for output streams and ©isacquire©\index{isacquire@©isacquire©}\index{istream@©istream©!isacquire@©isacquire©} for input streams.
 The common usage is manipulator ©acquire©\index{ostream@©ostream©!acquire@©acquire©} to lock a stream during a single cascaded I/O expression, with the manipulator appearing as the first item in a cascade list, \eg:
 \begin{cfa}
 $\emph{thread\(_1\)}$ : sout | ®acquire® | "abc " | "def ";   // manipulator
 $\emph{thread\(_2\)}$ : sout | ®acquire® | "uvw " | "xyz ";
+The common usage is the short form of the mutex statement\index{ostream@©ostream©!mutex@©mutex©} to lock a stream during a single cascaded I/O expression, \eg:
+\begin{cfa}
+$\emph{thread\(_1\)}$ : ®mutex()® sout | "abc " | "def ";
+$\emph{thread\(_2\)}$ : ®mutex()® sout | "uvw " | "xyz ";
 \end{cfa}
 Now, the order of the thread execution is still non-deterministic, but the output is constrained to two possible lines in either order.
 …
 In summary, the stream lock is acquired by the ©acquire© manipulator and implicitly released at the end of the cascaded I/O expression ensuring all operations in the expression occur atomically.
+To lock a stream across multiple I/O operations, an object of type ©osacquire© or ©isacquire© is declared to implicitly acquire/release the stream lock providing mutual exclusion for the object's duration, \eg:
+\begin{cfa}
+{       // acquire sout for block duration
+        ®osacquire® acq = { sout };                             $\C{// named stream locker}$
+To lock a stream across multiple I/O operations, he long form of the mutex statement is used, \eg:
+\begin{cfa}
+®mutex( sout )® {
         sout | 1;
         sout | ®acquire® | 2 | 3;                               $\C{// unnecessary, but ok to acquire and release again}$
+        ®mutex() sout® | 2 | 3;                         $\C{// unnecessary, but ok because of recursive lock}$
         sout | 4;
 }       // implicitly release the lock when "acq" is deallocated
 \end{cfa}
 Note, the unnecessary ©acquire© manipulator works because the recursive stream-lock can be acquired/released multiple times by the owner thread.
+} // implicitly release sout lock
+\end{cfa}
+Note, the unnecessary ©mutex© in the middle of the mutex statement, works because the recursive stream-lock can be acquired/released multiple times by the owner thread.
 Hence, calls to functions that also acquire a stream lock for their output do not result in \Index{deadlock}.
 The previous values written by threads 1 and 2 can be read in concurrently:
 \begin{cfa}
+{       // acquire sin lock for block duration
+        ®isacquire acq = { sin };®                              $\C{// named stream locker}$
+®mutex( sin )® {
         int x, y, z, w;
         sin | x;
         sin | ®acquire® | y | z;                                $\C{// unnecessary, but ok to acquire and release again}$
+        ®mutex() sin® | y | z;                          $\C{// unnecessary, but ok because of recursive lock}$
         sin | w;
 }       // implicitly release the lock when "acq" is deallocated
+} // implicitly release sin lock
 \end{cfa}
 Again, the order of the reading threads is non-deterministic.
 …
 \Textbf{WARNING:} The general problem of \Index{nested locking} can occur if routines are called in an I/O sequence that block, \eg:
 \begin{cfa}
 sout | ®acquire® | "data:" | rtn( mon );        $\C{// mutex call on monitor}$
+®mutex() sout® | "data:" | rtn( mon );  $\C{// mutex call on monitor}$
 \end{cfa}
 If the thread executing the I/O expression blocks in the monitor with the ©sout© lock, other threads writing to ©sout© also block until the thread holding the lock is unblocked and releases it.
 …
 \begin{cfa}
 int ®data® = rtn( mon );
 sout | acquire | "data:" | ®data®;
+mutex() sout | "data:" | ®data®;
 \end{cfa}
 …
 \section{String Stream}
+All the stream formatting capabilities are available to format text to/from a C string rather than to a stream file.
+\VRef[Figure]{f:StringStreamProcessing} shows writing (output) and reading (input) from a C string.
+The stream types ©ostrstream© and ©istrstream© provide all the stream formatting capabilities to/from a C string rather than a stream file.
+\VRef[Figure]{f:StringStreamProcessing} shows writing (output) to and reading (input) from a C string.
+The only string stream operations different from a file stream are:
+\begin{itemize}[topsep=4pt,itemsep=2pt,parsep=0pt]
+\item
+constructors to create a stream that writes to a write buffer (©ostrstream©) of ©size©, or reads from a read buffer (©istrstream©) containing a C string terminated with ©'\0'©.
+\begin{cfa}
+void ?{}( ostrstream &, char buf[], size_t size );
+void ?{}( istrstream & is, char buf[] );
+\end{cfa}
+\item
+\Indexc{write} (©ostrstream© only) writes all the buffered characters to the specified stream (©stdout© default).
+\begin{cfa}
+ostrstream & write( ostrstream & os, FILE * stream = stdout );
+\end{cfa}
+There is no ©read© for ©istrstream©.
+\end{itemize}
 \begin{figure}
 \begin{cfa}
 …
         double x = 12345678.9, y = 98765.4321e-11;
         osstr | i | hex(j) | wd(10, k) | sci(x) | unit(eng(y)); $\C{// same lines of output}$
         write( osstr );
         printf( "%s", buf );
         sout | i | hex(j) | wd(10, k) | sci(x) | unit(eng(y));
         char buf2[] = "12 14 15 3.5 7e4"; $\C{// input buffer}$
+        osstr | i | hex(j) | wd(10, k) | sci(x) | unit(eng(y)) | "abc";
+        write( osstr ); $\C{// write string to stdout}$
+        printf( "%s", buf ); $\C{// same lines of output}$
+        sout | i | hex(j) | wd(10, k) | sci(x) | unit(eng(y)) | "abc";
+        char buf2[] = "12 14 15 3.5 7e4 abc"; $\C{// input buffer}$
         ®istrstream isstr = { buf2 };®
+        isstr | i | j | k | x | y;
+        sout | i | j | k | x | y;
+}
+        char s[10];
+        isstr | i | j | k | x | y | s;
+        sout  | i | j | k | x | y | s;
+}
+0x5          7 1.234568e+07 987.654n abc
+0x5          7 1.234568e+07 987.654n abc
+0x5          7 1.234568e+07 987.654n abc
+14 15 3.5 70000. abc
 \end{cfa}
 \caption{String Stream Processing}
 \label{f:StringStreamProcessing}
 \end{figure}
-\VRef[Figure]{f:StringStreamFunctions} shows the string stream operations.
-\begin{itemize}[topsep=4pt,itemsep=2pt,parsep=0pt]
-\item
-\Indexc{write} (©ostrstream© only) writes all the buffered characters to the specified stream (©stdout© default).
-\end{itemize}
-The constructor functions:
-\begin{itemize}[topsep=4pt,itemsep=2pt,parsep=0pt]
-\item
-create a bound stream to a write buffer (©ostrstream©) of ©size© or a read buffer (©istrstream©) containing a C string terminated with ©'\0'©.
-\end{itemize}
-\begin{figure}
-\begin{cfa}
-// *********************************** ostrstream ***********************************
-ostrstream & write( ostrstream & os, FILE * stream = stdout );
-void ?{}( ostrstream &, char buf[], size_t size );
-// *********************************** istrstream ***********************************
-void ?{}( istrstream & is, char buf[] );
-\end{cfa}
-\caption{String Stream Functions}
-\label{f:StringStreamFunctions}
-\end{figure}
 \begin{comment}

libcfa/prelude/bootloader.cf

-                      r949339b
+                      rcc287800
 char ** cfa_args_argv;
 char ** cfa_args_envp;
 int cfa_main_returned = 0;
+__attribute__((weak)) extern int cfa_main_returned;
 int main(int argc, char* argv[], char* envp[]) {
 …
         cfa_args_envp = envp;
         int ret = invoke_main(argc, argv, envp);
         cfa_main_returned = 1;
+        if(&cfa_main_returned) cfa_main_returned = 1;
         return ret;
+}

libcfa/src/concurrency/io.cfa

-                      r949339b
+                      rcc287800
                 ctx.proc->io.pending = false;
-                ready_schedule_lock();
                 __cfa_io_drain( proc );
-                ready_schedule_unlock();
                 // for(i; 2) {
                 //      unsigned idx = proc->rdq.id + i;
 …
                 // Make the sqes visible to the submitter
                 __atomic_store_n(sq.kring.tail, tail + have, __ATOMIC_RELEASE);
                 sq.to_submit++;
+                sq.to_submit += have;
                 ctx->proc->io.pending = true;
                 ctx->proc->io.dirty   = true;
                 if(sq.to_submit > 30 || !lazy) {
+                        ready_schedule_lock();
                         __cfa_io_flush( ctx->proc );
+                        ready_schedule_unlock();
+                }
+        }

libcfa/src/concurrency/io/types.hfa

r949339b	rcc287800
188	188	return wait(this.self);
189	189	}
	190
	191	void reset( io_future_t & this ) {
	192	return reset(this.self);
	193	}
190	194	}

libcfa/src/concurrency/kernel.cfa

-                      r949339b
+                      rcc287800
                         if( !readyThread ) {
+                                ready_schedule_lock();
                                 __cfa_io_flush( this );
+                                ready_schedule_unlock();
                                 readyThread = __next_thread_slow( this->cltr );
+                        }
 …
                         if(this->io.pending && !this->io.dirty) {
+                                ready_schedule_lock();
                                 __cfa_io_flush( this );
+                                ready_schedule_unlock();
+                        }
 …
                                 // Don't block if we are done
+                                if( __atomic_load_n(&this->do_terminate, __ATOMIC_SEQ_CST) ) break MAIN_LOOP;
+                                if( __atomic_load_n(&this->do_terminate, __ATOMIC_SEQ_CST) ) {
+                                        ready_schedule_unlock();
+                                        break MAIN_LOOP;
+                                }
                                 __STATS( __tls_stats()->ready.sleep.halts++; )
 …
                         /* paranoid */ verifyf( it, "Unexpected null iterator, at index %u of %u\n", i, count);
                         /* paranoid */ verify( it->local_data->this_stats );
+                        // __print_stats( it->local_data->this_stats, cltr->print_stats, "Processor", it->name, (void*)it );
                         __tally_stats( cltr->stats, it->local_data->this_stats );
                         it = &(*it)`next;
 …
                 // this doesn't solve all problems but does solve many
                 // so it's probably good enough
+                disable_interrupts();
                 uint_fast32_t last_size = ready_mutate_lock();
 …
                 // Unlock the RWlock
                 ready_mutate_unlock( last_size );
+                enable_interrupts();
+        }

libcfa/src/concurrency/kernel/startup.cfa

-                      r949339b
+                      rcc287800
 // Other Forward Declarations
 extern void __wake_proc(processor *);
+extern int cfa_main_returned;                                                   // from interpose.cfa
 //-----------------------------------------------------------------------------
 …
 static void __kernel_shutdown(void) {
+        if(!cfa_main_returned) return;
         /* paranoid */ verify( __preemption_enabled() );
         disable_interrupts();

libcfa/src/concurrency/monitor.hfa

-                      r949339b
+                      rcc287800
         free( th );
+}
+static inline forall( T & | sized(T) | { void ^?{}( T & mutex ); } )
+void adelete( T arr[] ) {
+        if ( arr ) {                                                                            // ignore null
+                size_t dim = malloc_size( arr ) / sizeof( T );
+                for ( int i = dim - 1; i >= 0; i -= 1 ) {               // reverse allocation order, must be unsigned
+                        ^(arr[i]){};                                                            // run destructor
+                } // for
+                free( arr );
+        } // if
+} // adelete
 //-----------------------------------------------------------------------------

libcfa/src/concurrency/mutex_stmt.hfa

-                      r949339b
+                      rcc287800
 #include "bits/algorithm.hfa"
+#include <assert.h>
+#include "invoke.h"
+#include "stdlib.hfa"
+#include <stdio.h>
+#include "bits/defs.hfa"
 //-----------------------------------------------------------------------------

libcfa/src/device/cpu.cfa

r949339b	rcc287800
144	144	// Count number of cpus in the system
145	145	static int count_cpus(void) {
146		const char * fpath = "/sys/devices/system/cpu/~~present~~";
	146	const char * fpath = "/sys/devices/system/cpu/online";
147	147	int fd = open(fpath, 0, O_RDONLY);
148	148	/* paranoid */ verifyf(fd >= 0, "Could not open file %s", fpath);

libcfa/src/fstream.cfa

-                      r949339b
+                      rcc287800
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue Sep 21 21:51:38 2021
 // Update Count     : 460
+// Last Modified On : Sun Oct 10 11:23:05 2021
+// Update Count     : 512
 //
 …
 #define IO_MSG "I/O error: "
+void ?{}( ofstream & os, void * file ) with(os) {
+// private
+void ?{}( ofstream & os, void * file ) with( os ) {
         file$ = file;
         sepDefault$ = true;
 …
         prt$ = false;
         sawNL$ = false;
-        acquired$ = false;
         sepSetCur$( os, sepGet( os ) );
         sepSet( os, " " );
 …
 } // ?{}
+// private
+bool sepPrt$( ofstream & os ) { setNL$( os, false ); return os.sepOnOff$; }
+void sepReset$( ofstream & os ) { os.sepOnOff$ = os.sepDefault$; }
+void sepReset$( ofstream & os, bool reset ) { os.sepDefault$ = reset; os.sepOnOff$ = os.sepDefault$; }
+const char * sepGetCur$( ofstream & os ) { return os.sepCur$; }
+void sepSetCur$( ofstream & os, const char sepCur[] ) { os.sepCur$ = sepCur; }
+bool getNL$( ofstream & os ) { return os.sawNL$; }
+void setNL$( ofstream & os, bool state ) { os.sawNL$ = state; }
+bool getANL$( ofstream & os ) { return os.nlOnOff$; }
+bool getPrt$( ofstream & os ) { return os.prt$; }
+void setPrt$( ofstream & os, bool state ) { os.prt$ = state; }
+inline bool sepPrt$( ofstream & os ) { setNL$( os, false ); return os.sepOnOff$; }
+inline void sepReset$( ofstream & os ) { os.sepOnOff$ = os.sepDefault$; }
+inline void sepReset$( ofstream & os, bool reset ) { os.sepDefault$ = reset; os.sepOnOff$ = os.sepDefault$; }
+inline const char * sepGetCur$( ofstream & os ) { return os.sepCur$; }
+inline void sepSetCur$( ofstream & os, const char sepCur[] ) { os.sepCur$ = sepCur; }
+inline bool getNL$( ofstream & os ) { return os.sawNL$; }
+inline void setNL$( ofstream & os, bool state ) { os.sawNL$ = state; }
+inline bool getANL$( ofstream & os ) { return os.nlOnOff$; }
+inline bool getPrt$( ofstream & os ) { return os.prt$; }
+inline void setPrt$( ofstream & os, bool state ) { os.prt$ = state; }
+inline void lock( ofstream & os ) with( os ) {  lock( os.lock$ ); }
+inline void unlock( ofstream & os ) { unlock( os.lock$ ); }
 // public
 void ?{}( ofstream & os ) { os.file$ = 0p; }
+void ?{}( ofstream & os, const char name[], const char mode[] ) {
+        open( os, name, mode );
+} // ?{}
+void ?{}( ofstream & os, const char name[] ) {
+        open( os, name, "w" );
+} // ?{}
+void ^?{}( ofstream & os ) {
+        close( os );
+} // ^?{}
+void ?{}( ofstream & os, const char name[], const char mode[] ) { open( os, name, mode ); }
+void ?{}( ofstream & os, const char name[] ) { open( os, name, "w" ); }
+void ^?{}( ofstream & os ) { close( os ); }
 void sepOn( ofstream & os ) { os.sepOnOff$ = ! getNL$( os ); }
 …
         if ( &os == &exit ) exit( EXIT_FAILURE );
         if ( &os == &abort ) abort();
-        if ( os.acquired$ ) { os.acquired$ = false; release( os ); }
 } // ends
+bool fail( ofstream & os ) {
+        return os.file$ == 0 || ferror( (FILE *)(os.file$) );
+} // fail
+void clear( ofstream & os ) {
+        clearerr( (FILE *)(os.file$) );
+} // clear
+int flush( ofstream & os ) {
+        return fflush( (FILE *)(os.file$) );
+} // flush
+bool fail( ofstream & os ) { return os.file$ == 0 || ferror( (FILE *)(os.file$) ); }
+void clear( ofstream & os ) { clearerr( (FILE *)(os.file$) ); }
+int flush( ofstream & os ) { return fflush( (FILE *)(os.file$) ); }
 void open( ofstream & os, const char name[], const char mode[] ) {
+        FILE * file = fopen( name, mode );
+        FILE * file;
+    for ( cnt; 10 ) {
+                errno = 0;
+                file = fopen( name, mode );
+          if ( file != 0p || errno != EINTR ) break;            // timer interrupt ?
+          if ( cnt == 9 ) abort( "ofstream open EINTR spinning exceeded" );
+    } // for
         if ( file == 0p ) {
                 throw (Open_Failure){ os };
 …
 } // open
+void open( ofstream & os, const char name[] ) {
+        open( os, name, "w" );
+} // open
+void close( ofstream & os ) with(os) {
+void open( ofstream & os, const char name[] ) { open( os, name, "w" ); }
+void close( ofstream & os ) with( os ) {
   if ( (FILE *)(file$) == 0p ) return;
   if ( (FILE *)(file$) == (FILE *)stdout || (FILE *)(file$) == (FILE *)stderr ) return;
+        if ( fclose( (FILE *)(file$) ) == EOF ) {
+        int ret;
+    for ( cnt; 10 ) {
+                errno = 0;
+                ret = fclose( (FILE *)(file$) );
+          if ( ret != EOF || errno != EINTR ) break;            // timer interrupt ?
+          if ( cnt == 9 ) abort( "ofstream open EINTR spinning exceeded" );
+    } // for
+        if ( ret == EOF ) {
                 throw (Close_Failure){ os };
                 // abort | IO_MSG "close output" | nl | strerror( errno );
         } // if
         file$ = 0p;
+        file$ = 0p;                                                                                     // safety after close
 } // close
 …
         va_list args;
         va_start( args, format );
+        int len = vfprintf( (FILE *)(os.file$), format, args );
+        int len;
+    for ( cnt; 10 ) {
+                errno = 0;
+                len = vfprintf( (FILE *)(os.file$), format, args );
+          if ( len != EOF || errno != EINTR ) break;            // timer interrupt ?
+          if ( cnt == 9 ) abort( "ofstream fmt EINTR spinning exceeded" );
+    } // for
         if ( len == EOF ) {
                 if ( ferror( (FILE *)(os.file$) ) ) {
 …
 } // fmt
-inline void acquire( ofstream & os ) with(os) {
-        lock( lock$ );                                                                          // may increase recursive lock
-        if ( ! acquired$ ) acquired$ = true;                            // not locked ?
-        else unlock( lock$ );                                                           // unwind recursive lock at start
-} // acquire
-inline void release( ofstream & os ) {
-        unlock( os.lock$ );
-} // release
-void ?{}( osacquire & acq, ofstream & os ) { lock( os.lock$ ); &acq.os = &os; }
-void ^?{}( osacquire & acq ) { release( acq.os ); }
 static ofstream soutFile = { (FILE *)stdout };
 ofstream & sout = soutFile, & stdout = soutFile;
 …
         flush( os );
         return os;
-        // (ofstream &)(os | '\n');
-        // setPrt$( os, false );                                                        // turn off
-        // setNL$( os, true );
-        // flush( os );
-        // return sepOff( os );                                                 // prepare for next line
 } // nl
 …
 // private
 void ?{}( ifstream & is, void * file ) with(is) {
+void ?{}( ifstream & is, void * file ) with( is ) {
         file$ = file;
         nlOnOff$ = false;
+        acquired$ = false;
+} // ?{}
+} // ?{}
+bool getANL$( ifstream & os ) { return os.nlOnOff$; }
+inline void lock( ifstream & os ) with( os ) { lock( os.lock$ ); }
+inline void unlock( ifstream & os ) { unlock( os.lock$ ); }
 // public
 void ?{}( ifstream & is ) { is.file$ = 0p; }
+void ?{}( ifstream & is, const char name[], const char mode[] ) {
+        open( is, name, mode );
+} // ?{}
+void ?{}( ifstream & is, const char name[] ) {
+        open( is, name, "r" );
+} // ?{}
+void ^?{}( ifstream & is ) {
+        close( is );
+} // ^?{}
+void ?{}( ifstream & is, const char name[], const char mode[] ) { open( is, name, mode ); }
+void ?{}( ifstream & is, const char name[] ) { open( is, name, "r" ); }
+void ^?{}( ifstream & is ) { close( is ); }
+bool fail( ifstream & is ) { return is.file$ == 0p || ferror( (FILE *)(is.file$) ); }
+void clear( ifstream & is ) { clearerr( (FILE *)(is.file$) ); }
 void nlOn( ifstream & os ) { os.nlOnOff$ = true; }
 void nlOff( ifstream & os ) { os.nlOnOff$ = false; }
+bool getANL( ifstream & os ) { return os.nlOnOff$; }
+bool fail( ifstream & is ) {
+        return is.file$ == 0p || ferror( (FILE *)(is.file$) );
+} // fail
+void clear( ifstream & is ) {
+        clearerr( (FILE *)(is.file$) );
+} // clear
+void ends( ifstream & is ) {
+        if ( is.acquired$ ) { is.acquired$ = false; release( is ); }
+} // ends
+bool eof( ifstream & is ) {
+        return feof( (FILE *)(is.file$) );
+} // eof
+void ends( ifstream & is ) {}
+bool eof( ifstream & is ) { return feof( (FILE *)(is.file$) ) != 0; }
 void open( ifstream & is, const char name[], const char mode[] ) {
+        FILE * file = fopen( name, mode );
+        FILE * file;
+    for ( cnt; 10 ) {
+                errno = 0;
+                file = fopen( name, mode );
+          if ( file != 0p || errno != EINTR ) break;            // timer interrupt ?
+          if ( cnt == 9 ) abort( "ifstream open EINTR spinning exceeded" );
+    } // for
         if ( file == 0p ) {
                 throw (Open_Failure){ is };
 …
 } // open
+void open( ifstream & is, const char name[] ) {
+        open( is, name, "r" );
+} // open
+void close( ifstream & is ) with(is) {
+void open( ifstream & is, const char name[] ) { open( is, name, "r" ); }
+void close( ifstream & is ) with( is ) {
   if ( (FILE *)(file$) == 0p ) return;
   if ( (FILE *)(file$) == (FILE *)stdin ) return;
+        if ( fclose( (FILE *)(file$) ) == EOF ) {
+        int ret;
+    for ( cnt; 10 ) {
+                errno = 0;
+                ret = fclose( (FILE *)(file$) );
+          if ( ret != EOF || errno != EINTR ) break;            // timer interrupt ?
+          if ( cnt == 9 ) abort( "ifstream close EINTR spinning exceeded" );
+    } // for
+        if ( ret == EOF ) {
                 throw (Close_Failure){ is };
                 // abort | IO_MSG "close input" | nl | strerror( errno );
         } // if
         file$ = 0p;
+        file$ = 0p;                                                                                     // safety after close
 } // close
 …
 int fmt( ifstream & is, const char format[], ... ) {
         va_list args;
         va_start( args, format );
+        int len = vfscanf( (FILE *)(is.file$), format, args );
+        int len;
+    for () {                                                                                    // no check for EINTR limit waiting for keyboard input
+                errno = 0;
+                len = vfscanf( (FILE *)(is.file$), format, args );
+          if ( len != EOF || errno != EINTR ) break;            // timer interrupt ?
+    } // for
         if ( len == EOF ) {
                 if ( ferror( (FILE *)(is.file$) ) ) {
 …
         return len;
 } // fmt
-inline void acquire( ifstream & is ) with(is) {
-        lock( lock$ );                                                                          // may increase recursive lock
-        if ( ! acquired$ ) acquired$ = true;                            // not locked ?
-        else unlock( lock$ );                                                           // unwind recursive lock at start
-} // acquire
-inline void release( ifstream & is ) {
-        unlock( is.lock$ );
-} // release
-void ?{}( isacquire & acq, ifstream & is ) { lock( is.lock$ ); &acq.is = &is; }
-void ^?{}( isacquire & acq ) { release( acq.is ); }
 static ifstream sinFile = { (FILE *)stdin };

libcfa/src/fstream.hfa

-                      r949339b
+                      rcc287800
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Jul 28 07:35:50 2021
 // Update Count     : 234
+// Last Modified On : Sun Oct 10 09:37:32 2021
+// Update Count     : 243
 //
 …
         char tupleSeparator$[ofstream_sepSize];
         multiple_acquisition_lock lock$;
-        bool acquired$;
 }; // ofstream
 …
 bool getPrt$( ofstream & );
 void setPrt$( ofstream &, bool );
+void lock( ofstream & );
+void unlock( ofstream & );
 // public
 …
 void open( ofstream &, const char name[] );
 void close( ofstream & );
 ofstream & write( ofstream &, const char data[], size_t size );
-void acquire( ofstream & );
-void release( ofstream & );
-void lock( ofstream & );
-void unlock( ofstream & );
-struct osacquire {
-        ofstream & os;
-};
-void ?{}( osacquire & acq, ofstream & );
-void ^?{}( osacquire & acq );
 void ?{}( ofstream & );
 …
         bool nlOnOff$;
         multiple_acquisition_lock lock$;
-        bool acquired$;
 }; // ifstream
 // Satisfies istream
+// private
+bool getANL$( ifstream & );
+void lock( ifstream & );
+void unlock( ifstream & );
 // public
 void nlOn( ifstream & );
 void nlOff( ifstream & );
-bool getANL( ifstream & );
 void ends( ifstream & );
 int fmt( ifstream &, const char format[], ... ) __attribute__(( format(scanf, 2, 3) ));
 …
 void open( ifstream & is, const char name[] );
 void close( ifstream & is );
 ifstream & read( ifstream & is, char data[], size_t size );
 ifstream & ungetc( ifstream & is, char c );
-void acquire( ifstream & is );
-void release( ifstream & is );
-struct isacquire {
-        ifstream & is;
-};
-void ?{}( isacquire & acq, ifstream & is );
-void ^?{}( isacquire & acq );
 void ?{}( ifstream & is );

libcfa/src/heap.cfa

r949339b	rcc287800
102	102	} // prtUnfreed
103	103
104		extern int cfa_main_returned; // from ~~bootloader.cf~~
	104	extern int cfa_main_returned; // from interpose.cfa
105	105	extern "C" {
106	106	void heapAppStart() { // called by __cfaabi_appready_startup

libcfa/src/interpose.cfa

-                      r949339b
+                      rcc287800
 } __cabi_libc;
+int cfa_main_returned;
 extern "C" {
         void __cfaabi_interpose_startup( void ) {
                 const char *version = 0p;
+                cfa_main_returned = 0;
                 preload_libgcc();

libcfa/src/iostream.cfa

-                      r949339b
+                      rcc287800
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat May 15 09:39:21 2021
 // Update Count     : 1342
+// Last Modified On : Sun Oct 10 09:28:17 2021
+// Update Count     : 1345
 //
 …
                 return os;
         } // nlOff
-} // distribution
-forall( ostype & | ostream( ostype ) ) {
-        ostype & acquire( ostype & os ) {
-                acquire( os );                                                                  // call void returning
-                return os;
-        } // acquire
 } // distribution
 …
                         fmt( is, "%c", &temp );                                         // must pass pointer through varg to fmt
                         // do not overwrite parameter with newline unless appropriate
                         if ( temp != '\n' || getANL( is ) ) { c = temp; break; }
+                        if ( temp != '\n' || getANL$( is ) ) { c = temp; break; }
                         if ( eof( is ) ) break;
                 } // for
 …
                 return is;
         } // nlOff
-} // distribution
-forall( istype & | istream( istype ) ) {
-        istype & acquire( istype & is ) {
-                acquire( is );                                                                  // call void returning
-                return is;
-        } // acquire
 } // distribution

libcfa/src/iostream.hfa

-                      r949339b
+                      rcc287800
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Apr 28 20:37:56 2021
 // Update Count     : 401
+// Last Modified On : Sun Oct 10 10:02:07 2021
+// Update Count     : 407
 //
 …
         void close( ostype & );
         ostype & write( ostype &, const char [], size_t );
-        void acquire( ostype & );                                                       // concurrent access
 }; // ostream
 …
         ostype & nlOn( ostype & );
         ostype & nlOff( ostype & );
-} // distribution
-forall( ostype & | ostream( ostype ) ) {
-        ostype & acquire( ostype & );
 } // distribution
 …
 trait basic_istream( istype & ) {
+        bool getANL( istype & );                                                        // get scan newline (on/off)
+        // private
+        bool getANL$( istype & );                                                       // get scan newline (on/off)
+        // public
         void nlOn( istype & );                                                          // read newline
         void nlOff( istype & );                                                         // scan newline
         void ends( istype & os );                                                       // end of output statement
         int fmt( istype &, const char format[], ... ) __attribute__(( format(scanf, 2, 3) ));
 …
         void close( istype & is );
         istype & read( istype &, char [], size_t );
-        void acquire( istype & );                                                       // concurrent access
 }; // istream
 …
 } // distribution
-forall( istype & | istream( istype ) ) {
-        istype & acquire( istype & );
-} // distribution
 // *********************************** manipulators ***********************************

libcfa/src/strstream.cfa

-                      r949339b
+                      rcc287800
 // Created On       : Thu Apr 22 22:24:35 2021
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue Apr 27 20:59:53 2021
 // Update Count     : 78
+// Last Modified On : Sun Oct 10 16:13:20 2021
+// Update Count     : 101
 //
 #include "strstream.hfa"
+#include "fstream.hfa"                                                                  // abort
 #include <stdio.h>                                                                              // vsnprintf
 …
 // private
 bool sepPrt$( ostrstream & os ) { setNL$( os, false ); return os.sepOnOff$; }
 void sepReset$( ostrstream & os ) { os.sepOnOff$ = os.sepDefault$; }
 void sepReset$( ostrstream & os, bool reset ) { os.sepDefault$ = reset; os.sepOnOff$ = os.sepDefault$; }
 const char * sepGetCur$( ostrstream & os ) { return os.sepCur$; }
 void sepSetCur$( ostrstream & os, const char sepCur[] ) { os.sepCur$ = sepCur; }
 bool getNL$( ostrstream & os ) { return os.sawNL$; }
 void setNL$( ostrstream & os, bool state ) { os.sawNL$ = state; }
 bool getANL$( ostrstream & os ) { return os.nlOnOff$; }
 bool getPrt$( ostrstream & os ) { return os.prt$; }
 void setPrt$( ostrstream & os, bool state ) { os.prt$ = state; }
+inline bool sepPrt$( ostrstream & os ) { setNL$( os, false ); return os.sepOnOff$; }
+inline void sepReset$( ostrstream & os ) { os.sepOnOff$ = os.sepDefault$; }
+inline void sepReset$( ostrstream & os, bool reset ) { os.sepDefault$ = reset; os.sepOnOff$ = os.sepDefault$; }
+inline const char * sepGetCur$( ostrstream & os ) { return os.sepCur$; }
+inline void sepSetCur$( ostrstream & os, const char sepCur[] ) { os.sepCur$ = sepCur; }
+inline bool getNL$( ostrstream & os ) { return os.sawNL$; }
+inline void setNL$( ostrstream & os, bool state ) { os.sawNL$ = state; }
+inline bool getANL$( ostrstream & os ) { return os.nlOnOff$; }
+inline bool getPrt$( ostrstream & os ) { return os.prt$; }
+inline void setPrt$( ostrstream & os, bool state ) { os.prt$ = state; }
 // public
 …
 // *********************************** istrstream ***********************************
+// private
+bool getANL$( istrstream & is ) { return is.nlOnOff$; }
 // public
 …
 } // ?{}
-bool getANL( istrstream & is ) { return is.nlOnOff$; }
 void nlOn( istrstream & is ) { is.nlOnOff$ = true; }
 void nlOff( istrstream & is ) { is.nlOnOff$ = false; }
 void ends( istrstream & is ) {
+} // ends
+void ends( istrstream & is ) {}
+bool eof( istrstream & is ) { return false; }
+int eof( istrstream & is ) {
+        return 0;
+} // eof
+int fmt( istrstream & is, const char format[], ... ) with(is) {
+        va_list args;
+        va_start( args, format );
+        // THIS DOES NOT WORK BECAUSE VSSCANF RETURNS NUMBER OF VALUES READ VERSUS BUFFER POSITION SCANNED.
+        int len = vsscanf( buf$ + cursor$, format, args );
+        va_end( args );
+        if ( len == EOF ) {
+                abort | IO_MSG "invalid read";
+        } // if
+        // SKULLDUGGERY: This hack skips over characters read by vsscanf by moving to the next whitespace but it does not
+        // handle C reads with wdi manipulators that leave the cursor at a non-whitespace character.
+        for ( ; buf$[cursor$] != ' ' && buf$[cursor$] != '\t' && buf$[cursor$] != '\0'; cursor$ += 1 ) {
+                //printf( "X \'%c\'\n", buf$[cursor$] );
+        } // for
+        if ( buf$[cursor$] != '\0' ) cursor$ += 1;      // advance to whitespace
+        return len;
+} // fmt
 istrstream &ungetc( istrstream & is, char c ) {
 …
 } // ungetc
-int fmt( istrstream & is, const char format[], ... ) {
-        va_list args;
-        va_start( args, format );
-        // This does not work because vsscanf does not return buffer position.
-        int len = vsscanf( is.buf$ + is.cursor$, format, args );
-        va_end( args );
-        if ( len == EOF ) {
-                int j;
-                printf( "X %d%n\n", len, &j );
-        } // if
-        is.cursor$ += len;
-        return len;
-} // fmt
 // Local Variables: //
 // tab-width: 4 //

libcfa/src/strstream.hfa

-                      r949339b
+                      rcc287800
 // Created On       : Thu Apr 22 22:20:59 2021
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue Apr 27 20:58:50 2021
 // Update Count     : 41
+// Last Modified On : Sun Oct 10 10:14:22 2021
+// Update Count     : 47
 //
 …
 // Satisfies basic_istream
+// private
+bool getANL$( istrstream & );
 // public
-bool getANL( istrstream & );
 void nlOn( istrstream & );
 void nlOff( istrstream & );
 void ends( istrstream & );
 int fmt( istrstream &, const char format[], ... ) __attribute__(( format(scanf, 2, 3) ));
 istrstream & ungetc( istrstream & is, char c );
 int eof( istrstream & is );
+istrstream & ungetc( istrstream &, char );
+bool eof( istrstream & );
 void ?{}( istrstream & is, char buf[] );
+void ?{}( istrstream &, char buf[] );
 // Local Variables: //

src/AST/Decl.hpp

r949339b	rcc287800
131	131	// declared type, derived from parameter declarations
132	132	ptr<FunctionType> type;
	133	/// Null for the forward declaration of a function.
133	134	ptr<CompoundStmt> stmts;
134	135	std::vector< ptr<Expr> > withExprs;

src/AST/Pass.hpp

-                      r949339b
+                      rcc287800
         /// When this node is finished being visited, restore the value of a variable
+        /// You may assign to the return value to set the new value in the same statement.
         template< typename T >
         void GuardValue( T& val ) {
+        T& GuardValue( T& val ) {
                 at_cleanup( [ val ]( void * newVal ) {
                         * static_cast< T * >( newVal ) = val;
                 }, static_cast< void * >( & val ) );
+                return val;
+        }
 …
 };
+/// Used to get a pointer to the wrapping TranslationUnit.
+struct WithConstTranslationUnit {
+        const TranslationUnit * translationUnit = nullptr;
+        const TranslationUnit & transUnit() const {
+                assertf( translationUnit, "WithConstTranslationUnit not set-up." );
+                return *translationUnit;
+        }
+};
+}

src/AST/Pass.impl.hpp

-                      r949339b
+                      rcc287800
 template< typename core_t >
 inline void ast::accept_all( ast::TranslationUnit & unit, ast::Pass< core_t > & visitor ) {
+        return ast::accept_all( unit.decls, visitor );
+        if ( auto ptr = __pass::translation_unit::get_cptr( visitor.core, 0 ) ) {
+                ValueGuard<const TranslationUnit *> guard( *ptr );
+                *ptr = &unit;
+                return ast::accept_all( unit.decls, visitor );
+        } else {
+                return ast::accept_all( unit.decls, visitor );
+        }
+}

src/AST/Pass.proto.hpp

-                      r949339b
+                      rcc287800
         } // namespace forall
+        // For passes that need access to the global context. Sreaches `translationUnit`
+        namespace translation_unit {
+                template<typename core_t>
+                static inline auto get_cptr( core_t & core, int )
+                                -> decltype( &core.translationUnit ) {
+                        return &core.translationUnit;
+                }
+                template<typename core_t>
+                static inline const TranslationUnit ** get_cptr( core_t &, long ) {
+                        return nullptr;
+                }
+        }
         template<typename core_t>
         static inline auto get_result( core_t & core, char ) -> decltype( core.result() ) {

src/AST/Stmt.hpp

r949339b	rcc287800
175	175	class CaseStmt final : public Stmt {
176	176	public:
	177	/// Null for the default label.
177	178	ptr<Expr> cond;
178	179	std::vector<ptr<Stmt>> stmts;

src/AST/TranslationUnit.hpp

-                      r949339b
+                      rcc287800
         std::list< ptr< Decl > > decls;
         struct Globals {
+        struct Global {
                 std::map< UniqueId, Decl * > idMap;
                 const Type * sizeType;
+                ptr<Type> sizeType;
                 const FunctionDecl * dereference;
                 const StructDecl * dtorStruct;

src/AST/porting.md

r949339b	rcc287800
98	98	* `Initializer` => `ast::Init`
99	99	* `Statement` => `ast::Stmt`
	100	* `ReferenceToType` => `ast::BaseInstType`
100	101	* any field names should follow a similar renaming
101	102	* because they don't really belong to `Type` (and for consistency with `Linkage::Spec`):

src/CodeGen/FixMain.cc

-                      r949339b
+                      rcc287800
 #include <string>                  // for operator<<
+#include "AST/Decl.hpp"
+#include "AST/Type.hpp"
+#include "Common/PassVisitor.h"
 #include "Common/SemanticError.h"  // for SemanticError
 #include "CodeGen/GenType.h"       // for GenType
 …
 namespace CodeGen {
+namespace {
+struct FindMainCore {
+        FunctionDecl * main_signature = nullptr;
+        void previsit( FunctionDecl * decl ) {
+                if ( FixMain::isMain( decl ) ) {
+                        if ( main_signature ) {
+                                SemanticError( decl, "Multiple definition of main routine\n" );
+                        }
+                        main_signature = decl;
+                }
+        }
+};
+}
         bool FixMain::replace_main = false;
-        std::unique_ptr<FunctionDecl> FixMain::main_signature = nullptr;
         template<typename container>
 …
+        }
+        void FixMain::registerMain(FunctionDecl* functionDecl)
+        {
+                if(main_signature) {
+                        SemanticError(functionDecl, "Multiple definition of main routine\n");
+                }
+                main_signature.reset( functionDecl->clone() );
+        }
+        void FixMain::fix( std::list< Declaration * > & translationUnit,
+                        std::ostream &os, const char* bootloader_filename ) {
+                PassVisitor< FindMainCore > main_finder;
+                acceptAll( translationUnit, main_finder );
+                FunctionDecl * main_signature = main_finder.pass.main_signature;
-        void FixMain::fix(std::ostream &os, const char* bootloader_filename) {
                 if( main_signature ) {
                         os << "static inline int invoke_main(int argc, char* argv[], char* envp[]) { (void)argc; (void)argv; (void)envp; return ";
                         main_signature->mangleName = SymTab::Mangler::mangle(main_signature.get());
+                        main_signature->mangleName = SymTab::Mangler::mangle(main_signature);
                         os << main_signature->get_scopedMangleName() << "(";
 …
+                }
+        }
+namespace {
+ObjectDecl * signedIntObj() {
+        return new ObjectDecl(
+                "", Type::StorageClasses(), LinkageSpec::Cforall, 0,
+                new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nullptr );
+}
+ObjectDecl * charStarObj() {
+        return new ObjectDecl(
+                "", Type::StorageClasses(), LinkageSpec::Cforall, 0,
+                new PointerType( Type::Qualifiers(),
+                        new PointerType( Type::Qualifiers(),
+                                new BasicType( Type::Qualifiers(), BasicType::Char ) ) ),
+                nullptr );
+}
+std::string create_mangled_main_function_name( FunctionType * function_type ) {
+        std::unique_ptr<FunctionDecl> decl( new FunctionDecl(
+                "main", Type::StorageClasses(), LinkageSpec::Cforall,
+                function_type, nullptr ) );
+        return SymTab::Mangler::mangle( decl.get() );
+}
+std::string mangled_0_argument_main() {
+        FunctionType* main_type = new FunctionType( Type::Qualifiers(), true );
+        main_type->get_returnVals().push_back( signedIntObj() );
+        return create_mangled_main_function_name( main_type );
+}
+std::string mangled_2_argument_main() {
+        FunctionType* main_type = new FunctionType( Type::Qualifiers(), false );
+        main_type->get_returnVals().push_back( signedIntObj() );
+        main_type->get_parameters().push_back( signedIntObj() );
+        main_type->get_parameters().push_back( charStarObj() );
+        return create_mangled_main_function_name( main_type );
+}
+bool is_main( const std::string & mangled_name ) {
+        // This breaks if you move it out of the function.
+        static const std::string mangled_mains[] = {
+                mangled_0_argument_main(),
+                mangled_2_argument_main(),
+                //mangled_3_argument_main(),
+        };
+        for ( auto main_name : mangled_mains ) {
+                if ( main_name == mangled_name ) return true;
+        }
+        return false;
+}
+} // namespace
+bool FixMain::isMain( FunctionDecl * decl ) {
+        if ( std::string("main") != decl->name ) {
+                return false;
+        }
+        return is_main( SymTab::Mangler::mangle( decl, true, true ) );
+}
+bool FixMain::isMain( const ast::FunctionDecl * decl ) {
+        if ( std::string("main") != decl->name ) {
+                return false;
+        }
+        return is_main( Mangle::mangle( decl, Mangle::Type ) );
+}
 };

src/CodeGen/FixMain.h

-                      r949339b
+                      rcc287800
 // Author           : Thierry Delisle
 // Created On       : Thr Jan 12 14:11:09 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Feb 16 03:24:32 2020
 // Update Count     : 5
+// Last Modified By : Andrew Beach
+// Last Modified On : Fri Oct 29 16:20:00 2021
+// Update Count     : 8
 //
 …
 #include <iosfwd>
 #include <memory>
+#include <list>
 #include "SynTree/LinkageSpec.h"
+class Declaration;
 class FunctionDecl;
+namespace ast {
+        class FunctionDecl;
+}
 namespace CodeGen {
-        class FixMain {
-          public :
-                static inline LinkageSpec::Spec mainLinkage() {
-                        return replace_main ? LinkageSpec::Cforall : LinkageSpec::C;
+                }
-                static inline void setReplaceMain(bool val) {
-                        replace_main = val;
+                }
+                static void registerMain(FunctionDecl* val);
+class FixMain {
+public :
+        static inline LinkageSpec::Spec mainLinkage() {
+                return replace_main ? LinkageSpec::Cforall : LinkageSpec::C;
+        }
+                static void fix(std::ostream &os, const char* bootloader_filename);
+        static inline void setReplaceMain(bool val) {
+                replace_main = val;
+        }
+          private:
+                static bool replace_main;
+                static std::unique_ptr<FunctionDecl> main_signature;
+        };
+        static bool isMain(FunctionDecl* decl);
+        static bool isMain(const ast::FunctionDecl * decl);
+        static void fix( std::list< Declaration * > & decls,
+                        std::ostream &os, const char* bootloader_filename );
+private:
+        static bool replace_main;
+};
 } // namespace CodeGen

src/CodeGen/FixNames.cc

-                      r949339b
+                      rcc287800
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Dec 13 23:39:14 2019
 // Update Count     : 21
+// Last Modified By : Andrew Beach
+// Last Modified On : Fri Oct 29 15:49:00 2021
+// Update Count     : 23
 //
 …
 #include <string>                  // for string, operator!=, operator==
+#include "AST/Chain.hpp"
+#include "AST/Expr.hpp"
+#include "AST/Pass.hpp"
 #include "Common/PassVisitor.h"
 #include "Common/SemanticError.h"  // for SemanticError
 …
         };
-        std::string mangle_main() {
-                FunctionType* main_type;
-                std::unique_ptr<FunctionDecl> mainDecl { new FunctionDecl( "main", Type::StorageClasses(), LinkageSpec::Cforall,
-                                                                                                                                   main_type = new FunctionType( Type::Qualifiers(), true ), nullptr )
-                                };
-                main_type->get_returnVals().push_back(
-                        new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nullptr )
-                );
-                auto && name = SymTab::Mangler::mangle( mainDecl.get() );
-                // std::cerr << name << std::endl;
-                return std::move(name);
+        }
-        std::string mangle_main_args() {
-                FunctionType* main_type;
-                std::unique_ptr<FunctionDecl> mainDecl { new FunctionDecl( "main", Type::StorageClasses(), LinkageSpec::Cforall,
-                                                                                                                                   main_type = new FunctionType( Type::Qualifiers(), false ), nullptr )
-                                };
-                main_type->get_returnVals().push_back(
-                        new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nullptr )
-                );
-                main_type->get_parameters().push_back(
-                        new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nullptr )
-                );
-                main_type->get_parameters().push_back(
-                        new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, 0,
-                        new PointerType( Type::Qualifiers(), new PointerType( Type::Qualifiers(), new BasicType( Type::Qualifiers(), BasicType::Char ) ) ),
-                        nullptr )
-                );
-                auto&& name = SymTab::Mangler::mangle( mainDecl.get() );
-                // std::cerr << name << std::endl;
-                return std::move(name);
+        }
-        bool is_main(const std::string& name) {
-                static std::string mains[] = {
-                        mangle_main(),
-                        mangle_main_args()
-                };
-                for(const auto& m : mains) {
-                        if( name == m ) return true;
+                }
-                return false;
+        }
         void fixNames( std::list< Declaration* > & translationUnit ) {
                 PassVisitor<FixNames> fixer;
 …
                 fixDWT( functionDecl );
                 if(is_main( SymTab::Mangler::mangle(functionDecl, true, true) )) {
+                if ( FixMain::isMain( functionDecl ) ) {
                         int nargs = functionDecl->get_functionType()->get_parameters().size();
                         if( !(nargs == 0 || nargs == 2 || nargs == 3) ) {
 …
+                        }
                         functionDecl->get_statements()->get_kids().push_back( new ReturnStmt( new ConstantExpr( Constant::from_int( 0 ) ) ) );
-                        CodeGen::FixMain::registerMain( functionDecl );
+                }
+        }
 …
                 GuardAction( [this](){ scopeLevel--; } );
+        }
+/// Does work with the main function and scopeLevels.
+class FixNames_new : public ast::WithGuards {
+        int scopeLevel = 1;
+        bool shouldSetScopeLevel( const ast::DeclWithType * dwt ) {
+                return !dwt->name.empty() && dwt->linkage.is_mangled
+                        && dwt->scopeLevel != scopeLevel;
+        }
+public:
+        const ast::ObjectDecl *postvisit( const ast::ObjectDecl *objectDecl ) {
+                if ( shouldSetScopeLevel( objectDecl ) ) {
+                        return ast::mutate_field( objectDecl, &ast::ObjectDecl::scopeLevel, scopeLevel );
+                }
+                return objectDecl;
+        }
+        const ast::FunctionDecl *postvisit( const ast::FunctionDecl *functionDecl ) {
+                // This store is used to ensure a maximum of one call to mutate.
+                ast::FunctionDecl * mutDecl = nullptr;
+                if ( shouldSetScopeLevel( functionDecl ) ) {
+                        mutDecl = ast::mutate( functionDecl );
+                        mutDecl->scopeLevel = scopeLevel;
+                }
+                if ( FixMain::isMain( functionDecl ) ) {
+                        if ( !mutDecl ) { mutDecl = ast::mutate( functionDecl ); }
+                        int nargs = mutDecl->params.size();
+                        if ( 0 != nargs && 2 != nargs && 3 != nargs ) {
+                                SemanticError( functionDecl, "Main expected to have 0, 2 or 3 arguments\n" );
+                        }
+                        ast::chain_mutate( mutDecl->stmts )->kids.push_back(
+                                new ast::ReturnStmt(
+                                        mutDecl->location,
+                                        ast::ConstantExpr::from_int( mutDecl->location, 0 )
+                                )
+                        );
+                }
+                return mutDecl ? mutDecl : functionDecl;
+        }
+        void previsit( const ast::CompoundStmt * ) {
+                GuardValue( scopeLevel ) += 1;
+        }
+};
+void fixNames( ast::TranslationUnit & translationUnit ) {
+        ast::Pass<FixNames_new>::run( translationUnit );
+}
 } // namespace CodeGen

src/CodeGen/FixNames.h

-                      r949339b
+                      rcc287800
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul 21 22:17:33 2017
 // Update Count     : 3
+// Last Modified By : Andrew Beach
+// Last Modified On : Tue Oct 26 13:47:00 2021
+// Update Count     : 4
 //
 …
 class Declaration;
+namespace ast {
+        struct TranslationUnit;
+}
 namespace CodeGen {
         /// mangles object and function names
         void fixNames( std::list< Declaration* > & translationUnit );
+        void fixNames( ast::TranslationUnit & translationUnit );
 } // namespace CodeGen

src/CodeTools/DeclStats.cc

-                      r949339b
+                      rcc287800
                 /// number of counting bins for linkages
                 static const unsigned n_named_specs = 8;
+                /// map from total number of specs to bins
+                static const unsigned ind_for_linkage[16];
+                /// Mapping function from linkage to bin.
+                static unsigned linkage_index( LinkageSpec::Spec spec ) {
+                        switch ( spec ) {
+                        case LinkageSpec::Intrinsic:  return 0;
+                        case LinkageSpec::C:          return 1;
+                        case LinkageSpec::Cforall:    return 2;
+                        case LinkageSpec::AutoGen:    return 3;
+                        case LinkageSpec::Compiler:   return 4;
+                        case LinkageSpec::BuiltinCFA: return 5;
+                        case LinkageSpec::BuiltinC:   return 6;
+                        default:                      return 7;
+                        }
+                }
                 Stats for_linkage[n_named_specs];            ///< Stores separate stats per linkage
 …
                         const std::string& mangleName = decl->get_mangleName().empty() ? decl->name : decl->get_mangleName();
                         if ( seen_names.insert( mangleName ).second ) {
                                 Stats& stats = for_linkage[ ind_for_linkage[ decl->linkage ] ];
+                                Stats& stats = for_linkage[ linkage_index( decl->linkage ) ];
                                 ++stats.n_decls;
 …
         };
-        const unsigned DeclStats::ind_for_linkage[]
-                = { 7, 7, 2, 1,   7, 7, 7, 3,   4, 7, 6, 5,   7, 7, 7, 0 };
         void printDeclStats( std::list< Declaration * > &translationUnit ) {
                 PassVisitor<DeclStats> stats;

src/Common/module.mk

-                      r949339b
+                      rcc287800
       Common/CompilerError.h \
       Common/Debug.h \
+      Common/DeclStats.hpp \
+      Common/DeclStats.cpp \
       Common/ErrorObjects.h \
       Common/Eval.cc \
 …
       Common/PassVisitor.proto.h \
       Common/PersistentMap.h \
+      Common/ResolvProtoDump.hpp \
+      Common/ResolvProtoDump.cpp \
       Common/ScopedMap.h \
       Common/SemanticError.cc \

src/ControlStruct/ExceptTranslate.cc

r949339b	rcc287800
5	5	// file "LICENCE" distributed with Cforall.
6	6	//
7		// Except~~Visitor.cc --~~
	7	// ExceptTranslate.cc -- Conversion of exception control flow structures.
8	8	//
9	9	// Author : Andrew Beach

src/ControlStruct/ExceptTranslate.h

-                      r949339b
+                      rcc287800
 // file "LICENCE" distributed with Cforall.
 //
 // ExceptTranslate.h --
+// ExceptTranslate.h -- Conversion of exception control flow structures.
 //
 // Author           : Andrew Beach
 // Created On       : Tus Jun 06 10:13:00 2017
 // Last Modified By : Andrew Beach
 // Last Modified On : Tus May 19 11:47:00 2020
 // Update Count     : 5
+// Last Modified On : Mon Nov  8 11:43:00 2020
+// Update Count     : 6
 //
 …
 class Declaration;
+namespace ast {
+        class TranslationUnit;
+}
 namespace ControlStruct {
         void translateThrows( std::list< Declaration *> & translationUnit );
+        void translateThrows( ast::TranslationUnit & transUnit );
         /* Replaces all throw & throwResume statements with function calls.
          * These still need to be resolved, so call this before the reslover.

src/ControlStruct/LabelGenerator.cc

-                      r949339b
+                      rcc287800
 // Author           : Rodolfo G. Esteves
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Mar 11 22:23:20 2019
 // Update Count     : 15
+// Last Modified By : Andrew Beach
+// Last Modified On : Mon Nov  8 10:18:00 2021
+// Update Count     : 17
 //
 …
 #include "LabelGenerator.h"
+#include "AST/Attribute.hpp"
+#include "AST/Label.hpp"
+#include "AST/Stmt.hpp"
 #include "SynTree/Attribute.h"  // for Attribute
 #include "SynTree/Label.h"      // for Label, operator<<
 …
 namespace ControlStruct {
+        LabelGenerator * LabelGenerator::labelGenerator = 0;
+int LabelGenerator::current = 0;
+LabelGenerator * LabelGenerator::labelGenerator = nullptr;
         LabelGenerator * LabelGenerator::getGenerator() {
 …
                 return l;
+        }
+ast::Label LabelGenerator::newLabel(
+                const std::string & suffix, const ast::Stmt * stmt ) {
+        assert( stmt );
+        std::ostringstream os;
+        os << "__L" << current++ << "__" << suffix;
+        if ( stmt && !stmt->labels.empty() ) {
+                os << "_" << stmt->labels.front() << "__";
+        }
+        ast::Label ret_label( stmt->location, os.str() );
+        ret_label.attributes.push_back( new ast::Attribute( "unused" ) );
+        return ret_label;
+}
 } // namespace ControlStruct

src/ControlStruct/LabelGenerator.h

-                      r949339b
+                      rcc287800
 // Author           : Rodolfo G. Esteves
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:20:14 2017
 // Update Count     : 6
+// Last Modified By : Andrew Beach
+// Last Modified On : Mon Nov  8 10:16:00 2021
+// Update Count     : 8
 //
 …
 class Statement;
+namespace ast {
+        class Stmt;
+        class Label;
+}
 namespace ControlStruct {
+        class LabelGenerator {
+          public:
+                static LabelGenerator *getGenerator();
+                Label newLabel(std::string suffix, Statement * stmt = nullptr);
+                void reset() { current = 0; }
+                void rewind() { current--; }
+          protected:
+                LabelGenerator(): current(0) {}
+          private:
+                int current;
+                static LabelGenerator *labelGenerator;
+        };
+class LabelGenerator {
+        static int current;
+        static LabelGenerator *labelGenerator;
+protected:
+        LabelGenerator() {}
+public:
+        static LabelGenerator *getGenerator();
+        static Label newLabel(std::string suffix, Statement * stmt = nullptr);
+        static ast::Label newLabel( const std::string&, const ast::Stmt * );
+        static void reset() { current = 0; }
+        static void rewind() { current--; }
+};
 } // namespace ControlStruct

src/ControlStruct/module.mk

-                      r949339b
+                      rcc287800
         ControlStruct/ExceptDecl.cc \
         ControlStruct/ExceptDecl.h \
+        ControlStruct/FixLabels.cpp \
+        ControlStruct/FixLabels.hpp \
         ControlStruct/ForExprMutator.cc \
         ControlStruct/ForExprMutator.h \
 …
         ControlStruct/MLEMutator.cc \
         ControlStruct/MLEMutator.h \
+        ControlStruct/MultiLevelExit.cpp \
+        ControlStruct/MultiLevelExit.hpp \
         ControlStruct/Mutate.cc \
         ControlStruct/Mutate.h
+SRC += $(SRC_CONTROLSTRUCT) ControlStruct/ExceptTranslate.cc ControlStruct/ExceptTranslate.h
+SRC += $(SRC_CONTROLSTRUCT) \
+        ControlStruct/ExceptTranslateNew.cpp \
+        ControlStruct/ExceptTranslate.cc \
+        ControlStruct/ExceptTranslate.h
 SRCDEMANGLE += $(SRC_CONTROLSTRUCT)

src/InitTweak/GenInit.cc

-                      r949339b
+                      rcc287800
 // Author           : Rob Schluntz
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Dec 13 23:15:10 2019
 // Update Count     : 184
+// Last Modified By : Andrew Beach
+// Last Modified On : Mon Oct 25 13:53:00 2021
+// Update Count     : 186
 //
 #include "GenInit.h"
 …
 #include "AST/Decl.hpp"
 #include "AST/Init.hpp"
+#include "AST/Pass.hpp"
 #include "AST/Node.hpp"
 #include "AST/Stmt.hpp"
 …
+        }
+namespace {
+#       warning Remove the _New suffix after the conversion is complete.
+        struct HoistArrayDimension_NoResolve_New final :
+                        public ast::WithDeclsToAdd<>, public ast::WithShortCircuiting,
+                        public ast::WithGuards, public ast::WithConstTranslationUnit,
+                        public ast::WithVisitorRef<HoistArrayDimension_NoResolve_New> {
+                void previsit( const ast::ObjectDecl * decl );
+                const ast::DeclWithType * postvisit( const ast::ObjectDecl * decl );
+                // Do not look for objects inside there declarations (and type).
+                void previsit( const ast::AggregateDecl * ) { visit_children = false; }
+                void previsit( const ast::NamedTypeDecl * ) { visit_children = false; }
+                void previsit( const ast::FunctionType * ) { visit_children = false; }
+                const ast::Type * hoist( const ast::Type * type );
+                ast::Storage::Classes storageClasses;
+        };
+        void HoistArrayDimension_NoResolve_New::previsit(
+                        const ast::ObjectDecl * decl ) {
+                GuardValue( storageClasses ) = decl->storage;
+        }
+        const ast::DeclWithType * HoistArrayDimension_NoResolve_New::postvisit(
+                        const ast::ObjectDecl * objectDecl ) {
+                return mutate_field( objectDecl, &ast::ObjectDecl::type,
+                                hoist( objectDecl->type ) );
+        }
+        const ast::Type * HoistArrayDimension_NoResolve_New::hoist(
+                        const ast::Type * type ) {
+                static UniqueName dimensionName( "_array_dim" );
+                if ( !isInFunction() || storageClasses.is_static ) {
+                        return type;
+                }
+                if ( auto arrayType = dynamic_cast< const ast::ArrayType * >( type ) ) {
+                        if ( nullptr == arrayType->dimension ) {
+                                return type;
+                        }
+                        if ( !Tuples::maybeImpure( arrayType->dimension ) ) {
+                                return type;
+                        }
+                        ast::ptr<ast::Type> dimType = transUnit().global.sizeType;
+                        assert( dimType );
+                        add_qualifiers( dimType, ast::CV::Qualifiers( ast::CV::Const ) );
+                        ast::ObjectDecl * arrayDimension = new ast::ObjectDecl(
+                                arrayType->dimension->location,
+                                dimensionName.newName(),
+                                dimType,
+                                new ast::SingleInit(
+                                        arrayType->dimension->location,
+                                        arrayType->dimension
+                                )
+                        );
+                        ast::ArrayType * mutType = ast::mutate( arrayType );
+                        mutType->dimension = new ast::VariableExpr(
+                                        arrayDimension->location, arrayDimension );
+                        declsToAddBefore.push_back( arrayDimension );
+                        mutType->base = hoist( mutType->base );
+                        return mutType;
+                }
+                return type;
+        }
+        struct ReturnFixer_New final :
+                        public ast::WithStmtsToAdd<>, ast::WithGuards {
+                void previsit( const ast::FunctionDecl * decl );
+                const ast::ReturnStmt * previsit( const ast::ReturnStmt * stmt );
+        private:
+                const ast::FunctionDecl * funcDecl = nullptr;
+        };
+        void ReturnFixer_New::previsit( const ast::FunctionDecl * decl ) {
+                GuardValue( funcDecl ) = decl;
+        }
+        const ast::ReturnStmt * ReturnFixer_New::previsit(
+                        const ast::ReturnStmt * stmt ) {
+                auto & returns = funcDecl->returns;
+                assert( returns.size() < 2 );
+                // Hands off if the function returns a reference.
+                // Don't allocate a temporary if the address is returned.
+                if ( stmt->expr && 1 == returns.size() ) {
+                        ast::ptr<ast::DeclWithType> retDecl = returns.front();
+                        if ( isConstructable( retDecl->get_type() ) ) {
+                                // Explicitly construct the return value using the return
+                                // expression and the retVal object.
+                                assertf( "" != retDecl->name,
+                                        "Function %s has unnamed return value.\n",
+                                        funcDecl->name.c_str() );
+                                auto retVal = retDecl.strict_as<ast::ObjectDecl>();
+                                if ( auto varExpr = stmt->expr.as<ast::VariableExpr>() ) {
+                                        // Check if the return statement is already set up.
+                                        if ( varExpr->var == retVal ) return stmt;
+                                }
+                                ast::ptr<ast::Stmt> ctorStmt = genCtorDtor(
+                                        retVal->location, "?{}", retVal, stmt->expr );
+                                assertf( ctorStmt,
+                                        "ReturnFixer: genCtorDtor returned nllptr: %s / %s",
+                                        toString( retVal ).c_str(),
+                                        toString( stmt->expr ).c_str() );
+                                        stmtsToAddBefore.push_back( ctorStmt );
+                                // Return the retVal object.
+                                ast::ReturnStmt * mutStmt = ast::mutate( stmt );
+                                mutStmt->expr = new ast::VariableExpr(
+                                        stmt->location, retDecl );
+                                return mutStmt;
+                        }
+                }
+                return stmt;
+        }
+} // namespace
+        void genInit( ast::TranslationUnit & transUnit ) {
+                ast::Pass<HoistArrayDimension_NoResolve_New>::run( transUnit );
+                ast::Pass<ReturnFixer_New>::run( transUnit );
+        }
         void CtorDtor::generateCtorDtor( std::list< Declaration * > & translationUnit ) {
                 PassVisitor<CtorDtor> ctordtor;

src/InitTweak/GenInit.h

-                      r949339b
+                      rcc287800
 // Author           : Rodolfo G. Esteves
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:31:19 2017
 // Update Count     : 4
+// Last Modified By : Andrew Beach
+// Last Modified On : Fri Oct 22 16:08:00 2021
+// Update Count     : 6
 //
 …
         /// Adds return value temporaries and wraps Initializers in ConstructorInit nodes
         void genInit( std::list< Declaration * > & translationUnit );
+        void genInit( ast::TranslationUnit & translationUnit );
         /// Converts return statements into copy constructor calls on the hidden return variable

src/Parser/parser.yy

-                      r949339b
+                      rcc287800
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Sep 11 08:20:44 2021
 // Update Count     : 5040
+// Last Modified On : Fri Oct 15 09:20:17 2021
+// Update Count     : 5163
 //
 …
 // from ANSI90 to ANSI11 C are marked with the comment "C99/C11".
 // This grammar also has two levels of extensions. The first extensions cover most of the GCC C extensions All of the
+// This grammar also has two levels of extensions. The first extensions cover most of the GCC C extensions. All of the
 // syntactic extensions for GCC C are marked with the comment "GCC". The second extensions are for Cforall (CFA), which
 // fixes several of C's outstanding problems and extends C with many modern language concepts. All of the syntactic
 …
         // 2. String encodings are transformed into canonical form (one encoding at start) so the encoding can be found
         //    without searching the string, e.g.: "abc" L"def" L"ghi" => L"abc" "def" "ghi". Multiple encodings must match,
         //    i.e., u"a" U"b" L"c" is disallowed.
+        //    e.g., u"a" U"b" L"c" is disallowed.
         if ( from[0] != '"' ) {                                                         // encoding ?
 …
 %token ATassign                                                                                 // @=
+%type<tok> identifier
+%type<tok> identifier_or_type_name  attr_name
+%type<tok> identifier                                   identifier_at                           identifier_or_type_name         attr_name
 %type<tok> quasi_keyword
 %type<constant> string_literal
 …
 %type<en> conditional_expression                constant_expression                     assignment_expression           assignment_expression_opt
 %type<en> comma_expression                              comma_expression_opt
 %type<en> argument_expression_list_opt  argument_expression                     default_initializer_opt
+%type<en> argument_expression_list_opt  argument_expression_list        argument_expression                     default_initializer_opt
 %type<ifctl> if_control_expression
 %type<fctl> for_control_expression              for_control_expression_list
 …
         IDENTIFIER
         | quasi_keyword
+        ;
+identifier_at:
+        identifier
         | '@'                                                                                           // CFA
                 { Token tok = { new string( DeclarationNode::anonymous.newName() ), yylval.tok.loc }; $$ = tok; }
 …
         // empty
                 { $$ = nullptr; }
+        | argument_expression
+        | argument_expression_list
+        ;
+argument_expression_list:
+        argument_expression
         | argument_expression_list_opt ',' argument_expression
                 { $$ = (ExpressionNode *)($1->set_last( $3 )); }
 …
         | FLOATINGconstant fraction_constants_opt
                 { $$ = new ExpressionNode( build_field_name_fraction_constants( build_field_name_FLOATINGconstant( *$1 ), $2 ) ); }
         | identifier fraction_constants_opt
+        | identifier_at fraction_constants_opt                          // CFA, allow anonymous fields
+                {
                         $$ = new ExpressionNode( build_field_name_fraction_constants( build_varref( $1 ), $2 ) );
 …
         comma_expression_opt ';'
                 { $$ = new StatementNode( build_expr( $1 ) ); }
+        | MUTEX '(' ')' comma_expression ';'
+                { $$ = new StatementNode( build_mutex( nullptr, new StatementNode( build_expr( $4 ) ) ) ); }
+                // { SemanticError( yylloc, "Mutex expression is currently unimplemented." ); $$ = nullptr; }
+        ;
 …
 iteration_statement:
+        WHILE '(' push if_control_expression ')' statement pop
+                { $$ = new StatementNode( build_while( $4, maybe_build_compound( $6 ) ) ); }
+        | WHILE '(' ')' statement                                                       // CFA => while ( 1 )
+        WHILE '(' ')' statement                                                         // CFA => while ( 1 )
                 { $$ = new StatementNode( build_while( new IfCtrl( nullptr, new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ), maybe_build_compound( $4 ) ) ); }
+        | DO statement WHILE '(' comma_expression ')' ';'
+                { $$ = new StatementNode( build_do_while( $5, maybe_build_compound( $2 ) ) ); }
+        | WHILE '(' if_control_expression ')' statement         %prec THEN
+                { $$ = new StatementNode( build_while( $3, maybe_build_compound( $5 ) ) ); }
+        | WHILE '(' if_control_expression ')' statement ELSE statement // CFA
+                { SemanticError( yylloc, "Loop default block is currently unimplemented." ); $$ = nullptr; }
         | DO statement WHILE '(' ')' ';'                                        // CFA => do while( 1 )
                 { $$ = new StatementNode( build_do_while( new ExpressionNode( build_constantInteger( *new string( "1" ) ) ), maybe_build_compound( $2 ) ) ); }
+        | FOR '(' push for_control_expression_list ')' statement pop
+                { $$ = new StatementNode( build_for( $4, maybe_build_compound( $6 ) ) ); }
+        | DO statement WHILE '(' comma_expression ')' ';'       %prec THEN
+                { $$ = new StatementNode( build_do_while( $5, maybe_build_compound( $2 ) ) ); }
+        | DO statement WHILE '(' comma_expression ')' ELSE statement // CFA
+                { SemanticError( yylloc, "Loop default block is currently unimplemented." ); $$ = nullptr; }
         | FOR '(' ')' statement                                                         // CFA => for ( ;; )
                 { $$ = new StatementNode( build_for( new ForCtrl( (ExpressionNode * )nullptr, (ExpressionNode * )nullptr, (ExpressionNode * )nullptr ), maybe_build_compound( $4 ) ) ); }
+        | FOR '(' for_control_expression_list ')' statement     %prec THEN
+                { $$ = new StatementNode( build_for( $3, maybe_build_compound( $5 ) ) ); }
+        | FOR '(' for_control_expression_list ')' statement ELSE statement // CFA
+                { SemanticError( yylloc, "Loop default block is currently unimplemented." ); $$ = nullptr; }
+        ;
 …
 with_statement:
         WITH '(' tuple_expression_list ')' statement
+                {
+                        $$ = new StatementNode( build_with( $3, $5 ) );
+                }
+                { $$ = new StatementNode( build_with( $3, $5 ) ); }
+        ;
 // If MUTEX becomes a general qualifier, there are shift/reduce conflicts, so change syntax to "with mutex".
 mutex_statement:
         MUTEX '(' argument_expression_list_opt ')' statement
+        MUTEX '(' argument_expression_list ')' statement
                 { $$ = new StatementNode( build_mutex( $3, $5 ) ); }
+        ;
 …
 designation:
         designator_list ':'                                                                     // C99, CFA uses ":" instead of "="
         | identifier ':'                                                                        // GCC, field name
+        | identifier_at ':'                                                                     // GCC, field name
                 { $$ = new ExpressionNode( build_varref( $1 ) ); }
+        ;
 …
 designator:
         '.' identifier                                                                          // C99, field name
+        '.' identifier_at                                                                       // C99, field name
                 { $$ = new ExpressionNode( build_varref( $2 ) ); }
         | '[' push assignment_expression pop ']'                        // C99, single array element
 …
 paren_identifier:
         identifier
+        identifier_at
                 { $$ = DeclarationNode::newName( $1 ); }
         | '(' paren_identifier ')'                                                      // redundant parenthesis

src/main.cc

-                      r949339b
+                      rcc287800
 // Author           : Peter Buhr and Rob Schluntz
 // Created On       : Fri May 15 23:12:02 2015
 // Last Modified By : Henry Xue
 // Last Modified On : Mon Aug 23 15:42:08 2021
 // Update Count     : 650
+// Last Modified By : Andrew Beach
+// Last Modified On : Mon Nov  8 11:42:00 2021
+// Update Count     : 656
 //
 …
 #include "Common/CodeLocationTools.hpp"     // for forceFillCodeLocations
 #include "Common/CompilerError.h"           // for CompilerError
+#include "Common/DeclStats.hpp"             // for printDeclStats
+#include "Common/ResolvProtoDump.hpp"       // for dumpAsResolverProto
 #include "Common/Stats.h"
 #include "Common/PassVisitor.h"
 …
 #include "ControlStruct/ExceptDecl.h"       // for translateExcept
 #include "ControlStruct/ExceptTranslate.h"  // for translateEHM
+#include "ControlStruct/FixLabels.hpp"      // for fixLabels
 #include "ControlStruct/Mutate.h"           // for mutate
 #include "GenPoly/Box.h"                    // for box
 …
                 } // if
-                PASS( "Translate Throws", ControlStruct::translateThrows( translationUnit ) );
-                PASS( "Fix Labels", ControlStruct::fixLabels( translationUnit ) );
-                PASS( "Fix Names", CodeGen::fixNames( translationUnit ) );
-                PASS( "Gen Init", InitTweak::genInit( translationUnit ) );
-                if ( libcfap ) {
-                        // generate the bodies of cfa library functions
-                        LibCfa::makeLibCfa( translationUnit );
-                } // if
-                if ( declstatsp ) {
-                        CodeTools::printDeclStats( translationUnit );
-                        deleteAll( translationUnit );
-                        return EXIT_SUCCESS;
-                } // if
-                if ( bresolvep ) {
-                        dump( translationUnit );
-                        return EXIT_SUCCESS;
-                } // if
                 CodeTools::fillLocations( translationUnit );
-                if ( resolvprotop ) {
-                        CodeTools::dumpAsResolvProto( translationUnit );
-                        return EXIT_SUCCESS;
-                } // if
                 if( useNewAST ) {
 …
                         auto transUnit = convert( move( translationUnit ) );
+                        forceFillCodeLocations( transUnit );
+                        PASS( "Translate Throws", ControlStruct::translateThrows( transUnit ) );
+                        PASS( "Fix Labels", ControlStruct::fixLabels( transUnit ) );
+                        PASS( "Fix Names", CodeGen::fixNames( transUnit ) );
+                        PASS( "Gen Init", InitTweak::genInit( transUnit ) );
                         PASS( "Expand Member Tuples" , Tuples::expandMemberTuples( transUnit ) );
+                        if ( libcfap ) {
+                                // Generate the bodies of cfa library functions.
+                                LibCfa::makeLibCfa( transUnit );
+                        } // if
+                        if ( declstatsp ) {
+                                printDeclStats( transUnit );
+                                return EXIT_SUCCESS;
+                        } // if
+                        if ( bresolvep ) {
+                                dump( move( transUnit ) );
+                                return EXIT_SUCCESS;
+                        } // if
+                        if ( resolvprotop ) {
+                                dumpAsResolverProto( transUnit );
+                                return EXIT_SUCCESS;
+                        } // if
                         PASS( "Resolve", ResolvExpr::resolve( transUnit ) );
                         if ( exprp ) {
 …
                         PASS( "Fix Init", InitTweak::fix(transUnit, buildingLibrary()));
                         translationUnit = convert( move( transUnit ) );
                 } else {
+                        PASS( "Translate Throws", ControlStruct::translateThrows( translationUnit ) );
+                        PASS( "Fix Labels", ControlStruct::fixLabels( translationUnit ) );
+                        PASS( "Fix Names", CodeGen::fixNames( translationUnit ) );
+                        PASS( "Gen Init", InitTweak::genInit( translationUnit ) );
                         PASS( "Expand Member Tuples" , Tuples::expandMemberTuples( translationUnit ) );
+                        if ( libcfap ) {
+                                // Generate the bodies of cfa library functions.
+                                LibCfa::makeLibCfa( translationUnit );
+                        } // if
+                        if ( declstatsp ) {
+                                CodeTools::printDeclStats( translationUnit );
+                                deleteAll( translationUnit );
+                                return EXIT_SUCCESS;
+                        } // if
+                        if ( bresolvep ) {
+                                dump( translationUnit );
+                                return EXIT_SUCCESS;
+                        } // if
+                        CodeTools::fillLocations( translationUnit );
+                        if ( resolvprotop ) {
+                                CodeTools::dumpAsResolvProto( translationUnit );
+                                return EXIT_SUCCESS;
+                        } // if
                         PASS( "Resolve", ResolvExpr::resolve( translationUnit ) );
 …
                 PASS( "Code Gen", CodeGen::generate( translationUnit, *output, ! genproto, prettycodegenp, true, linemarks ) );
+                CodeGen::FixMain::fix( *output, (PreludeDirector + "/bootloader.c").c_str() );
+                CodeGen::FixMain::fix( translationUnit, *output,
+                                (PreludeDirector + "/bootloader.c").c_str() );
                 if ( output != &cout ) {
                         delete output;

tests/.expect/declarationSpecifier.x64.txt

-                      r949339b
+                      rcc287800
 char **_X13cfa_args_argvPPc_1;
 char **_X13cfa_args_envpPPc_1;
 signed int _X17cfa_main_returnedi_1 = ((signed int )0);
+__attribute__ ((weak)) extern signed int _X17cfa_main_returnedi_1;
 signed int main(signed int _X4argci_1, char **_X4argvPPc_1, char **_X4envpPPc_1){
     __attribute__ ((unused)) signed int _X12_retval_maini_1;
 …
     signed int _tmp_cp_ret6;
     signed int _X3reti_2 = (((void)(_tmp_cp_ret6=invoke_main(_X4argci_1, _X4argvPPc_1, _X4envpPPc_1))) , _tmp_cp_ret6);
+    {
+        ((void)(_X17cfa_main_returnedi_1=((signed int )1)));
+    if ( ((&_X17cfa_main_returnedi_1)!=((signed int *)0)) ) {
+        {
+            ((void)(_X17cfa_main_returnedi_1=((signed int )1)));
+        }
+    }

tests/.expect/declarationSpecifier.x86.txt

-                      r949339b
+                      rcc287800
 char **_X13cfa_args_argvPPc_1;
 char **_X13cfa_args_envpPPc_1;
 signed int _X17cfa_main_returnedi_1 = ((signed int )0);
+__attribute__ ((weak)) extern signed int _X17cfa_main_returnedi_1;
 signed int main(signed int _X4argci_1, char **_X4argvPPc_1, char **_X4envpPPc_1){
     __attribute__ ((unused)) signed int _X12_retval_maini_1;
 …
     signed int _tmp_cp_ret6;
     signed int _X3reti_2 = (((void)(_tmp_cp_ret6=invoke_main(_X4argci_1, _X4argvPPc_1, _X4envpPPc_1))) , _tmp_cp_ret6);
+    {
+        ((void)(_X17cfa_main_returnedi_1=((signed int )1)));
+    if ( ((&_X17cfa_main_returnedi_1)!=((signed int *)0)) ) {
+        {
+            ((void)(_X17cfa_main_returnedi_1=((signed int )1)));
+        }
+    }

tests/.expect/gccExtensions.x64.txt

-                      r949339b
+                      rcc287800
 char **_X13cfa_args_argvPPc_1;
 char **_X13cfa_args_envpPPc_1;
 signed int _X17cfa_main_returnedi_1 = ((signed int )0);
+__attribute__ ((weak)) extern signed int _X17cfa_main_returnedi_1;
 signed int main(signed int _X4argci_1, char **_X4argvPPc_1, char **_X4envpPPc_1){
     __attribute__ ((unused)) signed int _X12_retval_maini_1;
 …
     signed int _tmp_cp_ret6;
     signed int _X3reti_2 = (((void)(_tmp_cp_ret6=invoke_main(_X4argci_1, _X4argvPPc_1, _X4envpPPc_1))) , _tmp_cp_ret6);
+    {
+        ((void)(_X17cfa_main_returnedi_1=((signed int )1)));
+    if ( ((&_X17cfa_main_returnedi_1)!=((signed int *)0)) ) {
+        {
+            ((void)(_X17cfa_main_returnedi_1=((signed int )1)));
+        }
+    }

tests/.expect/gccExtensions.x86.txt

-                      r949339b
+                      rcc287800
 char **_X13cfa_args_argvPPc_1;
 char **_X13cfa_args_envpPPc_1;
 signed int _X17cfa_main_returnedi_1 = ((signed int )0);
+__attribute__ ((weak)) extern signed int _X17cfa_main_returnedi_1;
 signed int main(signed int _X4argci_1, char **_X4argvPPc_1, char **_X4envpPPc_1){
     __attribute__ ((unused)) signed int _X12_retval_maini_1;
 …
     signed int _tmp_cp_ret6;
     signed int _X3reti_2 = (((void)(_tmp_cp_ret6=invoke_main(_X4argci_1, _X4argvPPc_1, _X4envpPPc_1))) , _tmp_cp_ret6);
+    {
+        ((void)(_X17cfa_main_returnedi_1=((signed int )1)));
+    if ( ((&_X17cfa_main_returnedi_1)!=((signed int *)0)) ) {
+        {
+            ((void)(_X17cfa_main_returnedi_1=((signed int )1)));
+        }
+    }

tests/concurrent/semaphore.cfa

-                      r949339b
+                      rcc287800
 #include <locks.hfa>
 #include <thread.hfa>
+#include <mutex_stmt.hfa>
 enum { num_blockers = 17, num_unblockers = 13 };
 …
                 thrash();
                 P(ben);
                 if(((thread&)this).seqable.next != 0p) sout | acquire |"Link not invalidated";
+                if(((thread&)this).seqable.next != 0p) mutex(sout) sout | "Link not invalidated";
                 thrash();
+        }

tests/concurrent/sleep.cfa

-                      r949339b
+                      rcc287800
 #include <fstream.hfa>
 #include <thread.hfa>
+#include <mutex_stmt.hfa>
 #include <time.hfa>
 …
 int main() {
         sout | acquire | "start";
+        mutex( sout ) sout | "start";
+        {
                 slow_sleeper slow;
 …
                 yield();
+        }
         sout | acquire | "done";
+        mutex( sout ) sout | "done";
+}

tests/io/io-acquire.cfa

-                      r949339b
+                      rcc287800
 // Created On       : Mon Mar  1 18:40:09 2021
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue Apr 27 11:49:34 2021
 // Update Count     : 18
+// Last Modified On : Wed Oct  6 18:04:58 2021
+// Update Count     : 72
 //
 #include <fstream.hfa>
 #include <thread.hfa>
+#include <mutex_stmt.hfa>
 thread T {};
 …
         // output from parallel threads should not be scrambled
         for ( 100 ) {                                                                           // local protection
                 sout | acquire | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
+        for ( 100 ) {                                                                           // expression protection
+                mutex(sout) sout | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
+        }
+        {                                                                                                       // global protection (RAII)
+                osacquire acq = { sout };
+        mutex( sout ) {                                                                         // statement protection
                 for ( 100 ) {
                         sout | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
 …
+        }
         {                                                                                                       // duplicate protection demonstrating recursive lock
+                osacquire acq = { sout };
+                for ( 100 ) {
+                        osacquire acq = { sout };
+                        sout | acquire | 1 | 2 | 3 | 4 | 5 | acquire | 6 | 7 | 8 | 9;
+                        sout | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
+                ofstream & h1( ofstream & os ) {                                // helper
+                        mutex( os ) return os | 1 | 2 | 3 | 4;          // unnecessary mutex
+                }
+                ofstream & h2( ofstream & os ) {                                // helper
+                        mutex( os ) return os | 6 | 7 | 8 | 9;          // unnecessary mutex
+                }
+                mutex( sout ) {                                                                 // unnecessary mutex
+                        for ( 100 ) {
+                                mutex( sout ) {
+                                        sout | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
+                                        sout | h1 | 5 | h2;                                     // refactored code
+                                }
+                        }
+                }
+        }
 …
         int a, b, c, d, e, f, g, h, i;
         for ( 100 ) {                                                                           // local protection
                 sin | acquire | a | b | c | d | e | f | g | h | i;
+        for ( 100 ) {                                                                           // expression protection
+                mutex(sin) sin | a | b | c | d | e | f | g | h | i;
+        }
+        {                                                                                                       // global protection (RAII)
+                isacquire acq = { sin };
+        mutex( sin ) {                                                                          // statement protection
                 for ( 100 ) {
                         sin  | a | b | c | d | e | f | g | h | i;
 …
+        }
         {                                                                                                       // duplicate protection demonstrating recursive lock
+                isacquire acq = { sin };
+                for ( 100 ) {
+                        isacquire acq = { sin };
+                        sin | acquire | a | b | c | d | e | acquire | f | g | h | i;
+                        sin | a | b | c | d | e | f | g | h | i;
+                ifstream & h1( ifstream & is ) {                                // helper
+                        mutex( is ) return is | a | b | c | d;          // unnecessary mutex
+                }
+                ifstream & h2( ifstream & is ) {                                // helper
+                        mutex( is ) return is | f | g | h | i;          // unnecessary mutex
+                }
+                mutex( sin ) {                                                                  // unnecessary mutex
+                        for ( 5 ) {
+                                mutex( sin ) {
+                                        sin  | a | b | c | d | e | f | g | h | i;
+                                        sin  | h1 | e | h2;                                     // refactored code
+                                }
+                        }
+                }
+        }

tests/linking/io-acquire.cfa

-                      r949339b
+                      rcc287800
 #include <fstream.hfa>
 #include <stdlib.hfa>
+#include <mutex_stmt.hfa>
 int main() {
         int i;
         if(threading_enabled()) {
                 stdout | acquire | "YES";
+                mutex( stdout ) stdout | "YES";
                 stdin | i;
         } else {
                 stdout | acquire | "NO";
+                mutex( stdout ) stdout | "NO";
                 stdin | i;
+        }

tests/pybin/test_run.py

-                      r949339b
+                      rcc287800
         def toString( cls, retcode, duration ):
                 if settings.generating :
                         if   retcode == TestResult.SUCCESS:     text = "Done   "
                         elif retcode == TestResult.TIMEOUT:     text = "TIMEOUT"
                         else :                                          text = "ERROR code %d" % retcode
+                        if   retcode == TestResult.SUCCESS:     key = 'pass'; text = "Done   "
+                        elif retcode == TestResult.TIMEOUT:     key = 'time'; text = "TIMEOUT"
+                        else :  key = 'fail';   text = "ERROR code %d" % retcode
                 else :
                         if   retcode == TestResult.SUCCESS:     text = "PASSED "
                         elif retcode == TestResult.TIMEOUT:     text = "TIMEOUT"
                         else :                                          text = "FAILED with code %d" % retcode
+                        if   retcode == TestResult.SUCCESS:     key = 'pass'; text = "PASSED "
+                        elif retcode == TestResult.TIMEOUT:     key = 'time'; text = "TIMEOUT"
+                        else :  key = 'fail';   text = "FAILED with code %d" % retcode
                 text += "    C%s - R%s" % (fmtDur(duration[0]), fmtDur(duration[1]))
                 return text
+                return key, text

tests/test.py

-                      r949339b
+                      rcc287800
                 # update output based on current action
                 result_txt = TestResult.toString( retcode, duration )
+                result_key, result_txt = TestResult.toString( retcode, duration )
                 #print result with error if needed
 …
                         text = text + '\n' + error
                 return retcode == TestResult.SUCCESS, text
+                return retcode == TestResult.SUCCESS, result_key, text
         except KeyboardInterrupt:
                 return False, ""
+                return False, 'keybrd', ""
         # except Exception as ex:
         #       print("Unexpected error in worker thread running {}: {}".format(t.target(), ex), file=sys.stderr)
 …
         failed = False
+        rescnts = {     'pass': 0, 'fail': 0, 'time': 0, 'keybrd': 0 }
+        other = 0
         # for each test to run
 …
+                )
+                for i, (succ, txt) in enumerate(timed(results, timeout = settings.timeout.total), 1) :
+                for i, (succ, code, txt) in enumerate(timed(results, timeout = settings.timeout.total), 1) :
+                        if code in rescnts.keys():
+                                rescnts[code] += 1
+                        else:
+                                other += 1
                         if not succ :
                                 failed = True
 …
         # clean the workspace
         make('clean', output_file=subprocess.DEVNULL, error=subprocess.DEVNULL)
+        print("{} passes, {} failures, {} timeouts, {} cancelled, {} other".format(rescnts['pass'], rescnts['fail'], rescnts['time'], rescnts['keybrd'], other))
         return failed
 …
                         failed = run_tests(local_tests, options.jobs)
                         if failed:
-                                result = 1
                                 if not settings.continue_:
                                         break

Context Navigation

Legend:

Download in other formats: