this repo has no description
code clean up
+39
-46
+39
-46
src/austin.zig
+39
-46
src/austin.zig
···
93
93
94
94
var reached_end: bool = false;
95
95
96
-
var key_raw: std.ArrayList(u8) = .init(self.arena);
97
-
var value_raw: std.ArrayList(u8) = .init(self.arena);
98
-
99
96
var line: std.ArrayList(u8) = .init(self.arena);
100
97
defer line.deinit();
101
98
···
113
110
114
111
if (line.items[0] == '#') {
115
112
// Metadata
116
-
var key: MetadataFields = undefined;
117
-
var state: enum { key, value } = .key;
113
+
const input = mem.trimStart(u8, line.items, "# ");
114
+
var it = mem.tokenizeScalar(u8, input, ':');
118
115
119
-
for (line.items) |val| {
120
-
if (val == ' ' or val == '#') continue;
121
-
122
-
switch (state) {
123
-
.key => {
124
-
if (val == ':') {
125
-
state = .value;
126
-
key = std.meta.stringToEnum(MetadataFields, key_raw.items) orelse return error.UnknownMetadataField;
127
-
key_raw.clearAndFree();
128
-
} else try key_raw.append(val);
129
-
},
130
-
.value => try value_raw.append(val),
131
-
}
132
-
}
133
-
134
-
const value = value_raw.items;
135
-
defer value_raw.clearAndFree();
116
+
const key = std.meta.stringToEnum(
117
+
MetadataFields,
118
+
it.next() orelse return error.MissingKey,
119
+
) orelse return error.UnknownMetadataField;
120
+
const value = it.next() orelse return error.MissingValue;
136
121
137
122
switch (key) {
138
123
.austin => profile.meta.austin = try .parse(value),
139
124
.interval => profile.meta.interval = try std.fmt.parseUnsigned(usize, value, 0),
140
125
.memory => profile.meta.memory = try std.fmt.parseUnsigned(usize, value, 0),
141
-
.mode => profile.meta.mode = std.meta.stringToEnum(@TypeOf(profile.meta.mode), value) orelse return error.UnknownMetadataFieldValue,
126
+
.mode => profile.meta.mode = std.meta.stringToEnum(
127
+
@TypeOf(profile.meta.mode),
128
+
value,
129
+
) orelse return error.UnknownMetadataFieldValue,
142
130
.multiprocess => profile.meta.multiprocess = std.mem.eql(u8, "on", value),
143
131
.duration => {
144
132
profile.meta.duration = try std.fmt.parseUnsigned(usize, value, 0);
···
170
158
171
159
fn parseSample(self: *Parser, line: std.ArrayList(u8), line_num: usize) ParseSampleError!SampleWrapper {
172
160
var sample = try self.arena.create(Sample);
173
-
174
-
// var line_it = std.mem.tokenizeScalar(u8, line.items, ' ');
175
-
// var metric_raw: []const u8 = undefined;
176
-
// var metric_start: usize = 0;
177
-
// var i: usize = 0;
178
-
// while (line_it.next()) |seg| : (i += 1) {
179
-
// if (i > 0) metric_start += metric_raw.len;
180
-
// metric_raw = seg;
181
-
// }
182
161
183
162
var line_it_back = mem.splitBackwardsScalar(u8, line.items, ' ');
184
163
const metric_raw = line_it_back.next().?;
···
188
167
// Metric
189
168
var metric = mem.tokenizeScalar(u8, metric_raw, ',');
190
169
sample.metric = Metric{
191
-
.time_delta = try std.fmt.parseUnsigned(usize, metric.next() orelse return ParseError.NoTimeDelta, 0),
192
-
.idle_state = try std.fmt.parseUnsigned(u8, metric.next() orelse return ParseError.NoIdleState, 0) == 1,
193
-
.rss_memory_delta = try std.fmt.parseInt(isize, metric.next() orelse return ParseError.NoRSSMemoryDelta, 0),
170
+
.time_delta = try std.fmt.parseUnsigned(
171
+
usize,
172
+
metric.next() orelse return ParseError.NoTimeDelta,
173
+
0,
174
+
),
175
+
.idle_state = try std.fmt.parseUnsigned(
176
+
u8,
177
+
metric.next() orelse return ParseError.NoIdleState,
178
+
0,
179
+
) == 1,
180
+
.rss_memory_delta = try std.fmt.parseInt(
181
+
isize,
182
+
metric.next() orelse return ParseError.NoRSSMemoryDelta,
183
+
0,
184
+
),
194
185
};
195
186
196
187
const data_raw = line.items[0 .. line.items.len - metric_raw.len - 1];
197
188
self.parseFullSample(sample, data_raw) catch |err| {
198
-
std.log.err("Caught {} while parsing line {} returning metrics ({}):\n{s}", .{ err, line_num, sample.metric, line.items });
189
+
std.log.err(
190
+
"Caught {} while parsing line {} returning metrics ({}):\n{s}",
191
+
.{ err, line_num, sample.metric, line.items },
192
+
);
199
193
return SampleWrapper{ .metric = sample.metric };
200
194
};
201
-
202
-
// const data_raw = line_it.next() orelse return error.NoCallStack;
203
-
// const metric_raw = line_it.next() orelse return error.NoMetrics;
204
195
205
196
return SampleWrapper{ .full = sample.* };
206
197
}
···
227
218
var frames: std.ArrayList(FrameWrapper) = try .initCapacity(self.arena, 1);
228
219
229
220
while (data.next()) |frame_raw| {
230
-
// std.debug.print("{s}\n", .{frame_raw});
231
221
var frame = std.mem.tokenizeScalar(u8, frame_raw, ':');
232
222
const module = frame.next() orelse return ParseError.NoModule;
233
223
···
235
225
try frames.append(FrameWrapper{ .call_stack = Frame{
236
226
.module = "",
237
227
.function = "",
238
-
.line_number = std.fmt.parseInt(isize, module, 0) catch return ParseError.InvalidLineNumber,
228
+
.line_number = std.fmt.parseInt(isize, module, 0) catch
229
+
return ParseError.InvalidLineNumber,
239
230
} });
240
231
continue;
241
232
}
242
233
243
234
if (!mem.eql(u8, module, "INVALID")) {
244
-
const function = frame.next() orelse {
245
-
// std.debug.print("MODULE: {s} REST: {s}\n", .{ module, data.rest() });
246
-
return ParseError.NoFunction;
247
-
};
248
-
const line_number = std.fmt.parseInt(isize, frame.next() orelse return ParseError.NoLineNumber, 0) catch return ParseError.InvalidLineNumber;
235
+
const function = frame.next() orelse return ParseError.NoFunction;
236
+
237
+
const line_number = std.fmt.parseInt(
238
+
isize,
239
+
frame.next() orelse return ParseError.NoLineNumber,
240
+
0,
241
+
) catch return ParseError.InvalidLineNumber;
249
242
250
243
var f: Frame = .{ .line_number = line_number };
251
244
f.module = try self.arena.alloc(u8, module.len);