commit a9b4e7601cbf521026dbc67adabc41e54cc9fc50 from: Matthias L. Jugel date: Tue Jan 15 13:58:35 2019 UTC add free block dump commit - 601f42667bb4b969a0d85090c28c53c445681b20 commit + a9b4e7601cbf521026dbc67adabc41e54cc9fc50 blob - c7d69705cf53531a05d97d641404660df1c3016e blob + e5501eed5fb859a9ec85c5172f296884f5716946 --- README.md +++ README.md @@ -11,22 +11,77 @@ Run with: `python3 memtrace.py /dev/cu.XXXXX 115200` The script auto-resets the counts and output looks like: ``` -HEAP 0: -heap_start : 0x20002950 -heap_end : 0x20003600 -heap_size : 3248 -[F:3248] -mb_total_free : 3248 +>> RESET HEAP COUNTERS >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> + (NUM) TOTAL [ ADDRESS] CHANGE (COMMENT) +[F:3760] +mb_total_free : 3760 mb_total_used : 0 -== (001) 56 [20002954] +56 (malloc: ALLOCATED: 56 [0x20002954]) -== (002) 76 [20002990] +20 (malloc: ALLOCATED: 20 [0x20002990]) -== (003) 124 [200029a8] +48 (malloc: ALLOCATED: 48 [0x200029a8]) -... -== (032) 1254 [20002e50] -18 (free: 0x20002e50) -== (031) 1229 [20002ea8] -25 (free: 0x20002ea8) -== (030) 1209 [20002e90] -20 (free: 0x20002e90) -... -Calliope Accelerometer Test v1.0 +== (001) 3704 [20002954] +56 (malloc: ALLOCATED: 56 [0x20002954]) +== (002) 3684 [20002990] +20 (malloc: ALLOCATED: 20 [0x20002990]) +== (003) 3636 [200029a8] +48 (malloc: ALLOCATED: 48 [0x200029a8]) +== (004) 3620 [200029dc] +16 (malloc: ALLOCATED: 16 [0x200029dc]) +== (005) 3580 [200029f0] +40 (malloc: ALLOCATED: 40 [0x200029f0]) +== (006) 3556 [20002a1c] +24 (malloc: ALLOCATED: 24 [0x20002a1c]) +== (007) 3516 [20002a38] +40 (malloc: ALLOCATED: 40 [0x20002a38]) +== (008) 3492 [20002a64] +24 (malloc: ALLOCATED: 24 [0x20002a64]) +== (009) 3484 [20002a80] +8 (malloc: ALLOCATED: 8 [0x20002a80]) +== (010) 3476 [20002a8c] +8 (malloc: ALLOCATED: 8 [0x20002a8c]) +== (011) 3384 [20002a98] +92 (malloc: ALLOCATED: 92 [0x20002a98]) +== (012) 3376 [20002af8] +8 (malloc: ALLOCATED: 8 [0x20002af8]) +== (013) 3368 [20002b04] +8 (malloc: ALLOCATED: 8 [0x20002b04]) +== (014) 3256 [20002b10] +112 (malloc: ALLOCATED: 112 [0x20002b10]) +== (015) 3216 [20002b84] +40 (malloc: ALLOCATED: 40 [0x20002b84]) +== (016) 3192 [20002bb0] +24 (malloc: ALLOCATED: 24 [0x20002bb0]) +== (017) 3179 [20002bcc] +13 (malloc: ALLOCATED: 13 [0x20002bcc]) +== (018) 3087 [20002be0] +92 (malloc: ALLOCATED: 92 [0x20002be0]) +== (019) 2995 [20002c40] +92 (malloc: ALLOCATED: 92 [0x20002c40]) +== (020) 2955 [20002ca0] +40 (malloc: ALLOCATED: 40 [0x20002ca0]) +== (021) 2915 [20002ccc] +40 (malloc: ALLOCATED: 40 [0x20002ccc]) +== (022) 2903 [20002cf8] +12 (malloc: ALLOCATED: 12 [0x20002cf8]) +== (023) 2863 [20002d08] +40 (malloc: ALLOCATED: 40 [0x20002d08]) +== (024) 2839 [20002d34] +24 (malloc: ALLOCATED: 24 [0x20002d34]) +== (025) 2815 [20002d50] +24 (malloc: ALLOCATED: 24 [0x20002d50]) +== (026) 2591 [20002d6c] +224 (malloc: ALLOCATED: 224 [0x20002d6c]) +!! (026) WARN: free(0x0x20002d50) +== (026) 2591 [ 0] -0 (free: 0x20002d50) +== (026) 2581 [20002d50] +10 (malloc: ALLOCATED: 10 [0x20002d50]) +== (027) 2571 [20002e50] +10 (malloc: ALLOCATED: 10 [0x20002e50]) +== (028) 2561 [20002e60] +10 (malloc: ALLOCATED: 10 [0x20002e60]) +== (029) 2546 [20002e70] +15 (malloc: ALLOCATED: 15 [0x20002e70]) +!! (029) WARN: free(0x0x20002e60) +== (029) 2546 [ 0] -0 (free: 0x20002e60) +!! (029) WARN: free(0x0x20002e50) +== (029) 2546 [ 0] -0 (free: 0x20002e50) +== (029) 2528 [20002e50] +18 (malloc: ALLOCATED: 18 [0x20002e50]) +== (030) 2521 [20002d60] +7 (malloc: ALLOCATED: 7 [0x20002d60]) +== (031) 2515 [20002e84] +6 (malloc: ALLOCATED: 6 [0x20002e84]) +== (032) 2495 [20002e90] +20 (malloc: ALLOCATED: 20 [0x20002e90]) +== (033) 2470 [20002ea8] +25 (malloc: ALLOCATED: 25 [0x20002ea8]) +== (034) 2444 [20002ec8] +26 (malloc: ALLOCATED: 26 [0x20002ec8]) +!! (034) WARN: free(0x0x20002e50) +== (034) 2444 [ 0] -0 (free: 0x20002e50) +!! (034) WARN: free(0x0x20002ea8) +== (034) 2444 [ 0] -0 (free: 0x20002ea8) +!! (034) WARN: free(0x0x20002e90) +== (034) 2444 [ 0] -0 (free: 0x20002e90) +== (034) 2436 [20002e50] +8 (malloc: ALLOCATED: 8 [0x20002e50]) +== (035) 2116 [20002ee8] +320 (malloc: ALLOCATED: 320 [0x20002ee8]) +== (036) 2108 [20002e5c] +8 (malloc: ALLOCATED: 8 [0x20002e5c]) +== (036) 2088 [20002e90] +20 (malloc: ALLOCATED: 20 [0x20002e90]) +== (037) 1476 [2000302c] +612 (malloc: ALLOCATED: 612 [0x2000302c]) +== (037) 1456 [20002ea8] +20 (malloc: ALLOCATED: 20 [0x20002ea8]) +== (038) 1436 [20003294] +20 (malloc: ALLOCATED: 20 [0x20003294]) +== (039) 1400 [200032ac] +36 (malloc: ALLOCATED: 36 [0x200032ac]) +!! (039) WARN: free(0x0x20002e84) +== (039) 1400 [ 0] -0 (free: 0x20002e84) +!! (039) WARN: free(0x0x20002d60) +== (039) 1400 [ 0] -0 (free: 0x20002d60) +!! (039) WARN: free(0x0x20002ec8) +== (039) 1400 [ 0] -0 (free: 0x20002ec8) +!! (039) WARN: free(0x0x20002e70) +== (039) 1400 [ 0] -0 (free: 0x20002e70) +== (040) 1365 [20002e68] +35 (malloc: ALLOCATED: 35 [0x20002e68]) +== (041) 1344 [20002ec0] +21 (malloc: ALLOCATED: 21 [0x20002ec0]) ``` ## License blob - d7a7cf1684f1ec2a66b6292cd77dbd72d16160c7 blob + d4ab67d6da86298bc692c0f69a87e9b2ddca2d55 --- memtrace_calliope_trns.py +++ memtrace_calliope_trns.py @@ -101,15 +101,14 @@ class CalliopeDebugTransform(Transform): m = self.r_free.search(line) if m: out = "" - addr = 0 freed = 0 - if m.group(1) in self.mem: - addr = int(m.group(1), 16) + addr = int(m.group(1), 16) + if addr in self.mem: freed = self.mem[addr] self.allocated -= freed del self.mem[addr] else: - out += "\033[33m!! (%03d) WARN: free(0x%s)\033[0m\r\n" % (len(self.mem), m.group(1)) + out += "\033[33m!! (%03d) WARN: free(0x%x)\033[0m\r\n" % (len(self.mem), addr) free = self.max - self.allocated out += "\033[1m== (%03d) \033[3%sm%8d\033[0m [%8x] \033[92m-%-6d\033[0m (%s)\r\n" % \ @@ -122,23 +121,33 @@ class CalliopeDebugTransform(Transform): wanted = int(m.group(1)) out += "\033[31m!! (%03d) : malloc(): no free block of size %d\033[0m\r\n" % (len(self.mem), wanted) - out += "HEAP ALLOCATION:\r\n" mem = "" end = 0 for addr in range(self.heap_start, self.heap_end): - if addr in self.mem: - end = addr + self.mem[addr] + if addr+4 in self.mem: + start = addr+4 + end = addr+4 + self.mem[addr+4] if addr == end: end = 0 if end: - mem += "*" + if addr < start: mem += "%" + else: mem += "*" else: mem += "." + out += "HEAP ALLOCATION (% header | * data | . free)\r\n" for a in range(0, self.max, 64): out += "%06d %08x %s\r\n" % (a, self.heap_start + a, mem[a:a+64]) + addr = 0 + out += "\033[31m== Free blocks: ==\033[0m\r\n" + blocks = re.findall("[%*]+|[.]+", mem) + for b in blocks: + if len(b) > 4 and b[0] == '.': + out += "%08x %d bytes\r\n" % (self.heap_start + addr, len(b)) + addr += len(b) + return out # print all other lines as is, so we can still use the log functionality