I recently came across the malloc function. I wanted to test my understanding of it so I created a simple sketch, where I expected the memory allocation to fail. Here's the sketch:
void setup() {
// put your setup code here, to run once:
Serial.begin(115200);
Serial.println("Hello");
uint8_t *buf = (uint8_t *)malloc(600000);
if(buf == NULL){
Serial.println("Memory Allocated Failed");
}
else{
Serial.println("Memory test Passed");
}
}
The issue is, this sketch doesn't fail. I'm using an adafruit bluefruit nRF52832. According to the IDE it has a max of 52224 bytes of dynamic memory. My assumption was that it would return a null pointer because I'm trying to allocate more memory than there is but the serial monitor keeps printing: "Memory Test Passed". Please explain why it is passing.
Check the docs or the source code to learn what actually happens. Keep in mind that any action taken should be based on the board you have selected in the IDE.
My assumption on what it would return is based on reading the docs. Haven't found anything that has suggested it behaves differently on different boards.
No, I'm not trolling, but I probably expected too much insight from you.
There is no operating system on Arduinos, no garbage collection and no memory management. Use of malloc() is strongly discouraged, because of severe limitations on memory and the unpredictability of collisions between heap and stack.
Arduino is a collection of stuff contributed by hundreds, if not thousands of people, covering several dozens of boards and manufacturers, with different CPUs, amounts of RAM and program memory.
There is no one to hold any contributor to accepted standards for C/C++. But, it is all FREE for the download, so you are getting much more than what you pay for.
nRF52832 is an ARM processor, so I wouldn't think that would be the case. But, you never know. It's worth a try. Otherwise, try this and see what it prints:
Even if malloc took a 16-bit unsigned integer (which it doesn't), 600,000 would be truncated to 10,176. malloc takes a size_t which on Arm is a 32-bit unsigned integer. malloc should return null in this case since it definitely should know that it can't satisfy a 600,000 byte allocation, even without taking the stack and BSS and such into account.
It is worth noting that if the OP had started with, say, a genuine Arduino Uno R3 (minus the silly integer error mentioned above), we never would have had this discussion.
This works as expected, according to the textbook theory:
void setup() {
// put your setup code here, to run once:
Serial.begin(115200);
Serial.println("Hello");
uint8_t *buf = (uint8_t *)malloc(10000);
if(buf == NULL){
Serial.println("Memory Allocated Failed");
}
else{
Serial.println("Memory test Passed");
}
}
void loop(){}
I think the odds of a random Arduino user finding such an egregious fault in the implementation of malloc is about the same as the odds of a random Arduino user finding an egregious fault in the compiler. malloc has been implemented thousands of times on thousands of thousands of platforms over the last 50-60 years, and the implementer would have to be truly, massively, galactically incompetent to screw it up as badly as it being suggested here.
I suppose some platform dependent implementation of the NULL macro could also be responsible. In strange cases it is always worth looking first in Arduino.h and ensure compiler warnings are enabled in the IDE.
Did you actually try running this code on your UNO?
coz I did and it did returned "Memory Allocated Failed" as expected!
I guess in IDE when compilng it has no way of cross-referencing the various board memory sizes against the actual code to return any potential memory related issued!
Instead of one massive request, make a number of smaller ones, and PRINT the return values
Write a simple function to PRINT out the memory linked list at the start, and again after each call to malloc. Then we can SEE exactly what is happening.
This will eliminate speculation, and provide actual, factual data.
