GoSyscallEnd dt=196
GoDestroy dt=15
ProcStop dt=37
EventBatch gen=1 m=1709046 time=7689670697530 size=167
ProcStart dt=236 p=5 p_seq=1
ProcStop dt=281
ProcStart dt=1683 p=2 p_seq=14
ProcStop dt=33
ProcStart dt=147800 p=2 p_seq=16
ProcStop dt=29
ProcStart dt=3880 p=1 p_seq=28
ProcStop dt=30
ProcStart dt=801175 p=5 p_seq=3
ProcStop dt=19
ProcStart dt=47961 p=6 p_seq=4
ProcStop dt=15

UserRegionEnd dt=2 task=14 name_string=35 stack=28
GoDestroy dt=2
ProcStop dt=28
ProcStart dt=141923 p=0 p_seq=12
ProcStop dt=19
ProcStart dt=16780 p=0 p_seq=13
GoUnblock dt=22 g=43 g_seq=2 stack=0
GoStart dt=162 g=43 g_seq=3
UserTaskEnd dt=16 task=15 stack=36
UserRegionEnd dt=12 task=14 name_string=31 stack=28
GoDestroy dt=2
ProcStop dt=8
ProcStart dt=1532 p=2 p_seq=9
ProcStop dt=12
ProcStart dt=141906 p=4 p_seq=11
ProcStop dt=16

GoLabel dt=1 label_string=4
GoBlock dt=20 reason_string=15 stack=5
ProcStop dt=60
ProcStart dt=31 p=19 p_seq=2
GoUnblock dt=9 g=56 g_seq=7 stack=0
GoStart dt=6 g=56 g_seq=8
GoLabel dt=3 label_string=4
GoBlock dt=949 reason_string=15 stack=5
ProcStop dt=41
ProcStart dt=433 p=19 p_seq=3
ProcStop dt=43
ProcStart dt=9942 p=11 p_seq=4
ProcStop dt=50
ProcStart dt=2351 p=22 p_seq=6

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Tests syscall P stealing.
//
// Specifically, it tests a scenario where a thread 'steals'
// a P from itself. It's just a ProcStop with extra steps when
// it happens on the same P.

package main

import (
	"internal/trace"
	"internal/trace/event/go122"
	testgen "internal/trace/internal/testgen/go122"
)

func main() {

	// is during a syscall.
	tl.eventWriter(traceGoSyscall, traceProcIdle).commit(traceEvProcStart, traceArg(pp.id), pp.trace.nextSeq(tl.gen))
}

// ProcStop traces a ProcStop event.
func (tl traceLocker) ProcStop(pp *p) {
	// The only time a goroutine is allowed to have its Proc moved around
	// from under it is during a syscall.
	tl.eventWriter(traceGoSyscall, traceProcRunning).commit(traceEvProcStop)
}

	//
	// There are 2 ways a P can stop: ProcStop and ProcSteal. ProcStop is used when the P
	// is stopped by the same M that started it, while ProcSteal is used when another M
	// steals the P by stopping it from a distance.
	//
	// Since a P is bound to an M, and we're stopping on the same M we started, it must
	// always be possible to advance the current M's P from a ProcStop. This is also why

		StackIDs:     []int{2},
	},
	EvProcStart: event.Spec{
		Name:         "ProcStart",
		Args:         []string{"dt", "p", "p_seq"},
		IsTimedEvent: true,
	},
	EvProcStop: event.Spec{
		Name:         "ProcStop",
		Args:         []string{"dt"},
		IsTimedEvent: true,
	},
	EvProcSteal: event.Spec{
		Name:         "ProcSteal",
		Args:         []string{"dt", "p", "p_seq", "m"},
		IsTimedEvent: true,
	},

	EvGomaxprocs:        {"Gomaxprocs", 5, true, []string{"procs"}, nil},
	EvProcStart:         {"ProcStart", 5, false, []string{"thread"}, nil},
	EvProcStop:          {"ProcStop", 5, false, []string{}, nil},
	EvGCStart:           {"GCStart", 5, true, []string{"seq"}, nil}, // in 1.5 format it was {}
	EvGCDone:            {"GCDone", 5, false, []string{}, nil},

			// then and now it's totally possible it had been stolen and
			// then put back into _Psyscall for us to acquire here. In such
			// case ProcStop would be incorrect.
			//
			// TODO(mknyszek): Consider emitting a ProcStop instead when
			// gp.m.syscalltick == pp.syscalltick, since then we know we never
			// lost the P.
			trace.ProcSteal(pp, true)
			traceRelease(trace)
		}