Skip to content

Commit 77806ae

Browse files
MaartenS11MaartenS11
committed
Use logger in woodstate so it doesn't print at all times
1 parent e93d014 commit 77806ae

2 files changed

Lines changed: 75 additions & 70 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 & 70 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,10 +233,10 @@ 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

239241
val ws = this
240242
var stack = this.woodResponse.stack.map{ v -> serializeValue(v) }
@@ -250,7 +252,7 @@ class WOODState(woodResponse: WOODDumpResponse) {
250252
val payload = "${ExecutionStateType.stackState}${amountVals}${vals}"
251253
stateMsgs.addPayload(payload)
252254
stack = stack.slice(fit ..< stack.size)
253-
println("msg: AmountStackValues ${fit}")
255+
logger.trace("msg: AmountStackValues ${fit}")
254256
}
255257
}
256258

@@ -261,11 +263,11 @@ class WOODState(woodResponse: WOODDumpResponse) {
261263
if (this.woodResponse.table == null) {
262264
return
263265
}
264-
println("==============")
265-
println("TABLE")
266-
println("--------------")
266+
logger.trace("==============")
267+
logger.trace("TABLE")
268+
logger.trace("--------------")
267269
var elements = this.woodResponse.table.elements.map{ HexaEncoder.serializeUInt32BE(it) }
268-
println("Total Elements ${this.woodResponse.table.elements.size}")
270+
logger.trace("Total Elements ${this.woodResponse.table.elements.size}")
269271
val nrBytesUsedForAmountElements = 4 * 2
270272
val headerSize = ExecutionStateType.tableState.length + nrBytesUsedForAmountElements
271273
while (elements.size != 0) {
@@ -277,7 +279,7 @@ class WOODState(woodResponse: WOODDumpResponse) {
277279
val amountElements = HexaEncoder.serializeUInt32BE(fit)
278280
val elems = elements.slice(0 ..< fit).joinToString("")
279281
val el_str = this.woodResponse.table.elements .slice(0 ..< fit).map{ e -> e.toString() }.joinToString(", ")
280-
println("msg: amountElements ${fit} elements ${el_str}")
282+
logger.trace("msg: amountElements ${fit} elements ${el_str}")
281283
val payload = "${ExecutionStateType.tableState}${amountElements}${elems}"
282284
stateMsgs.addPayload(payload)
283285
elements = elements .slice(fit ..< elements.size)
@@ -291,10 +293,10 @@ class WOODState(woodResponse: WOODDumpResponse) {
291293
if (this.woodResponse.callstack == null) {
292294
return
293295
}
294-
println("==============")
295-
println("CallStack")
296-
println("--------------")
297-
println("Total Frames ${this.woodResponse.callstack.size}")
296+
logger.trace("==============")
297+
logger.trace("CallStack")
298+
logger.trace("--------------")
299+
logger.trace("Total Frames {}", this.woodResponse.callstack.size)
298300

299301
var frames = this.woodResponse.callstack.map{ f -> serializeFrame(f) }
300302
val nrBytesUsedForAmountFrames = 2 * 2
@@ -307,7 +309,7 @@ class WOODState(woodResponse: WOODDumpResponse) {
307309
}
308310
val amountFrames = HexaEncoder.serializeUInt16BE(fit)
309311
val fms = frames.slice(0 ..< fit).joinToString("")
310-
println("msg: amountFrames=${fit}")
312+
logger.trace("msg: amountFrames={}", fit)
311313
val payload = "${ExecutionStateType.callstackState}${amountFrames}${fms}"
312314
stateMsgs.addPayload(payload)
313315
frames = frames .slice(fit ..< frames.size)
@@ -321,11 +323,11 @@ class WOODState(woodResponse: WOODDumpResponse) {
321323
if (this.woodResponse.globals == null) {
322324
return
323325
}
324-
println("==============")
325-
println("GLOBALS")
326-
println("--------------")
326+
logger.trace("==============")
327+
logger.trace("GLOBALS")
328+
logger.trace("--------------")
327329

328-
println("Total Globals ${this.woodResponse.globals.size}")
330+
logger.trace("Total Globals {}", this.woodResponse.globals.size)
329331
val ws = this
330332
var globals = this.woodResponse.globals.map{ v -> serializeValue(v) }
331333
val nrBytesNeededForAmountGlbs = 4 * 2
@@ -341,7 +343,7 @@ class WOODState(woodResponse: WOODDumpResponse) {
341343
val payload = "${ExecutionStateType.globalsState}${amountGlobals}${glbs}"
342344
stateMsgs.addPayload(payload)
343345
globals = globals .slice(fit ..< globals.size)
344-
println("msg: AmountGlobals ${fit}")
346+
logger.trace("msg: AmountGlobals {}", fit)
345347
}
346348
}
347349

@@ -352,29 +354,29 @@ class WOODState(woodResponse: WOODDumpResponse) {
352354
if (this.woodResponse.memory == null) {
353355
return
354356
}
355-
println("==============")
356-
println("Memory")
357-
println("--------------")
357+
logger.trace("==============")
358+
logger.trace("Memory")
359+
logger.trace("--------------")
358360
val sizeHeader = ExecutionStateType.memState.length + 4 * 2 + 4 * 2 + 4 * 2
359361
/*val testArray = ByteArray(65536 / 2)
360362
Random(42).nextBytes(testArray)
361363
var bytes = testArray.map{ b -> HexFormat.of().formatHex(byteArrayOf(b)) }*/
362364
var bytes = this.woodResponse.memory.bytes.map{ b -> HexFormat.of().formatHex(byteArrayOf(b)) }
363-
println("Total Memory Bytes ${this.woodResponse.memory.bytes.size}")
365+
logger.trace("Total Memory Bytes {}", this.woodResponse.memory.bytes.size)
364366
var startMemIdx = 0
365367
var endMemIdx = 0
366368
while (bytes.isNotEmpty()) {
367369
// Step 1. Check how much space we still have.
368370
val freeSpace = stateMsgs.getFreeSpace() - sizeHeader
369-
println("Free space = $freeSpace")
371+
logger.trace("Free space = {}", freeSpace)
370372
// Step 2. Compress the remaining bytes so that the compressed output is at most length freeSpace
371373
val (compressed, consumed) = compressRLE(bytes, freeSpace)
372-
println("Compressed = ${compressed.size}, consumed = $consumed")
374+
logger.trace("Compressed = {}, consumed = {}", compressed.size, consumed)
373375

374376
compressed.forEach {
375377
if (it.length != 2) throw Exception()
376378
}
377-
println(stateMsgs.howManyFit(sizeHeader, compressed))
379+
logger.trace("Fit = {}", stateMsgs.howManyFit(sizeHeader, compressed))
378380
if (stateMsgs.howManyFit(sizeHeader, compressed) != compressed.size) {
379381
throw Exception("Invalid")
380382
}
@@ -385,8 +387,8 @@ class WOODState(woodResponse: WOODDumpResponse) {
385387
val endMemIdxHexa = HexaEncoder.serializeUInt32BE(endMemIdx)
386388
val count = HexaEncoder.serializeUInt32BE(bytesHexa.length/2)
387389
val payload = "${ExecutionStateType.memState}${startMemIdxHexa}${endMemIdxHexa}${count}${bytesHexa}"
388-
println("Start position = $startMemIdx $startMemIdxHexa ${startMemIdx + consumed - 1} $endMemIdxHexa")
389-
println("Bytes payload: $payload")
390+
logger.trace("Start position = $startMemIdx $startMemIdxHexa ${startMemIdx + consumed - 1} $endMemIdxHexa")
391+
logger.trace("Bytes payload: $payload")
390392
stateMsgs.addPayload(payload)
391393
startMemIdx = endMemIdx + 1
392394

@@ -405,10 +407,10 @@ class WOODState(woodResponse: WOODDumpResponse) {
405407
if (this.woodResponse.br_table == null) {
406408
return
407409
}
408-
println("==============")
409-
println("BRTable")
410-
println("--------------")
411-
println("Total Labels ${this.woodResponse.br_table.labels.size}")
410+
logger.trace("==============")
411+
logger.trace("BRTable")
412+
logger.trace("--------------")
413+
logger.trace("Total Labels ${this.woodResponse.br_table.labels.size}")
412414

413415
var elements = this.woodResponse.br_table.labels.map{ HexaEncoder.serializeUInt32BE(it) }
414416
val sizeHeader = ExecutionStateType.branchingTableState.length + 2 * 2 + 2 * 2
@@ -426,7 +428,7 @@ class WOODState(woodResponse: WOODDumpResponse) {
426428
val endTblIdxHexa = HexaEncoder.serializeUInt16BE(endTblIdx)
427429
val payload = "${ExecutionStateType.branchingTableState}${startTblIdxHexa}${endTblIdxHexa}${elems}"
428430
stateMsgs.addPayload(payload)
429-
println("msg: startTblIdx=${startTblIdx} endTblIdx=${endTblIdx}")
431+
logger.trace("msg: startTblIdx=${startTblIdx} endTblIdx=${endTblIdx}")
430432
startTblIdx = endTblIdx + 1
431433

432434
elements = elements .slice(fit ..< elements.size)
@@ -439,11 +441,11 @@ class WOODState(woodResponse: WOODDumpResponse) {
439441
if (this.woodResponse.pc == null) {
440442
return
441443
}
442-
println("==========")
443-
println("PC")
444-
println("----------")
444+
logger.trace("==========")
445+
logger.trace("PC")
446+
logger.trace("----------")
445447
val ser = this.serializePointer(this.woodResponse.pc)
446-
println("PC: pc=${this.woodResponse.pc}")
448+
logger.trace("PC: pc=${this.woodResponse.pc}")
447449
val payload = "${ExecutionStateType.pcState}${ser}"
448450
stateMsgs.addPayload(payload)
449451
}
@@ -454,14 +456,14 @@ class WOODState(woodResponse: WOODDumpResponse) {
454456
throw Error("cannot serialise Allocaton Message when state is missing")
455457
}
456458

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

461463
// Globals
462464

463465
val gblsAmountHex = HexaEncoder.serializeUInt32BE(wr.globals.size)
464-
println("Globals: total=${wr.globals.size}")
466+
logger.trace("Globals: total=${wr.globals.size}")
465467
val globals = "${ExecutionStateType.globalsState}${gblsAmountHex}"
466468

467469
// Table
@@ -470,13 +472,13 @@ class WOODState(woodResponse: WOODDumpResponse) {
470472
val tblSizeHex = HexaEncoder.serializeUInt32BE(wr.table.elements.size)
471473
val tbl = "${ExecutionStateType.tableState}${tblInitHex}${tblMaxHex}${tblSizeHex}"
472474

473-
println("Table: init=${wr.table.init} max=${wr.table.max} size=${wr.table.elements.size}")
475+
logger.trace("Table: init=${wr.table.init} max=${wr.table.max} size=${wr.table.elements.size}")
474476
// Memory
475477
val memInitHex = HexaEncoder.serializeUInt32BE(wr.memory.init)
476478
val memMaxHex = HexaEncoder.serializeUInt32BE(wr.memory.max)
477479
val memPagesHex = HexaEncoder.serializeUInt32BE(wr.memory.pages)
478480
val mem = "${ExecutionStateType.memState}${memMaxHex}${memInitHex}${memPagesHex}"
479-
println("Mem: max=${wr.memory.max} init=${wr.memory.init} pages=${wr.memory.pages}")
481+
logger.trace("Mem: max=${wr.memory.max} init=${wr.memory.init} pages=${wr.memory.pages}")
480482
val payload = "${globals}${tbl}${mem}"
481483

482484
stateMsgs.addPayload(payload)
@@ -515,25 +517,25 @@ class WOODState(woodResponse: WOODDumpResponse) {
515517
rest = this.serializePointer(frame.block_key)
516518
res_str = "block_key=${frame.block_key}"
517519
}
518-
println("Frame: type=${frame.type} sp=${frame.sp} fp=${frame.fp} ra=${frame.ra} ${res_str}")
520+
logger.trace("Frame: type=${frame.type} sp=${frame.sp} fp=${frame.fp} ra=${frame.ra} ${res_str}")
519521
return "${type}${sp}${fp}${ra}${rest}"
520522
}
521523

522524
private fun serializeException(stateMsgs: HexaStateMessages) {
523525
if (this.woodResponse.pc_error == null) {
524526
return
525527
}
526-
println("==========")
527-
println("PC_ERROR")
528-
println("----------")
528+
logger.trace("==========")
529+
logger.trace("PC_ERROR")
530+
logger.trace("----------")
529531
val pcError = this.serializePointer(this.woodResponse.pc_error)
530532
var exceptionMsg = ""
531533
var exceptionMsgSize = 0
532534
if (this.woodResponse.exception_msg != null && this.woodResponse.exception_msg != "") {
533535
exceptionMsg = this.woodResponse.exception_msg
534536
exceptionMsgSize = exceptionMsg.length
535537
}
536-
println("PC_ERROR: pc_error=${this.woodResponse.pc_error} exception_msg(#${exceptionMsgSize} chars)=${exceptionMsg}")
538+
logger.trace("PC_ERROR: pc_error=${this.woodResponse.pc_error} exception_msg(#${exceptionMsgSize} chars)=${exceptionMsg}")
537539
val sizeInHexa = HexaEncoder.serializeUInt32BE(exceptionMsgSize)
538540
val msgInHexa = HexaEncoder.serializeString(exceptionMsg)
539541
val payload = "${ExecutionStateType.errorState}${pcError}${sizeInHexa}${msgInHexa}"
@@ -548,10 +550,10 @@ class WOODState(woodResponse: WOODDumpResponse) {
548550
if (this.woodResponse.callbacks == null) {
549551
return
550552
}
551-
println("==============")
552-
println("CallbackMapping")
553-
println("--------------")
554-
println("Total Mappings ${this.woodResponse.callbacks.size}")
553+
logger.trace("==============")
554+
logger.trace("CallbackMapping")
555+
logger.trace("--------------")
556+
logger.trace("Total Mappings ${this.woodResponse.callbacks.size}")
555557

556558
val ws = this
557559
var mappings = this.woodResponse.callbacks.map{ f -> ws.serializeCallbackMapping(f) }
@@ -565,7 +567,7 @@ class WOODState(woodResponse: WOODDumpResponse) {
565567
}
566568
val amountMappings = HexaEncoder.serializeUInt32BE(fit)
567569
val fms = mappings .slice(0 ..< fit).joinToString("")
568-
println("msg: amountMappings=${fit}")
570+
logger.trace("msg: amountMappings=${fit}")
569571
val payload = "${ExecutionStateType.callbacksState}${amountMappings}${fms}"
570572
stateMsgs.addPayload(payload)
571573
mappings = mappings .slice(fit ..< mappings.size)
@@ -595,11 +597,11 @@ class WOODState(woodResponse: WOODDumpResponse) {
595597
if (woodResponse.io == null) {
596598
return
597599
}
598-
println("==============")
599-
println("IO")
600-
println("--------------")
600+
logger.trace("==============")
601+
logger.trace("IO")
602+
logger.trace("--------------")
601603
for (ioState in woodResponse.io) {
602-
println(HexaEncoder.serializeString(ioState.key) + HexaEncoder.serializeString("\u0000"))
604+
logger.trace(HexaEncoder.serializeString(ioState.key) + HexaEncoder.serializeString("\u0000"))
603605
}
604606
serializeList(stateMsgs, ExecutionStateType.ioState, woodResponse.io) {
605607
HexaEncoder.serializeString(it.key) + HexaEncoder.serializeString("\u0000") + HexaEncoder.serializeBool(it.output) + HexaEncoder.serializeUInt32BE(it.value)
@@ -610,10 +612,10 @@ class WOODState(woodResponse: WOODDumpResponse) {
610612
if (woodResponse.overrides == null) {
611613
return
612614
}
613-
println("==============")
614-
println("Overrides")
615-
println("--------------")
616-
println("Found ${woodResponse.overrides.size} active overrides.")
615+
logger.trace("==============")
616+
logger.trace("Overrides")
617+
logger.trace("--------------")
618+
logger.trace("Found ${woodResponse.overrides.size} active overrides.")
617619
serializeList(stateMsgs, ExecutionStateType.overridesState, woodResponse.overrides) {
618620
HexaEncoder.serializeUInt32BE(it.fidx) + HexaEncoder.serializeUInt32BE(it.arg) + HexaEncoder.serializeUInt32BE(it.return_value)
619621
}
@@ -631,7 +633,7 @@ class WOODState(woodResponse: WOODDumpResponse) {
631633
*/
632634
private fun <T> serializeList(stateMsgs: HexaStateMessages, execState: ExecutionStateType, list: List<T>, serializeElement: (T) -> String) {
633635
if (list.size >= 256) {
634-
System.err.println("WARNING: count might not fit!")
636+
logger.warn("WARNING: count might not fit!")
635637
}
636638
val elementCount = HexaEncoder.serializeUInt8(list.size)
637639
val headerSize = execState.length + elementCount.length
@@ -652,9 +654,9 @@ class WOODState(woodResponse: WOODDumpResponse) {
652654
val partialListPayload = serializedElements.slice(0 ..< fitCount).joinToString("")
653655
serializedElements = serializedElements.slice(fitCount ..< serializedElements.size)
654656
val payload = "${execState}${HexaEncoder.serializeUInt8(fitCount)}${partialListPayload}"
655-
println("execState = $execState")
656-
println("elementCount = $elementCount")
657-
println("partialListPayload = $partialListPayload")
657+
logger.trace("execState = {}", execState)
658+
logger.trace("elementCount = {}", elementCount)
659+
logger.trace("partialListPayload = {}", partialListPayload)
658660
stateMsgs.addPayload(payload)
659661
}
660662
}

0 commit comments

Comments
 (0)