Question about different ways to declare objects and their effects on RAM usuage

system · August 31, 2012, 2:01pm

Long story short, I have what I believe is a memory leak in my sketch that's causing the value in a variable to change after returning from a function call (variable is not used in the function). My sketch uses several different libraries and one particular function makes calls to at least one member function in each of the libraries. I want to experiment on various ways to declare the objects in my sketch to try and minimize RAM usage so I'm looking for feedback on the pro's and con's on different ways to declare objects. Here are some basic concept sketches of what I've come up with on different ways to use the objects:

First case is what I'm currently doing. Declaring the objects globally and making calls to the member functions from the main sketch. Applying my basic knowledge of OOP, I'm thinking this particular usage may be causing my problems.

#include <classes.h>

Class1 c1;
Class2 c2;
Class3 c3;

void setup()
{
	c1.init();
	c2.init();
	c3.init();
}

void loop()
{
	ds();
}

void ds()
{
	c1.doSomething();
	c2.doSomething();
	c3.doSomething();
}

The second case, declares the objects in Setup() and the ds() function and not globally. My understanding of how constructors/destructors work is once both Setup() and ds() go out of scope (at the ending } ) the destructors are called and the memory is freed up for use by other variables.

#include <classes.h>

void setup()
{
	Class1 c1;
	Class2 c2;
	Class3 c3;
	c1.init();
	c2.init();
	c3.init();
}

void loop()
{
	ds();
}

void ds()
{
	Class1 c1;
	Class2 c2;
	Class3 c3;
	c1.doSomething();
	c2.doSomething();
	c3.doSomething();
}

Now if my above assumptions are correct, would encasing the object declaration and corresponding member function call within it's own curly braces maximize the amount of free RAM since it frees up each instance after it's used?

#include <classes.h>

void setup()
{
	{Class1 c1;c1.init();}
	{Class2 c2;c2.init();}
	{Class3 c3;c3.init();}
}

void loop()
{
	ds();
}

void ds()
{
	{Class1 c1;c1.doSomething();}
	{Class2 c2;c2.doSomething();}
	{Class3 c3;c3.doSomething();}
}

Again I realize these are basic examples but I believe you get the gist of what I'm trying to accomplish. Any input would be greatly appreciated.

system · August 31, 2012, 2:17pm

void setup()
{
	Class1 c1;
	Class2 c2;
	Class3 c3;
	c1.init();
	c2.init();
	c3.init();
}

void loop()
{
	ds();
}

This won't work, since the c1, c2, and c3 objects go out of scope when setup() ends and are undefined outside of setup. When you then try to reference them in ds(), you would cause all kinds of grief, but the compiler knows that you can't, because c1, c2, and c3 have scope that does not extend to ds().

	{Class1 c1;c1.init();}

In this case, c1 goes out of scope even sooner. It's scope does not extend to ds().

	{Class1 c1;c1.doSomething();}

Here you are creating a different instance called c1, and calling that instance's doSomething() method. This is not the same instance that was init()ed in setup().

system · August 31, 2012, 2:44pm

PaulS:
Here you are creating a different instance called c1, and calling that instance's doSomething() method. This is not the same instance that was init()ed in setup().

Thanks PaulS. I actually don't mind if the new instance is different from the first instance (as long as they're not duplicated in memory that is). Let's say one of the library's is for a device like an accelerometer (which it is) and the .init() call configures the data registers in the accelerometer only. I don't care if the instance of the object is destroyed at the end of Setup() as it's only function is to configure the accelerometer. Now later on I create another instance to access features of the accelerometer (grab X,Y,Z crunch some numbers, etc..) and once again don't care that it gets destroyed when it goes out of scope.

I guess what I'm ultimately asking is (and in retrospect should have phrased it this way):

Is dynamically creating instances of objects similar to using local variables in functions? I know in a function when you declare a local variable, it is freed from memory once you return from the function call. Does the same apply to an instance of an object when it goes out of scope? Are there any pro's or con's (related to RAM usage) with the three examples above?

system · August 31, 2012, 2:52pm

Is dynamically creating instances of objects similar to using local variables in functions?

Yes. The dynamically created objects go out of scope at the end of the block they are defined in, just like local variables. When they go out of scope, the desctructor is called, freeing the memory for other uses.

Are there any pro's or con's (related to RAM usage) with the three examples above?

Well, obviously the second example won't work, so you really only have two working examples. One uses global variables. The other uses local variables. If the objects don't need to persist information in the instance, then local variables will use less memory all the time. That's OK for some things, but not for others.

For the time the object exists, it uses the same amount of memory whether it is a local object, a static object, or a global object. Only its lifetime changes.

PGTBOOS · August 31, 2012, 2:53pm

this might be handy for freemem checks and code optimization http://www.faludi.com/itp/arduino/Arduino_Available_RAM_Test.pde

system · August 31, 2012, 3:01pm

Well, obviously the second example won't work

It should? I thought I declared an instance of each of the classes before the calls.

Regardless, as usual...thanks for the help... you are wealth of knowledge!

system · September 10, 2012, 1:49pm

I have related questions. I'm running out of memory and I'm not sure where it is going. All 2K is being used somewhere, presumably in Ethernet header files because I'm declaring less than 200 bytes of variables. I did a serious rework to move a few hundred bytes from RAM to EEPROM and found that I actually lost RAM (other changes may be a cause, so still checking this). Is there documentation somewhere that says where the compiler puts stuff. For example, does the string in return "a string";get stored in RAM or in program memory ? Likewise, where is a const variable stored (and if not in program memory by default, why not?). Do structure definitions use RAM ?

struct example { // should not use RAM 
  int a; 
  char b[30];
};
example c; // uses RAM

Is there a way of getting a RAM allocation map from the compile process ?

wildbill · September 10, 2012, 2:12pm

String literals occupy both progmem and RAM - they are copied to RAM when the sketch starts. Struct definitions don't consume RAM. Take a look at the F macro - you can keep your strings in progmem only. Consider posting your code for more specific advice.

system · September 10, 2012, 2:59pm

Thanks very much for the prompt reply. String literal (mis)handling is enough to explain my problem. I've heard of PROGMEM but not the 'F macro'... I'll hunt it down. I can probably sort things by moving more into EEPROM.
Copying string (const by definition) literals into RAM is really wasteful and cannot be needed if there is such a thing as the 'F macro': can this default behaviour be changed ?
For convenience, here is the reference to the macro...
http://arduiniana.org/libraries/Flash/

eried · September 10, 2012, 3:20pm

An old forum user called dcb did a nice little improvement to help with this kind of decisions to the programmer:

I included his enhancements into the ide mod of my signature

system · September 10, 2012, 7:23pm

I don't think anyone has actually answered your question yet, so here are my thoughts.

All three will work assuming you are not relying on the instance in consecutive calls to ds() being the same as each other or the same as the instance in setup()

Global objects: all memory is assigned on start-up and never freed.

Local function objects: memory for all three classes is assigned at the start of the method and freed at the end of the method.

Extra curly braces: this will assign the memory for each class and free it in turn.

If you want to see the order of things happening, I would add a constructor and destructor to each of your classes that outputs over the serial bus or something. The memory is assigned immediately before the constructor and freed immediately after the destructor.

Hope this helps.

marcello.romani · September 10, 2012, 9:30pm

Shouldn't init() and doSomething() be class-methods instead of instance methods ?

pYro_65 · September 11, 2012, 12:47am

tuxduino:
Shouldn't init() and doSomething() be class-methods instead of instance methods ?

If you mean static then yes, taking the example below ( provided by OP )

#include <classes.h>

void setup()
{
	{Class1 c1;c1.init();}
	{Class2 c2;c2.init();}
	{Class3 c3;c3.init();}
}

void loop()
{
	ds();
}

void ds()
{
	{Class1 c1;c1.doSomething();}
	{Class2 c2;c2.doSomething();}
	{Class3 c3;c3.doSomething();}
}

The classes here are doing specific tasks in two different places, which is fine, but a waste of memory weather it be the stack or heap.
If the class definitions don't need to keep unique instance data then the class could be entirely static i.e.

class Class1{
  public:
    static void DoSomething( void ){ return; }
};

void ds()
  {
    Class1::DoSomething();
    Class2::DoSomething();
    Class3::DoSomething();
  }

marcello.romani · September 11, 2012, 10:27am

Static in C++, Shared in VB... but yes: that's what I meant

Topic		Replies	Views
#include library uses RAM Programming	22	3661	May 5, 2021
Releasing an object? Syntax & Programs	3	1831	May 6, 2021
Memory Efficiency of Classes Programming	7	3624	May 5, 2021
Initialize Global object Later Question Programming	42	2772	October 3, 2022
Unsure what is considered dynamic memory Programming	44	1559	July 19, 2023

Question about different ways to declare objects and their effects on RAM usuage

Related topics