create report from sss server log

sblog.scm

#!/usr/bin/env gosh
;;
;; sss server log output report
;;
(use gauche.parseopt)
(use gauche.record)
(use slib)
(use text.csv)
(use util.match)

(require 'format)

(define (p . args) (for-each print args))

(define (usage)
  (p (format #f "Usage: ~a [options] file" *program-name*)
     "Options:"
     "  -w, --wiki : print output as trac/wiki table")
  (exit 0))

(define-class <test> ()
  ((clv :init-keyword :command)
   (ksiz :init-keyword :keysize)
   (vsiz :init-keyword :valsize)))

(define-method object-equal? ((a <test>) (b <test>))
  (and (eq? (ref a 'clv) (ref b 'clv))
       (eq? (ref a 'ksiz) (ref b 'ksiz))
       (eq? (ref a 'vsiz) (ref b 'vsiz))))

(define-method object-compare ((a <test>) (b <test>))
  (cond [(string<? (symbol->string (ref a 'clv))
                   (symbol->string (ref b 'clv))) -1]
        [(and (eq? (ref a 'clv) (ref b 'clv))
              (< (ref a 'ksiz) (ref b 'ksiz))) -1]
        [(and (eq? (ref a 'clv) (ref b 'clv))
              (= (ref a 'ksiz) (ref b 'ksiz))
              (< (ref a 'vsiz) (ref b 'vsiz))) -1]
        [(object-equal? a b) 0]
        [else 1]))

(define-method object-hash ((a <test>))
  (hash `(,(ref a 'clv) ,(ref a 'ksiz) ,(ref a 'vsiz))))

(define-record-type result #t #t
  (put) (get) (out))

(define (get-trial dict clv kz vz)
  (let* ((id (make <test> :command clv :keysize kz :valsize vz))
         (entry (hash-table-get dict id #f)))
    (if (boolean entry)
        entry
        (let1 newentry (make-result '() '() '())
          (hash-table-put! dict id newentry)
          newentry))
    ))

(define (read-log dict test line)
  (match line
    [(_ _ _ _ _ _ ".db_use_vanilla" _ clv)
     (slot-set! test 'clv (if (string=? clv "true") 'vanilla 'extended))]
    [(_ _ _ _ "TupleGenerator" _ property)
     (rxmatch-cond
       [(rxmatch #/^tuplegenerator.key.size=(\d+)$/ property)
        (#f ksiz)
        (slot-set! test 'ksiz (string->number ksiz))]
       [(rxmatch #/^tuplegenerator.key.count=(\d+)$/ property)
        (#f count)                   ; just ignore `count' for now
        #f #;(format #t "count=~a\n" count)]
       [(rxmatch #/^tuplegenerator.val.size=(\d+)$/ property)
        (#f vsiz)
        (slot-set! test 'vsiz (string->number vsiz))]
      )]
    [(_ _ _ _ "MapTaskBase" _ "ELAPSED" "TIME:" et)
     (if (and (slot-bound? test 'clv)
              (slot-bound? test 'ksiz)
              (slot-bound? test 'vsiz))
         (let* ((rs (get-trial dict
                       (ref test 'clv) (ref test 'ksiz) (ref test 'vsiz)))
                (plen (length (result-put rs)))
                (glen (length (result-get rs)))
                (olen (length (result-out rs))))
           (cond
            [(and (= plen glen) (= glen olen))
             (slot-set! rs 'put
                        (append (result-put rs) `(,(string->number et))))]
            [(and (> plen glen) (= glen olen))
             (slot-set! rs 'get
                        (append (result-get rs) `(,(string->number et))))]
            [else (error "log event sequence error")]
            ))
         (error "log event sequence error: unbound slot(s)"))]
    [(_ _ _ _ _ _ "CommandRemoveTupleGroup" _ "ELAPSED" "TIME:" et)
     (if (and (slot-bound? test 'clv)
              (slot-bound? test 'ksiz)
              (slot-bound? test 'vsiz))
         (let* ((rs (get-trial dict
                       (ref test 'clv) (ref test 'ksiz) (ref test 'vsiz)))
                (plen (length (result-put rs)))
                (glen (length (result-get rs)))
                (olen (length (result-out rs))))
           (if (and (= plen glen) (> glen olen))
               (begin
                 (slot-set! rs 'out
                            (append (result-out rs) `(,(string->number et))))
                 (slot-set! test 'clv (undefined))
                 (slot-set! test 'ksiz (undefined))
                 (slot-set! test 'vsiz (undefined)))
               (error "log event sequence error")))
         (error "log event sequence error: unbound slot(s)"))]
    [else (values)])
  )

(define (average sum n lis)
  (if (null? lis)
      (/. sum n)
      (average (+ (car lis) sum) (+ n 1) (cdr lis))))

(define (throughput time bytes)
  (* (/. bytes time) 1000))

(define (report dict)
  (letrec
      ((println (^[op lis dsiz]
                  (for-each (^t (format #t "~a,~a,~6,3f\n"
                                        op t (throughput t dsiz)))
                            lis)))
       (printer (^[op rs dsiz]
                  (println op (ref rs op) dsiz)
                  (let1 avg (average 0 0 (ref rs op))
                    (format #t "avg.~a,~a,~6,3f\n"
                            op avg (throughput avg dsiz)))))
       )
    (for-each
     (^t
      (format #t "~a,~a,~a\n" (ref t 'clv) (ref t 'ksiz) (ref t 'vsiz))
      (for-each (^o (printer o (hash-table-get dict t)
                             (* (+ (ref t 'ksiz) (ref t 'vsiz)) 65536 16)))
                '(put get out)))
     (sort (hash-table-keys dict)))
    ))

(define (wiki-report dict)
  (let ((printer (^[op t rs]
                   (let1 avg (average 0 0 (ref rs op))
                     (format #t "||~a||~a||~a||~a||~d||~6,3f||\n"
                             op (if (eq? (ref t 'clv) 'vanilla) "v" "e")
                             (ref t 'ksiz) (ref t 'vsiz)
                             (inexact->exact (truncate avg))
                             (/ (throughput avg
                                            (* (+ (ref t 'ksiz)
                                                  (ref t 'vsiz))
                                               65536 16))
                                1024 1024))
                     ))))
    (for-each
     (^t
      (for-each (^o (printer o t (hash-table-get dict t)))
                '(put get out)))
     (sort (hash-table-keys dict)))
    ))

;; Entry point
(define (main args)
  (let-args (cdr args)
      ([wiki "w|wiki"]
       [#f   "h|help" => usage]
       [else (opt . _) (print "Unknown option : " opt) (usage)]
       . args)
    (match args
      [() (usage)]
      [(log-file)
       (let ([reader (make-csv-reader #\space)]
             [dict (make-hash-table 'equal?)]
             [test (make <test>)])
         (call-with-input-file log-file
           (^[in]
             (port-for-each
              (^[line] (read-log dict test line))
              (^[] (reader in)))))
         ((if wiki wiki-report report) dict))]
      [else (usage)])))