Concatenate utime.ticks_ms()

[MrGibbage]

Working on a Spike Prime. The following code works fine:

test = []
for i in range(0, 800):
    t = str(utime.ticks_ms())
    entry = "2655382 [Gyroturn] Current heading 35"
    test.append(entry)

but if I change it to

test = []
for i in range(0, 800):
    t = str(utime.ticks_ms())
    entry = t + " [Gyroturn] Current heading 35"
    test.append(entry)

I get an out of memory error
MemoryError: memory allocation failed, allocating 4096 bytes (on the append line)

Is there any way to concatenate the ticks to a string?

[dlech]

Do you have to have all of those strings in memory at the same time?

Just log the timestamp (as an int) in test and then print or save the strings to a file one at a time later.

[MrGibbage]

I don't necessarily need 800 items, but I will need a couple hundred. This is for a logging function and I don't want to write the log entries right away to save on the overhead for doing that. I just thought I'd save everything to a list and then dump the list to the storage at the end.

[rkompass]

entry = t + " [Gyroturn] Current heading 35" is very memory consuming. Every time a new string is created and consumes new memory. In the loop the garbage collector seems not to automatically collect.
You may try

test = []
for i in range(0, 800):
    entry = "%d  [Gyroturn] Current heading 35" % utime.ticks_ms()
    test.append(entry)

or

test = []
for i in range(0, 800):
    test.append("{:d}  [Gyroturn] Current heading 35".format(utime.ticks_ms()))

and thus avoid this waste of memory. Then only the growing test list consumes memory. Alternatively you do a gc.collect() in each 50-th iteration or so (which takes time).
Of course if you do not have to have the data in memory then printing to file (which may be not an option, also for timing reasons; i don't recall if this is blocking, but assume so) even avoids that the growing test list consumes the memory as dlech mentioned and then you should be able to iterate much further, given you avoid the string "+".

[MrGibbage]

the gc.collect works fine. It's a small delay (abt 40ms, which is acceptable for testing purposes). Thanks!

[rkompass]

I suggest then you store the time ticks in a pre-allocated array.array('I', (0 for _ in range(800))) and the heading in a similar array of typecode 'H'.

import gc
gc.collect(); f = gc.mem_free()
import array
import utime

ticks = array.array('I', (0 for _ in range(800)))
headings = array.array('H', (0 for _ in range(800)))

for i in range(0, 800):
    ticks[i] = utime.ticks_ms()
    headings[i] = 35

print('used memory:', f-gc.mem_free())

This consumes only about 1/10th of memory in my measurements. Arrays consume much less memory than lists. Also you
avoid storing the same "[Gyroturn] Current heading" phrase every time.
If you have several phrases assign numbers to them in a dict and store the numbers in an array too.
You then have the data and may compose the logging strings from them later.

[rkompass]

Of course as you have consecutive tick values you may store their differences (using ticks_diff()) and economize still more memory as you have now values that fit in a byte so you may use ticks_diffs = array.array('B', (0 for _ in range(800))) which consumes only 1/4 of the former versions ticks array.

[MrGibbage]

This is so helpful! Thanks :)

Like I said, this is for a logging function that I am writing to help me troubleshoot my Spike Prime robot. I know memory is limited, so every bit helps. Maybe you wouldn't mind taking a look at a program I am testing right now:
https://github.com/FLL-Team-24277/BaseRobotFall2022/blob/main/gyro_turn_test.py

The logging function is right at the top. I like your idea to put the ticks in a separate array, but I don't know that I need to put the message templates in a separate array (just yet). At this point, the truth is, I only have a couple of things to log, and when I am done troubleshooting, I'll be turning the logging off completely.

At this point it is working, and maybe it is Good Enough(tm) to get me through this troubleshoot. But my guess is, at some point I will need to start troubleshooting some other problem, and having a decent logger will be helpful. So having a robust and solid logger will come in handy. I do very much welcome your ideas for improvement.

[rkompass]

MP has a logging module and it has recently been updated and bumped to version 0.5 so I think it's definitely worth studying it.
I would rather suppose that compatibility with standard Python is the main goal here and I doubt that optimizations regarding memory usage in the case all messages are held in memory are made/planned.