source: benchmark/io/http/printer.cfa@ 137974ae

#include "printer.hfa"

#include <fstream.hfa>
#include <stats.hfa>

void ?{}( sendfile_stats_t & this ) {
        this.calls = 0;
        this.tries = 0;
        this.header = 0;
        this.splcin = 0;
        this.splcot = 0;
        for(i; zipf_cnts) {
                this.avgrd[i].calls = 0;
                this.avgrd[i].bytes = 0;
        };
}

void push(sendfile_stats_t & from, sendfile_stats_t & to) {
        __atomic_fetch_add(&to.calls, from.calls, __ATOMIC_RELAXED); from.calls = 0;
        __atomic_fetch_add(&to.tries, from.tries, __ATOMIC_RELAXED); from.tries = 0;
        __atomic_fetch_add(&to.header, from.header, __ATOMIC_RELAXED); from.header = 0;
        __atomic_fetch_add(&to.splcin, from.splcin, __ATOMIC_RELAXED); from.splcin = 0;
        __atomic_fetch_add(&to.splcot, from.splcot, __ATOMIC_RELAXED); from.splcot = 0;
        for(i; zipf_cnts) {
                __atomic_fetch_add(&to.avgrd[i].calls, from.avgrd[i].calls, __ATOMIC_RELAXED); from.avgrd[i].calls = 0;
                __atomic_fetch_add(&to.avgrd[i].bytes, from.avgrd[i].bytes, __ATOMIC_RELAXED); from.avgrd[i].bytes = 0;
        };
}

void ?{}( acceptor_stats_t & this ) {
        this.creates = 0;
        this.accepts = 0;
        this.eagains = 0;
}

void push(acceptor_stats_t & from, acceptor_stats_t & to) {
        __atomic_fetch_add(&to.creates, from.creates, __ATOMIC_RELAXED); from.creates = 0;
        __atomic_fetch_add(&to.accepts, from.accepts, __ATOMIC_RELAXED); from.accepts = 0;
        __atomic_fetch_add(&to.eagains, from.eagains, __ATOMIC_RELAXED); from.eagains = 0;
}

void ?{}( StatsPrinter & this, cluster & cl ) {
        ((thread&)this){ "Stats Printer Thread", cl };

        memset(&this.stats, 0, sizeof(this.stats));;
}

void ^?{}( StatsPrinter & mutex this ) {}

#define eng3(X) (ws(3, 3, unit(eng( X ))))

void main(StatsPrinter & this) {
        LOOP: for() {
                waitfor( ^?{} : this) {
                        break LOOP;
                }
                or else {}

                wait(this.var, 10`s);

                print_stats_now( *active_cluster(), CFA_STATS_READY_Q | CFA_STATS_IO );
                {
                        struct {
                                volatile uint64_t calls;
                                volatile uint64_t bytes;
                        } avgrd[zipf_cnts];
                        memset(avgrd, 0, sizeof(avgrd));

                        uint64_t tries = this.stats.send.tries;
                        uint64_t calls  = this.stats.send.calls;
                        uint64_t header = this.stats.send.header;
                        uint64_t splcin = this.stats.send.splcin;
                        uint64_t splcot = this.stats.send.splcot;
                        for(j; zipf_cnts) {
                                avgrd[j].calls += this.stats.send.avgrd[j].calls;
                                avgrd[j].bytes += this.stats.send.avgrd[j].bytes;
                        }

                        double ratio = ((double)tries) / calls;

                        if(this.stats.accpt.accepts > 0) {
                                sout | "----- Acceptor Stats -----";
                                sout | "accept  : " | this.stats.accpt.accepts | "calls," | this.stats.accpt.eagains | "eagains," | this.stats.accpt.creates | " thrds";
                        }

                        sout | "----- Connection Stats -----";
                        sout | "sendfile  : " | calls | "calls," | tries | "tries (" | ratio | " try/call)";
                        sout | "            " | header | "header," | splcin | "splice in," | splcot | "splice out";
                        sout | " - zipf sizes:";
                        for(i; zipf_cnts) {
                                double written = avgrd[i].calls > 0 ? ((double)avgrd[i].bytes) / avgrd[i].calls : 0;
                                sout | "        " | zipf_sizes[i] | "bytes," | avgrd[i].calls | "shorts," | written | "written";
                        }
                }
        }
}

StatsPrinter * stats_thrd;