This is a description of the profile.proto format.


Profile.proto is a data representation for profile data. It is independent of the type of data being collected and the sampling process used to collect that data. On disk, it is represented as a gzip-compressed protocol buffer, described at src/proto/profile.proto

A profile in this context refers to a collection of samples, each one representing measurements performed at a certain point in the life of a job. A sample associates a set of measurement values with a list of locations, commonly representing the program call stack when the sample was taken.

Tools such as pprof analyze these samples and display this information in multiple forms, such as identifying hottest locations, building graphical call graphs or trees, etc.

General structure of a profile

A profile is represented on a Profile message, which contain the following fields:

  • sample: A profile sample, with the values measured and the associated call stack as a list of location ids. Samples with identical call stacks can be merged by adding their respective values, element by element.
  • location: A unique place in the program, commonly mapped to a single instruction address. It has a unique nonzero id, to be referenced from the samples. It contains source information in the form of lines, and a mapping id that points to a binary.
  • function: A program function as defined in the program source. It has a unique nonzero id, referenced from the location lines. It contains a human-readable name for the function (eg a C++ demangled name), a system name (eg a C++ mangled name), the name of the corresponding source file, and other function attributes.
  • mapping: A binary that is part of the program during the profile collection. It has a unique nonzero id, referenced from the locations. It includes details on how the binary was mapped during program execution. By convention the main program binary is the first mapping, followed by any shared libraries.
  • string_table: All strings in the profile are represented as indices into this repeating field. The first string is empty, so index == 0 always represents the empty string.

Measurement values

Measurement values are represented as 64-bit integers. The profile contains an explicit description of each value represented, using a ValueType message, with two fields:

  • Type: A human-readable description of the type semantics. For example “cpu” to represent CPU time, “wall” or “time” for wallclock time, or “memory” for bytes allocated.
  • Unit: A human-readable name of the unit represented by the 64-bit integer values. For example, it could be “nanoseconds” or “milliseconds” for a time value, or “bytes” or “megabytes” for a memory size. If this is just representing a number of events, the recommended unit name is “count”.

A profile can represent multiple measurements per sample, but all samples must have the same number and type of measurements. The actual values are stored in the Sample.value fields, each one described by the corresponding Profile.sample_type field.

Some profiles have a uniform period that describe the granularity of the data collection. For example, a CPU profile may have a period of 100ms, or a memory allocation profile may have a period of 512kb. Profiles can optionally describe such a value on the Profile.period and Profile.period_type fields. The profile period is meant for human consumption and does not affect the interpretation of the profiling data.

By convention, the first value on all profiles is the number of samples collected at this call stack, with unit “count”. Because the profile does not describe the sampling process beyond the optional period, it must include unsampled values for all measurements. For example, a CPU profile could have value[0] == samples, and value[1] == time in milliseconds.

Locations, functions and mappings

Each sample lists the id of each location where the sample was collected, in bottom-up order. Each location has an explicit unique nonzero integer id, independent of its position in the profile, and holds additional information to identify the corresponding source.

The profile source is expected to perform any adjustment required to the locations in order to point to the calls in the stack. For example, if the profile source extracts the call stack by walking back over the program stack, it must adjust the instruction addresses to point to the actual call instruction, instead of the instruction that each call will return to.

Sources usually generate profiles that fall into these two categories:

  • Unsymbolized profiles: These only contain instruction addresses, and are to be symbolized by a separate tool. It is critical for each location to point to a valid mapping, which will provide the information required for symbolization. These are used for profiles of compiled languages, such as C++ and Go.

  • Symbolized profiles: These contain all the symbol information available for the profile. Mappings and instruction addresses are optional for symbolized locations. These are used for profiles of interpreted or jitted languages, such as Java or Python. Also, the profile format allows the generation of mixed profiles, with symbolized and unsymbolized locations.

The symbol information is represented in the repeating lines field of the Location message. A location has multiple lines if it reflects multiple program sources, for example if representing inlined call stacks. Lines reference functions by their unique nonzero id, and the source line number within the source file listed by the function. A function contains the source attributes for a function, including its name, source file, etc. Functions include both a user and a system form of the name, for example to include C++ demangled and mangled names. For profiles where only a single name exists, both should be set to the same string.

Mappings are also referenced from locations by their unique nonzero id, and include all information needed to symbolize addresses within the mapping. It includes similar information to the Linux /proc/self/maps file. Locations associated to a mapping should have addresses that land between the mapping start and limit. Also, if available, mappings should include a build id to uniquely identify the version of the binary being used.


Samples optionally contain labels, which are annotations to discriminate samples with identical locations. For example, a label can be used on a malloc profile to indicate allocation size, so two samples on the same call stack with sizes 2MB and 4MB do not get merged into a single sample with two allocations and a size of 6MB.

Labels can be string-based or numeric. They are represented by the Label message, with a key identifying the label and either a string or numeric value. For numeric labels, the measurement unit can be specified in the profile. If no unit is specified and the key is “request” or “alignment”, then the units are assumed to be “bytes”. Otherwise when no unit is specified the key will be used as the measurement unit of the numeric value. All tags with the same key should have the same unit.

Keep and drop expressions

Some profile sources may have knowledge of locations that are uninteresting or irrelevant. However, if symbolization is needed in order to identify these locations, the profile source may not be able to remove them when the profile is generated. The profile format provides a mechanism to identify these frames by name, through regular expressions.

These expressions must match the function name in its entirety. Frames that match Profile.drop_frames will be dropped from the profile, along with any frames below it. Frames that match Profile.keep_frames will be kept, even if they match drop_frames.