mirror of https://github.com/golang/go.git
499 lines
19 KiB
Go
499 lines
19 KiB
Go
// Copyright 2018 The Go Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
// Package traceparser parses the trace files produced by runtime.StartTrace
|
|
package traceparser
|
|
|
|
import (
|
|
"fmt"
|
|
"internal/traceparser/filebuf"
|
|
"io"
|
|
"strings"
|
|
)
|
|
|
|
// Parsed is the result of parsing a trace file
|
|
type Parsed struct {
|
|
// Set by New
|
|
Name string // File's name
|
|
Size int64 // File's size
|
|
Count int64 // approximate number of all events
|
|
MaxTs int64 // range of all events, in nanoseconds
|
|
Strings map[uint64]string
|
|
Stacks map[uint32][]*Frame
|
|
Version int // version of the trace file from header
|
|
TicksPerSec int64 // from EvFrequency in trailer
|
|
minticks, maxticks int64 // from Init
|
|
r filebuf.Buf // implements io.Seek and io.Read
|
|
batches []batch // location of each Batch and time of start
|
|
timerGoids map[uint64]bool
|
|
// the following are per Parse
|
|
MinWant, MaxWant int64 // range wanted, from the arguments to Parse()
|
|
Err error // set by internal functions to stop further processing
|
|
Events []*Event // after Parse, the events from MinWant to MaxWant
|
|
Preflen int // how long a prefix we added
|
|
Ignored int // how many events we elided
|
|
Added int // how many events we added, not including the prefix
|
|
// internal processing variables
|
|
seenArgs map[uint64]*[]uint64
|
|
byproc map[int][]*Event
|
|
lastGs map[int]uint64
|
|
lastG uint64
|
|
lastP int
|
|
lastTs int64
|
|
}
|
|
|
|
func (p *Parsed) String() string {
|
|
ans := []string{}
|
|
ans = append(ans, fmt.Sprintf("%s Sz:%d Count:%d MaxTs:%d #strs:%d #stks:%d",
|
|
p.Name, p.Size, p.Count, p.MaxTs, len(p.Strings), len(p.Stacks)))
|
|
ans = append(ans, fmt.Sprintf("%d clock:%d ticks:(%d,%d) #b:%d",
|
|
p.Version, p.TicksPerSec, p.minticks, p.maxticks, len(p.batches)))
|
|
return strings.Join(ans, "\n\t")
|
|
}
|
|
|
|
// clean up after previous call to Parse
|
|
func (p *Parsed) clean() {
|
|
// some of these are redundant
|
|
p.Err = nil
|
|
p.Events = nil
|
|
p.Preflen = 0
|
|
p.Ignored = 0
|
|
p.Added = 0
|
|
p.seenArgs = nil // redundant, but safe
|
|
p.byproc = nil
|
|
p.lastGs = nil
|
|
p.lastG = 0
|
|
p.lastTs = 0
|
|
}
|
|
|
|
// Frame is a frame in a stack traces
|
|
type Frame struct {
|
|
PC uint64
|
|
Fn string
|
|
File string
|
|
Line int
|
|
}
|
|
|
|
// An Event is the parsed form of a single trace event
|
|
type Event struct {
|
|
Type byte
|
|
P int32
|
|
Ts int64
|
|
G uint64
|
|
StkID uint32 // key to Parsed.Stacks
|
|
Args [3]uint64
|
|
SArgs []string // EvUserLog has 2. Others are 1 or none
|
|
Link *Event
|
|
}
|
|
|
|
// Batch remembers the EvBatch events. PJW: keep an index of User events?
|
|
type batch struct {
|
|
Off int
|
|
P int64
|
|
Cycles int64 // as read from EvBatch
|
|
Nano int64 // start time of batch, set in commonInit()
|
|
raws []rawEvent // filled in during Parse() for those batches that overlap the desired interval
|
|
}
|
|
|
|
// rawEvent is a raw event parsed from batches that overlap the time interval
|
|
type rawEvent struct { // about 75 bytes
|
|
// the choice of what to share (args) and what to make unique per rawEvent
|
|
// (arg0, sarg) was done by measuring the space impact of various choices.
|
|
off uint32 // offset in batch (at batch.Off + off in file)
|
|
typ byte
|
|
arg0 uint64
|
|
args *[]uint64 // remainder of the args (frequently nil), shared
|
|
sarg string
|
|
}
|
|
|
|
func (r rawEvent) String() string {
|
|
if r.args != nil && len(*r.args) > 0 {
|
|
return fmt.Sprintf("[%s %d %v %s]", evname(r.typ), r.arg0, *r.args, r.sarg)
|
|
}
|
|
return fmt.Sprintf("[%s, %d, [], %s]", evname(r.typ), r.arg0, r.sarg)
|
|
}
|
|
|
|
// New scans the trace file, finding the number of events, the earliest and latest
|
|
// timestamps, and the stacks and strings referenced in the file.
|
|
func New(fname string) (*Parsed, error) {
|
|
fd, err := filebuf.New(fname)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return commonInit(fd, fname)
|
|
}
|
|
|
|
// ParseError may be returned by New() or ParseBuffer() to make available
|
|
// some information in the case that the raw trace file seems to contain
|
|
// negative time stamps. (In P, Name, Size, count, Strings, Stacks, Versions are valid,
|
|
// and MaxTs or TicksPerSec is negative.)
|
|
type ParseError struct {
|
|
P *Parsed
|
|
Err error
|
|
}
|
|
|
|
func (pe ParseError) Error() string {
|
|
return pe.Err.Error()
|
|
}
|
|
|
|
func commonInit(fd filebuf.Buf, fname string) (*Parsed, error) {
|
|
ans := &Parsed{Name: fname, minticks: 1 << 62} // minticks can only decrease
|
|
var err error
|
|
defer func() {
|
|
if err != nil {
|
|
fd.Close() // try to clean up after error
|
|
}
|
|
}()
|
|
ans.Size = fd.Size()
|
|
ans.r = fd
|
|
// parseRaw here for header, trailer: clock, stacks, strings,
|
|
if err = ans.parseHeader(); err != nil {
|
|
return nil, err
|
|
}
|
|
if err = ans.scanFile(); err != nil {
|
|
return nil, err
|
|
}
|
|
// done with seenArgs
|
|
ans.seenArgs = nil
|
|
// convert the clicks in batches to nanoseconds
|
|
ans.toNanoseconds()
|
|
if ans.MaxTs <= 0 || ans.TicksPerSec <= 0 {
|
|
err := ParseError{
|
|
P: ans,
|
|
Err: fmt.Errorf("corrupt trace file: negative time: (max TS=%d, ticks per sec=%d",
|
|
ans.MaxTs, ans.TicksPerSec),
|
|
}
|
|
return nil, err
|
|
}
|
|
return ans, nil
|
|
}
|
|
|
|
// Parse parses the events in the interval: start <= ts <= start+length.
|
|
// f, if not nil, will be called at various stages of the parse, each identified by the string
|
|
// argument. It could report on elapsed time, or memory usage, or whatever the user wants.
|
|
// The number of times it is called and the contents of the string argument are both
|
|
// changeable details of the implementation. Parse is not safe for concurrent use.
|
|
func (p *Parsed) Parse(start, length int64, f func(string)) error {
|
|
p.clean()
|
|
if f == nil {
|
|
f = func(string) {} // avoid any further testing for nil
|
|
}
|
|
|
|
p.MinWant = start
|
|
p.MaxWant = start + length
|
|
// arrange the slice of batches by P
|
|
byp := map[int64][]*batch{}
|
|
// PJW: keep track of the order the Ps occur and use that for batchify
|
|
for i, b := range p.batches {
|
|
byp[b.P] = append(byp[b.P], &p.batches[i])
|
|
p.batches[i].raws = nil // reset from last call to Parse
|
|
}
|
|
// batchify the ones that overlap the time range
|
|
for _, v := range byp {
|
|
for i := 0; i < len(v); i++ {
|
|
b := v[i]
|
|
var bnext *batch
|
|
if i < len(v)-1 {
|
|
bnext = v[i+1]
|
|
}
|
|
if b.Nano >= p.MaxWant {
|
|
// starts too late
|
|
continue
|
|
} else if b.Nano <= p.MinWant && (bnext != nil && bnext.Nano <= p.MinWant) {
|
|
// entirely too early
|
|
continue
|
|
}
|
|
err := p.batchify(b)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
}
|
|
f("batchify done")
|
|
return p.createEvents(f)
|
|
}
|
|
|
|
// ParseBuffer treats its argument as a trace file, and returns the
|
|
// result of parsing it
|
|
func ParseBuffer(rd io.Reader) (*Parsed, error) {
|
|
pr, err := filebuf.FromReader(rd)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
p, err := commonInit(pr, "<buf>")
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
// need the version and the initial scan
|
|
err = p.Parse(0, 1<<62, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return p, nil
|
|
}
|
|
|
|
// called from commonInit to compute the nanosecond when batches start
|
|
func (p *Parsed) toNanoseconds() {
|
|
minCycles := p.minticks
|
|
freq := 1e9 / float64(p.TicksPerSec)
|
|
// Batches, and more to come. Don't call this twice!
|
|
for i, ex := range p.batches {
|
|
p.batches[i].Nano = int64(float64(ex.Cycles-minCycles) * freq)
|
|
}
|
|
p.MaxTs = int64(float64(p.maxticks-minCycles) * freq)
|
|
}
|
|
|
|
// argsAt returns the args of an event in the file and the offset for the next event.
|
|
//
|
|
// For EvString it returns off, nil, nil, and
|
|
// for EvUserLog it ignores the string argument, which must be read by the
|
|
// caller.
|
|
func (p *Parsed) argsAt(off int, check byte) (int, []uint64, error) {
|
|
off0 := off
|
|
r := p.r
|
|
loc, err := r.Seek(int64(off), 0)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
var buf [1]byte
|
|
n, err := r.Read(buf[:])
|
|
if err != nil || n != 1 {
|
|
return 0, nil, fmt.Errorf("read failed at 0x%x, %d %v, loc=%d",
|
|
off, n, err, loc)
|
|
}
|
|
off += n
|
|
typ := buf[0] << 2 >> 2
|
|
narg := buf[0]>>6 + 1
|
|
inlineArgs := byte(4)
|
|
|
|
if typ == EvNone || typ >= EvCount ||
|
|
EventDescriptions[typ].MinVersion > p.Version {
|
|
return 0, nil, fmt.Errorf("unk type %v at offset 0x%x", typ, off0)
|
|
}
|
|
if typ == EvString { // skip, wihtout error checking
|
|
_, off, err = readVal(r, off)
|
|
var ln uint64
|
|
ln, off, err = readVal(r, off)
|
|
off += int(ln)
|
|
return off, nil, nil
|
|
}
|
|
args := []uint64{}
|
|
if narg < inlineArgs {
|
|
for i := 0; i < int(narg); i++ {
|
|
var v uint64
|
|
v, off, err = readVal(r, off)
|
|
if err != nil {
|
|
err = fmt.Errorf("failed to read event %v argument at offset %v (%v)", typ, off, err)
|
|
return 0, nil, err
|
|
}
|
|
args = append(args, v)
|
|
}
|
|
} else {
|
|
// More than inlineArgs args, the first value is length of the event in bytes.
|
|
var v uint64
|
|
v, off, err = readVal(r, off)
|
|
if err != nil {
|
|
err = fmt.Errorf("failed to read event %v argument at offset %v (%v)", typ, off, err)
|
|
return 0, nil, err
|
|
}
|
|
evLen := v
|
|
off1 := off
|
|
for evLen > uint64(off-off1) {
|
|
v, off, err = readVal(r, off)
|
|
if err != nil {
|
|
err = fmt.Errorf("failed to read event %v argument at offset %v (%v)", typ, off, err)
|
|
return 0, nil, err
|
|
}
|
|
args = append(args, v)
|
|
}
|
|
if evLen != uint64(off-off1) {
|
|
err = fmt.Errorf("event has wrong length at offset 0x%x: want %v, got %v", off0, evLen, off-off1)
|
|
return 0, nil, err
|
|
}
|
|
}
|
|
// This routine does not read the string argument. Callers must tread EvUserLog specially.
|
|
return off, args, nil
|
|
}
|
|
|
|
// read a string from r
|
|
func readStr(r io.Reader, off0 int) (s string, off int, err error) {
|
|
var sz uint64
|
|
sz, off, err = readVal(r, off0)
|
|
if err != nil || sz == 0 {
|
|
return "", off, err
|
|
}
|
|
if sz > 1e6 {
|
|
return "", off, fmt.Errorf("string at offset %d is too large (len=%d)", off, sz)
|
|
}
|
|
buf := make([]byte, sz)
|
|
n, err := io.ReadFull(r, buf)
|
|
if err != nil || sz != uint64(n) {
|
|
return "", off + n, fmt.Errorf("failed to read trace at offset %d: read %v, want %v, error %v", off, n, sz, err)
|
|
}
|
|
return string(buf), off + n, nil
|
|
}
|
|
|
|
// readVal reads unsigned base-128 value from r.
|
|
func readVal(r io.Reader, off0 int) (v uint64, off int, err error) {
|
|
off = off0
|
|
for i := 0; i < 10; i++ {
|
|
var buf [1]byte
|
|
var n int
|
|
n, err = r.Read(buf[:])
|
|
if err != nil || n != 1 {
|
|
return 0, 0, fmt.Errorf("failed to read trace at offset %d: read %v, error %v", off0, n, err)
|
|
}
|
|
off++
|
|
v |= uint64(buf[0]&0x7f) << (uint(i) * 7)
|
|
if buf[0]&0x80 == 0 {
|
|
return
|
|
}
|
|
}
|
|
return 0, 0, fmt.Errorf("bad value at offset 0x%x", off0)
|
|
}
|
|
|
|
// OSStats reports on the underlying i/o. If p was created by New,
|
|
// the fields report filesystem activity. If p was created by ParseBuffer,
|
|
// only Size is set.
|
|
func (p *Parsed) OSStats() filebuf.Stat {
|
|
return p.r.Stats()
|
|
}
|
|
|
|
func (ev *Event) String() string {
|
|
var tslink int64
|
|
if ev.Link != nil {
|
|
tslink = ev.Link.Ts
|
|
}
|
|
return fmt.Sprintf("[g:%d p:%d %s/%d %v %v %x ->%x]",
|
|
ev.G, ev.P, evname(ev.Type), ev.Type,
|
|
ev.Args, ev.SArgs, ev.Ts, tslink)
|
|
|
|
}
|
|
|
|
func evname(t byte) string {
|
|
if t >= EvCount || t < 0 {
|
|
return fmt.Sprintf("typ%d?", t)
|
|
}
|
|
return EventDescriptions[t].Name
|
|
}
|
|
|
|
// Close the underlying file.
|
|
func (p *Parsed) Close() error {
|
|
return p.r.Close()
|
|
}
|
|
|
|
// Event types in the trace.
|
|
// Verbatim copy from src/runtime/trace.go with the "trace" prefix removed.
|
|
const (
|
|
EvNone = 0 // unused
|
|
EvBatch = 1 // start of per-P batch of events [pid, timestamp]
|
|
EvFrequency = 2 // contains tracer timer frequency [frequency (ticks per second)]
|
|
EvStack = 3 // stack [stack id, number of PCs, array of {PC, func string ID, file string ID, line}]
|
|
EvGomaxprocs = 4 // current value of GOMAXPROCS [timestamp, GOMAXPROCS, stack id]
|
|
EvProcStart = 5 // start of P [timestamp, thread id]
|
|
EvProcStop = 6 // stop of P [timestamp]
|
|
EvGCStart = 7 // GC start [timestamp, seq, stack id]
|
|
EvGCDone = 8 // GC done [timestamp]
|
|
EvGCSTWStart = 9 // GC mark termination start [timestamp, kind]
|
|
EvGCSTWDone = 10 // GC mark termination done [timestamp]
|
|
EvGCSweepStart = 11 // GC sweep start [timestamp, stack id]
|
|
EvGCSweepDone = 12 // GC sweep done [timestamp, swept, reclaimed]
|
|
EvGoCreate = 13 // goroutine creation [timestamp, new goroutine id, new stack id, stack id]
|
|
EvGoStart = 14 // goroutine starts running [timestamp, goroutine id, seq]
|
|
EvGoEnd = 15 // goroutine ends [timestamp]
|
|
EvGoStop = 16 // goroutine stops (like in select{}) [timestamp, stack]
|
|
EvGoSched = 17 // goroutine calls Gosched [timestamp, stack]
|
|
EvGoPreempt = 18 // goroutine is preempted [timestamp, stack]
|
|
EvGoSleep = 19 // goroutine calls Sleep [timestamp, stack]
|
|
EvGoBlock = 20 // goroutine blocks [timestamp, stack]
|
|
EvGoUnblock = 21 // goroutine is unblocked [timestamp, goroutine id, seq, stack]
|
|
EvGoBlockSend = 22 // goroutine blocks on chan send [timestamp, stack]
|
|
EvGoBlockRecv = 23 // goroutine blocks on chan recv [timestamp, stack]
|
|
EvGoBlockSelect = 24 // goroutine blocks on select [timestamp, stack]
|
|
EvGoBlockSync = 25 // goroutine blocks on Mutex/RWMutex [timestamp, stack]
|
|
EvGoBlockCond = 26 // goroutine blocks on Cond [timestamp, stack]
|
|
EvGoBlockNet = 27 // goroutine blocks on network [timestamp, stack]
|
|
EvGoSysCall = 28 // syscall enter [timestamp, stack]
|
|
EvGoSysExit = 29 // syscall exit [timestamp, goroutine id, seq, real timestamp]
|
|
EvGoSysBlock = 30 // syscall blocks [timestamp]
|
|
EvGoWaiting = 31 // denotes that goroutine is blocked when tracing starts [timestamp, goroutine id]
|
|
EvGoInSyscall = 32 // denotes that goroutine is in syscall when tracing starts [timestamp, goroutine id]
|
|
EvHeapAlloc = 33 // memstats.heap_live change [timestamp, heap_alloc]
|
|
EvNextGC = 34 // memstats.next_gc change [timestamp, next_gc]
|
|
EvTimerGoroutine = 35 // denotes timer goroutine [timer goroutine id]
|
|
EvFutileWakeup = 36 // denotes that the previous wakeup of this goroutine was futile [timestamp]
|
|
EvString = 37 // string dictionary entry [ID, length, string]
|
|
EvGoStartLocal = 38 // goroutine starts running on the same P as the last event [timestamp, goroutine id]
|
|
EvGoUnblockLocal = 39 // goroutine is unblocked on the same P as the last event [timestamp, goroutine id, stack]
|
|
EvGoSysExitLocal = 40 // syscall exit on the same P as the last event [timestamp, goroutine id, real timestamp]
|
|
EvGoStartLabel = 41 // goroutine starts running with label [timestamp, goroutine id, seq, label string id]
|
|
EvGoBlockGC = 42 // goroutine blocks on GC assist [timestamp, stack]
|
|
EvGCMarkAssistStart = 43 // GC mark assist start [timestamp, stack]
|
|
EvGCMarkAssistDone = 44 // GC mark assist done [timestamp]
|
|
EvUserTaskCreate = 45 // trace.NewContext [timestamp, internal task id, internal parent id, stack, name string]
|
|
EvUserTaskEnd = 46 // end of task [timestamp, internal task id, stack]
|
|
EvUserRegion = 47 // trace.WithSpan [timestamp, internal task id, mode(0:start, 1:end), stack, name string]
|
|
EvUserLog = 48 // trace.Log [timestamp, internal id, key string id, stack, value string]
|
|
EvCount = 49
|
|
)
|
|
|
|
// EventDescriptions describe the Events
|
|
var EventDescriptions = [EvCount]struct {
|
|
Name string
|
|
MinVersion int
|
|
Stack bool
|
|
Args []string
|
|
SArgs []string // string arguments
|
|
}{
|
|
EvNone: {"None", 1005, false, []string{}, nil},
|
|
EvBatch: {"Batch", 1005, false, []string{"p", "ticks"}, nil}, // in 1.5 format it was {"p", "seq", "ticks"}
|
|
EvFrequency: {"Frequency", 1005, false, []string{"freq"}, nil}, // in 1.5 format it was {"freq", "unused"}
|
|
EvStack: {"Stack", 1005, false, []string{"id", "siz"}, nil},
|
|
EvGomaxprocs: {"Gomaxprocs", 1005, true, []string{"procs"}, nil},
|
|
EvProcStart: {"ProcStart", 1005, false, []string{"thread"}, nil},
|
|
EvProcStop: {"ProcStop", 1005, false, []string{}, nil},
|
|
EvGCStart: {"GCStart", 1005, true, []string{"seq"}, nil}, // in 1.5 format it was {}
|
|
EvGCDone: {"GCDone", 1005, false, []string{}, nil},
|
|
EvGCSTWStart: {"GCSTWStart", 1005, false, []string{"kindid"}, []string{"kind"}}, // <= 1.9, args was {} (implicitly {0})
|
|
EvGCSTWDone: {"GCSTWDone", 1005, false, []string{}, nil},
|
|
EvGCSweepStart: {"GCSweepStart", 1005, true, []string{}, nil},
|
|
EvGCSweepDone: {"GCSweepDone", 1005, false, []string{"swept", "reclaimed"}, nil}, // before 1.9, format was {}
|
|
EvGoCreate: {"GoCreate", 1005, true, []string{"g", "stack"}, nil},
|
|
EvGoStart: {"GoStart", 1005, false, []string{"g", "seq"}, nil}, // in 1.5 format it was {"g"}
|
|
EvGoEnd: {"GoEnd", 1005, false, []string{}, nil},
|
|
EvGoStop: {"GoStop", 1005, true, []string{}, nil},
|
|
EvGoSched: {"GoSched", 1005, true, []string{}, nil},
|
|
EvGoPreempt: {"GoPreempt", 1005, true, []string{}, nil},
|
|
EvGoSleep: {"GoSleep", 1005, true, []string{}, nil},
|
|
EvGoBlock: {"GoBlock", 1005, true, []string{}, nil},
|
|
EvGoUnblock: {"GoUnblock", 1005, true, []string{"g", "seq"}, nil}, // in 1.5 format it was {"g"}
|
|
EvGoBlockSend: {"GoBlockSend", 1005, true, []string{}, nil},
|
|
EvGoBlockRecv: {"GoBlockRecv", 1005, true, []string{}, nil},
|
|
EvGoBlockSelect: {"GoBlockSelect", 1005, true, []string{}, nil},
|
|
EvGoBlockSync: {"GoBlockSync", 1005, true, []string{}, nil},
|
|
EvGoBlockCond: {"GoBlockCond", 1005, true, []string{}, nil},
|
|
EvGoBlockNet: {"GoBlockNet", 1005, true, []string{}, nil},
|
|
EvGoSysCall: {"GoSysCall", 1005, true, []string{}, nil},
|
|
EvGoSysExit: {"GoSysExit", 1005, false, []string{"g", "seq", "ts"}, nil},
|
|
EvGoSysBlock: {"GoSysBlock", 1005, false, []string{}, nil},
|
|
EvGoWaiting: {"GoWaiting", 1005, false, []string{"g"}, nil},
|
|
EvGoInSyscall: {"GoInSyscall", 1005, false, []string{"g"}, nil},
|
|
EvHeapAlloc: {"HeapAlloc", 1005, false, []string{"mem"}, nil},
|
|
EvNextGC: {"NextGC", 1005, false, []string{"mem"}, nil},
|
|
EvTimerGoroutine: {"TimerGoroutine", 1005, false, []string{"g"}, nil}, // in 1.5 format it was {"g", "unused"}
|
|
EvFutileWakeup: {"FutileWakeup", 1005, false, []string{}, nil},
|
|
EvString: {"String", 1007, false, []string{}, nil},
|
|
EvGoStartLocal: {"GoStartLocal", 1007, false, []string{"g"}, nil},
|
|
EvGoUnblockLocal: {"GoUnblockLocal", 1007, true, []string{"g"}, nil},
|
|
EvGoSysExitLocal: {"GoSysExitLocal", 1007, false, []string{"g", "ts"}, nil},
|
|
EvGoStartLabel: {"GoStartLabel", 1008, false, []string{"g", "seq", "labelid"}, []string{"label"}},
|
|
EvGoBlockGC: {"GoBlockGC", 1008, true, []string{}, nil},
|
|
EvGCMarkAssistStart: {"GCMarkAssistStart", 1009, true, []string{}, nil},
|
|
EvGCMarkAssistDone: {"GCMarkAssistDone", 1009, false, []string{}, nil},
|
|
EvUserTaskCreate: {"UserTaskCreate", 1011, true, []string{"taskid", "pid", "typeid"}, []string{"name"}},
|
|
EvUserTaskEnd: {"UserTaskEnd", 1011, true, []string{"taskid"}, nil},
|
|
EvUserRegion: {"UserRegion", 1011, true, []string{"taskid", "mode", "typeid"}, []string{"name"}},
|
|
EvUserLog: {"UserLog", 1011, true, []string{"id", "keyid"}, []string{"category", "message"}},
|
|
}
|