tracer

GoChan-Tracer

- This code is still work in progress and may not work or result in incorrect behavior!

What?

GoChan-Tracer implements drop in replacements for channel operations in Go. Those replacements can be used to create a trace of the executed program similar to the trace described in [1].

Installation

go get github.com/ErikKassubek/GoChan/tracer

How?

For the tracer, channel functionality is replaced by costum functions to create a trace of the program. The instrumenter can be used to automatically translate Go-Code into code with the replacements.

Example

Let's look at the following code:

package main

import (
	"math/rand"
	"sync"
	"time"
)

func func1(x chan int) {
	x <- rand.Intn(100)
}

func test() {

	x := make(chan int)
	y := make(chan int)

	a := make(chan int, 1)
	b := make(chan int, 0)
	c := make(chan string, 0)

	var l sync.Mutex
	var m sync.RWMutex

	i := 3

	go func1(x)
	go func() {
		m.Lock()
		<-x
		x <- rand.Intn(100)
		m.Unlock()
	}()
	go func(i int) {
		l.Lock()
		y <- i
		<-x
		l.Unlock()
	}(i)
	go func() {
		m.RLock()
		<-y
		m.RUnlock()
	}()

	time.Sleep(1 * time.Second)

	select {
	case x := <-a:
		println(x)
	case <-b:
		println("b")
	case c <- "3":
		println("c")
	default:
		println("default")
	}
}

func main() {
	test()
	time.Sleep(4 * time.Second)
}

By the instrumenter it gets translated into

package main

import (
	"math/rand"
	"time"

	"github.com/ErikKassubek/GoChan/tracer"
)

func func1(x tracer.Chan[int]) {
	x.Send(rand.Intn(100))
}

func test() {

	x := tracer.NewChan[int](0)
	y := tracer.NewChan[int](0)

	a := tracer.NewChan[int](1)
	b := tracer.NewChan[int](0)
	c := tracer.NewChan[string](0)

	l := tracer.NewLock()
	m := tracer.NewRWLock()

	i := 3

	func() {
		GoChanRoutineIndex := tracer.SpawnPre()
		go func() {
			tracer.SpawnPost(GoChanRoutineIndex)
			{

				func1(x)
			}
		}()
	}()

	func() {
		GoChanRoutineIndex := tracer.SpawnPre()
		go func() {
			tracer.SpawnPost(GoChanRoutineIndex)
			{
				m.Lock()
				x.Receive()
				x.Send(rand.Intn(100))
				m.Unlock()
			}
		}()
	}()

	func() {
		GoChanRoutineIndex := tracer.SpawnPre()
		go func(i int) {
			tracer.SpawnPost(GoChanRoutineIndex)
			{
				l.Lock()
				y.Send(i)
				x.Receive()

				l.Unlock()
			}
		}(i)
	}()

	func() {
		GoChanRoutineIndex := tracer.SpawnPre()
		go func() {
			tracer.SpawnPost(GoChanRoutineIndex)
			{
				m.RLock()
				y.Receive()
				m.RUnlock()
			}
		}()
	}()

	time.Sleep(1 * time.Second)

	{
		tracer.PreSelect(true, a.GetIdPre(true), b.GetIdPre(true), c.GetIdPre(false))
		sel_HctcuAxh := tracer.BuildMessage("3")

		select {
		case sel_XVlBzgbaiC := <-a.GetChan():
			a.PostSelect(true, sel_XVlBzgbaiC)
			x := sel_XVlBzgbaiC.GetInfo()
			println(x)
		case sel_MRAjWwhT := <-b.GetChan():
			b.PostSelect(true, sel_MRAjWwhT)
			println("b")
		case c.GetChan() <- sel_HctcuAxh:
			c.PostSelect(false, sel_HctcuAxh)
			println("c")
		default:
			tracer.PostDefault()
			println("default")
		}
	}
}

func main() {
	tracer.Init()
	defer tracer.PrintTrace()

	test()
	time.Sleep(4 * time.Second)
}

By running this program we get the resulting trace. One possible trace is

[signal(1, 2), signal(2, 3), signal(3, 4), signal(4, 5), pre(23, 3?, 4?, 5!, default), post(24, default)]
[wait(8, 2), pre(9, 2!), post(19, 2, 2!)]
[wait(10, 3), lock(11, 2, -, 1), pre(22, 2?)]
[wait(12, 4), lock(13, 1, -, 1), pre(14, 3!), post(15, 4, 3!), pre(16, 2?), post(17, 2, 2?, 9), unlock(18, 1)]
[wait(5, 5), lock(6, 2, r, 1), pre(7, 3?), post(20, 4, 3?, 14), unlock(21, 2)]

Every line represents a routine (the first line is the main routine). The elements have the following meaning:

References

[1] M. Sulzmann and K. Stadtmüller, “Two-phase dynamic analysis of message-passing go programs based on vector clocks,” CoRR, vol. abs/1807.03585, 2018.