From 1a57267a17c2fc17fb6e104846fabc3e363c326c Mon Sep 17 00:00:00 2001
From: Emile <git@emile.space>
Date: Fri, 16 Aug 2024 19:50:26 +0200
Subject: initial commit

---
 vendor/modernc.org/libc/probes.go | 169 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 169 insertions(+)
 create mode 100644 vendor/modernc.org/libc/probes.go

(limited to 'vendor/modernc.org/libc/probes.go')

diff --git a/vendor/modernc.org/libc/probes.go b/vendor/modernc.org/libc/probes.go
new file mode 100644
index 0000000..b92cfa1
--- /dev/null
+++ b/vendor/modernc.org/libc/probes.go
@@ -0,0 +1,169 @@
+// Copyright 2022 The Libc Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package libc // import "modernc.org/libc"
+
+import (
+	"bytes"
+	"fmt"
+	"math"
+	"runtime/debug"
+	"sort"
+	"strings"
+	"sync"
+	"sync/atomic"
+
+	"github.com/dustin/go-humanize"
+)
+
+type PerfCounter struct {
+	a      []int32
+	labels []string
+
+	enabled bool
+}
+
+func NewPerfCounter(labels []string) *PerfCounter {
+	return &PerfCounter{
+		a:       make([]int32, len(labels)),
+		labels:  labels,
+		enabled: true,
+	}
+}
+
+func (c *PerfCounter) Disable() { c.enabled = false }
+func (c *PerfCounter) Enable()  { c.enabled = true }
+
+func (c *PerfCounter) Clear() {
+	for i := range c.a {
+		c.a[i] = 0
+	}
+}
+
+func (c *PerfCounter) Inc(n int) {
+	if c.enabled {
+		atomic.AddInt32(&c.a[n], 1)
+	}
+}
+
+func (c *PerfCounter) IncN(n, m int) {
+	if c.enabled {
+		atomic.AddInt32(&c.a[n], int32(m))
+	}
+}
+
+func (c *PerfCounter) String() string {
+	sv := c.enabled
+
+	defer func() { c.enabled = sv }()
+
+	c.enabled = false
+
+	var a []string
+	for i, v := range c.a {
+		if v != 0 {
+			a = append(a, fmt.Sprintf("%q: %s", c.labels[i], h(v)))
+		}
+	}
+	return fmt.Sprint(a)
+}
+
+func h(v interface{}) string {
+	switch x := v.(type) {
+	case int:
+		return humanize.Comma(int64(x))
+	case int32:
+		return humanize.Comma(int64(x))
+	case int64:
+		return humanize.Comma(x)
+	case uint32:
+		return humanize.Comma(int64(x))
+	case uint64:
+		if x <= math.MaxInt64 {
+			return humanize.Comma(int64(x))
+		}
+
+		return "-" + humanize.Comma(-int64(x))
+	}
+	return fmt.Sprint(v)
+}
+
+type StackCapture struct {
+	sync.Mutex
+	m map[string]int
+
+	depth int
+
+	enabled bool
+}
+
+func NewStackCapture(depth int) *StackCapture {
+	return &StackCapture{
+		m:       map[string]int{},
+		depth:   depth,
+		enabled: true,
+	}
+}
+
+func (c *StackCapture) Disable() { c.enabled = false }
+func (c *StackCapture) Enable()  { c.enabled = true }
+
+func (c *StackCapture) Clear() {
+	c.Lock()
+
+	defer c.Unlock()
+	c.m = map[string]int{}
+}
+
+var (
+	stackCapturePrefix = []byte("\n\t")
+)
+
+func (c *StackCapture) Record() {
+	if !c.enabled {
+		return
+	}
+
+	b := debug.Stack()
+	var s strings.Builder
+out:
+	for i := 0; len(b) > 0 && i < c.depth+2; i++ {
+		l := bytes.Index(b, stackCapturePrefix)
+		if l < 0 {
+			break out
+		}
+
+		b = b[l+len(stackCapturePrefix):]
+		h := bytes.IndexByte(b, '\n')
+		if h < 0 {
+			h = len(b)
+		}
+		if i > 1 {
+			fmt.Fprintf(&s, "\n\t%s", b[:h])
+		}
+		b = b[h:]
+	}
+	c.Lock()
+
+	defer c.Unlock()
+
+	c.m[s.String()]++
+}
+
+func (c *StackCapture) String() string {
+	c.Lock()
+
+	defer c.Unlock()
+
+	var b strings.Builder
+	var a []string
+	for k := range c.m {
+		a = append(a, k)
+	}
+	sort.Slice(a, func(i, j int) bool { return c.m[a[i]] < c.m[a[j]] })
+	for _, k := range a {
+		fmt.Fprintf(&b, "%d%s\n", c.m[k], k)
+	}
+	return b.String()
+}
-- 
cgit 1.4.1