syncthing/cmd/stbench/main.go

// Copyright (C) 2016 The Syncthing Authors.
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this file,
// You can obtain one at http://mozilla.org/MPL/2.0/.

// This doesn't build on Windows due to the Rusage stuff.

// +build !windows

package main

import (
	"flag"
	"fmt"
	"log"
	"runtime"
	"syscall"
	"time"

	"github.com/syncthing/syncthing/lib/rc"
)

var homeDir = "h1"
var syncthingBin = "./bin/syncthing"
var test = "scan"

func main() {
	flag.StringVar(&homeDir, "home", homeDir, "Home directory location")
	flag.StringVar(&syncthingBin, "bin", syncthingBin, "Binary location")
	flag.StringVar(&test, "test", test, "Test to run")
	flag.Parse()

	switch test {
	case "scan":
		// scan measures the resource usage required to perform the initial
		// scan, without cleaning away the database first.
		testScan()
	}
}

// testScan starts a process and reports on the resource usage required to
// perform the initial scan.
func testScan() {
	log.Println("Starting...")
	p := rc.NewProcess("127.0.0.1:8081")
	if err := p.Start(syncthingBin, "-home", homeDir, "-no-browser"); err != nil {
		log.Println(err)
		return
	}
	defer p.Stop()

	wallTime := awaitScanComplete(p)

	report(p, wallTime)
}

// awaitScanComplete waits for a folder to transition idle->scanning and
// then scanning->idle and returns the time taken for the scan.
func awaitScanComplete(p *rc.Process) time.Duration {
	log.Println("Awaiting scan completion...")
	var t0, t1 time.Time
	lastEvent := 0
loop:
	for {
		evs, err := p.Events(lastEvent)
		if err != nil {
			continue
		}

		for _, ev := range evs {
			if ev.Type == "StateChanged" {
				data := ev.Data.(map[string]interface{})
				log.Println(ev)

				if data["to"].(string) == "scanning" {
					t0 = ev.Time
					continue
				}

				if !t0.IsZero() && data["to"].(string) == "idle" {
					t1 = ev.Time
					break loop
				}
			}
			lastEvent = ev.ID
		}

		time.Sleep(250 * time.Millisecond)
	}

	return t1.Sub(t0)
}

// report stops the given process and reports on it's resource usage in two
// ways: human readable to stderr, and CSV to stdout.
func report(p *rc.Process, wallTime time.Duration) {
	sv, err := p.SystemVersion()
	if err != nil {
		log.Println(err)
		return
	}

	ss, err := p.SystemStatus()
	if err != nil {
		log.Println(err)
		return
	}

	proc, err := p.Stop()
	if err != nil {
		return
	}

	rusage, ok := proc.SysUsage().(*syscall.Rusage)
	if !ok {
		return
	}

	log.Println("Version:", sv.Version)
	log.Println("Alloc:", ss.Alloc/1024, "KiB")
	log.Println("Sys:", ss.Sys/1024, "KiB")
	log.Println("Goroutines:", ss.Goroutines)
	log.Println("Wall time:", wallTime)
	log.Println("Utime:", time.Duration(rusage.Utime.Nano()))
	log.Println("Stime:", time.Duration(rusage.Stime.Nano()))
	if runtime.GOOS == "darwin" {
		// Darwin reports in bytes, Linux seems to report in KiB even
		// though the manpage says otherwise.
		rusage.Maxrss /= 1024
	}
	log.Println("MaxRSS:", rusage.Maxrss, "KiB")

	fmt.Printf("%s,%d,%d,%d,%.02f,%.02f,%.02f,%d\n",
		sv.Version,
		ss.Alloc/1024,
		ss.Sys/1024,
		ss.Goroutines,
		wallTime.Seconds(),
		time.Duration(rusage.Utime.Nano()).Seconds(),
		time.Duration(rusage.Stime.Nano()).Seconds(),
		rusage.Maxrss)
}