Radical surgery: Slimming Pebble apps down to run on Aplite
A long way to go
In December 2015, when first I released Powernoter, an unofficial Evernote client for the Pebble Watch, I initially targeted Pebble Time (codename Basalt), and Pebble Time Round (codename Chalk).
After all there was already the official Evernote Pebble app (which I also created) for the original Pebble (codename Aplite).
Then Pebble released a firmware update and SDK for the original Pebble which meant that I could easily release Powernoter for the original Pebble too, using the same SDK I’d already used.
This is the build log from the first time I built Powernoter targeting Aplite (the original Pebble), Basalt (Pebble Time) and Chalk (Pebble Time Round):
-------------------------------------------------------
BASALT APP MEMORY USAGE
Total size of resources: 26461 bytes / 256KB
Total footprint in RAM: 25895 bytes / 64KB
Free RAM available (heap): 39641 bytes
-------------------------------------------------------
...
-------------------------------------------------------
CHALK APP MEMORY USAGE
Total size of resources: 26461 bytes / 256KB
Total footprint in RAM: 25943 bytes / 64KB
Free RAM available (heap): 39593 bytes
-------------------------------------------------------
...
-------------------------------------------------------
APLITE APP MEMORY USAGE
Total size of resources: 26341 bytes / 125KB
Total footprint in RAM: 23789 bytes / 24KB
Free RAM available (heap): 787 bytes
-------------------------------------------------------
See the 787 bytes on the last line? That was how much free memory my app had before it even started running on an original Pebble. Before it created its first window or allocated memory to receive and send messages.
Although I successfully built Powernoter for Aplite, it couldn’t even start up, crashing immediately as it ran out of memory.
Not so verbose with the error messages
The first thing I did, was to run the pebble analyze-size command, which gave me a sense of where the memory was being used.
Like all good programmers, I very carefully and very consistently checked all OS calls for out of memory situations, and logged (very) verbose messages if I ran out of memory. Like this:
bitmap_layer = bitmap_layer_create(image_layer_size);
if(!bitmap_layer) {
APP_LOG(APP_LOG_LEVEL_ERROR, "Couldn&'t allocate memory for the image");
...
All those strings had to be allocated somewhere. I went through my app and removed all those lovely descriptive messages. Instead I just logged the line number - that was enough to work out where it went wrong.
bitmap_layer = bitmap_layer_create(image_layer_size);
if(!bitmap_layer) {
OOMCF();
...
I defined a couple of macros for Out Of Memory (OOM) situations:
#define OOM(s) log_oom(__FILE_NAME__, __LINE__, (int)s)
#define OOMCF() log_create_failed(__FILE_NAME__, __LINE__)
void log_create_failed(char* file, int line) {
app_log(APP_LOG_LEVEL_DEBUG, file, line, "create failed %d free", (int)heap_bytes_free());
}
void log_oom(char* file, int line, int size) {
app_log(APP_LOG_LEVEL_DEBUG, file, line, "oom %d, %d", size, (int)heap_bytes_free());
}
I also declared some handy logging macros, so that debug log strings were stripped out of shipping builds
#ifdef SHIPPING
#define LOG_MEM_START()
#define LOG_MEM_END()
#define LOG_FUNC_START(name)
#define LOG_FUNC_END(name)
#define LOG_DBG(fmt, args...)
#define LOG_ERR(fmt, args...) app_log(APP_LOG_LEVEL_ERROR, __FILE_NAME__, __LINE__, " ")
#else
#define LOG_DBG(fmt, args...) app_log(APP_LOG_LEVEL_DEBUG, __FILE_NAME__, __LINE__, fmt, ## args)
#define LOG_MEM_START() app_log(APP_LOG_LEVEL_DEBUG, __FILE_NAME__, __LINE__, "start %d", (int)heap_bytes_free())
#define LOG_MEM_END() app_log(APP_LOG_LEVEL_DEBUG, __FILE_NAME__, __LINE__, "end %d", (int)heap_bytes_free())
#define LOG_FUNC_START(name) app_log(APP_LOG_LEVEL_DEBUG, __FILE_NAME__, __LINE__, "%s invoked", name)
#define LOG_FUNC_END(name) app_log(APP_LOG_LEVEL_DEBUG, __FILE_NAME__, __LINE__, "%s returning", name)
#define LOG_ERR(fmt, args...) app_log(APP_LOG_LEVEL_ERROR, __FILE_NAME__, __LINE__, fmt, ## args)
#endif
Use statics in moderation
Next I looked into how I was defining static variables. I like statics because they are only visible to the file in which they are declared: a primitive form of encapsulation. A typical C source file might have started with:
static CustomMenu* customMenu;
static CustomMenuItem* items;
static uint16_t itemCount;
static AppTimer *send_timeout_timer;
static NoteSelectedCallback noteSelectedCallback;
The types don’t matter (CustomMenu is my own class that does things like automatically scrolling long menu items).
What matters is that I have four pointers and a short declared as statics, meaning I have a whole chunk of memory statically allocated just for this one file.
Powernoter is not a small app … this multiplied by tens of files means that I had a load of memory statically allocated, which was never used unless the user was actually invoking the functionality represented by those files.
The solution was to move to a dynamically allocated memory:
typedef struct NoteList {
CustomMenu *customMenu;
CustomMenuItem *items;
uint16_t itemCount;
AppTimer *send_timeout_timer;
NoteSelectedCallback noteSelectedCallback;
} NoteList;
I only allocate a NoteList when it is being used, and free it as soon as possible.
Omit needless code
Although the SDK includes definitions for things like DictationSession on Aplite, so that code can be compiled regardless of the platform (you do need to check return calls though), it made no sense to include that code at all. I #ifdefed whole chunks of code to reduce the app size:
#ifdef SUPPORTS_VOICE
static void dictation_session_callback(DictationSession *session, DictationSessionStatus status,
char *transcription, void *context) {
LOG_FUNC_START("dictation_session_callback");
if(DictationSessionStatusSuccess == status) {
if(!noteContext->waitingAnimation) {
if(noteContext->customMenu) {
layer_set_hidden(custom_menu_get_layer(noteContext->customMenu), true);
}
...
}
#endif
SUPPORTS_VOICE is my own macro:
#ifndef PBL_PLATFORM_APLITE
#define SUPPORTS_VOICE
#else
#define LOW_MEMORY_DEVICE
#endif
Pebble have added a PBL_MICROPHONE macro so my use of SUPPORTS_VOICE is no longer necessary.
I did the same thing for animations and color support.
Although I think I am a decent enough software engineer, I am under few illusions as to my abilities as a designer, which is why I let you choose your very own foreground and background colors in Powernoter, except if you are running on an original Pebble, in which case all that code, including the color names, is #ifdefed out.
Be careful what you ask for (when calling app_message_xyz_maximum)
Once upon a time were were limited to 120 or so bytes per message sent between the watch and the phone. I wrote inordinately complex code to page menu items in dynamically from the phone to the watch so that you could scroll through infinitely long menus. Then Pebble gave us what we wanted, with massive (8Kish) message buffers.
When you only have a little memory free to start with, the last thing you want to do is go allocating 8K buffers. It won’t work.
My code to determine the size of the input buffer looks like this now:
#ifdef LOW_MEMORY_DEVICE
#define MAX_INBOX_SIZE 512
#else
#define MAX_INBOX_SIZE 4096
#endif
The LOW_MEMORY_DEVICE macro is set on Aplite only. Users on the original Pebble won’t see an enormous number of notes listed, or a lot of a note’s content, but at least they’ll see something.
Make long strings into Resources
There is an excellent Internationalization sample for the Pebble. Although Powernoter isn’t internationalized, there are no strings hardcoded in code … all strings are accessed via a single point. I include the strings in a single source file in the app, except for certain very long strings, such as the About page. These I load as resources from files:
static char* loadResource(uint32_t resourceId) {
ResHandle handle = resource_get_handle(resourceId);
size_t res_size = resource_size(handle);
// Copy to buffer
char* result = (char*)malloc(res_size + 1);
if(!result) {
OOM(res_size);
result = (char*)malloc(1);
if(result) {
*result = &'\0&';
}
return result;
}
resource_load(handle, (uint8_t*)result, res_size);
result[res_size] = &'\0&';
return result;
}
Once I’m done with them, I free them as quickly as possible.
Summary
In case you were wondering, this is how things look right now:
CHALK APP MEMORY USAGE
Total size of resources: 27313 bytes / 256KB
Total footprint in RAM: 24244 bytes / 64KB
Free RAM available (heap): 41292 bytes
-------------------------------------------------------
BASALT APP MEMORY USAGE
Total size of resources: 27313 bytes / 256KB
Total footprint in RAM: 24176 bytes / 64KB
Free RAM available (heap): 41360 bytes
-------------------------------------------------------
APLITE APP MEMORY USAGE
Total size of resources: 13966 bytes / 125KB
Total footprint in RAM: 17353 bytes / 24KB
Free RAM available (heap): 7223 bytes
-------------------------------------------------------
Getting from 787 bytes free to 7,223 bytes free, so that Powernoter can really run on Aplite involved many changes, some which I’d say were generally good practice (reducing statics and instead using structs which are allocated/freed), and some less so (removing error log messages).
In general I don’t think the code looks too unreadable as a result of supporting Aplite … certainly I’d prefer not to have as many #ifdefs sprinkled throughout my code as I have, but it’s not that bad.
You may also wish to check out this Pebble presentation on Pebble app memory usage.
One thing is for sure, the changes I had to make to Powernoter to get it to run on Aplite are nothing compared with the miracles the Pebble team pulled to get the original Pebble to support the same SDK as Pebble Time and Pebble Time Round.
About me
I’m an independent consultant and speaker, available for ad-hoc Pebble, Android and Android Wear and Tizen consulting and development.
If you like and use Powernoter, please consider supporting it.
On the other hand if something is missing or doesn’t work, check out this Trello board where you can comment to request enhancements or report bugs.