test/typeparam/metrics.go

   1 // run
   2
   3 // Copyright 2021 The Go Authors. All rights reserved.
   4 // Use of this source code is governed by a BSD-style
   5 // license that can be found in the LICENSE file.
   6
   7 // Package metrics provides tracking arbitrary metrics composed of
   8 // values of comparable types.
   9 package main
  10
  11 import (
  12         "fmt"
  13         "sort"
  14         "sync"
  15 )
  16
  17 // _Metric1 tracks metrics of values of some type.
  18 type _Metric1[T comparable] struct {
  19         mu sync.Mutex
  20         m  map[T]int
  21 }
  22
  23 // Add adds another instance of some value.
  24 func (m *_Metric1[T]) Add(v T) {
  25         m.mu.Lock()
  26         defer m.mu.Unlock()
  27         if m.m == nil {
  28                 m.m = make(map[T]int)
  29         }
  30         m.m[v]++
  31 }
  32
  33 // Count returns the number of instances we've seen of v.
  34 func (m *_Metric1[T]) Count(v T) int {
  35         m.mu.Lock()
  36         defer m.mu.Unlock()
  37         return m.m[v]
  38 }
  39
  40 // Metrics returns all the values we've seen, in an indeterminate order.
  41 func (m *_Metric1[T]) Metrics() []T {
  42         return _Keys(m.m)
  43 }
  44
  45 type key2[T1, T2 comparable] struct {
  46         f1 T1
  47         f2 T2
  48 }
  49
  50 // _Metric2 tracks metrics of pairs of values.
  51 type _Metric2[T1, T2 comparable] struct {
  52         mu sync.Mutex
  53         m  map[key2[T1, T2]]int
  54 }
  55
  56 // Add adds another instance of some pair of values.
  57 func (m *_Metric2[T1, T2]) Add(v1 T1, v2 T2) {
  58         m.mu.Lock()
  59         defer m.mu.Unlock()
  60         if m.m == nil {
  61                 m.m = make(map[key2[T1, T2]]int)
  62         }
  63         m.m[key2[T1, T2]{v1, v2}]++
  64 }
  65
  66 // Count returns the number of instances we've seen of v1/v2.
  67 func (m *_Metric2[T1, T2]) Count(v1 T1, v2 T2) int {
  68         m.mu.Lock()
  69         defer m.mu.Unlock()
  70         return m.m[key2[T1, T2]{v1, v2}]
  71 }
  72
  73 // Metrics returns all the values we've seen, in an indeterminate order.
  74 func (m *_Metric2[T1, T2]) Metrics() (r1 []T1, r2 []T2) {
  75         for _, k := range _Keys(m.m) {
  76                 r1 = append(r1, k.f1)
  77                 r2 = append(r2, k.f2)
  78         }
  79         return r1, r2
  80 }
  81
  82 type key3[T1, T2, T3 comparable] struct {
  83         f1 T1
  84         f2 T2
  85         f3 T3
  86 }
  87
  88 // _Metric3 tracks metrics of triplets of values.
  89 type _Metric3[T1, T2, T3 comparable] struct {
  90         mu sync.Mutex
  91         m  map[key3[T1, T2, T3]]int
  92 }
  93
  94 // Add adds another instance of some triplet of values.
  95 func (m *_Metric3[T1, T2, T3]) Add(v1 T1, v2 T2, v3 T3) {
  96         m.mu.Lock()
  97         defer m.mu.Unlock()
  98         if m.m == nil {
  99                 m.m = make(map[key3[T1, T2, T3]]int)
 100         }
 101         m.m[key3[T1, T2, T3]{v1, v2, v3}]++
 102 }
 103
 104 // Count returns the number of instances we've seen of v1/v2/v3.
 105 func (m *_Metric3[T1, T2, T3]) Count(v1 T1, v2 T2, v3 T3) int {
 106         m.mu.Lock()
 107         defer m.mu.Unlock()
 108         return m.m[key3[T1, T2, T3]{v1, v2, v3}]
 109 }
 110
 111 // Metrics returns all the values we've seen, in an indeterminate order.
 112 func (m *_Metric3[T1, T2, T3]) Metrics() (r1 []T1, r2 []T2, r3 []T3) {
 113         for k := range m.m {
 114                 r1 = append(r1, k.f1)
 115                 r2 = append(r2, k.f2)
 116                 r3 = append(r3, k.f3)
 117         }
 118         return r1, r2, r3
 119 }
 120
 121 type S struct{ a, b, c string }
 122
 123 func TestMetrics() {
 124         m1 := _Metric1[string]{}
 125         if got := m1.Count("a"); got != 0 {
 126                 panic(fmt.Sprintf("Count(%q) = %d, want 0", "a", got))
 127         }
 128         m1.Add("a")
 129         m1.Add("a")
 130         if got := m1.Count("a"); got != 2 {
 131                 panic(fmt.Sprintf("Count(%q) = %d, want 2", "a", got))
 132         }
 133         if got, want := m1.Metrics(), []string{"a"}; !_SlicesEqual(got, want) {
 134                 panic(fmt.Sprintf("Metrics = %v, want %v", got, want))
 135         }
 136
 137         m2 := _Metric2[int, float64]{}
 138         m2.Add(1, 1)
 139         m2.Add(2, 2)
 140         m2.Add(3, 3)
 141         m2.Add(3, 3)
 142         k1, k2 := m2.Metrics()
 143
 144         sort.Ints(k1)
 145         w1 := []int{1, 2, 3}
 146         if !_SlicesEqual(k1, w1) {
 147                 panic(fmt.Sprintf("_Metric2.Metrics first slice = %v, want %v", k1, w1))
 148         }
 149
 150         sort.Float64s(k2)
 151         w2 := []float64{1, 2, 3}
 152         if !_SlicesEqual(k2, w2) {
 153                 panic(fmt.Sprintf("_Metric2.Metrics first slice = %v, want %v", k2, w2))
 154         }
 155
 156         m3 := _Metric3[string, S, S]{}
 157         m3.Add("a", S{"d", "e", "f"}, S{"g", "h", "i"})
 158         m3.Add("a", S{"d", "e", "f"}, S{"g", "h", "i"})
 159         m3.Add("a", S{"d", "e", "f"}, S{"g", "h", "i"})
 160         m3.Add("b", S{"d", "e", "f"}, S{"g", "h", "i"})
 161         if got := m3.Count("a", S{"d", "e", "f"}, S{"g", "h", "i"}); got != 3 {
 162                 panic(fmt.Sprintf("Count(%v, %v, %v) = %d, want 3", "a", S{"d", "e", "f"}, S{"g", "h", "i"}, got))
 163         }
 164 }
 165
 166 func main() {
 167         TestMetrics()
 168 }
 169
 170 // _Equal reports whether two slices are equal: the same length and all
 171 // elements equal. All floating point NaNs are considered equal.
 172 func _SlicesEqual[Elem comparable](s1, s2 []Elem) bool {
 173         if len(s1) != len(s2) {
 174                 return false
 175         }
 176         for i, v1 := range s1 {
 177                 v2 := s2[i]
 178                 if v1 != v2 {
 179                         isNaN := func(f Elem) bool { return f != f }
 180                         if !isNaN(v1) || !isNaN(v2) {
 181                                 return false
 182                         }
 183                 }
 184         }
 185         return true
 186 }
 187
 188 // _Keys returns the keys of the map m.
 189 // The keys will be an indeterminate order.
 190 func _Keys[K comparable, V any](m map[K]V) []K {
 191         r := make([]K, 0, len(m))
 192         for k := range m {
 193                 r = append(r, k)
 194         }
 195         return r
 196 }