Linux: report number of processes and threads

main.go

// This package is Linux only

package main

import (
        "flag"
        "fmt"
        "io/ioutil"
        "log"
        "strconv"
        "time"
)

func die(err error) {
        if err != nil {
                log.Fatal(err)
        }
}

// list all numerical files in dir.
func list(dir string) ([]int, error) {
        var ids []int
        fis, err := ioutil.ReadDir(dir)
        if err != nil {
                return ids, err
        }
        for _, fi := range fis {
                i, err := strconv.Atoi(fi.Name())
                if err == nil {
                        ids = append(ids, i)
                }
        }
        return ids, nil
}

// Pids returns all active processes identified by their process ID.
// Note that this is a volatile snapshot and may change as processes start
// and stop at any time.
func Pids() ([]int, error) {
        return list("/proc")
}

// Tids returns all thread IDs for a given PID.
// TID is not as common as PID but serves a thread id nicely
func Tids(pid int) ([]int, error) {
        return list(fmt.Sprintf("/proc/%d/task", pid))
}

func main() {
        var list = flag.Bool("list", false, "List all PIDs and their TIDs")
        var total = flag.Bool("total", true, "Show totals")
        flag.Parse()
        pids, err := Pids()
        die(err)
        ntids := 0
        t := time.Now().Format(time.RFC3339)
        for _, pid := range pids {
                tids, err := Tids(pid)
                die(err)
                ntids += len(tids)
                if *list {
                        fmt.Printf("%s\t%d\t%d\n", t, pid, len(tids))
                }
        }
        if *total {
                fmt.Printf("%s\ttotal:\tPIDs:\t%d\tTIDs:\t%d\n",
                        t, len(pids), ntids)
        }
}