Question

Our server recently has been going down a lot and I was tasked to improve the memory usage of a set of classes that was identified to be the culprit.

I have code which initializes an instance of an object and goes like this:

boolean var1;
boolean var2;
.
.
.
boolean var100;

void setup() {
 var1 = map.hasFlag("var1");
 var2 = map.hasFlag("var2);
 .
 .
 .
 if (map.hasFlag("some flag") {
     doSomething();
 }
 if (var1) {
   increment something
 }
 if (var2) {
   increment something
 }

}

The setup code takes about 1300 lines. My question is if it is possible for this method to be more efficient in terms of using too many instance variables.

The instance variables by the way are used in a “main” method handleRow() where for example:

handleRow(){
   if (var1) {
     doSomething();
   }
   .
   .
   . 
   if (var100) {
     doSomething();
    }
}

One solution I am thinking is to change the implementation by removing the instance variables in the setup method and just calling it directly from the map when I need it:

handleRow(){
  if (map.hasFlag("var1") {
      doSomething();
  }
  .
  .
  . 
  if (map.hasFlag("var100") {
     doSomething();
  }
}

That’s one solution I am considering but I would like to hear the inputs of the community. 🙂

Answer 1

100 boolean variables will take 1.6k of memory when every boolean with overhead takes 16 bytes (which is a bit much imho) I do not think this will be the source of the problem.

Replacing these flags with calls into the map will negatively impact performance, so your change will probably make things worse.

Before you go redesigning your code (a command pattern looks like a good candidate) you should look further into where the memory leak is that you are asked to solve.

Look for maps that the classes keep adding to, collections that are static variables etc. Once you find out where the reason for the memory growth lies you can decide which part of your classes to refactor.