Separate result to step and result

Author: rosylilly

benchmark.go

@@ -16,15 +16,15 @@ var (
 	ErrValidation failure.StringCode = "validation"
 )
 
-type BenchmarkStep func(context.Context, *Result) error
-type BenchmarkErrorHook func(error, *Result)
+type BenchmarkStepFunc func(context.Context, *BenchmarkStep) error
+type BenchmarkErrorHook func(error, *BenchmarkStep)
 
 type Benchmark struct {
 	mu sync.Mutex
 
-	prepareSteps    []BenchmarkStep
-	loadSteps       []BenchmarkStep
-	validationSteps []BenchmarkStep
+	prepareSteps    []BenchmarkStepFunc
+	loadSteps       []BenchmarkStepFunc
+	validationSteps []BenchmarkStepFunc
 
 	prepateTimeout time.Duration
 	loadTimeout    time.Duration
@@ -35,9 +35,9 @@ type Benchmark struct {
 func NewBenchmark(opts ...BenchmarkOption) (*Benchmark, error) {
 	benchmark := &Benchmark{
 		mu:              sync.Mutex{},
-		prepareSteps:    []BenchmarkStep{},
-		loadSteps:       []BenchmarkStep{},
-		validationSteps: []BenchmarkStep{},
+		prepareSteps:    []BenchmarkStepFunc{},
+		loadSteps:       []BenchmarkStepFunc{},
+		validationSteps: []BenchmarkStepFunc{},
 		prepateTimeout:  time.Duration(0),
 		loadTimeout:     time.Duration(0),
 		ignoreCodes:     []failure.Code{},
@@ -53,15 +53,21 @@ func NewBenchmark(opts ...BenchmarkOption) (*Benchmark, error) {
 	return benchmark, nil
 }
 
-func (b *Benchmark) Start(parent context.Context) *Result {
+func (b *Benchmark) Start(parent context.Context) *BenchmarkResult {
 	ctx, cancel := context.WithCancel(parent)
-	result := newResult(ctx, cancel)
-	defer result.Cancel()
+	result := newBenchmarkResult(ctx)
+	defer cancel()
+
+	step := &BenchmarkStep{
+		mu:     sync.RWMutex{},
+		result: result,
+		cancel: cancel,
+	}
 
 	for _, hook := range b.errorHooks {
 		func(hook BenchmarkErrorHook) {
 			result.Errors.Hook(func(err error) {
-				hook(err, result)
+				hook(err, step)
 			})
 		}(hook)
 	}
@@ -72,6 +78,7 @@ func (b *Benchmark) Start(parent context.Context) *Result {
 		loadCancel context.CancelFunc
 	)
 
+	step.setErrorCode(ErrPrepare)
 	for _, prepare := range b.prepareSteps {
 		var (
 			prepareCtx    context.Context
@@ -85,13 +92,13 @@ func (b *Benchmark) Start(parent context.Context) *Result {
 		}
 		defer prepareCancel()
 
-		if err := panicWrapper(func() error { return prepare(prepareCtx, result) }); err != nil {
+		if err := panicWrapper(func() error { return prepare(prepareCtx, step) }); err != nil {
 			for _, ignore := range b.ignoreCodes {
 				if failure.IsCode(err, ignore) {
 					goto Result
 				}
 			}
-			result.Errors.Add(failure.NewError(ErrPrepare, err))
+			step.AddError(err)
 			goto Result
 		}
 	}
@@ -102,6 +109,7 @@ func (b *Benchmark) Start(parent context.Context) *Result {
 		goto Result
 	}
 
+	step.setErrorCode(ErrLoad)
 	if b.loadTimeout > 0 {
 		loadCtx, loadCancel = context.WithTimeout(ctx, b.loadTimeout)
 	} else {
@@ -110,15 +118,15 @@ func (b *Benchmark) Start(parent context.Context) *Result {
 	defer loadCancel()
 
 	for _, load := range b.loadSteps {
-		func(f BenchmarkStep) {
+		func(f BenchmarkStepFunc) {
 			loadParallel.Do(loadCtx, func(c context.Context) {
-				if err := panicWrapper(func() error { return f(c, result) }); err != nil {
+				if err := panicWrapper(func() error { return f(c, step) }); err != nil {
 					for _, ignore := range b.ignoreCodes {
 						if failure.IsCode(err, ignore) {
 							return
 						}
 					}
-					result.Errors.Add(failure.NewError(ErrLoad, err))
+					step.AddError(err)
 				}
 			})
 		}(load)
@@ -131,21 +139,23 @@ func (b *Benchmark) Start(parent context.Context) *Result {
 		goto Result
 	}
 
+	step.setErrorCode(ErrValidation)
 	for _, validation := range b.validationSteps {
-		if err := panicWrapper(func() error { return validation(ctx, result) }); err != nil {
+		if err := panicWrapper(func() error { return validation(ctx, step) }); err != nil {
 			for _, ignore := range b.ignoreCodes {
 				if failure.IsCode(err, ignore) {
 					goto Result
 				}
 			}
-			result.Errors.Add(failure.NewError(ErrValidation, err))
+			step.AddError(err)
 			goto Result
 		}
 	}
 
 Result:
 	cancel()
-	result.wait()
+	step.wait()
+	step.setErrorCode(nil)
 
 	return result
 }
@@ -157,21 +167,21 @@ func (b *Benchmark) OnError(f BenchmarkErrorHook) {
 	b.errorHooks = append(b.errorHooks, f)
 }
 
-func (b *Benchmark) Prepare(f BenchmarkStep) {
+func (b *Benchmark) Prepare(f BenchmarkStepFunc) {
 	b.mu.Lock()
 	defer b.mu.Unlock()
 
 	b.prepareSteps = append(b.prepareSteps, f)
 }
 
-func (b *Benchmark) Load(f BenchmarkStep) {
+func (b *Benchmark) Load(f BenchmarkStepFunc) {
 	b.mu.Lock()
 	defer b.mu.Unlock()
 
 	b.loadSteps = append(b.loadSteps, f)
 }
 
-func (b *Benchmark) Validation(f BenchmarkStep) {
+func (b *Benchmark) Validation(f BenchmarkStepFunc) {
 	b.mu.Lock()
 	defer b.mu.Unlock()
 

benchmark_result.go

@@ -0,0 +1,19 @@
+package isucandar
+
+import (
+	"context"
+	"github.com/rosylilly/isucandar/failure"
+	"github.com/rosylilly/isucandar/score"
+)
+
+type BenchmarkResult struct {
+	Score  *score.Score
+	Errors *failure.Errors
+}
+
+func newBenchmarkResult(ctx context.Context) *BenchmarkResult {
+	return &BenchmarkResult{
+		Score:  score.NewScore(ctx),
+		Errors: failure.NewErrors(ctx),
+	}
+}

scenario.go benchmark_scenario.go

@@ -10,15 +10,15 @@ var (
 )
 
 type PrepareScenario interface {
-	Prepare(context.Context, *Result) error
+	Prepare(context.Context, *BenchmarkStep) error
 }
 
 type LoadScenario interface {
-	Load(context.Context, *Result) error
+	Load(context.Context, *BenchmarkStep) error
 }
 
 type ValidationScenario interface {
-	Validation(context.Context, *Result) error
+	Validation(context.Context, *BenchmarkStep) error
 }
 
 func (b *Benchmark) AddScenario(scenario interface{}) {

scenario_test.go benchmark_scenario_test.go

@@ -12,17 +12,17 @@ type exampleScenario struct {
 	validation uint32
 }
 
-func (e *exampleScenario) Prepare(_ context.Context, r *Result) error {
+func (e *exampleScenario) Prepare(_ context.Context, _ *BenchmarkStep) error {
 	atomic.StoreUint32(&e.prepare, 1)
 	return nil
 }
 
-func (e *exampleScenario) Load(_ context.Context, r *Result) error {
+func (e *exampleScenario) Load(_ context.Context, _ *BenchmarkStep) error {
 	atomic.StoreUint32(&e.load, 1)
 	return nil
 }
 
-func (e *exampleScenario) Validation(_ context.Context, r *Result) error {
+func (e *exampleScenario) Validation(_ context.Context, _ *BenchmarkStep) error {
 	atomic.StoreUint32(&e.validation, 1)
 	return nil
 }

benchmark_step.go

@@ -0,0 +1,52 @@
+package isucandar
+
+import (
+	"context"
+	"github.com/rosylilly/isucandar/failure"
+	"github.com/rosylilly/isucandar/score"
+	"sync"
+)
+
+type BenchmarkStep struct {
+	errorCode failure.Code
+	mu        sync.RWMutex
+	result    *BenchmarkResult
+	cancel    context.CancelFunc
+}
+
+func (b *BenchmarkStep) setErrorCode(code failure.Code) {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+
+	b.errorCode = code
+}
+
+func (b *BenchmarkStep) AddError(err error) {
+	b.mu.RLock()
+	defer b.mu.RUnlock()
+
+	b.result.Errors.Add(failure.NewError(b.errorCode, err))
+}
+
+func (b *BenchmarkStep) AddScore(tag score.ScoreTag) {
+	b.result.Score.Add(tag)
+}
+
+func (b *BenchmarkStep) Cancel() {
+	b.cancel()
+}
+
+func (b *BenchmarkStep) wait() {
+	wg := sync.WaitGroup{}
+	wg.Add(1)
+	go func() {
+		b.result.Score.Wait()
+		wg.Done()
+	}()
+	wg.Add(1)
+	go func() {
+		b.result.Errors.Wait()
+		wg.Done()
+	}()
+	wg.Wait()
+}