I ran the code again and I saw that the memory usage had dropped from 1.6 gigs to 100 MBS. Huge improvement, but still not what it should be. I see that I am not manually allocating any memory into the heap and that all my variables are on the stack. This seemed to tell me that I don't really have a memory leak, but I am consuming way too much memory. I analyzed the code a little longer and spotted the what I thought was the problem. For every pixel of the image, I am creating a new variable of type EtCameraInput and a new pointer to an EtCameraOutput. This looks bad, I moved the declaration of such variables to outside of the double "for" loop. This greatly reduced memory consumption, however, it still did not feel as the right answer to the problem.
The stack should deallocate "camIn", "camOut" and "cammtds" once they go out of scope, so these cant be the issue. I looked at the code and found this line to be quite interesting:
// // EtCameraOutput *camOut = EiCameraOutput; //
In an effort to write a framework that would allow me to write faster code, I had written this preprocessor macro.
//
//
#define EiCameraOutput (EtCameraOutput*)malloc(sizeof(EtCameraOutput))
//
//
So I was allocating memory on the heap and I was not deallocating It. Once again, I seem to conspire against myself by trying to be a little too smart. Maybe using such shorthand macros is not such a good idea. I re-arranged the code to what is listed below and the memory usage dropped to 3 MB.
void EiProcessBucket(EtBucket bucket, Rgba *px) {
extern EtWorld world;
int x,y;
float r,g,b;
int j;
Rgba *p;
EtCameraOutput *camOut = EiCameraOutput;
EtCameraMethods *cammtds = (EtCameraMethods*)world.cameras->mtds;
for (int y = bucket.pos.y; y < bucket.pos.y + bucket.height; y++)
{
for (int x = bucket.pos.x; x < bucket.pos.x + bucket.width; x++)
{
EtCameraInput camIn;
camIn.xres=world.film.xres;
camIn.yres=world.film.yres;
camIn.x = x; camIn.y=y;
g = y / (float)camIn.yres;
r = x / (float)camIn.xres;
b = 1;
......
......
}
}
free(camOut);
}
Next, I uncomment the lower part of the loop, the part where the intersections are actually performed and vroom, memory usage again launched to 1.5 gigs! There is a very serious memory leak in this block of code. After a good amount of digging, I found that the code responsible for the memory leak was the intersectP method in the sphere shape. Inside this function, I am performing several operations to apply the transformation to the shape. Here is the code that handles the transformation
EtPoint pos = EiNodeGetPnt(node,"center");
EtMatrix m = EiNodeGetMtrx(node,"matrix");
EtMatrix mi;
EiMatrixInvert(&m,&mi);
// create a transform
EtTransform xf = EiTransform(m);
// create a trasform for the center
EtTransform xpoint = EiTranslate(pos);
// Multiply the object transform by the pos
EiTransformMult(&xf,&xpoint);
I commented lines of code one by one and I realized that the issue was in EiTransformMult. I opened the transform module and I found 2 variables that were dynamically allocated and where not being deallocated at all. Here is the old code
void EiTransformMult(EtTransform *aa, const EtTransform *bb)
{
EtMatrix *mat = malloc(sizeof(EtMatrix));
float *mm = (float*)mat;
float m[16];
EtTransform *tmp=malloc(sizeof(EtTransform));
float *a = (float*)&aa->m;
float *b = (float*)&bb->m;
......
memcpy(&tmp->m,&m,sizeof(float) * 16);
EtMatrix mi;
EiMatrixInvert(&tmp->m,&mi);
memcpy(&tmp->mInv,&mi,sizeof(float)*16);
memcpy(aa,tmp,sizeof(EtTransform));
}
First of all, one of the allocated pointers (*mat) is not even used anymore, so I deleted it. The other pointer, *tmp, is never deallocated. I added a free(tmp) at the end of the function and voila! The renderer memory usage now stays at a mere 3mbs per render and as a side effect, now using 8 threads greatly improves the render times. A scene that takes 71 seconds to render on 1 thread, takes about 20 seconds with 8 threads. Here is an image rendered with the latest version of Equinox.
So keep an eye open for those malloc()s while programming in C. Remember to always deallocate whatever you allocated or evil leprechauns will spawn and consume as much memory as the can get your hands on. Oh, and like a good friend told me once, don't try to be too smart or over complicate things with C. It is already super simple, which makes it super powerful.
