1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
|
/*
* This file is part of spark.
*
* Copyright (c) lucko (Luck) <luck@lucko.me>
* Copyright (c) contributors
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package me.lucko.spark.common.sampler.async;
import me.lucko.spark.common.sampler.async.jfr.JfrReader;
import java.nio.charset.StandardCharsets;
/**
* Represents a profile "segment".
*
* <p>async-profiler groups unique stack traces together per-thread in its output.</p>
*/
public class ProfileSegment {
/** The native thread id (does not correspond to Thread#getId) */
private final int nativeThreadId;
/** The name of the thread */
private final String threadName;
/** The stack trace for this segment */
private final AsyncStackTraceElement[] stackTrace;
/** The time spent executing this segment in microseconds */
private final long value;
public ProfileSegment(int nativeThreadId, String threadName, AsyncStackTraceElement[] stackTrace, long value) {
this.nativeThreadId = nativeThreadId;
this.threadName = threadName;
this.stackTrace = stackTrace;
this.value = value;
}
public int getNativeThreadId() {
return this.nativeThreadId;
}
public String getThreadName() {
return this.threadName;
}
public AsyncStackTraceElement[] getStackTrace() {
return this.stackTrace;
}
public long getValue() {
return this.value;
}
public static ProfileSegment parseSegment(JfrReader reader, JfrReader.Event sample, String threadName, long value) {
JfrReader.StackTrace stackTrace = reader.stackTraces.get(sample.stackTraceId);
int len = stackTrace.methods.length;
AsyncStackTraceElement[] stack = new AsyncStackTraceElement[len];
for (int i = 0; i < len; i++) {
stack[i] = parseStackFrame(reader, stackTrace.methods[i]);
}
return new ProfileSegment(sample.tid, threadName, stack, value);
}
private static AsyncStackTraceElement parseStackFrame(JfrReader reader, long methodId) {
AsyncStackTraceElement result = reader.stackFrames.get(methodId);
if (result != null) {
return result;
}
JfrReader.MethodRef methodRef = reader.methods.get(methodId);
JfrReader.ClassRef classRef = reader.classes.get(methodRef.cls);
byte[] className = reader.symbols.get(classRef.name);
byte[] methodName = reader.symbols.get(methodRef.name);
if (className == null || className.length == 0) {
// native call
result = new AsyncStackTraceElement(
AsyncStackTraceElement.NATIVE_CALL,
new String(methodName, StandardCharsets.UTF_8),
null
);
} else {
// java method
byte[] methodDesc = reader.symbols.get(methodRef.sig);
result = new AsyncStackTraceElement(
new String(className, StandardCharsets.UTF_8).replace('/', '.'),
new String(methodName, StandardCharsets.UTF_8),
new String(methodDesc, StandardCharsets.UTF_8)
);
}
reader.stackFrames.put(methodId, result);
return result;
}
}
|
