| Benchmark | go-toml v1 | BurntSushi/toml |
|---|---|---|
| Marshal/HugoFrontMatter-2 | 1.9x | 2.2x |
| Marshal/ReferenceFile/map-2 | 1.7x | 2.1x |
| Marshal/ReferenceFile/struct-2 | 2.2x | 3.0x |
| Unmarshal/HugoFrontMatter-2 | 2.9x | 2.7x |
| Unmarshal/ReferenceFile/map-2 | 2.6x | 2.7x |
| Unmarshal/ReferenceFile/struct-2 | 4.6x | 5.1x |
The table above has the results of the most common use-cases. The table below +contains the results of all benchmarks, including unrealistic ones. It is +provided for completeness.
+ +| Benchmark | go-toml v1 | BurntSushi/toml |
|---|---|---|
| Marshal/SimpleDocument/map-2 | 1.8x | 2.7x |
| Marshal/SimpleDocument/struct-2 | 2.7x | 3.8x |
| Unmarshal/SimpleDocument/map-2 | 3.8x | 3.0x |
| Unmarshal/SimpleDocument/struct-2 | 5.6x | 4.1x |
| UnmarshalDataset/example-2 | 3.0x | 3.2x |
| UnmarshalDataset/code-2 | 2.3x | 2.9x |
| UnmarshalDataset/twitter-2 | 2.6x | 2.7x |
| UnmarshalDataset/citm_catalog-2 | 2.2x | 2.3x |
| UnmarshalDataset/canada-2 | 1.8x | 1.5x |
| UnmarshalDataset/config-2 | 4.1x | 2.9x |
| geomean | 2.7x | 2.8x |
This table can be generated with ./ci.sh benchmark -a -html.
| Benchmark | go-toml v1 | BurntSushi/toml |
|---|---|---|
| {} | {} | {} |
The table above has the results of the most common use-cases. The table below +contains the results of all benchmarks, including unrealistic ones. It is +provided for completeness.
""") +printtable(below) +print('This table can be generated with ./ci.sh benchmark -a -html.
stdlib |
+conc |
+
|---|---|
| + +```go +type caughtPanicError struct { + val any + stack []byte +} + +func (e *caughtPanicError) Error() string { + return fmt.Sprintf( + "panic: %q\n%s", + e.val, + string(e.stack) + ) +} + +func main() { + done := make(chan error) + go func() { + defer func() { + if v := recover(); v != nil { + done <- &caughtPanicError{ + val: v, + stack: debug.Stack() + } + } else { + done <- nil + } + }() + doSomethingThatMightPanic() + }() + err := <-done + if err != nil { + panic(err) + } +} +``` + | ++ +```go +func main() { + var wg conc.WaitGroup + wg.Go(doSomethingThatMightPanic) + // panics with a nice stacktrace + wg.Wait() +} +``` + | +
stdlib |
+conc |
+
|---|---|
| + +```go +func main() { + var wg sync.WaitGroup + for i := 0; i < 10; i++ { + wg.Add(1) + go func() { + defer wg.Done() + // crashes on panic! + doSomething() + }() + } + wg.Wait() +} +``` + | ++ +```go +func main() { + var wg conc.WaitGroup + for i := 0; i < 10; i++ { + wg.Go(doSomething) + } + wg.Wait() +} +``` + | +
stdlib |
+conc |
+
|---|---|
| + +```go +func process(stream chan int) { + var wg sync.WaitGroup + for i := 0; i < 10; i++ { + wg.Add(1) + go func() { + defer wg.Done() + for elem := range stream { + handle(elem) + } + }() + } + wg.Wait() +} +``` + | ++ +```go +func process(stream chan int) { + p := pool.New().WithMaxGoroutines(10) + for elem := range stream { + elem := elem + p.Go(func() { + handle(elem) + }) + } + p.Wait() +} +``` + | +
stdlib |
+conc |
+
|---|---|
| + +```go +func process(values []int) { + feeder := make(chan int, 8) + + var wg sync.WaitGroup + for i := 0; i < 10; i++ { + wg.Add(1) + go func() { + defer wg.Done() + for elem := range feeder { + handle(elem) + } + }() + } + + for _, value := range values { + feeder <- value + } + close(feeder) + wg.Wait() +} +``` + | ++ +```go +func process(values []int) { + iter.ForEach(values, handle) +} +``` + | +
stdlib |
+conc |
+
|---|---|
| + +```go +func concMap( + input []int, + f func(int) int, +) []int { + res := make([]int, len(input)) + var idx atomic.Int64 + + var wg sync.WaitGroup + for i := 0; i < 10; i++ { + wg.Add(1) + go func() { + defer wg.Done() + + for { + i := int(idx.Add(1) - 1) + if i >= len(input) { + return + } + + res[i] = f(input[i]) + } + }() + } + wg.Wait() + return res +} +``` + | ++ +```go +func concMap( + input []int, + f func(*int) int, +) []int { + return iter.Map(input, f) +} +``` + | +
stdlib |
+conc |
+
|---|---|
| + +```go +func mapStream( + in chan int, + out chan int, + f func(int) int, +) { + tasks := make(chan func()) + taskResults := make(chan chan int) + + // Worker goroutines + var workerWg sync.WaitGroup + for i := 0; i < 10; i++ { + workerWg.Add(1) + go func() { + defer workerWg.Done() + for task := range tasks { + task() + } + }() + } + + // Ordered reader goroutines + var readerWg sync.WaitGroup + readerWg.Add(1) + go func() { + defer readerWg.Done() + for result := range taskResults { + item := <-result + out <- item + } + }() + + // Feed the workers with tasks + for elem := range in { + resultCh := make(chan int, 1) + taskResults <- resultCh + tasks <- func() { + resultCh <- f(elem) + } + } + + // We've exhausted input. + // Wait for everything to finish + close(tasks) + workerWg.Wait() + close(taskResults) + readerWg.Wait() +} +``` + | ++ +```go +func mapStream( + in chan int, + out chan int, + f func(int) int, +) { + s := stream.New().WithMaxGoroutines(10) + for elem := range in { + elem := elem + s.Go(func() stream.Callback { + res := f(elem) + return func() { out <- res } + }) + } + s.Wait() +} +``` + | +