108 lines
3.7 KiB
Go
108 lines
3.7 KiB
Go
package award
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"testing"
|
|
"time"
|
|
|
|
"hamlog/internal/qso"
|
|
)
|
|
|
|
// A synthetic log with the shape a real one has: a spread of bands, modes,
|
|
// entities, and the free-text fields the harder awards actually scan.
|
|
func benchLog(n int) []qso.QSO {
|
|
bands := []string{"160m", "80m", "40m", "30m", "20m", "17m", "15m", "12m", "10m", "6m"}
|
|
modes := []string{"SSB", "CW", "FT8", "FT4", "RTTY"}
|
|
entities := []int{291, 248, 227, 230, 339, 5, 108, 110, 6, 281}
|
|
towns := []string{"SERIATE (BG)", "MILANO (MI)", "ROMA (RM)", "TORINO (TO)", "NAPOLI (NA)"}
|
|
out := make([]qso.QSO, n)
|
|
base := time.Date(2015, 1, 1, 0, 0, 0, 0, time.UTC)
|
|
for i := range out {
|
|
e := entities[i%len(entities)]
|
|
out[i] = qso.QSO{
|
|
ID: int64(i + 1),
|
|
Callsign: fmt.Sprintf("I%dABC", i%10),
|
|
Band: bands[i%len(bands)],
|
|
Mode: modes[i%len(modes)],
|
|
DXCC: &e,
|
|
QSODate: base.Add(time.Duration(i) * time.Hour),
|
|
QTH: towns[i%len(towns)],
|
|
Address: "Via Roma 12, 24068 " + towns[i%len(towns)] + " Italy",
|
|
Grid: "JN45AA",
|
|
State: "CA",
|
|
LOTWRcvd: "Y",
|
|
}
|
|
}
|
|
return out
|
|
}
|
|
|
|
// WAIP is the worst realistic shape: a predefined list, an exact-match primary
|
|
// that always produces a doomed candidate, then a fallback chain that tokenises a
|
|
// free-text field. If anything is slow, it is this.
|
|
func benchWAIP() (Def, []RefMeta) {
|
|
d := Def{
|
|
Code: "WAIP", Valid: true, Type: TypeReference,
|
|
Field: "address", MatchBy: "code", ExactMatch: true,
|
|
OrRules: []OrRule{
|
|
{Field: "qth", MatchBy: "description"},
|
|
{Field: "qth", MatchBy: "code"},
|
|
{Field: "address", MatchBy: "code"},
|
|
},
|
|
DXCCFilter: []int{248},
|
|
Confirm: []string{"lotw", "qsl"},
|
|
}
|
|
codes := []string{"AG", "AL", "AN", "AO", "AP", "AQ", "AR", "AT", "AV", "BA", "BG", "BI", "BL", "BN", "BO", "BR", "BS", "BT", "BZ", "CA", "CB", "CE", "CH", "CL", "CN", "CO", "CR", "CS", "CT", "CZ", "EN", "FC", "FE", "FG", "FI", "FM", "FR", "GE", "GO", "GR", "IM", "IS", "KR", "LC", "LE", "LI", "LO", "LT", "LU", "MB", "MC", "ME", "MI", "MN", "MO", "MS", "MT", "NA", "NO", "NU", "OR", "PA", "PC", "PD", "PE", "PG", "PI", "PN", "PO", "PR", "PT", "PU", "PV", "PZ", "RA", "RC", "RE", "RG", "RI", "RM", "RN", "RO", "SA", "SI", "SO", "SP", "SR", "SS", "SU", "SV", "TA", "TE", "TN", "TO", "TP", "TR", "TS", "TV", "UD", "VA", "VB", "VC", "VE", "VI", "VR", "VT", "VV"}
|
|
metas := make([]RefMeta, 0, len(codes))
|
|
for _, c := range codes {
|
|
metas = append(metas, RefMeta{Code: c, Name: "Province " + c, Valid: true})
|
|
}
|
|
return d, metas
|
|
}
|
|
|
|
// One award, whole log — what GetAward(code) does when the Awards panel opens.
|
|
func BenchmarkComputeOneAward(b *testing.B) {
|
|
d, metas := benchWAIP()
|
|
for _, n := range []int{10_000, 50_000, 100_000} {
|
|
log := benchLog(n)
|
|
b.Run(fmt.Sprintf("WAIP/%dqso", n), func(b *testing.B) {
|
|
for i := 0; i < b.N; i++ {
|
|
Compute([]Def{d}, log, map[string][]RefMeta{"WAIP": metas}, nil)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// Every shipped award at once — GetAwards(), the heaviest thing the app can ask.
|
|
func BenchmarkComputeWholeCatalog(b *testing.B) {
|
|
defs := Defaults()
|
|
metas := map[string][]RefMeta{}
|
|
wd, wm := benchWAIP()
|
|
defs = append(defs, wd)
|
|
metas["WAIP"] = wm
|
|
for _, c := range Catalog() {
|
|
if raw, ok := CatalogRefs(c.Def.Code); ok {
|
|
var refs []struct {
|
|
Code string `json:"code"`
|
|
Name string `json:"name"`
|
|
Valid bool `json:"valid"`
|
|
}
|
|
if json.Unmarshal(raw, &refs) == nil {
|
|
m := make([]RefMeta, 0, len(refs))
|
|
for _, r := range refs {
|
|
m = append(m, RefMeta{Code: r.Code, Name: r.Name, Valid: r.Valid})
|
|
}
|
|
metas[c.Def.Code] = m
|
|
}
|
|
}
|
|
}
|
|
for _, n := range []int{10_000, 100_000} {
|
|
log := benchLog(n)
|
|
b.Run(fmt.Sprintf("%dawards/%dqso", len(defs), n), func(b *testing.B) {
|
|
for i := 0; i < b.N; i++ {
|
|
Compute(defs, log, metas, nil)
|
|
}
|
|
})
|
|
}
|
|
}
|