Changeset d11d6eb


Ignore:
Timestamp:
Aug 28, 2020, 1:26:28 PM (15 months ago)
Author:
Thierry Delisle <tdelisle@…>
Branches:
arm-eh, jacob/cs343-translation, master, new-ast-unique-expr
Children:
8e3034d
Parents:
8e2cb4a
Message:

Fixed some compilation errors.
Fixed file descriptor support in progress.

Location:
benchmark/io/http
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • benchmark/io/http/filecache.cfa

    r8e2cb4a rd11d6eb  
    7373        cache_line * entries;
    7474        size_t size;
     75        int * rawfds;
     76        int nfds;
    7577} file_cache;
    7678
     
    98100}
    99101
    100 int put_file( cache_line & entry ) {
     102int put_file( cache_line & entry, int fd ) {
    101103        uint32_t idx = murmur3_32( (const uint8_t *)entry.file, strlen(entry.file), options.file_cache.hash_seed ) % file_cache.size;
    102104
     
    108110
    109111        file_cache.entries[idx] = entry;
     112        file_cache.entries[idx].fd = fd;
    110113        return i > 0 ? 1 : 0;
    111114}
     
    121124        size_t fcount = 0;
    122125        size_t fsize = 16;
    123         cache_line * raw = 0p;
    124         raw = alloc(raw, fsize, true);
     126        cache_line * raw = alloc(fsize);
    125127        // Step 1 get a dense array of all files
    126128        int walk(const char *fpath, const struct stat *sb, int typeflag) {
     
    131133                if(fcount > fsize) {
    132134                        fsize *= 2;
    133                         raw = alloc(raw, fsize, true);
     135                        raw = alloc(fsize, raw`realloc);
    134136                }
    135137
     
    162164        file_cache.entries = anew(file_cache.size);
    163165
     166        if(options.file_cache.fixed_fds) {
     167                file_cache.nfds   = fcount;
     168                file_cache.rawfds = alloc(fcount);
     169        }
     170
    164171        // Step 3 fill the cache
    165172        int conflicts = 0;
    166173        for(i; fcount) {
    167                 conflicts += put_file( raw[i] );
     174                int fd;
     175                if(options.file_cache.fixed_fds) {
     176                        file_cache.rawfds[i] = raw[i].fd;
     177                        fd = i;
     178                }
     179                else {
     180                        fd = raw[i].fd;
     181                }
     182                conflicts += put_file( raw[i], fd );
    168183        }
    169184        printf("Filled cache from path \"%s\" with %zu files\n", path, fcount);
     
    197212        }
    198213
    199         return [aalloc(extra), 0];
     214        size_t s = file_cache.nfds + extra;
     215        int * data = alloc(s, file_cache.rawfds`realloc);
     216        return [data, file_cache.nfds];
    200217}
    201218
  • benchmark/io/http/main.cfa

    r8e2cb4a rd11d6eb  
    1212#include <kernel.hfa>
    1313#include <stats.hfa>
     14#include <time.hfa>
    1415#include <thread.hfa>
    1516
     
    1819#include "options.hfa"
    1920#include "worker.hfa"
     21
     22extern void register_fixed_files( cluster &, int *, unsigned count );
     23
     24Duration default_preemption() {
     25        return 0;
     26}
    2027
    2128//=============================================================================================
     
    8491        // Run Server Cluster
    8592        {
    86                 cluster cl = { "Server Cluster", options.clopts.flags };
     93                cluster cl = { "Server Cluster", options.clopts.params };
    8794                #if !defined(__CFA_NO_STATISTICS__)
    8895                        print_stats_at_exit( cl, CFA_STATS_READY_Q | CFA_STATS_IO );
     
    102109                }
    103110
     111                if(options.file_cache.fixed_fds) {
     112                        register_fixed_files(cl, fds, pipe_off);
     113                }
     114
    104115                {
    105116                        ServerProc procs[options.clopts.nprocs];
     
    107118                                Worker workers[options.clopts.nworkers];
    108119                                for(i; options.clopts.nworkers) {
    109                                         if( options.file_cache.fixed_fds ) {
    110                                                 workers[i].pipe[0] = pipe_off + (i * 2) + 0;
    111                                                 workers[i].pipe[1] = pipe_off + (i * 2) + 1;
    112                                         }
    113                                         else {
     120                                        // if( options.file_cache.fixed_fds ) {
     121                                        //      workers[i].pipe[0] = pipe_off + (i * 2) + 0;
     122                                        //      workers[i].pipe[1] = pipe_off + (i * 2) + 1;
     123                                        // }
     124                                        // else
     125                                        {
    114126                                                workers[i].pipe[0] = fds[pipe_off + (i * 2) + 0];
    115127                                                workers[i].pipe[1] = fds[pipe_off + (i * 2) + 1];
  • benchmark/io/http/options.cfa

    r8e2cb4a rd11d6eb  
    3939
    4040const char * parse_options( int argc, char * argv[] ) {
    41         bool uthrdpo = false;
    4241        bool subthrd = false;
    4342        bool eagrsub = false;
     
    5756                {'C', "cache-size",     "Size of the cache to use, if set to small, will uses closes power of 2", options.file_cache.size },
    5857                {'l', "list-files",     "List the files in the specified path and exit", options.file_cache.list, parse_settrue },
    59                 {'u', "userthread",     "If set, cluster uses user-thread to poll I/O", uthrdpo, parse_settrue },
    6058                {'s', "submitthread",   "If set, cluster uses polling thread to submit I/O", subthrd, parse_settrue },
    6159                {'e', "eagersubmit",    "If set, cluster submits I/O eagerly but still aggregates submits", eagrsub, parse_settrue},
     
    7169        parse_args( argc, argv, opt, opt_cnt, "[OPTIONS]... [PATH]\ncforall http server", left );
    7270
    73         if( uthrdpo ) {
    74                 options.clopts.flags |= CFA_CLUSTER_IO_POLLER_USER_THREAD;
    75         }
    76 
    77         if( subthrd ) {
    78                 options.clopts.flags |= CFA_CLUSTER_IO_POLLER_THREAD_SUBMITS;
    79         }
    80 
    81         if( eagrsub ) {
    82                 options.clopts.flags |= CFA_CLUSTER_IO_EAGER_SUBMITS;
    83         }
     71        options.clopts.params.poller_submits = subthrd;
     72        options.clopts.params.eager_submits  = eagrsub;
    8473
    8574        if( fixedfd ) {
     
    8877
    8978        if( sqkpoll ) {
    90                 options.clopts.flags |= CFA_CLUSTER_IO_KERNEL_POLL_SUBMITS;
     79                options.clopts.params.poll_submit = true;
    9180                options.file_cache.fixed_fds = true;
    9281        }
    9382
    9483        if( iokpoll ) {
    95                 options.clopts.flags |= CFA_CLUSTER_IO_KERNEL_POLL_COMPLETES;
     84                options.clopts.params.poll_complete = true;
    9685                options.file_cache.open_flags |= O_DIRECT;
    9786        }
    9887
    99         options.clopts.flags |= (sublen << CFA_CLUSTER_IO_BUFFLEN_OFFSET);
     88        options.clopts.params.num_ready = sublen;
    10089
    10190        if( left[0] == 0p ) { return "."; }
  • benchmark/io/http/options.hfa

    r8e2cb4a rd11d6eb  
    22
    33#include <stdint.h>
     4
     5#include <kernel.hfa>
    46
    57struct cluster;
     
    2325                int nprocs;
    2426                int nworkers;
    25                 int flags;
     27                io_context_params params;
    2628                int chan_size;
    2729                bool procstats;
  • benchmark/io/http/protocol.cfa

    r8e2cb4a rd11d6eb  
    1111extern "C" {
    1212      int snprintf ( char * s, size_t n, const char * format, ... );
     13        #include <linux/io_uring.h>
    1314}
    1415#include <string.h>
    15 
    1616#include <errno.h>
    1717
     18#include "options.hfa"
    1819
    1920const char * http_msgs[] = {
     
    7475        READ:
    7576        for() {
    76                 int ret = cfa_read(fd, it, count);
    77                 if(ret == 0 ) return [OK200, true, 0p, 0];
     77                int ret = cfa_read(fd, (void*)it, count, 0, -1`s, 0p, 0p);
     78                if(ret == 0 ) return [OK200, true, 0, 0];
    7879                if(ret < 0 ) {
    7980                        if( errno == EAGAIN || errno == EWOULDBLOCK) continue READ;
     
    8889                count -= ret;
    8990
    90                 if( count < 1 ) return [E414, false, 0p, 0];
     91                if( count < 1 ) return [E414, false, 0, 0];
    9192        }
    9293
     
    9596        it = buffer;
    9697        int ret = memcmp(it, "GET /", 5);
    97         if( ret != 0 ) return [E400, false, 0p, 0];
     98        if( ret != 0 ) return [E400, false, 0, 0];
    9899        it += 5;
    99100
     
    106107        ssize_t ret;
    107108        SPLICE1: while(count > 0) {
    108                 ret = cfa_splice(ans_fd, &offset, pipe[1], 0p, count, SPLICE_F_MOVE | SPLICE_F_MORE);
     109                ret = cfa_splice(ans_fd, &offset, pipe[1], 0p, count, SPLICE_F_MOVE | SPLICE_F_MORE, 0, -1`s, 0p, 0p);
    109110                if( ret < 0 ) {
    110111                        if( errno != EAGAIN && errno != EWOULDBLOCK) continue SPLICE1;
     
    116117                size_t in_pipe = ret;
    117118                SPLICE2: while(in_pipe > 0) {
    118                         ret = cfa_splice(pipe[0], 0p, fd, 0p, in_pipe, SPLICE_F_MOVE | SPLICE_F_MORE);
     119                        ret = cfa_splice(pipe[0], 0p, fd, 0p, in_pipe, SPLICE_F_MOVE | SPLICE_F_MORE, 0, -1`s, 0p, 0p);
    119120                        if( ret < 0 ) {
    120121                                if( errno != EAGAIN && errno != EWOULDBLOCK) continue SPLICE2;
  • benchmark/io/http/worker.cfa

    r8e2cb4a rd11d6eb  
    9696void main( Acceptor & this ) {
    9797        for() {
    98                 int ret = cfa_accept4( this.[sockfd, addr, addrlen, flags] );
     98                int ret = cfa_accept4( this.[sockfd, addr, addrlen, flags], 0, -1`s, 0p, 0p );
    9999                if(ret < 0) {
    100100                        if( errno == ECONNABORTED ) break;
Note: See TracChangeset for help on using the changeset viewer.