I learn best when I have a working example I can poke and prod and tinker to see how it works. With Adafruit’s Uncanny Eye sort of running on my ESP32 running ESP_8_BIT code, I have a long list of things I could learn using this example as test case.
ESP32 CPU Core Allocation
Peter Barrett / rossumur of ESP_8_BIT said one of the things that made ESP_8_BIT run well were the two high performance cores available on an ESP32. Even the single-core variant only hiccups when accessing flash storage. When running on the more popular dual-core chips, core 0 handles running the emulator and core 1 handles the composite video signal generation. In
esp_8_bit.ino we see the
xTaskCreatePinnedToCore() call tying emulator to core 0, but I didn’t see why the Arduino default
loop() was necessarily on core 1. It’s certainly an assertion backed by claims elsewhere online, but I wanted to get to the source.
Digging through Espressif’s Arduino Core for ESP32 repository, I found the key is configuration parameter
ARDUINO_RUNNING_CORE. This is used to launch the task running Arduino
main.cpp. It is core 1 by default, but that’s not necessarily the case. The fact it is a project configuration parameter means it could be changed, but it’s not clear when we might want to do so.
Why is core 1 the preferred core for running our code? Again the convention wisdom here says this is because the WiFi stack on an ESP32 runs on core 0. But again, this is not necessarily the case. It is in fact possible to configure the WiFi task with a different core affinity than the default, but again it’s not clear when we might want to do so. But at least now I know where to look to see if someone has switched it up, in case that becomes an important data point for debugging or just understanding a piece of code.
ESP32 Memory Allocation
I knew a Harvard architecture microcontroller like the ESP32 doesn’t have the freedom of a large pool of universally applicable memory I can allocate at will. I remember I lost ability to run ESP_8_BIT in Atari mode due to a memory allocation issue, so I went back and re-read the documentation on ESP32 memory allocation. There is a lot of information in that section, and this wasn’t the first time I read it. Every time I do, I understand a little more.
My Atari emulator failure was its inability to get a large contiguous block of memory. For the best chances of getting this memory, the
MALLOC() allocator specified 32-bit accessible memory. This would open up areas that would otherwise be unavailable. But even with this mechanism, the Atari allocation failed. There are tools available to diagnose heap memory allocation problems and while it might be instructive to understand exactly why Atari emulator failed, I decided that’s not my top priority right now because I’m not using the Atari path.
I thought it was more important to better understand the video generation code, which I am using. I noticed methods in the video generation code were marked with
IRAM_ATTR and thought it was important to learn what that meant. I learned
IRAM_ATTR marked these as pieces of code that needs to stay in instruction RAM and not optimized out to flash memory. This is necessary for interrupt service routines registered with
But those are just the instructions, how about the data those pieces of code need? That’s the corresponding
DRAM_ATTR and I believe I need to add them to the palette tables. They are part of video generation, and they are constant unchanging values that the compiler/linker might be tempted to toss out to flash. But they must no be moved out because the video generation routine (including ISRs) need to access them, and if they are not immediately available in memory everything comes crashing down.
With these new nuggets of information now in my brain, I think I should try to turn this particular ESP32 adventure into something that would be useful to others.
2 thoughts on “ESP32 Lessons From ESP_8_BIT: CPU and Memory Allocation”
I have managed to get the Atari emulator to work with both cores.
The problem is that the memory consumption of core 0 has to be reduced. This can be done by reducing the stack size for core 0. For this I lower USING_DEFAULT_ARDUINO_LOOP_STACK_SIZE from 8192 to 6192 Bytes. (Arduino15\packages\esp32\hardware\esp32\1.0.6\cores\esp32\main.cpp)
The Atari needs more than 3KByte for core 1. So I increased this to 4KByte.
With these changes, the Atari emulator runs beautifully in 2 core mode.
This is a great tip, thanks. I’ll try it the next time I have ESP_8_BIT on my ESP32 connected to a composite video display.