Abstract: Preserving memory values during replay includes identifying trace sections that each represents events executed by an entity over a period of time. A parallel replay of trace sections is performed at a plurality of processing units. While performing the parallel replay, a persistence data structure corresponding to each trace section is maintained. This includes, for each trace section, storing, in the trace section's persistence data structure, a record of each memory address consumed by the processing unit while replaying the trace section, and a most recent memory value stored at each memory address. Returning a memory value during replay includes identifying relevant persistence data structures, and searching these data structures, in turn, based on a defined ordering. When a relevant memory address is identified during the search, the search is ceased and the value associated at the memory address, as stored in a persistence data structure, is returned.

Abstract: Recording a replay-able trace of execution of an executable entity using cache data includes executing one or more threads of the executable entity concurrently across one or more processing units of the one or more processors. During execution of the one or more threads, a separate replay-able trace is recorded for each thread independently. Recording includes, for each thread, recording initial processor register state for the thread. Recording also includes, for each thread, and upon detecting a processor data cache miss, recording at least one line of cache data imported into the processor data cache.

Abstract: Recording a replay-able trace of execution of an executable entity using cache data includes executing one or more threads of the executable entity concurrently across one or more processing units of the one or more processors. During execution of the one or more threads, a separate replay-able trace is recorded for each thread independently. Recording includes, for each thread, recording initial processor register state for the thread. Recording also includes, for each thread, and upon detecting a processor data cache miss, recording at least one line of cache data imported into the processor data cache. Recording also includes recording the occurrence of at least one event by recording its side effects.

Abstract: Efficient breakpoint detections via caches comprises monitoring a memory location by detecting cache misses on a cache. A memory address that is to be monitored is stored in a monitoring list, and any cache line overlapping with the memory address is evicted if it exists in a cache. When the occurrence of a cache miss based on a memory access operation is detected, a determination is made as to whether a portion of a cache line imported into the cache based on the cache miss overlaps with the memory address stored in the monitoring list. When there is an overlap, one or more monitoring operations are processed on the memory address, and the imported cache line is evicted from the cache.

Abstract: Embodiments herein are directed to parallel replay of code execution. An embodiment parses trace data comprising a plurality of trace data streams that each represents execution of a corresponding one of a plurality of executable entities, and identifies a plurality of trace sections that each represents one or more events executed by one of the executable entities over a period of time. The embodiment defines an ordering among the trace sections, identifies a point of interest in at least one of the executable entities, and identifies a subset of the trace sections that, when replayed linearly according to the ordering, would encounter the point of interest. The embodiment queues the subset of trace sections in an execution pool for replay by one or more processors. Then, based on the trace data, the embodiment uses the processor(s) to replay two or more of the subset of trace sections in parallel.

Abstract: Techniques for processing recorded program data are described. In implementations, a trace module in a computing device processes instructions of a recorded program and generates a trace file for program optimization. In implementations, the trace module records a subset of a received program for inclusion in the trace file. The computing device can also or instead be implemented to gather and initiate analysis of application data proactively and without user initiation.

Abstract: Performing a query over a trace of program execution. A method includes receiving a query expression targeted at least a portion of a trace of program execution. A data structure that represents the query expression is built. The data structure has a plurality of data elements representing concepts and operations of the query. Based on the data structure, an order for evaluating the data elements is identified. The plurality of data elements is evaluated. Based on the evaluation, at least a portion of a result set is conveyed for consumption.

Abstract: Recording a memory address includes identifying a first subset of high bits of the memory address, determining that a first value of the first subset equals a second value of a group of high bits already recorded, recording a second subset of low bits of the memory address while refraining from recording the first subset, and setting one or more flag bits to indicate that only the second subset were recorded. Also, recording a memory value includes identifying a plurality of groups of consecutive bits of the memory value, determining that a first group contains bits having a defined pattern and that a second group contains bits lacking the defined pattern, recording the second group while refraining from recording at least a portion of the first group, and setting one or more flag bits to indicate that the first group was not recorded.

Abstract: Performing a speculative replay of code execution. Embodiments include replaying trace data comprising a trace data stream that represents execution of one or more executable entities, including storing first runtime state of replaying the trace data in a first replay data structure. During replay, a first point of interest in the executable entities is encountered. Based on encountering the first point of interest, replay of the trace data is ceased, and a user interface presents a portion of the first runtime state. While presenting the portion of runtime state, the trace data is speculatively replayed. Speculative replay includes automatically selecting a second point of interest in the executable entities, creating a second replay data structure from the first replay data structure, and replaying the trace data until encountering the second point of interest, including storing second runtime state of replaying the trace data in the second replay data structure.

Abstract: Inserting memory snapshots during indexing of a trace for responsive trace replay. A method includes identifying a plurality of points of interest in execution of executable entit(ies) whose execution is traced in first data stream(s). Based on the first data stream(s), a traced section of execution of the executable entit(ies) preceding each point of interest is replayed. During replay of each traced section of execution, memory addresses that are accessed by the executable entit(ies) during replay of the section, and a most recent value encountered at each memory address, is tracked. Second data stream(s) are recorded, which includes recording a plurality of memory snapshots in connection with the plurality of points of interest into the second data stream(s). Each memory snapshot summarizes memory addresses and values encountered in at least one section of execution preceding each point of interest.

Abstract: Facilitating recording a trace file of code execution using a processor cache. A method includes identifying an operation by a processing unit on a line of the cache. Based on identifying the operation, index bits for the cache line are set. Setting the index bits includes one of: (i) setting the bits to a reserved value when the operation is a write operation and tracing is disabled, (i) setting the bits to an index of the processing unit when the operation is a write operation and the bits are already set to a value other than the index of the processing unit, or (iii) setting the bits to the index of the processing unit when the operation is a read operation that is consumed by the processing unit and the bits are already set to a value other than the index of the processing unit.

Abstract: Reusing a related thread's cache during tracing. An embodiment includes executing a first thread at a processing unit while recording a trace to a first buffer. During execution, a context switch from the first thread to a second thread at the same processing unit is detected. Based on the context switch, it is determined that the second thread is related to the first thread, and that it is being traced to a separate second buffer. Based on this determination, a cache of the first thread is reused. The reuse includes recording a first identifier in the first buffer, and recording a second identifier in the second buffer. The first and second identifiers provide a linkage between the first buffer and the second buffer. Execution of the second thread is then initiated, while recording a trace to the second buffer, and without invalidating logging state of a cache.

Abstract: Facilitating recording a trace of code execution using way-locking in a set-associative processor cache. A computing device reserves cache line(s) in set(s) of cache lines of a set-associative cache for caching only locations in the system memory that are allocated to a particular executable entity. During a traced execution of the particular executable entity, the computing device detects that a cache miss has occurred on a location in the system memory that is allocated to a particular executable entity, and that a value at the location of system memory is being cached into one of the reserved cache lines. Based on the value at the location of system memory being cached into a reserved cache line, the computing device logs into a trace data stream at least a portion of the value at the location of system memory being cached into the reserved cache line.

Abstract: Facilitating recording a trace file of code execution using a processor cache. A computing device includes a plurality of processing units and a processor cache shared by the plurality of processing units. The processor cache includes a set of accounting bits that include different pluralities of accounting bits. Each plurality of accounting bits is associated with a different cache line of a plurality of cache lines of the processor cache, and includes a different unit bit associated with a different one of the plurality of processing units. The computing device also includes control logic that is configured to use the pluralities of accounting bits to indicate, for each cache line and for each processing unit, whether or not the processing unit has logged into a trace file a current value stored in the value portion of the cache line.

Abstract: Performing a search over a trace of program execution. A method includes receiving a search expression including one or more search criteria. The search expression is targeted at one or more trace data streams storing a trace of program execution. Based on the one or more search criteria, a plurality of families of code entity invocations are identified. Each family identifies a plurality of code entity invocations that are related to each other, and that are identified based in on one or more trace data streams. A ranking among the plurality of families of code entity invocations is identified, and based at least on the ranking a set of code entity invocations determined to meet the one or more search criteria is returned. The set of code entity invocations is ordered by a relevance determined based at least on the ranking among the plurality of families.

Abstract: Augmenting a trace with at least one reverse lookup data structure during indexing of the trace. A method includes receiving trace data observed during execution of executable entit(ies), and replaying a plurality of different sections of the trace data. The replay includes, for each trace section, executing a plurality of code instructions of the executable entit(ies) based on the section's portion of the trace data, and recording attribute(s) observed during the execution of the code instructions along with an identity of the trace section. At least one reverse lookup data structure is created. It associates each of at least a subset of the attributes observed during the replay of the plurality of trace sections with the identity of each trace section in which it was observed. This reverse lookup data structure is stored as part of one or more trace data streams.

Abstract: Inserting key frames during indexing of a trace for responsive trace replay. A method includes identifying responsiveness goal(s) for trace replay, including identifying a target trace section replay time. A portion of execution of executable entit(ies) is replayed based on first trace data stream(s). While replaying execution of the executable entit(ies), and based on the identified target trace section replay time, points of interest in execution of the executable entit(ies) are identified. Second trace data stream(s) are recorded, which includes inserting a key frame into the second trace data stream(s) at, or near, each of the identified points of interest, to create a plurality of trace sections. Each key frame enables replay of at least one of the executable entities beginning at the key frame.

Abstract: Recording a replay-able trace of execution of an executable entity using cache data includes executing one or more threads of the executable entity concurrently across one or more processing units of the one or more processors. During execution of the one or more threads, a separate replay-able trace is recorded for each thread independently. Recording includes, for each thread, recording initial processor register state for the thread. Recording also includes, for each thread, and upon detecting a processor data cache miss, recording at least one line of cache data imported into the processor data cache. Recording also includes recording the occurrence of at least one event by recording its side effects.

Abstract: Recording a replay-able trace of execution of a multi-threaded process includes identifying a trace memory model that defines one or more orderable events that are to be ordered across a plurality of threads of the multi-threaded process. The plurality of threads are executed concurrently across one or more processing units of one or more processors. During execution of the plurality of threads, a separate replay-able trace is recorded for each thread independently. Recording includes, for each thread, recording initial state for the thread, recording at least one memory read performed by at least one processor instruction executed by the thread that takes memory as input, and recording a least one orderable event performed by the thread with a monotonically increasing number that orders the event among other orderable events across the plurality of threads.

Abstract: Recording a replay-able trace of execution of an executable entity using cache data includes executing one or more threads of the executable entity concurrently across one or more processing units of the one or more processors. During execution of the one or more threads, a separate replay-able trace is recorded for each thread independently. Recording includes, for each thread, recording initial processor register state for the thread. Recording also includes, for each thread, and upon detecting a processor data cache miss, recording at least one line of cache data imported into the processor data cache.