-
Notifications
You must be signed in to change notification settings - Fork 40
/
issues.txt
375 lines (340 loc) · 13.1 KB
/
issues.txt
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
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
Prio Component Issue
-------------------------------
wizeng Load tool-convention core dumps
wizeng Eager pre-linking of some host modules
wizeng Lazy link errors for unbound imports that are never called
fast-int Optimize 4-byte sidetable entry loads
spc implement deoptimization for inserting probes when on-stack
spc Improve prologue; assume instance, mem0_base in registers
spc Optimize empty transfers
spc Load hot locals before loop
spc Explore loop peeling
spc Analyze loop for read/written locals
spc Always allocate registers for transfer values
spc instr-combine for cmp+branch
spc unit-test SpcState
spc unit-test regalloc
spc inlining of direct calls / whamm probes
interpreter compress ctlxfer entries (4 byte cases)
eh implement catch in SPC
gc tests for binary iso-rec canonicalization
gc tests for verifying supertype decls
gc implement array.new_data, array.new_elem in init expressions
spc non-final subtyping check for call_indirect
wizeng repl for loading and running modules
validator typecheck whole signatures at a time
validator prettier trace output
spec is it legal to have 0-count funcs and no code section?
parse Tracing of indexes/offsets might be wrong
parse Simplify BinParser state machine
util Improve objdump utility, add control rendering
util Dump module into text format
wasi Implement x86-64-linux wasi
ext memory64
ext threads
ext custom-page-sizes
test Add testing of --trace-interpreter and --trace-calls
test Add fuzzy-matching of stacktraces for CRASH opcodes
test all ext:gc instructions
bin reorganize BinParser, BpFsm, and WasmParser
util Test objdump utility with canned modules
v3-int Implement and use NativeMemory
v3-int Implement and use NativeValueStack
test Test proper value tags in SPC/int
ci test tail-call, multi-memory, function-references, gc, exception-handling, stack-switching, custom-page-sizes, extended-const
fast-int tune: use 2^n-byte handler blocks to avoid load for first dispatch
fast-int tune: register assignment
fast-int tune: handler order, alignment
fast-int tune: inline some extended LEB cases?
fast-int tune: hot-swap bytecode implementations, e.g. memory64
fast-int tune: preload next handler at beginning of handler
Monitors + trace
--------------------------------
All --trace-interpreter, memory, calls, etc output events in code in nested call trace format
> func1
> func2A
call event
> func3
instr event
memory access event
> func2B
--trace-interpreter accepts a function filter
--break-at inserts breakpoints at given location(s) and drops into debugger
--trace-at inserts tracepoints at given location(s)
build general-purpose "what is this program doing" monitor
CallsMonitor should report source-names of callees
--trace-tables should report read/write/calls through tables
TrapsMonitor shows state of program at trap points (default?)
VirgilMonitor hooks into sections of Virgil-generated Wasm
--trace-exception tracks try/throw/catch
MallocMonitor tracks malloc/free behavior
- tries to find memory leaks
- perf metrics: total usage, average usage, distribution of alloc sizes, free distance
- heatmap of allocation sites, memory ranges
- timeseries of memory consumption (bytes, objects)
- lifetime analysis (time between allocate and free)
MemoryMonitor records/reports at multiple granularities
- read/write count
- strides (FFT somehow ?), use prefetching detector algorithms
- hotness / heatmap
- memory access density (accesses per 1000K instructions)
- aliasing relationship between "pointers" into memory
CacheMonitor simulates and analyzes cache behavior
BranchPredictMonitor simulates and analyzes branch predictor behavior
DebugMonitor supports tab completion, uncooked terminal, etc
PathsMonitor profiles program paths
PhaseMonitor detects program phases
ObjectMonitor tracks allocations and mutations for WasmGC objects
-trace-calls, trace-globals, trace-tables show mutations
-trace-memory should show what memory monitor does currently
Global call stack depth tracking for monitor outputs
events: instructions, calls, exceptions
Coverage monitor should have more useful default output
{Instr,Block}TraceMonitor outputs compressed instruction/block traces for analysis
ProfileMonitor:
add a flat mode that is more efficient
add profiling of compilation, runtime, gc, and host calls
Hooks needed:
- wasm: traps, throw/catch, memory access, suspend/resume, host calls, frame unwind
- engine: gc, compile, load, verify
LoopMonitor track and display loop count distribution, improve display
Interactive - show an interactive, terminal-animated view of execution, e.g. which function
func | xxx xx | <- color indicates how recent / hot
mem | ====== |
ConstMonitor - track const load/store, global get/set
- track whether a given store instruction>
- always stores to the same address
- track whether a given load instruction:
- always loads from the same address
- always loads the same value => partial eval
- always loads data that is not later modified by the program => partial eval
- track whether a given global.get:
- always loads the same value
- track whether a given global.set:
- always writes the same value
Test Coverage
--------------------------------
Interpreter
doCallHost of null host function
doCallFunction of host function
pushFrame of EXTERNREF, FUNCREF, RefNullFunc locals
traceCallHostFunction deeper than 0
loop unbounded
Memory
.new with OOM
.read/write OOB for all elem sizes
.copyD of null
.size of null
SpecTestParser
.parseCommand error
.parseList boundary conditions
.parseOneCommandForTesting boundary conditions
.parseExpectedValue i64, f32, f64, refnull, refextern
BinParser
invalid section code
render invalid type con
.readElemFuncIndexes of FUNCREF, FuncRef, ExternRef
.readValueType of VEC128
.readDataIndex max > explicit_data_count
invalid import/export kind
renderLimitFlags of shared
readMemoryArg of full memory index
readLabels exceeding maximum
custom section name length too long
readDataDecl with different flags settings
readInitExpr readRefNull type
readMemoryLimits expecting shared memory maximum
decodeFunctionBody func count mismatch
decodeFunctionBody with code validation
readBlockType of double, vec128
readBlockType with function types
readRefType of function types
readElemDecl
Values
.f64 of underflow exponent
.render of host function
ValueType
.render of vec 128
Arrays
.boundsCheck of null
.map of null
Instantiator
check data bounds of null memory
check limits of Max.None
check elem bounds of expressions
checkBounds fails
Instance
evalInitExpr of f32, f64, FUNCREF, EXTERNREF, global
CodeValidator
.checkArgs of null
.readLocals exceeds maximum
.mergeTypesAt, invalid block type
checkAlignment (loads/stores)
table.init: element type mismatch
CtlXferTest
0 entries
Result
.equals of mismatched sizes
Opcodes
.renderInstr of not found prefix
.readBlockType .readValueType PARAM_INDEX
.find with 0 prefix
Max
.check of None
.min of None
Utf8
.findError of null
Strings
.equals of null
StringBuilder
.putx of u16
Stack
.pop of empty stack
.pushA with grow
.resize
Decoder
.read_x64leb with EOF
.read_u64 with EOF
.skip_bytes with EOF
.check_bytes with EOF
Module
.addDef of AbsTypeDecl
.addDef of EventDecl
AbsTypeDecl
.render of imported
BinBuilder
.put_ValueType
ElemDetails
.length of exprs
HostType
.isAssignableTo
V3C optimization hints
--------------------------------
Value representation
Inline 1-byte case of LEB
Inline SpcVal methods
Inline Values.v_* methods
Inline V3Interpreter.do_ii_i methods
Inline WasmObject.values array
Done
--------------------------------
gc Test for final types
monitor Track runtime function argument consts to detect specialization/inlining opportunities
ext extended constants
fast-int non-final subtyping check for call_indirect
interpreter implement atomics
BranchMonitor print full CFG and block nesting (done in ControlMonitor)
ext gc
ext function-references
wave Run monitor reports on System.error
ctlxfer more tests for greater depths
spc -jit-filter for debugging
validator more br tests
ext exception-handling
eh implement catch in fast int
spc,fast-int Unwind stack instead of checks for abrupt return
loop-monitor Don't show output of 0-count loops by default
v3-int implement simd
fast-int tune: loop for repeated blocks
ext multi-memory
validate move init expr validation into CodeValidator
fast-int tune: inline dispatch of END
eh Implement option B' for exnref
gc array.fill, array.new_data, array.new_elem
wizeng basic profiler
fast-int implement simd
spc implement simd
wizeng wizeng module: rdtsc call
spc trap locations and stacktraces
spc allow register to be used for more than one slot
tiering implement dynamic tier-up
test Add crash-exec and crash-compile bytecodes
test measure and report execution time of individual tests
spc lazy compilation
spc return_call_indirect
wizeng trace calls
fast-int stack traces for wasm traps
spc implement state splitting/merging
ext tail-call
v3-int print value stack / call stack in tracing mode
probes Probes should support full frame access
wizeng run start function of modules
func-refs no subtyping for function references without gc proposal
gc new array opcodes
fast-int scan value stack for GC
interpreter rename Xcode to sidetable
fast-int support main loop probe
fast-int support extended LEB secondary opcodes
gc Refactor type comparison for iso-recursion
validate implement simd
opcodes add simd
fast-int tagless interpreter
fast-int support instruction probes
interpreter reimplement break support using probes
interpreter reimplement timeout support using probes
interpreter support probes
fast-int Implement tail calls
fast-int Implement BREAK opcode
fast-int save VSP into ValueStack for runtime calls
fast-int Direct calls to runtime functions
fast-int Include descriptions of interpreter frames in fatal errors
wizeng trace imports/modules
fast-int scan interpreter frames for GC
trace Unify all tracing patterns as if(Trace.foo)
build sense host platform
fast-int skip tag for ref<T> types
fast-int allocate binary space for interpreter code
fast-int gen code into global array
fast-int 4 byte entries in dispatch table
interpreter factor context out of v3 int and fast int
test support TEST_TARGET= for all tests
fast-int refactor codegen to eliminate looping over bytecodes
runtime Fast native memories (pointer, memmap)
binary Parse names section
trace Reuse opcode renderer across calls
unit Improve overall unit testing framework
validator bug: Unreachable in one-armed if-value
wave implementation to bootstrap Virgil
instance Write unit tests for instantiation
interpreter test host functions
interpreter multivalue blocks, loops
ext bulk_memory
ext reference_types
ext sign_extension
ext tail_call: interpreter
ext multiple_memories
ext non_trapping_fic
spec floating point opcodes
interpreter floating point
ext tail_call: opcodes and validation
spec spectest includes 0xFFFE and 0xFFFF special characters
binparse offsets for errors incorrectly buffer relative
binparse reduce type specialization of readMultiple<T>
validator check for mutability of global in write
spec subnormal floats
spec br_table popcount bug
spec br_table merging of types
spec binary LEB 5-byte limit
spec elements bugs
spec duplicate export name
spec invalid memory flags
spec parse unicode escapes in strings
spec assign to immutable global
spec invalid global flags
spec assert_trap of module: start function
spec UTF-8 encoding
spec br_if bugs
util use "def var" Virgil feature for .length
spec support _ in literals
binparse tests for streaming
config properly check config settings for decoding and running
instance move oom logic into instantiator, out of constructors
trace Always use StringBuffer.out(STDOUT)
validator multivalue blocks, loops
test spec test loader and runner
interpreter memory index decoding
core introduce Extension enum
binparse double check memory operand decoding
validator check alignment of memory operators
interpreter convert unit tests to params, results order
binparse write tests for binary decoding