Is free()ing memory on exit() really necessary in Pebble?

Question

In the More C Concepts (Google webcache, not on Internet Archive), I read the following:

When the app is exiting or when the buffer is no longer needed, the memory must be freed for applications to use:

// Free dynamically allocated memory
free(s_buffer);

In the Learning C for the Pebble SDK (Internet Archive), I read:

Unlike other languages (such as Python or JavaScript), the C language relies on the developers to manage any memory they use. This means that any memory allocated by a program for storing data must be freed up again by the developer so that other progams can make use of it.

I am used to programming on non-embedded scenarios where each application has its own address space and upon process termination the OS reclaims the memory allocated. However, the two above statements from Pebble’s SDK suggest that if I call malloc() and then the program exits or is killed before calling free() the watch will be unable to reclaim the memory. It also shows examples of deinitializing windows after the event loops exits, etc.

I was really hoping that if I needed to dynamically calculate a buffer size once at startup I could just not worry about cleaning it up before process exit. Of course, for things which have a shorter-than-process lifetime, I would need to track those and clean things up to avoid leaking and causing my app to run out of memory. But trying to do this for everything—and, more so, in a way that ensures that free() or *_deinit() gets called even when the program terminates uncleanly—seems both a waste of time and impossible.

How can one write a Pebble Watch app safely so that when the app is killed all allocated memory is deallocated? Or does Pebble’s OS track and clean up resources allocated by an app when it terminates like modern OSes?

Answer 1

The answer seems to be:

• Yes, everything will be cleaned up after you if your app exits, whether through a kill or a normal exit
• Ensuring 0B reported as still allocated on exit is good practice, since it helps prevent memory leaks.

As you've seen, the official documentation is almost entirely silent on the subject, so short of a statement by a Pebble dev we won't be able to get a definitive answer. We have a few options to come close, though: the first is to turn to the Pebble forums:

• "everything will get released when you exit the app, including the font. You do NOT have to free them by hand, but the size of unfreed memory (the memory that the system had to free for you) will still be reported as an information when you exit."

We can also check that most reliable source, Reddit's /r/pebbledevelopers, who claim:

• "the entire process will be killed on exit, so you don't technically have to worry about it. Cleaning up after yourself is a nice habit to get into, though."
• "When your app is closed, all memory it had allocated is freed. Strictly speaking, this means that deallocating things in your main window isn't necessary. However, making sure 0 bytes are allocated when you exit the app helps you prevent future problems."
• "all the memory you allocated is released by the system when your app is closed, so there's really no reason to shut it down."
• "It actually doesn't matter if you have memory still allocated when your watchface quits. The system frees up all the memory that you use automatically"

We may also look at this set of slides, particularly:

(I believe this only applies to Aplite, a.k.a. Pebble 1.O)

which would suggest that there's not much app "headroom" -- if an app or apps started leaking and weren't fully cleaned up by the OS, it would quickly make it impossible to launch new apps.

In conclusion: I wouldn't worry too much about it.