Example #1
0
func loadFromAll(generators []generator, datacentre string,
	logger *log.Logger) (*mdb.Mdb, error) {
	machineMap := make(map[string]mdb.Machine)
	startTime := time.Now()
	var rusageStart, rusageStop syscall.Rusage
	syscall.Getrusage(syscall.RUSAGE_SELF, &rusageStart)
	for _, gen := range generators {
		mdb, err := gen.Generate(datacentre, logger)
		if err != nil {
			return nil, err
		}
		for _, machine := range mdb.Machines {
			if oldMachine, ok := machineMap[machine.Hostname]; ok {
				oldMachine.UpdateFrom(machine)
				machineMap[machine.Hostname] = oldMachine
			} else {
				machineMap[machine.Hostname] = machine
			}
		}
	}
	var newMdb mdb.Mdb
	for _, machine := range machineMap {
		newMdb.Machines = append(newMdb.Machines, machine)
	}
	syscall.Getrusage(syscall.RUSAGE_SELF, &rusageStop)
	loadTimeDistribution.Add(time.Since(startTime))
	loadCpuTimeDistribution.Add(time.Duration(
		rusageStop.Utime.Sec)*time.Second +
		time.Duration(rusageStop.Utime.Usec)*time.Microsecond -
		time.Duration(rusageStart.Utime.Sec)*time.Second -
		time.Duration(rusageStart.Utime.Usec)*time.Microsecond)
	return &newMdb, nil
}
Example #2
0
func main() {
	lim := &syscall.Rlimit{}

	syscall.Getrlimit(syscall.RLIMIT_NOFILE, lim)
	lim.Cur = 15
	syscall.Setrlimit(syscall.RLIMIT_NOFILE, lim)
	fmt.Println(lim)
	var s []*os.File
	for i := 0; i < int(lim.Max+10); i++ {
		f, err := os.Open("/tmp/whj.txt")
		fmt.Println(f, err)
		s = append(s, f)
		err = syscall.Getrlimit(syscall.RLIMIT_NOFILE, lim)
		fmt.Println(lim, err)
	}
	err := syscall.Getrlimit(syscall.RLIMIT_CORE, lim)
	fmt.Println(lim, err)
	rusage := &syscall.Rusage{}
	err = syscall.Getrusage(0, rusage)
	fmt.Println(rusage, err)
	err = syscall.Getrusage(1, rusage)
	fmt.Println(rusage, err)
	err = syscall.Getrusage(2, rusage)
	fmt.Println(rusage, err)
	err = syscall.Getrusage(3, rusage)
	fmt.Println(rusage, err)
	err = syscall.Getrusage(4, rusage)
	fmt.Println(rusage, err)
}
Example #3
0
func (imageObjectServers *imageObjectServersType) WriteHtml(writer io.Writer) {
	// TODO(rgooch): These statistics should be cached and the cache invalidated
	//               when images and objects are added/deleted.
	var rusageStart, rusageStop syscall.Rusage
	syscall.Getrusage(syscall.RUSAGE_SELF, &rusageStart)
	objectsMap := imageObjectServers.objSrv.ListObjectSizes()
	var totalBytes uint64
	for _, bytes := range objectsMap {
		totalBytes += bytes
	}
	numObjects := len(objectsMap)
	fmt.Fprintf(writer, "Number of objects: %d, consumimg %s<br>\n",
		numObjects, format.FormatBytes(totalBytes))
	for _, imageName := range imageObjectServers.imdb.ListImages() {
		image := imageObjectServers.imdb.GetImage(imageName)
		if image == nil {
			continue
		}
		for _, inode := range image.FileSystem.InodeTable {
			if inode, ok := inode.(*filesystem.RegularInode); ok {
				delete(objectsMap, inode.Hash)
			}
		}
	}
	var unreferencedBytes uint64
	for _, bytes := range objectsMap {
		unreferencedBytes += bytes
	}
	unreferencedObjectsPercent := 0.0
	if numObjects > 0 {
		unreferencedObjectsPercent =
			100.0 * float64(len(objectsMap)) / float64(numObjects)
	}
	unreferencedBytesPercent := 0.0
	if totalBytes > 0 {
		unreferencedBytesPercent =
			100.0 * float64(unreferencedBytes) / float64(totalBytes)
	}
	syscall.Getrusage(syscall.RUSAGE_SELF, &rusageStop)
	statisticsComputeCpuTimeDistribution.Add(time.Duration(
		rusageStop.Utime.Sec)*time.Second +
		time.Duration(rusageStop.Utime.Usec)*time.Microsecond -
		time.Duration(rusageStart.Utime.Sec)*time.Second -
		time.Duration(rusageStart.Utime.Usec)*time.Microsecond)
	fmt.Fprintf(writer,
		"Number of unreferenced objects: %d (%.1f%%), "+
			"consuming %s (%.1f%%)<br>\n",
		len(objectsMap), unreferencedObjectsPercent,
		format.FormatBytes(unreferencedBytes), unreferencedBytesPercent)
}
Example #4
0
// Returns true if no update needs to be performed.
func (sub *Sub) buildUpdateRequest(request *subproto.UpdateRequest) bool {
	var state state
	state.subFS = &sub.fileSystem.FileSystem
	requiredImage := sub.herd.getImage(sub.requiredImage)
	state.requiredFS = requiredImage.FileSystem
	filter := requiredImage.Filter
	request.Triggers = requiredImage.Triggers
	state.requiredInodeToSubInode = make(map[uint64]uint64)
	state.inodesChanged = make(map[uint64]bool)
	state.inodesCreated = make(map[uint64]string)
	state.subObjectCacheUsage = make(map[hash.Hash]uint64,
		len(sub.fileSystem.ObjectCache))
	var rusageStart, rusageStop syscall.Rusage
	syscall.Getrusage(syscall.RUSAGE_SELF, &rusageStart)
	// Populate subObjectCacheUsage.
	for _, hash := range sub.fileSystem.ObjectCache {
		state.subObjectCacheUsage[hash] = 0
	}
	compareDirectories(request, &state,
		&state.subFS.DirectoryInode, &state.requiredFS.DirectoryInode,
		"/", filter)
	// Look for multiply used objects and tell the sub.
	for obj, useCount := range state.subObjectCacheUsage {
		if useCount > 1 {
			if request.MultiplyUsedObjects == nil {
				request.MultiplyUsedObjects = make(map[hash.Hash]uint64)
			}
			request.MultiplyUsedObjects[obj] = useCount
		}
	}
	syscall.Getrusage(syscall.RUSAGE_SELF, &rusageStop)
	sub.lastComputeUpdateCpuDuration = time.Duration(
		rusageStop.Utime.Sec)*time.Second +
		time.Duration(rusageStop.Utime.Usec)*time.Microsecond -
		time.Duration(rusageStart.Utime.Sec)*time.Second -
		time.Duration(rusageStart.Utime.Usec)*time.Microsecond
	computeCpuTimeDistribution.Add(sub.lastComputeUpdateCpuDuration)
	if len(request.FilesToCopyToCache) > 0 ||
		len(request.InodesToMake) > 0 ||
		len(request.HardlinksToMake) > 0 ||
		len(request.PathsToDelete) > 0 ||
		len(request.DirectoriesToMake) > 0 ||
		len(request.InodesToChange) > 0 {
		sub.herd.logger.Printf(
			"buildUpdateRequest(%s) took: %s user CPU time\n",
			sub.hostname, sub.lastComputeUpdateCpuDuration)
		return false
	}
	return true
}
Example #5
0
func RunSysStats(startedAt time.Time, interval time.Duration) {
	const nsInMs uint64 = 1000 * 1000

	ticker := time.NewTicker(interval)
	defer func() {
		ticker.Stop()
	}()

	var (
		ms           = new(runtime.MemStats)
		rusage       = &syscall.Rusage{}
		lastUserTime int64
		lastSysTime  int64
		userTime     int64
		sysTime      int64
		userCpuUtil  float64
		sysCpuUtil   float64
	)

	for _ = range ticker.C {
		runtime.ReadMemStats(ms)

		syscall.Getrusage(syscall.RUSAGE_SELF, rusage)
		syscall.Getrusage(syscall.RUSAGE_SELF, rusage)
		userTime = rusage.Utime.Sec*1000000000 + int64(rusage.Utime.Usec)
		sysTime = rusage.Stime.Sec*1000000000 + int64(rusage.Stime.Usec)
		userCpuUtil = float64(userTime-lastUserTime) * 100 / float64(interval)
		sysCpuUtil = float64(sysTime-lastSysTime) * 100 / float64(interval)

		lastUserTime = userTime
		lastSysTime = sysTime

		log.Info("ver:%s, since:%s, go:%d, gc:%dms/%d=%d, heap:{%s, %s, %s, %s %s} cpu:{%3.2f%%us, %3.2f%%sy}",
			BuildId,
			time.Since(startedAt),
			runtime.NumGoroutine(),
			ms.PauseTotalNs/nsInMs,
			ms.NumGC,
			ms.PauseTotalNs/(nsInMs*uint64(ms.NumGC))+1,
			gofmt.ByteSize(ms.HeapSys),      // bytes it has asked the operating system for
			gofmt.ByteSize(ms.HeapAlloc),    // bytes currently allocated in the heap
			gofmt.ByteSize(ms.HeapIdle),     // bytes in the heap that are unused
			gofmt.ByteSize(ms.HeapReleased), // bytes returned to the operating system, 5m for scavenger
			gofmt.Comma(int64(ms.HeapObjects)),
			userCpuUtil,
			sysCpuUtil)

	}
}
Example #6
0
func getrusage(who int, rusage *Rusage) error {
	switch who {
	case RUSAGE_CHILDREN:
		who = syscall.RUSAGE_CHILDREN
	case RUSAGE_SELF:
		who = syscall.RUSAGE_SELF
	default:
		return syscall.ENOTSUP
	}
	var syscallRusage syscall.Rusage
	if err := syscall.Getrusage(who, &syscallRusage); err != nil {
		return err
	}
	rusage.Utime.Sec = int64(syscallRusage.Utime.Sec)
	rusage.Utime.Usec = int64(syscallRusage.Utime.Usec)
	rusage.Stime.Sec = int64(syscallRusage.Stime.Sec)
	rusage.Stime.Usec = int64(syscallRusage.Stime.Usec)
	rusage.Maxrss = int64(syscallRusage.Maxrss) >> 10
	rusage.Ixrss = int64(syscallRusage.Ixrss) >> 10
	rusage.Idrss = int64(syscallRusage.Idrss) >> 10
	rusage.Minflt = int64(syscallRusage.Minflt)
	rusage.Majflt = int64(syscallRusage.Majflt)
	rusage.Nswap = int64(syscallRusage.Nswap)
	rusage.Inblock = int64(syscallRusage.Inblock)
	rusage.Oublock = int64(syscallRusage.Oublock)
	rusage.Msgsnd = int64(syscallRusage.Msgsnd)
	rusage.Msgrcv = int64(syscallRusage.Msgrcv)
	rusage.Nsignals = int64(syscallRusage.Nsignals)
	rusage.Nvcsw = int64(syscallRusage.Nvcsw)
	rusage.Nivcsw = int64(syscallRusage.Nivcsw)
	return nil
}
Example #7
0
func (s *Stats) Stats() map[string]int64 {
	st := make(map[string]int64)
	st["cmd_get"] = s.cmd_get
	st["cmd_set"] = s.cmd_set
	st["cmd_delete"] = s.cmd_delete
	st["get_hits"] = s.get_hits
	st["get_misses"] = s.get_misses
	st["curr_connections"] = s.curr_connections
	st["total_connections"] = s.total_connections
	st["bytes_read"] = s.bytes_read
	st["bytes_written"] = s.bytes_written
	for k, v := range s.stat {
		st[k] = v
	}

	t := time.Now()
	st["time"] = int64(t.Second())
	st["uptime"] = int64(t.Sub(s.start).Seconds())
	st["pid"] = int64(os.Getpid())
	st["threads"] = int64(runtime.NumGoroutine())
	rusage := syscall.Rusage{}
	syscall.Getrusage(0, &rusage)
	st["rusage_user"] = int64(rusage.Utime.Sec)
	st["rusage_system"] = int64(rusage.Stime.Sec)

	var memstat runtime.MemStats
	runtime.ReadMemStats(&memstat)
	st["rusage_maxrss"] = int64(memstat.HeapSys/1024) + cmem.Alloced()/1024
	return st
}
Example #8
0
func CommonGmetrics(gmetric MetricSender) {
	gmetric("goroutines", fmt.Sprintf("%d", runtime.NumGoroutine()), Uint, "num", false)

	var mem runtime.MemStats
	runtime.ReadMemStats(&mem)
	gmetric("mem_alloc", fmt.Sprintf("%d", mem.Alloc), Uint, "bytes", false)
	gmetric("mem_sys", fmt.Sprintf("%d", mem.Sys), Uint, "bytes", false)
	gmetric("mem_gc_pause_last", fmt.Sprintf("%.6f", float64(mem.PauseNs[(mem.NumGC+255)%256])/1e6), Float, "ms", false)
	var gcPauseMax uint64
	for _, v := range mem.PauseNs {
		if v > gcPauseMax {
			gcPauseMax = v
		}
	}
	gmetric("mem_gc_pause_max", fmt.Sprintf("%.6f", float64(gcPauseMax)/1e6), Float, "ms", false)
	gmetric("mem_gc_pause_total", fmt.Sprintf("%.6f", float64(mem.PauseTotalNs)/1e6), Float, "ms", true)
	since := time.Now().Sub(time.Unix(0, int64(mem.LastGC))).Seconds()
	gmetric("mem_gc_pause_since", fmt.Sprintf("%.6f", since), Float, "sec", false)

	var r syscall.Rusage
	if syscall.Getrusage(syscall.RUSAGE_SELF, &r) == nil {
		gmetric("rusage_utime", fmt.Sprintf("%.6f", float64(r.Utime.Nano())/1e9), Float, "cpusecs", true)
		gmetric("rusage_stime", fmt.Sprintf("%.6f", float64(r.Stime.Nano())/1e9), Float, "cpusecs", true)
		gmetric("cpu_pct", fmt.Sprintf("%.4f", 100*float64((r.Utime.Nano()+r.Stime.Nano()))/1e9), Float, "%", true)
	}
}
Example #9
0
func GetSystemStats() SystemStats {
	stats := SystemStats{}

	stats.NumGoRoutines = runtime.NumGoroutine()
	var r syscall.Rusage
	if syscall.Getrusage(syscall.RUSAGE_SELF, &r) == nil {
		stats.UserTime = float64(r.Utime.Nano()) / 1e9
		stats.SystemTime = float64(r.Stime.Nano()) / 1e9
	}

	var mem runtime.MemStats
	runtime.ReadMemStats(&mem)
	stats.BytesAlloc = mem.Alloc
	stats.BytesFromSystem = mem.Sys
	stats.GCPauseTimeLast = float64(mem.PauseNs[(mem.NumGC+255)%256]) / 1e6
	var gcPauseMax uint64
	for _, v := range mem.PauseNs {
		if v > gcPauseMax {
			gcPauseMax = v
		}
	}
	stats.GCPauseTimeMax = float64(gcPauseMax) / 1e6
	stats.GCPauseTimeTotal = float64(mem.PauseTotalNs) / 1e6
	stats.GCPauseSince = time.Now().Sub(time.Unix(0, int64(mem.LastGC))).Seconds()

	return stats
}
Example #10
0
func savePerfStats(file string) {
	fd, err := os.Create(file)
	if err != nil {
		panic(err)
	}

	var prevUsage int64
	var prevTime int64
	var rusage syscall.Rusage
	var memstats runtime.MemStats

	t0 := time.Now()
	for t := range time.NewTicker(250 * time.Millisecond).C {
		syscall.Getrusage(syscall.RUSAGE_SELF, &rusage)
		curTime := time.Now().UnixNano()
		timeDiff := curTime - prevTime
		curUsage := rusage.Utime.Nano() + rusage.Stime.Nano()
		usageDiff := curUsage - prevUsage
		cpuUsagePercent := 100 * float64(usageDiff) / float64(timeDiff)
		prevTime = curTime
		prevUsage = curUsage

		runtime.ReadMemStats(&memstats)

		startms := int(t.Sub(t0).Seconds() * 1000)

		fmt.Fprintf(fd, "%d\t%f\t%d\t%d\n", startms, cpuUsagePercent, memstats.Alloc, memstats.Sys-memstats.HeapReleased)
	}
}
Example #11
0
func registerPlatformEnvironment(group *MonitorGroup) {
	group.Chain("rusage", MonitorFunc(
		func(cb func(name string, val float64)) {
			var rusage syscall.Rusage
			err := syscall.Getrusage(syscall.RUSAGE_SELF, &rusage)
			if err != nil {
				logger.Errorf("failed getting rusage data: %s", err)
				return
			}
			MonitorStruct(&rusage, cb)
		}))
	group.Chain("proc.stat", MonitorFunc(
		func(cb func(name string, val float64)) {
			var stat procSelfStat
			err := readProcSelfStat(&stat)
			if err != nil {
				logger.Errorf("failed getting /proc/self/stat data: %s", err)
				return
			}
			MonitorStruct(&stat, cb)
		}))
	group.Chain("proc.statm", MonitorFunc(
		func(cb func(name string, val float64)) {
			var stat procSelfStatm
			err := readProcSelfStatm(&stat)
			if err != nil {
				logger.Errorf("failed getting /proc/self/statm data: %s", err)
				return
			}
			MonitorStruct(&stat, cb)
		}))
}
Example #12
0
func clock(l *State) int {
	var rusage syscall.Rusage
	_ = syscall.Getrusage(syscall.RUSAGE_SELF, &rusage) // ignore errors
	l.PushNumber(float64(rusage.Utime.Sec+rusage.Stime.Sec) + float64(rusage.Utime.Usec+rusage.Stime.Usec)/1000000.0)
	return 1

}
Example #13
0
func (server *server) statistics() serverStats {
	stats := *server.stats
	stats.Uptime = time.Since(server.startedAt).Seconds()
	stats.CurrentTubes = len(server.tubes)
	stats.TotalJobs = len(server.jobs)

	for _, tube := range server.tubes {
		stats.CurrentJobsBuried += tube.buried.Len()
		stats.CurrentJobsDelayed += tube.delayed.Len()
		stats.CurrentJobsReady += tube.ready.Len()
		stats.CurrentJobsReserved += tube.reserved.Len()
	}

	var duration time.Duration
	usage := new(syscall.Rusage)
	err := syscall.Getrusage(syscall.RUSAGE_SELF, usage)
	if err == nil {
		s, ns := usage.Utime.Unix()
		duration, err = time.ParseDuration(fmt.Sprintf("%d.%ds", s, ns))
		stats.RusageStime = duration.Seconds()

		s, ns = usage.Stime.Unix()
		duration, err = time.ParseDuration(fmt.Sprintf("%d.%ds", s, ns))
		stats.RusageUtime = duration.Seconds()
	} else {
		pf("failed to get rusage : %v", err)
	}

	return stats
}
Example #14
0
func writeHeader(writer io.Writer) {
	fmt.Fprintf(writer, "Start time: %s<br>\n", startTime.Format(timeFormat))
	uptime := time.Since(startTime) + time.Millisecond*50
	uptime = (uptime / time.Millisecond / 100) * time.Millisecond * 100
	fmt.Fprintf(writer, "Uptime: %s<br>\n", uptime)
	var rusage syscall.Rusage
	syscall.Getrusage(syscall.RUSAGE_SELF, &rusage)
	userCpuTime := time.Duration(rusage.Utime.Sec)*time.Second +
		time.Duration(rusage.Utime.Usec)*time.Microsecond
	sysCpuTime := time.Duration(rusage.Stime.Sec)*time.Second +
		time.Duration(rusage.Stime.Usec)*time.Microsecond
	cpuTime := rusage.Utime.Sec + rusage.Stime.Sec
	fmt.Fprintf(writer, "CPU Time: %.1f%% (User: %s Sys: %s)<br>\n",
		float64(cpuTime*100)/float64(uptime.Seconds()), userCpuTime, sysCpuTime)
	var memStatsBeforeGC, memStatsAfterGC runtime.MemStats
	runtime.ReadMemStats(&memStatsBeforeGC)
	runtime.GC()
	runtime.ReadMemStats(&memStatsAfterGC)
	fmt.Fprintf(writer, "Allocated memory: %s (%s after GC)<br>\n",
		format.FormatBytes(memStatsBeforeGC.Alloc),
		format.FormatBytes(memStatsAfterGC.Alloc))
	fmt.Fprintf(writer, "System memory: %s (%s after GC)<br>\n",
		format.FormatBytes(memStatsBeforeGC.Sys),
		format.FormatBytes(memStatsAfterGC.Sys))
	fmt.Fprintln(writer, "Raw <a href=\"metrics\">metrics</a>")
}
Example #15
0
func showSystemStat(interval time.Duration, count int) {

	usage1 := &syscall.Rusage{}
	var lastUtime int64
	var lastStime int64

	counter := 0
	for {

		//http://man7.org/linux/man-pages/man3/vtimes.3.html
		syscall.Getrusage(syscall.RUSAGE_SELF, usage1)

		utime := usage1.Utime.Nano()
		stime := usage1.Stime.Nano()
		userCPUUtil := float64(utime-lastUtime) * 100 / float64(interval)
		sysCPUUtil := float64(stime-lastStime) * 100 / float64(interval)
		memUtil := usage1.Maxrss * 1024

		lastUtime = utime
		lastStime = stime

		if counter > 0 {
			fmt.Printf("cpu: %3.2f%% us  %3.2f%% sy, mem:%s \n", userCPUUtil, sysCPUUtil, toH(uint64(memUtil)))
		}

		counter += 1
		if count >= 1 && count < counter {
			return
		}
		time.Sleep(interval)
	}

}
Example #16
0
func loadImageDataBase(baseDir string, objSrv objectserver.FullObjectServer,
	cleanupUnreferencedObjects bool,
	logger *log.Logger) (*ImageDataBase, error) {
	fi, err := os.Stat(baseDir)
	if err != nil {
		return nil, errors.New(
			fmt.Sprintf("Cannot stat: %s: %s\n", baseDir, err))
	}
	if !fi.IsDir() {
		return nil, errors.New(fmt.Sprintf("%s is not a directory\n", baseDir))
	}
	imdb := &ImageDataBase{
		baseDir:                    baseDir,
		directoryMap:               make(map[string]image.DirectoryMetadata),
		imageMap:                   make(map[string]*image.Image),
		addNotifiers:               make(notifiers),
		deleteNotifiers:            make(notifiers),
		mkdirNotifiers:             make(makeDirectoryNotifiers),
		objectServer:               objSrv,
		cleanupUnreferencedObjects: cleanupUnreferencedObjects,
		logger: logger,
	}
	state := concurrent.NewState(0)
	startTime := time.Now()
	var rusageStart, rusageStop syscall.Rusage
	syscall.Getrusage(syscall.RUSAGE_SELF, &rusageStart)
	if err := imdb.scanDirectory(".", state, logger); err != nil {
		return nil, err
	}
	if err := state.Reap(); err != nil {
		return nil, err
	}
	if logger != nil {
		plural := ""
		if imdb.CountImages() != 1 {
			plural = "s"
		}
		syscall.Getrusage(syscall.RUSAGE_SELF, &rusageStop)
		userTime := time.Duration(rusageStop.Utime.Sec)*time.Second +
			time.Duration(rusageStop.Utime.Usec)*time.Microsecond -
			time.Duration(rusageStart.Utime.Sec)*time.Second -
			time.Duration(rusageStart.Utime.Usec)*time.Microsecond
		logger.Printf("Loaded %d image%s in %s (%s user CPUtime)\n",
			imdb.CountImages(), plural, time.Since(startTime), userTime)
	}
	return imdb, nil
}
Example #17
0
func (this *Engine) handleHttpQuery(w http.ResponseWriter, req *http.Request,
	params map[string]interface{}) (interface{}, error) {
	var (
		vars      = mux.Vars(req)
		cmd       = vars["cmd"]
		rpcServer = this.rpcServer.(*TFunServer)
		output    = make(map[string]interface{})
	)

	switch cmd {
	case "ping":
		output["status"] = "ok"

	case "debug":
		stack := make([]byte, 1<<20)
		stackSize := runtime.Stack(stack, true)
		output["result"] = "go to global logger to see result"
		log.Info(string(stack[:stackSize]))

	case "stop":
		this.rpcServer.Stop()
		output["status"] = "stopped"

	case "stat", "stats":
		rusage := syscall.Rusage{}
		syscall.Getrusage(0, &rusage)
		output["rusage"] = rusage
		output["started"] = this.StartedAt
		output["elapsed"] = time.Since(this.StartedAt).String()
		output["pid"] = this.pid
		output["hostname"] = this.hostname
		output["ver"] = server.Version
		output["build_id"] = server.BuildId
		output["rpc"] = rpcServer.Runtime()

	case "runtime":
		output["runtime"] = rpcServer.stats.Runtime()

	case "conf":
		output["engine"] = *config.Engine
		output["rpc"] = *config.Engine.Rpc
		output["servants"] = *config.Engine.Servants

	case "guide", "help", "h":
		output["uris"] = []string{
			"/engine/ping",
			"/engine/debug",
			"/engine/stop",
			"/engine/stat",
			"/engine/runtime",
			"/engine/conf",
		}

	default:
		return nil, server.ErrHttp404
	}

	return output, nil
}
Example #18
0
func main() {

	// Test that NaNs in maps don't go quadratic.
	t := func(n int) time.Duration {
		var u0 syscall.Rusage
		if err := syscall.Getrusage(0, &u0); err != nil {
			panic(err)
		}
		m := map[float64]int{}
		nan := math.NaN()
		for i := 0; i < n; i++ {
			m[nan] = 1
		}
		if len(m) != n {
			panic("wrong size map after nan insertion")
		}
		var u1 syscall.Rusage
		if err := syscall.Getrusage(0, &u1); err != nil {
			panic(err)
		}
		return time.Duration(u1.Utime.Nano() - u0.Utime.Nano())
	}

	// Depending on the machine and OS, this test might be too fast
	// to measure with accurate enough granularity. On failure,
	// make it run longer, hoping that the timing granularity
	// is eventually sufficient.

	n := 30000 // ~8ms user time on a Mid 2011 MacBook Air (1.8 GHz Core i7)
	fails := 0
	for {
		t1 := t(n)
		t2 := t(2 * n)
		// should be 2x (linear); allow up to 3x
		if t2 < 3*t1 {
			return
		}
		fails++
		if fails == 6 {
			panic(fmt.Sprintf("too slow: %d inserts: %v; %d inserts: %v\n", n, t1, 2*n, t2))
		}
		if fails < 4 {
			n *= 2
		}
	}
}
Example #19
0
//  CPUtime returns the current CPU usage (user time + system time).
func CPUtime() time.Duration {
	var ustruct syscall.Rusage
	rx.CkErr(syscall.Getrusage(0, &ustruct))
	user := time.Duration(syscall.TimevalToNsec(ustruct.Utime))
	sys := time.Duration(syscall.TimevalToNsec(ustruct.Stime))
	return user + sys
	return 0
}
Example #20
0
func getRSS() uint64 {
	rusage := &syscall.Rusage{}
	ret := syscall.Getrusage(0, rusage)
	if ret == nil && rusage.Maxrss > 0 {
		return uint64(rusage.Maxrss)
	}
	return 0
}
Example #21
0
// Returns the sytem and the user time so far.
func getRTime() (tSys, tUsr float64) {
	rusage := &syscall.Rusage{}
	if err := syscall.Getrusage(syscall.RUSAGE_SELF, rusage); err != nil {
		log.Error("Couldn't get rusage time:", err)
	}
	s, u := rusage.Stime, rusage.Utime
	return iiToF(int64(s.Sec), int64(s.Usec)), iiToF(int64(u.Sec), int64(u.Usec))
}
Example #22
0
func update_rusage() {
	rusage_mutex.Lock()
	defer rusage_mutex.Unlock()
	err := syscall.Getrusage(syscall.RUSAGE_SELF, rusage)
	if err != nil {
		panic(err)
	}
}
Example #23
0
// SampleEnvironment queries the runtime system for various interesting metrics,
// storing the resulting values in the set of metric gauges maintained by
// RuntimeStatSampler. This makes runtime statistics more convenient for
// consumption by the time series and status systems.
//
// This method should be called periodically by a higher level system in order
// to keep runtime statistics current.
func (rsr *RuntimeStatSampler) SampleEnvironment() {
	// Record memory and call stats from the runtime package.
	// TODO(mrtracy): memory statistics will not include usage from RocksDB.
	// Determine an appropriate way to compute total memory usage.
	numCgoCall := runtime.NumCgoCall()
	numGoroutine := runtime.NumGoroutine()

	// It might be useful to call ReadMemStats() more often, but it stops the
	// world while collecting stats so shouldn't be called too often.
	ms := runtime.MemStats{}
	runtime.ReadMemStats(&ms)

	// Record CPU statistics using syscall package.
	ru := syscall.Rusage{}
	if err := syscall.Getrusage(syscall.RUSAGE_SELF, &ru); err != nil {
		log.Errorf("Getrusage failed: %v", err)
	}

	// Time statistics can be compared to the total elapsed time to create a
	// useful percentage of total CPU usage, which would be somewhat less accurate
	// if calculated later using downsampled time series data.
	now := rsr.clock.PhysicalNow()
	dur := float64(now - rsr.lastNow)
	newUtime := ru.Utime.Nano()
	newStime := ru.Stime.Nano()
	uPerc := float64(newUtime-rsr.lastUtime) / dur
	sPerc := float64(newStime-rsr.lastStime) / dur
	pausePerc := float64(ms.PauseTotalNs-rsr.lastPauseTime) / dur
	rsr.lastNow = now
	rsr.lastUtime = newUtime
	rsr.lastStime = newStime
	rsr.lastPauseTime = ms.PauseTotalNs

	// Log summary of statistics to console, if requested.
	activeMiB := float64(ms.Alloc) / (1 << 20)
	cgoRate := float64((numCgoCall-rsr.lastCgoCall)*int64(time.Second)) / dur
	log.Infof("runtime stats: %d goroutines, %.2fMiB active, %.2fcgo/sec, %.2f/%.2f %%(u/s)time, %.2f %%gc (%dx)",
		numGoroutine, activeMiB, cgoRate, uPerc, sPerc, pausePerc, ms.NumGC-rsr.lastNumGC)
	if log.V(2) {
		log.Infof("memstats: %+v", ms)
	}
	if logOSStats != nil {
		logOSStats()
	}
	rsr.lastCgoCall = numCgoCall
	rsr.lastNumGC = ms.NumGC

	rsr.cgoCalls.Update(numCgoCall)
	rsr.goroutines.Update(int64(numGoroutine))
	rsr.allocBytes.Update(int64(ms.Alloc))
	rsr.gcCount.Update(int64(ms.NumGC))
	rsr.gcPauseNS.Update(int64(ms.PauseTotalNs))
	rsr.gcPausePercent.Update(pausePerc)
	rsr.cpuUserNS.Update(newUtime)
	rsr.cpuUserPercent.Update(uPerc)
	rsr.cpuSysNS.Update(newStime)
	rsr.cpuSysPercent.Update(sPerc)
}
Example #24
0
// Rusage returns a StatSource that provides as many statistics as possible
// gathered from the Rusage syscall. Not expected to be called directly, as
// this StatSource is added by Register.
func Rusage() monkit.StatSource {
	return monkit.StatSourceFunc(func(cb func(name string, val float64)) {
		var rusage syscall.Rusage
		err := syscall.Getrusage(syscall.RUSAGE_SELF, &rusage)
		if err == nil {
			monkit.StatSourceFromStruct(&rusage).Stats(cb)
		}
	})
}
Example #25
0
func getRusage() *syscall.Rusage {
	var r syscall.Rusage
	err := syscall.Getrusage(0, &r)
	if err != nil {
		log.Errorf("[Server] error getting rusage %v", err)
		return nil
	}

	return &r
}
Example #26
0
func (ctx *FsRateContext) SetSpeedPercent(percent uint) {
	if percent > 100 {
		percent = 100
	}
	ctx.speedPercent = uint64(percent)
	var rusage syscall.Rusage
	syscall.Getrusage(syscall.RUSAGE_SELF, &rusage)
	ctx.blocksSinceLastPause = uint64(rusage.Inblock)
	ctx.timeOfLastPause = time.Now()
}
Example #27
0
// ProcessTimes returns CPU usage time of the process
func ProcessTimes() (user, system float64, size uint64) {
	var usage syscall.Rusage
	if err := syscall.Getrusage(syscall.RUSAGE_SELF, &usage); err != nil {
		fmt.Printf("Error: unable to gather resource usage data: %v\n", err)
	}
	user = float64(usage.Utime.Sec) + float64(usage.Utime.Usec)/1e6
	system = float64(usage.Stime.Sec) + float64(usage.Stime.Usec)/1e6
	size = uint64(uint32(usage.Maxrss))
	return
}
Example #28
0
func memUnix() int64 {
	var ru syscall.Rusage
	syscall.Getrusage(0, &ru)
	if runtime.GOOS == "linux" {
		// in KB
		return int64(ru.Maxrss) << 10
	}
	// In bytes:
	return int64(ru.Maxrss)
}
Example #29
0
// GetTimeSeriesData returns a slice of TimeSeriesData updates based on current
// runtime statistics.
//
// Calling this method will query various system packages for runtime statistics
// and convert the information to time series data. This is currently done in
// one method because it is convenient; however, in the future querying and
// recording can be easily separated, similar to the way that NodeStatus is
// separated into a monitor and a recorder.
func (rsr *RuntimeStatRecorder) GetTimeSeriesData() []ts.TimeSeriesData {
	data := make([]ts.TimeSeriesData, 0, rsr.lastDataCount)

	// Record memory and call stats from the runtime package.
	// TODO(mrtracy): memory statistics will not include usage from RocksDB.
	// Determine an appropriate way to compute total memory usage.
	numCgoCall := runtime.NumCgoCall()
	numGoroutine := runtime.NumGoroutine()
	ms := runtime.MemStats{}
	runtime.ReadMemStats(&ms)

	// Record CPU statistics using syscall package.
	ru := syscall.Rusage{}
	if err := syscall.Getrusage(syscall.RUSAGE_SELF, &ru); err != nil {
		log.Errorf("Getrusage failed: %v", err)
	}

	// Time statistics can be compared to the total elapsed time to create a
	// useful percentage of total CPU usage, which would be somewhat less accurate
	// if calculated later using downsampled time series data.
	now := rsr.clock.PhysicalNow()
	dur := float64(now - rsr.lastNow)
	newUtime := ru.Utime.Nano()
	newStime := ru.Stime.Nano()
	uPerc := float64(newUtime-rsr.lastUtime) / dur
	sPerc := float64(newStime-rsr.lastStime) / dur
	pausePerc := float64(ms.PauseTotalNs-rsr.lastPauseTime) / dur
	rsr.lastNow = now
	rsr.lastUtime = newUtime
	rsr.lastStime = newStime
	rsr.lastPauseTime = ms.PauseTotalNs

	// Log summary of statistics to console, if requested.
	if log.V(1) {
		activeMiB := float64(ms.Alloc) / (1 << 20)
		cgoRate := float64((numCgoCall-rsr.lastCgoCall)*int64(time.Second)) / dur
		log.Infof("runtime stats: %d goroutines, %.2fMiB active, %.2fcgo/sec, %.2f/%.2f %%(u/s)time, %.2f %%gc (%dx)",
			numGoroutine, activeMiB, cgoRate, uPerc, sPerc, pausePerc, ms.NumGC-rsr.lastNumGC)
		rsr.lastCgoCall = numCgoCall
		rsr.lastNumGC = ms.NumGC
	}

	data = append(data, rsr.record(now, "cgocalls", float64(numCgoCall)))
	data = append(data, rsr.record(now, "goroutines", float64(numGoroutine)))
	data = append(data, rsr.record(now, "allocbytes", float64(ms.Alloc)))
	data = append(data, rsr.record(now, "gc.count", float64(ms.NumGC)))
	data = append(data, rsr.record(now, "gc.pause.ns", float64(ms.PauseTotalNs)))
	data = append(data, rsr.record(now, "gc.pause.percent", pausePerc))
	data = append(data, rsr.record(now, "cpu.user.ns", float64(newUtime)))
	data = append(data, rsr.record(now, "cpu.user.percent", uPerc))
	data = append(data, rsr.record(now, "cpu.sys.ns", float64(newStime)))
	data = append(data, rsr.record(now, "cpu.sys.percent", sPerc))
	rsr.lastDataCount = len(data)
	return data
}
Example #30
0
// Compute the maximum read speed of a block device, given a file within a
// file-system mounted on the block device.
// If I/O accounting is enabled, blocksPerSecond will be non-zero.
func GetReadSpeed(name string) (bytesPerSecond, blocksPerSecond uint64,
	err error) {
	bytesPerSecond = 0
	blocksPerSecond = 0
	var devpath string
	devpath, err = getDevnodeForFile(name)
	if err != nil {
		return
	}
	var file *os.File
	file, err = openDirect(devpath, os.O_RDONLY, 0)
	if err != nil {
		return
	}
	var tread uint = 0
	buffer := make([]byte, BUFLEN)
	var rusage_start, rusage_stop syscall.Rusage
	err = syscall.Getrusage(syscall.RUSAGE_SELF, &rusage_start)
	if err != nil {
		return
	}
	time_start := time.Now()
	for tread < MAX_TO_READ {
		var nread int
		nread, err = file.Read(buffer)
		if err != nil {
			return
		}
		tread += uint(nread)
	}
	elapsed := time.Since(time_start)
	bytesPerSecond = uint64(float64(tread) / elapsed.Seconds())
	err = syscall.Getrusage(syscall.RUSAGE_SELF, &rusage_stop)
	if err != nil {
		return
	}
	if rusage_stop.Inblock > rusage_start.Inblock {
		blocksPerSecond = uint64(float64(rusage_stop.Inblock-
			rusage_start.Inblock) / elapsed.Seconds())
	}
	return
}