Skip to content

Commit 3426509

Browse files
MaartenS11MaartenS11
committed
Use logger in woodstate so it doesn't print at all times
1 parent 7c67eb6 commit 3426509

2 files changed

Lines changed: 75 additions & 71 deletions

File tree

‎build.gradle.kts‎

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -29,6 +29,9 @@ dependencies {
2929
// Needed for AssemblyScript source mapping:
3030
//implementation("com.atlassian.sourcemap:sourcemap:2.0.0")
3131
implementation("com.google.code.gson:gson:2.11.0")
32+
33+
// Logging
34+
implementation("ch.qos.logback:logback-classic:1.5.32")
3235
}
3336

3437
tasks.test {

‎src/main/kotlin/be/ugent/topl/mio/woodstate/WOODState.kt‎

Lines changed: 72 additions & 71 deletions
Original file line numberDiff line numberDiff line change
@@ -9,6 +9,7 @@ import com.fasterxml.jackson.databind.JsonNode
99
import com.fasterxml.jackson.databind.ObjectMapper
1010
import com.fasterxml.jackson.databind.annotation.JsonDeserialize
1111
import com.fasterxml.jackson.module.kotlin.registerKotlinModule
12+
import org.slf4j.LoggerFactory
1213
import java.io.IOException
1314
import java.util.*
1415

@@ -163,6 +164,7 @@ class WOODState(woodResponse: WOODDumpResponse) {
163164
private val unparsedJSON = ""
164165
public val callbacks = ""
165166
private val woodResponse: WOODDumpResponse = woodResponse
167+
private val logger = LoggerFactory.getLogger(WOODState::class.java)
166168

167169
fun getState(): WOODDumpResponse {
168170
return this.woodResponse
@@ -202,9 +204,9 @@ class WOODState(woodResponse: WOODDumpResponse) {
202204
if (bps == null) {
203205
return
204206
}
205-
println("==============")
206-
println("Breakpoints")
207-
println("--------------")
207+
logger.trace("==============")
208+
logger.trace("Breakpoints")
209+
logger.trace("--------------")
208210
val ws = this
209211
val nrBytesUsedForAmountBPs = 1 * 2
210212
val headerSize = ExecutionStateType.breakpointState.hexStr.length + nrBytesUsedForAmountBPs
@@ -217,7 +219,7 @@ class WOODState(woodResponse: WOODDumpResponse) {
217219
}
218220
val bps = breakpoints.slice(0 ..< fits).joinToString("")
219221
val amountBPs = HexaEncoder.serializeUInt8(fits)
220-
println("Breakpoints: amount=${breakpoints.size}")
222+
logger.trace("Breakpoints: amount=${breakpoints.size}")
221223
val payload = "${ExecutionStateType.breakpointState}${amountBPs}${bps}"
222224
stateMsgs.addPayload(payload)
223225
breakpoints = breakpoints.slice(fits ..< breakpoints.size)
@@ -231,12 +233,11 @@ class WOODState(woodResponse: WOODDumpResponse) {
231233
if (this.woodResponse.stack == null) {
232234
return
233235
}
234-
println("==============")
235-
println("STACK")
236-
println("--------------")
237-
println("Total Stack length ${this.woodResponse.stack.size}")
236+
logger.trace("==============")
237+
logger.trace("STACK")
238+
logger.trace("--------------")
239+
logger.trace("Total Stack length {}", this.woodResponse.stack.size)
238240

239-
val ws = this
240241
var stack = this.woodResponse.stack.map{ v -> serializeValue(v) }
241242
val nrBytesUsedForAmountVals = 2 * 2
242243
val headerSize = ExecutionStateType.stackState.length + nrBytesUsedForAmountVals
@@ -250,7 +251,7 @@ class WOODState(woodResponse: WOODDumpResponse) {
250251
val payload = "${ExecutionStateType.stackState}${amountVals}${vals}"
251252
stateMsgs.addPayload(payload)
252253
stack = stack.slice(fit ..< stack.size)
253-
println("msg: AmountStackValues ${fit}")
254+
logger.trace("msg: AmountStackValues ${fit}")
254255
}
255256
}
256257

@@ -261,11 +262,11 @@ class WOODState(woodResponse: WOODDumpResponse) {
261262
if (this.woodResponse.table == null) {
262263
return
263264
}
264-
println("==============")
265-
println("TABLE")
266-
println("--------------")
265+
logger.trace("==============")
266+
logger.trace("TABLE")
267+
logger.trace("--------------")
267268
var elements = this.woodResponse.table.elements.map{ HexaEncoder.serializeUInt32BE(it) }
268-
println("Total Elements ${this.woodResponse.table.elements.size}")
269+
logger.trace("Total Elements ${this.woodResponse.table.elements.size}")
269270
val nrBytesUsedForAmountElements = 4 * 2
270271
val headerSize = ExecutionStateType.tableState.length + nrBytesUsedForAmountElements
271272
while (elements.size != 0) {
@@ -277,7 +278,7 @@ class WOODState(woodResponse: WOODDumpResponse) {
277278
val amountElements = HexaEncoder.serializeUInt32BE(fit)
278279
val elems = elements.slice(0 ..< fit).joinToString("")
279280
val el_str = this.woodResponse.table.elements .slice(0 ..< fit).map{ e -> e.toString() }.joinToString(", ")
280-
println("msg: amountElements ${fit} elements ${el_str}")
281+
logger.trace("msg: amountElements ${fit} elements ${el_str}")
281282
val payload = "${ExecutionStateType.tableState}${amountElements}${elems}"
282283
stateMsgs.addPayload(payload)
283284
elements = elements .slice(fit ..< elements.size)
@@ -291,10 +292,10 @@ class WOODState(woodResponse: WOODDumpResponse) {
291292
if (this.woodResponse.callstack == null) {
292293
return
293294
}
294-
println("==============")
295-
println("CallStack")
296-
println("--------------")
297-
println("Total Frames ${this.woodResponse.callstack.size}")
295+
logger.trace("==============")
296+
logger.trace("CallStack")
297+
logger.trace("--------------")
298+
logger.trace("Total Frames {}", this.woodResponse.callstack.size)
298299

299300
var frames = this.woodResponse.callstack.map{ f -> serializeFrame(f) }
300301
val nrBytesUsedForAmountFrames = 2 * 2
@@ -307,7 +308,7 @@ class WOODState(woodResponse: WOODDumpResponse) {
307308
}
308309
val amountFrames = HexaEncoder.serializeUInt16BE(fit)
309310
val fms = frames.slice(0 ..< fit).joinToString("")
310-
println("msg: amountFrames=${fit}")
311+
logger.trace("msg: amountFrames={}", fit)
311312
val payload = "${ExecutionStateType.callstackState}${amountFrames}${fms}"
312313
stateMsgs.addPayload(payload)
313314
frames = frames .slice(fit ..< frames.size)
@@ -321,11 +322,11 @@ class WOODState(woodResponse: WOODDumpResponse) {
321322
if (this.woodResponse.globals == null) {
322323
return
323324
}
324-
println("==============")
325-
println("GLOBALS")
326-
println("--------------")
325+
logger.trace("==============")
326+
logger.trace("GLOBALS")
327+
logger.trace("--------------")
327328

328-
println("Total Globals ${this.woodResponse.globals.size}")
329+
logger.trace("Total Globals {}", this.woodResponse.globals.size)
329330
val ws = this
330331
var globals = this.woodResponse.globals.map{ v -> serializeValue(v) }
331332
val nrBytesNeededForAmountGlbs = 4 * 2
@@ -341,7 +342,7 @@ class WOODState(woodResponse: WOODDumpResponse) {
341342
val payload = "${ExecutionStateType.globalsState}${amountGlobals}${glbs}"
342343
stateMsgs.addPayload(payload)
343344
globals = globals .slice(fit ..< globals.size)
344-
println("msg: AmountGlobals ${fit}")
345+
logger.trace("msg: AmountGlobals {}", fit)
345346
}
346347
}
347348

@@ -352,29 +353,29 @@ class WOODState(woodResponse: WOODDumpResponse) {
352353
if (this.woodResponse.memory == null) {
353354
return
354355
}
355-
println("==============")
356-
println("Memory")
357-
println("--------------")
356+
logger.trace("==============")
357+
logger.trace("Memory")
358+
logger.trace("--------------")
358359
val sizeHeader = ExecutionStateType.memState.length + 4 * 2 + 4 * 2 + 4 * 2
359360
/*val testArray = ByteArray(65536 / 2)
360361
Random(42).nextBytes(testArray)
361362
var bytes = testArray.map{ b -> HexFormat.of().formatHex(byteArrayOf(b)) }*/
362363
var bytes = this.woodResponse.memory.bytes.map{ b -> HexFormat.of().formatHex(byteArrayOf(b)) }
363-
println("Total Memory Bytes ${this.woodResponse.memory.bytes.size}")
364+
logger.trace("Total Memory Bytes {}", this.woodResponse.memory.bytes.size)
364365
var startMemIdx = 0
365366
var endMemIdx = 0
366367
while (bytes.isNotEmpty()) {
367368
// Step 1. Check how much space we still have.
368369
val freeSpace = stateMsgs.getFreeSpace() - sizeHeader
369-
println("Free space = $freeSpace")
370+
logger.trace("Free space = {}", freeSpace)
370371
// Step 2. Compress the remaining bytes so that the compressed output is at most length freeSpace
371372
val (compressed, consumed) = compressRLE(bytes, freeSpace)
372-
println("Compressed = ${compressed.size}, consumed = $consumed")
373+
logger.trace("Compressed = {}, consumed = {}", compressed.size, consumed)
373374

374375
compressed.forEach {
375376
if (it.length != 2) throw Exception()
376377
}
377-
println(stateMsgs.howManyFit(sizeHeader, compressed))
378+
logger.trace("Fit = {}", stateMsgs.howManyFit(sizeHeader, compressed))
378379
if (stateMsgs.howManyFit(sizeHeader, compressed) != compressed.size) {
379380
throw Exception("Invalid")
380381
}
@@ -385,8 +386,8 @@ class WOODState(woodResponse: WOODDumpResponse) {
385386
val endMemIdxHexa = HexaEncoder.serializeUInt32BE(endMemIdx)
386387
val count = HexaEncoder.serializeUInt32BE(bytesHexa.length/2)
387388
val payload = "${ExecutionStateType.memState}${startMemIdxHexa}${endMemIdxHexa}${count}${bytesHexa}"
388-
println("Start position = $startMemIdx $startMemIdxHexa ${startMemIdx + consumed - 1} $endMemIdxHexa")
389-
println("Bytes payload: $payload")
389+
logger.trace("Start position = $startMemIdx $startMemIdxHexa ${startMemIdx + consumed - 1} $endMemIdxHexa")
390+
logger.trace("Bytes payload: $payload")
390391
stateMsgs.addPayload(payload)
391392
startMemIdx = endMemIdx + 1
392393

@@ -405,10 +406,10 @@ class WOODState(woodResponse: WOODDumpResponse) {
405406
if (this.woodResponse.br_table == null) {
406407
return
407408
}
408-
println("==============")
409-
println("BRTable")
410-
println("--------------")
411-
println("Total Labels ${this.woodResponse.br_table.labels.size}")
409+
logger.trace("==============")
410+
logger.trace("BRTable")
411+
logger.trace("--------------")
412+
logger.trace("Total Labels ${this.woodResponse.br_table.labels.size}")
412413

413414
var elements = this.woodResponse.br_table.labels.map{ HexaEncoder.serializeUInt32BE(it) }
414415
val sizeHeader = ExecutionStateType.branchingTableState.length + 2 * 2 + 2 * 2
@@ -426,7 +427,7 @@ class WOODState(woodResponse: WOODDumpResponse) {
426427
val endTblIdxHexa = HexaEncoder.serializeUInt16BE(endTblIdx)
427428
val payload = "${ExecutionStateType.branchingTableState}${startTblIdxHexa}${endTblIdxHexa}${elems}"
428429
stateMsgs.addPayload(payload)
429-
println("msg: startTblIdx=${startTblIdx} endTblIdx=${endTblIdx}")
430+
logger.trace("msg: startTblIdx=${startTblIdx} endTblIdx=${endTblIdx}")
430431
startTblIdx = endTblIdx + 1
431432

432433
elements = elements .slice(fit ..< elements.size)
@@ -439,11 +440,11 @@ class WOODState(woodResponse: WOODDumpResponse) {
439440
if (this.woodResponse.pc == null) {
440441
return
441442
}
442-
println("==========")
443-
println("PC")
444-
println("----------")
443+
logger.trace("==========")
444+
logger.trace("PC")
445+
logger.trace("----------")
445446
val ser = this.serializePointer(this.woodResponse.pc)
446-
println("PC: pc=${this.woodResponse.pc}")
447+
logger.trace("PC: pc=${this.woodResponse.pc}")
447448
val payload = "${ExecutionStateType.pcState}${ser}"
448449
stateMsgs.addPayload(payload)
449450
}
@@ -454,14 +455,14 @@ class WOODState(woodResponse: WOODDumpResponse) {
454455
throw Error("cannot serialise Allocaton Message when state is missing")
455456
}
456457

457-
println("==============")
458-
println("Allocate MSG")
459-
println("--------------")
458+
logger.trace("==============")
459+
logger.trace("Allocate MSG")
460+
logger.trace("--------------")
460461

461462
// Globals
462463

463464
val gblsAmountHex = HexaEncoder.serializeUInt32BE(wr.globals.size)
464-
println("Globals: total=${wr.globals.size}")
465+
logger.trace("Globals: total=${wr.globals.size}")
465466
val globals = "${ExecutionStateType.globalsState}${gblsAmountHex}"
466467

467468
// Table
@@ -470,13 +471,13 @@ class WOODState(woodResponse: WOODDumpResponse) {
470471
val tblSizeHex = HexaEncoder.serializeUInt32BE(wr.table.elements.size)
471472
val tbl = "${ExecutionStateType.tableState}${tblInitHex}${tblMaxHex}${tblSizeHex}"
472473

473-
println("Table: init=${wr.table.init} max=${wr.table.max} size=${wr.table.elements.size}")
474+
logger.trace("Table: init=${wr.table.init} max=${wr.table.max} size=${wr.table.elements.size}")
474475
// Memory
475476
val memInitHex = HexaEncoder.serializeUInt32BE(wr.memory.init)
476477
val memMaxHex = HexaEncoder.serializeUInt32BE(wr.memory.max)
477478
val memPagesHex = HexaEncoder.serializeUInt32BE(wr.memory.pages)
478479
val mem = "${ExecutionStateType.memState}${memMaxHex}${memInitHex}${memPagesHex}"
479-
println("Mem: max=${wr.memory.max} init=${wr.memory.init} pages=${wr.memory.pages}")
480+
logger.trace("Mem: max=${wr.memory.max} init=${wr.memory.init} pages=${wr.memory.pages}")
480481
val payload = "${globals}${tbl}${mem}"
481482

482483
stateMsgs.addPayload(payload)
@@ -515,25 +516,25 @@ class WOODState(woodResponse: WOODDumpResponse) {
515516
rest = this.serializePointer(frame.block_key)
516517
res_str = "block_key=${frame.block_key}"
517518
}
518-
println("Frame: type=${frame.type} sp=${frame.sp} fp=${frame.fp} ra=${frame.ra} ${res_str}")
519+
logger.trace("Frame: type=${frame.type} sp=${frame.sp} fp=${frame.fp} ra=${frame.ra} ${res_str}")
519520
return "${type}${sp}${fp}${ra}${rest}"
520521
}
521522

522523
private fun serializeException(stateMsgs: HexaStateMessages) {
523524
if (this.woodResponse.pc_error == null) {
524525
return
525526
}
526-
println("==========")
527-
println("PC_ERROR")
528-
println("----------")
527+
logger.trace("==========")
528+
logger.trace("PC_ERROR")
529+
logger.trace("----------")
529530
val pcError = this.serializePointer(this.woodResponse.pc_error)
530531
var exceptionMsg = ""
531532
var exceptionMsgSize = 0
532533
if (this.woodResponse.exception_msg != null && this.woodResponse.exception_msg != "") {
533534
exceptionMsg = this.woodResponse.exception_msg
534535
exceptionMsgSize = exceptionMsg.length
535536
}
536-
println("PC_ERROR: pc_error=${this.woodResponse.pc_error} exception_msg(#${exceptionMsgSize} chars)=${exceptionMsg}")
537+
logger.trace("PC_ERROR: pc_error=${this.woodResponse.pc_error} exception_msg(#${exceptionMsgSize} chars)=${exceptionMsg}")
537538
val sizeInHexa = HexaEncoder.serializeUInt32BE(exceptionMsgSize)
538539
val msgInHexa = HexaEncoder.serializeString(exceptionMsg)
539540
val payload = "${ExecutionStateType.errorState}${pcError}${sizeInHexa}${msgInHexa}"
@@ -548,10 +549,10 @@ class WOODState(woodResponse: WOODDumpResponse) {
548549
if (this.woodResponse.callbacks == null) {
549550
return
550551
}
551-
println("==============")
552-
println("CallbackMapping")
553-
println("--------------")
554-
println("Total Mappings ${this.woodResponse.callbacks.size}")
552+
logger.trace("==============")
553+
logger.trace("CallbackMapping")
554+
logger.trace("--------------")
555+
logger.trace("Total Mappings ${this.woodResponse.callbacks.size}")
555556

556557
val ws = this
557558
var mappings = this.woodResponse.callbacks.map{ f -> ws.serializeCallbackMapping(f) }
@@ -565,7 +566,7 @@ class WOODState(woodResponse: WOODDumpResponse) {
565566
}
566567
val amountMappings = HexaEncoder.serializeUInt32BE(fit)
567568
val fms = mappings .slice(0 ..< fit).joinToString("")
568-
println("msg: amountMappings=${fit}")
569+
logger.trace("msg: amountMappings=${fit}")
569570
val payload = "${ExecutionStateType.callbacksState}${amountMappings}${fms}"
570571
stateMsgs.addPayload(payload)
571572
mappings = mappings .slice(fit ..< mappings.size)
@@ -595,11 +596,11 @@ class WOODState(woodResponse: WOODDumpResponse) {
595596
if (woodResponse.io == null) {
596597
return
597598
}
598-
println("==============")
599-
println("IO")
600-
println("--------------")
599+
logger.trace("==============")
600+
logger.trace("IO")
601+
logger.trace("--------------")
601602
for (ioState in woodResponse.io) {
602-
println(HexaEncoder.serializeString(ioState.key) + HexaEncoder.serializeString("\u0000"))
603+
logger.trace(HexaEncoder.serializeString(ioState.key) + HexaEncoder.serializeString("\u0000"))
603604
}
604605
serializeList(stateMsgs, ExecutionStateType.ioState, woodResponse.io) {
605606
HexaEncoder.serializeString(it.key) + HexaEncoder.serializeString("\u0000") + HexaEncoder.serializeBool(it.output) + HexaEncoder.serializeUInt32BE(it.value)
@@ -610,10 +611,10 @@ class WOODState(woodResponse: WOODDumpResponse) {
610611
if (woodResponse.overrides == null) {
611612
return
612613
}
613-
println("==============")
614-
println("Overrides")
615-
println("--------------")
616-
println("Found ${woodResponse.overrides.size} active overrides.")
614+
logger.trace("==============")
615+
logger.trace("Overrides")
616+
logger.trace("--------------")
617+
logger.trace("Found ${woodResponse.overrides.size} active overrides.")
617618
serializeList(stateMsgs, ExecutionStateType.overridesState, woodResponse.overrides) {
618619
HexaEncoder.serializeUInt32BE(it.fidx) + HexaEncoder.serializeUInt32BE(it.arg) + HexaEncoder.serializeUInt32BE(it.return_value)
619620
}
@@ -631,7 +632,7 @@ class WOODState(woodResponse: WOODDumpResponse) {
631632
*/
632633
private fun <T> serializeList(stateMsgs: HexaStateMessages, execState: ExecutionStateType, list: List<T>, serializeElement: (T) -> String) {
633634
if (list.size >= 256) {
634-
System.err.println("WARNING: count might not fit!")
635+
logger.warn("WARNING: count might not fit!")
635636
}
636637
val elementCount = HexaEncoder.serializeUInt8(list.size)
637638
val headerSize = execState.length + elementCount.length
@@ -652,9 +653,9 @@ class WOODState(woodResponse: WOODDumpResponse) {
652653
val partialListPayload = serializedElements.slice(0 ..< fitCount).joinToString("")
653654
serializedElements = serializedElements.slice(fitCount ..< serializedElements.size)
654655
val payload = "${execState}${HexaEncoder.serializeUInt8(fitCount)}${partialListPayload}"
655-
println("execState = $execState")
656-
println("elementCount = $elementCount")
657-
println("partialListPayload = $partialListPayload")
656+
logger.trace("execState = {}", execState)
657+
logger.trace("elementCount = {}", elementCount)
658+
logger.trace("partialListPayload = {}", partialListPayload)
658659
stateMsgs.addPayload(payload)
659660
}
660661
}

0 commit comments

Comments
 (0)