profile/legacy_java_profile.go - third_party/github.com/google/pprof - Git at Google

 // Copyright 2014 Google Inc. All Rights Reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.

 // This file implements parsers to convert java legacy profiles into
 // the profile.proto format.

 package profile

 import (
 	"bytes"
 	"fmt"
 	"io"
 	"path/filepath"
 	"regexp"
 	"strconv"
 	"strings"
 )

 var (
 	attributeRx            = regexp.MustCompile(`([\w ]+)=([\w ]+)`)
 	javaSampleRx           = regexp.MustCompile(` *(\d+) +(\d+) +@ +([ x0-9a-f]*)`)
 	javaLocationRx         = regexp.MustCompile(`^\s*0x([[:xdigit:]]+)\s+(.*)\s*$`)
 	javaLocationFileLineRx = regexp.MustCompile(`^(.*)\s+\((.+):(-?[[:digit:]]+)\)$`)
 	javaLocationPathRx     = regexp.MustCompile(`^(.*)\s+\((.*)\)$`)
 )

 // javaCPUProfile returns a new Profile from profilez data.
 // b is the profile bytes after the header, period is the profiling
 // period, and parse is a function to parse 8-byte chunks from the
 // profile in its native endianness.
 func javaCPUProfile(b []byte, period int64, parse func(b []byte) (uint64, []byte)) (*Profile, error) {
 	p := &Profile{
 		Period:     period * 1000,
 		PeriodType: &ValueType{Type: "cpu", Unit: "nanoseconds"},
 		SampleType: []*ValueType{{Type: "samples", Unit: "count"}, {Type: "cpu", Unit: "nanoseconds"}},
 	}
 	var err error
 	var locs map[uint64]*Location
 	if b, locs, err = parseCPUSamples(b, parse, false, p); err != nil {
 		return nil, err
 	}

 	if err = parseJavaLocations(b, locs, p); err != nil {
 		return nil, err
 	}

 	// Strip out addresses for better merge.
 	if err = p.Aggregate(true, true, true, true, false); err != nil {
 		return nil, err
 	}

 	return p, nil
 }

 // parseJavaProfile returns a new profile from heapz or contentionz
 // data. b is the profile bytes after the header.
 func parseJavaProfile(b []byte) (*Profile, error) {
 	h := bytes.SplitAfterN(b, []byte("\n"), 2)
 	if len(h) < 2 {
 		return nil, errUnrecognized
 	}

 	p := &Profile{
 		PeriodType: &ValueType{},
 	}
 	header := string(bytes.TrimSpace(h[0]))

 	var err error
 	var pType string
 	switch header {
 	case "--- heapz 1 ---":
 		pType = "heap"
 	case "--- contentionz 1 ---":
 		pType = "contention"
 	default:
 		return nil, errUnrecognized
 	}

 	if b, err = parseJavaHeader(pType, h[1], p); err != nil {
 		return nil, err
 	}
 	var locs map[uint64]*Location
 	if b, locs, err = parseJavaSamples(pType, b, p); err != nil {
 		return nil, err
 	}
 	if err = parseJavaLocations(b, locs, p); err != nil {
 		return nil, err
 	}

 	// Strip out addresses for better merge.
 	if err = p.Aggregate(true, true, true, true, false); err != nil {
 		return nil, err
 	}

 	return p, nil
 }

 // parseJavaHeader parses the attribute section on a java profile and
 // populates a profile. Returns the remainder of the buffer after all
 // attributes.
 func parseJavaHeader(pType string, b []byte, p *Profile) ([]byte, error) {
 	nextNewLine := bytes.IndexByte(b, byte('\n'))
 	for nextNewLine != -1 {
 		line := string(bytes.TrimSpace(b[0:nextNewLine]))
 		if line != "" {
 			h := attributeRx.FindStringSubmatch(line)
 			if h == nil {
 				// Not a valid attribute, exit.
 				return b, nil
 			}

 			attribute, value := strings.TrimSpace(h[1]), strings.TrimSpace(h[2])
 			var err error
 			switch pType + "/" + attribute {
 			case "heap/format", "cpu/format", "contention/format":
 				if value != "java" {
 					return nil, errUnrecognized
 				}
 			case "heap/resolution":
 				p.SampleType = []*ValueType{
 					{Type: "inuse_objects", Unit: "count"},
 					{Type: "inuse_space", Unit: value},
 				}
 			case "contention/resolution":
 				p.SampleType = []*ValueType{
 					{Type: "contentions", Unit: "count"},
 					{Type: "delay", Unit: value},
 				}
 			case "contention/sampling period":
 				p.PeriodType = &ValueType{
 					Type: "contentions", Unit: "count",
 				}
 				if p.Period, err = strconv.ParseInt(value, 0, 64); err != nil {
 					return nil, fmt.Errorf("failed to parse attribute %s: %v", line, err)
 				}
 			case "contention/ms since reset":
 				millis, err := strconv.ParseInt(value, 0, 64)
 				if err != nil {
 					return nil, fmt.Errorf("failed to parse attribute %s: %v", line, err)
 				}
 				p.DurationNanos = millis * 1000 * 1000
 			default:
 				return nil, errUnrecognized
 			}
 		}
 		// Grab next line.
 		b = b[nextNewLine+1:]
 		nextNewLine = bytes.IndexByte(b, byte('\n'))
 	}
 	return b, nil
 }

 // parseJavaSamples parses the samples from a java profile and
 // populates the Samples in a profile. Returns the remainder of the
 // buffer after the samples.
 func parseJavaSamples(pType string, b []byte, p *Profile) ([]byte, map[uint64]*Location, error) {
 	nextNewLine := bytes.IndexByte(b, byte('\n'))
 	locs := make(map[uint64]*Location)
 	for nextNewLine != -1 {
 		line := string(bytes.TrimSpace(b[0:nextNewLine]))
 		if line != "" {
 			sample := javaSampleRx.FindStringSubmatch(line)
 			if sample == nil {
 				// Not a valid sample, exit.
 				return b, locs, nil
 			}

 			// Java profiles have data/fields inverted compared to other
 			// profile types.
 			var err error
 			value1, value2, value3 := sample[2], sample[1], sample[3]
 			addrs, err := parseHexAddresses(value3)
 			if err != nil {
 				return nil, nil, fmt.Errorf("malformed sample: %s: %v", line, err)
 			}

 			var sloc []*Location
 			for _, addr := range addrs {
 				loc := locs[addr]
 				if locs[addr] == nil {
 					loc = &Location{
 						Address: addr,
 					}
 					p.Location = append(p.Location, loc)
 					locs[addr] = loc
 				}
 				sloc = append(sloc, loc)
 			}
 			s := &Sample{
 				Value:    make([]int64, 2),
 				Location: sloc,
 			}

 			if s.Value[0], err = strconv.ParseInt(value1, 0, 64); err != nil {
 				return nil, nil, fmt.Errorf("parsing sample %s: %v", line, err)
 			}
 			if s.Value[1], err = strconv.ParseInt(value2, 0, 64); err != nil {
 				return nil, nil, fmt.Errorf("parsing sample %s: %v", line, err)
 			}

 			switch pType {
 			case "heap":
 				const javaHeapzSamplingRate = 524288 // 512K
 				if s.Value[0] == 0 {
 					return nil, nil, fmt.Errorf("parsing sample %s: second value must be non-zero", line)
 				}
 				s.NumLabel = map[string][]int64{"bytes": {s.Value[1] / s.Value[0]}}
 				s.Value[0], s.Value[1] = scaleHeapSample(s.Value[0], s.Value[1], javaHeapzSamplingRate)
 			case "contention":
 				if period := p.Period; period != 0 {
 					s.Value[0] = s.Value[0] * p.Period
 					s.Value[1] = s.Value[1] * p.Period
 				}
 			}
 			p.Sample = append(p.Sample, s)
 		}
 		// Grab next line.
 		b = b[nextNewLine+1:]
 		nextNewLine = bytes.IndexByte(b, byte('\n'))
 	}
 	return b, locs, nil
 }

 // parseJavaLocations parses the location information in a java
 // profile and populates the Locations in a profile. It uses the
 // location addresses from the profile as both the ID of each
 // location.
 func parseJavaLocations(b []byte, locs map[uint64]*Location, p *Profile) error {
 	r := bytes.NewBuffer(b)
 	fns := make(map[string]*Function)
 	for {
 		line, err := r.ReadString('\n')
 		if err != nil {
 			if err != io.EOF {
 				return err
 			}
 			if line == "" {
 				break
 			}
 		}

 		if line = strings.TrimSpace(line); line == "" {
 			continue
 		}

 		jloc := javaLocationRx.FindStringSubmatch(line)
 		if len(jloc) != 3 {
 			continue
 		}
 		addr, err := strconv.ParseUint(jloc[1], 16, 64)
 		if err != nil {
 			return fmt.Errorf("parsing sample %s: %v", line, err)
 		}
 		loc := locs[addr]
 		if loc == nil {
 			// Unused/unseen
 			continue
 		}
 		var lineFunc, lineFile string
 		var lineNo int64

 		if fileLine := javaLocationFileLineRx.FindStringSubmatch(jloc[2]); len(fileLine) == 4 {
 			// Found a line of the form: "function (file:line)"
 			lineFunc, lineFile = fileLine[1], fileLine[2]
 			if n, err := strconv.ParseInt(fileLine[3], 10, 64); err == nil && n > 0 {
 				lineNo = n
 			}
 		} else if filePath := javaLocationPathRx.FindStringSubmatch(jloc[2]); len(filePath) == 3 {
 			// If there's not a file:line, it's a shared library path.
 			// The path isn't interesting, so just give the .so.
 			lineFunc, lineFile = filePath[1], filepath.Base(filePath[2])
 		} else if strings.Contains(jloc[2], "generated stub/JIT") {
 			lineFunc = "STUB"
 		} else {
 			// Treat whole line as the function name. This is used by the
 			// java agent for internal states such as "GC" or "VM".
 			lineFunc = jloc[2]
 		}
 		fn := fns[lineFunc]

 		if fn == nil {
 			fn = &Function{
 				Name:       lineFunc,
 				SystemName: lineFunc,
 				Filename:   lineFile,
 			}
 			fns[lineFunc] = fn
 			p.Function = append(p.Function, fn)
 		}
 		loc.Line = []Line{
 			{
 				Function: fn,
 				Line:     lineNo,
 			},
 		}
 		loc.Address = 0
 	}

 	p.remapLocationIDs()
 	p.remapFunctionIDs()
 	p.remapMappingIDs()

 	return nil
 }
	// Copyright 2014 Google Inc. All Rights Reserved.
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.

	// This file implements parsers to convert java legacy profiles into
	// the profile.proto format.

	package profile

	import (
	"bytes"
	"fmt"
	"io"
	"path/filepath"
	"regexp"
	"strconv"
	"strings"
	)

	var (
	attributeRx = regexp.MustCompile(`([\w ]+)=([\w ]+)`)
	javaSampleRx = regexp.MustCompile(` (\d+) +(\d+) +@ +([ x0-9a-f])`)
	javaLocationRx = regexp.MustCompile(`^\s0x([[:xdigit:]]+)\s+(.)\s*$`)
	javaLocationFileLineRx = regexp.MustCompile(`^(.*)\s+\((.+):(-?[[:digit:]]+)\)$`)
	javaLocationPathRx = regexp.MustCompile(`^(.)\s+\((.)\)$`)
	)

	// javaCPUProfile returns a new Profile from profilez data.
	// b is the profile bytes after the header, period is the profiling
	// period, and parse is a function to parse 8-byte chunks from the
	// profile in its native endianness.
	func javaCPUProfile(b []byte, period int64, parse func(b []byte) (uint64, []byte)) (*Profile, error) {
	p := &Profile{
	Period: period * 1000,
	PeriodType: &ValueType{Type: "cpu", Unit: "nanoseconds"},
	SampleType: []*ValueType{{Type: "samples", Unit: "count"}, {Type: "cpu", Unit: "nanoseconds"}},
	}
	var err error
	var locs map[uint64]*Location
	if b, locs, err = parseCPUSamples(b, parse, false, p); err != nil {
	return nil, err
	}

	if err = parseJavaLocations(b, locs, p); err != nil {
	return nil, err
	}

	// Strip out addresses for better merge.
	if err = p.Aggregate(true, true, true, true, false); err != nil {
	return nil, err
	}

	return p, nil
	}

	// parseJavaProfile returns a new profile from heapz or contentionz
	// data. b is the profile bytes after the header.
	func parseJavaProfile(b []byte) (*Profile, error) {
	h := bytes.SplitAfterN(b, []byte("\n"), 2)
	if len(h) < 2 {
	return nil, errUnrecognized
	}

	p := &Profile{
	PeriodType: &ValueType{},
	}
	header := string(bytes.TrimSpace(h[0]))

	var err error
	var pType string
	switch header {
	case "--- heapz 1 ---":
	pType = "heap"
	case "--- contentionz 1 ---":
	pType = "contention"
	default:
	return nil, errUnrecognized
	}

	if b, err = parseJavaHeader(pType, h[1], p); err != nil {
	return nil, err
	}
	var locs map[uint64]*Location
	if b, locs, err = parseJavaSamples(pType, b, p); err != nil {
	return nil, err
	}
	if err = parseJavaLocations(b, locs, p); err != nil {
	return nil, err
	}

	// Strip out addresses for better merge.
	if err = p.Aggregate(true, true, true, true, false); err != nil {
	return nil, err
	}

	return p, nil
	}

	// parseJavaHeader parses the attribute section on a java profile and
	// populates a profile. Returns the remainder of the buffer after all
	// attributes.
	func parseJavaHeader(pType string, b []byte, p *Profile) ([]byte, error) {
	nextNewLine := bytes.IndexByte(b, byte('\n'))
	for nextNewLine != -1 {
	line := string(bytes.TrimSpace(b[0:nextNewLine]))
	if line != "" {
	h := attributeRx.FindStringSubmatch(line)
	if h == nil {
	// Not a valid attribute, exit.
	return b, nil
	}

	attribute, value := strings.TrimSpace(h[1]), strings.TrimSpace(h[2])
	var err error
	switch pType + "/" + attribute {
	case "heap/format", "cpu/format", "contention/format":
	if value != "java" {
	return nil, errUnrecognized
	}
	case "heap/resolution":
	p.SampleType = []*ValueType{
	{Type: "inuse_objects", Unit: "count"},
	{Type: "inuse_space", Unit: value},
	}
	case "contention/resolution":
	p.SampleType = []*ValueType{
	{Type: "contentions", Unit: "count"},
	{Type: "delay", Unit: value},
	}
	case "contention/sampling period":
	p.PeriodType = &ValueType{
	Type: "contentions", Unit: "count",
	}
	if p.Period, err = strconv.ParseInt(value, 0, 64); err != nil {
	return nil, fmt.Errorf("failed to parse attribute %s: %v", line, err)
	}
	case "contention/ms since reset":
	millis, err := strconv.ParseInt(value, 0, 64)
	if err != nil {
	return nil, fmt.Errorf("failed to parse attribute %s: %v", line, err)
	}
	p.DurationNanos = millis * 1000 * 1000
	default:
	return nil, errUnrecognized
	}
	}
	// Grab next line.
	b = b[nextNewLine+1:]
	nextNewLine = bytes.IndexByte(b, byte('\n'))
	}
	return b, nil
	}

	// parseJavaSamples parses the samples from a java profile and
	// populates the Samples in a profile. Returns the remainder of the
	// buffer after the samples.
	func parseJavaSamples(pType string, b []byte, p Profile) ([]byte, map[uint64]Location, error) {
	nextNewLine := bytes.IndexByte(b, byte('\n'))
	locs := make(map[uint64]*Location)
	for nextNewLine != -1 {
	line := string(bytes.TrimSpace(b[0:nextNewLine]))
	if line != "" {
	sample := javaSampleRx.FindStringSubmatch(line)
	if sample == nil {
	// Not a valid sample, exit.
	return b, locs, nil
	}

	// Java profiles have data/fields inverted compared to other
	// profile types.
	var err error
	value1, value2, value3 := sample[2], sample[1], sample[3]
	addrs, err := parseHexAddresses(value3)
	if err != nil {
	return nil, nil, fmt.Errorf("malformed sample: %s: %v", line, err)
	}

	var sloc []*Location
	for _, addr := range addrs {
	loc := locs[addr]
	if locs[addr] == nil {
	loc = &Location{
	Address: addr,
	}
	p.Location = append(p.Location, loc)
	locs[addr] = loc
	}
	sloc = append(sloc, loc)
	}
	s := &Sample{
	Value: make([]int64, 2),
	Location: sloc,
	}

	if s.Value[0], err = strconv.ParseInt(value1, 0, 64); err != nil {
	return nil, nil, fmt.Errorf("parsing sample %s: %v", line, err)
	}
	if s.Value[1], err = strconv.ParseInt(value2, 0, 64); err != nil {
	return nil, nil, fmt.Errorf("parsing sample %s: %v", line, err)
	}

	switch pType {
	case "heap":
	const javaHeapzSamplingRate = 524288 // 512K
	if s.Value[0] == 0 {
	return nil, nil, fmt.Errorf("parsing sample %s: second value must be non-zero", line)
	}
	s.NumLabel = map[string][]int64{"bytes": {s.Value[1] / s.Value[0]}}
	s.Value[0], s.Value[1] = scaleHeapSample(s.Value[0], s.Value[1], javaHeapzSamplingRate)
	case "contention":
	if period := p.Period; period != 0 {
	s.Value[0] = s.Value[0] * p.Period
	s.Value[1] = s.Value[1] * p.Period
	}
	}
	p.Sample = append(p.Sample, s)
	}
	// Grab next line.
	b = b[nextNewLine+1:]
	nextNewLine = bytes.IndexByte(b, byte('\n'))
	}
	return b, locs, nil
	}

	// parseJavaLocations parses the location information in a java
	// profile and populates the Locations in a profile. It uses the
	// location addresses from the profile as both the ID of each
	// location.
	func parseJavaLocations(b []byte, locs map[uint64]Location, p Profile) error {
	r := bytes.NewBuffer(b)
	fns := make(map[string]*Function)
	for {
	line, err := r.ReadString('\n')
	if err != nil {
	if err != io.EOF {
	return err
	}
	if line == "" {
	break
	}
	}

	if line = strings.TrimSpace(line); line == "" {
	continue
	}

	jloc := javaLocationRx.FindStringSubmatch(line)
	if len(jloc) != 3 {
	continue
	}
	addr, err := strconv.ParseUint(jloc[1], 16, 64)
	if err != nil {
	return fmt.Errorf("parsing sample %s: %v", line, err)
	}
	loc := locs[addr]
	if loc == nil {
	// Unused/unseen
	continue
	}
	var lineFunc, lineFile string
	var lineNo int64

	if fileLine := javaLocationFileLineRx.FindStringSubmatch(jloc[2]); len(fileLine) == 4 {
	// Found a line of the form: "function (file:line)"
	lineFunc, lineFile = fileLine[1], fileLine[2]
	if n, err := strconv.ParseInt(fileLine[3], 10, 64); err == nil && n > 0 {
	lineNo = n
	}
	} else if filePath := javaLocationPathRx.FindStringSubmatch(jloc[2]); len(filePath) == 3 {
	// If there's not a file:line, it's a shared library path.
	// The path isn't interesting, so just give the .so.
	lineFunc, lineFile = filePath[1], filepath.Base(filePath[2])
	} else if strings.Contains(jloc[2], "generated stub/JIT") {
	lineFunc = "STUB"
	} else {
	// Treat whole line as the function name. This is used by the
	// java agent for internal states such as "GC" or "VM".
	lineFunc = jloc[2]
	}
	fn := fns[lineFunc]

	if fn == nil {
	fn = &Function{
	Name: lineFunc,
	SystemName: lineFunc,
	Filename: lineFile,
	}
	fns[lineFunc] = fn
	p.Function = append(p.Function, fn)
	}
	loc.Line = []Line{
	{
	Function: fn,
	Line: lineNo,
	},
	}
	loc.Address = 0
	}

	p.remapLocationIDs()
	p.remapFunctionIDs()
	p.remapMappingIDs()

	return nil
	}