protoactor linked list benchmark

gistfile1.txt

package main

import (
	"fmt"
	"runtime"
	"sync"
	"time"

	"github.com/AsynkronIT/protoactor-go/actor"
)

type Test struct {
	next *actor.PID
	wg   *sync.WaitGroup
}

type OutputMsg struct {
}

type ForwardMsg struct {
	Content   int
	StartTime time.Time
}

func (t *Test) Receive(ctx actor.Context) {
	switch msg := ctx.Message().(type) {
	case *OutputMsg:
		t.next = ctx.Sender()

	case *ForwardMsg:
		if t.next != nil {
			msg.Content += 1
			ctx.Send(t.next, msg)
		} else {
			fmt.Println("forwarding done : ", time.Since(msg.StartTime))
		}
		t.wg.Done()
	}
}

func newTest(wg *sync.WaitGroup) actor.Producer {
	return func() actor.Actor {
		return &Test{
			wg: wg,
		}
	}
}

func main() {
	runtime.GOMAXPROCS(runtime.NumCPU())
	runtime.GC()

	rootContext := actor.EmptyRootContext

	ts := []*actor.PID{}

	before := time.Now()
	wg := &sync.WaitGroup{}

	props := actor.PropsFromProducer(newTest(wg))

	var p *actor.PID
	for i := 0; i < 1000000; i++ {
		wg.Add(1)
		t := rootContext.
			Spawn(props)

		ts = append(ts, t)

		// linked list
		if p != nil && i > 0 {
			o := &OutputMsg{}
			p.Request(o, t)
		}

		p = t
	}
	fmt.Println("spawn done : ", time.Since(before))

	ts[0].Request(&ForwardMsg{Content: 0, StartTime: time.Now()}, nil)

	wg.Wait()
}