freeing memory in shortest time

[vivek]

Hello,

I have a pointer to a main structure which again consists of
structures, enums, char, int, float and again complex structures.

When i free all the contents of the main structure, it takes me a lot
of time (since i have to loop determining the data type and freeing
it). Is there any idea to free all the contents of the structure in
shortest possible time.

[vivek]

Or probably should i switch to static memory instead??? In that case
what care should be taken.

Pl advice

[santosh]

vivek wrote:

Hello,

I have a pointer to a main structure which again consists of
structures, enums, char, int, float and again complex structures.

When i free all the contents of the main structure, it takes me a lot
of time (since i have to loop determining the data type and freeing
it). Is there any idea to free all the contents of the structure in
shortest possible time.

You might try making the structure static. Or you might try having a
separate cache of all the pointers to dynamic memory for each structure
element. This will consume additional memory, but will eliminate the
need to traverse the structure to free all it's components.

In anycase, I doubt that traversing the structure is going to be your
most serious bottleneck, particularly if you do it all at once.

[Richard Heathfield]

vivek said:

Hello,

I have a pointer to a main structure which again consists of
structures, enums, char, int, float and again complex structures.

When i free all the contents of the main structure, it takes me a lot
of time (since i have to loop determining the data type and freeing
it). Is there any idea to free all the contents of the structure in
shortest possible time.

Well, exit(0) will do it. But I'm curious to know why you think it's taking
a lot of time. Computers are pretty fast nowadays. Is this really the
bottleneck for your program? What did profiling tell you?

--
Richard Heathfield <http://www.cpax.org.uk >
Email: -http://www. +rjh@
Google users: <http://www.cpax.org.uk/prg/writings/googly.php>
"Usenet is a strange place" - dmr 29 July 1999

[vivek]

Oh, it is for an embedded system, where that freeing the structure
takes about 0.4 ms, which is a lot of time for an embedded
system...Thats why!!!

[vivek]

"you might try having a

separate cache of all the pointers to dynamic memory for each structure
element. This will consume additional memory, but will eliminate the
need to traverse the structure to free all it's components.

In anycase, I doubt that traversing the structure is going to be your
most serious bottleneck, particularly if you do it all at once"

Can you explain in detail about the caching, please? I could not
follow that part.

[santosh]

vivek wrote:

Oh, it is for an embedded system, where that freeing the structure
takes about 0.4 ms, which is a lot of time for an embedded
system...Thats why!!!

Okay. Some of your options are:

1. Don't free anything. Obviously this might not be feasible.
2. Use static or automatic objects. Static objects will persist
throughout the program lifetime while auto objects will be destroyed
once their scope is exited.
3. Use something like alloca. See the recent threads on this. Objects
allocated with alloca persist throughout the function and need no
explicit call to free.
4. Modify your data structures so that dynamic memory is minimised
or "clumped" together, thus minimising the number calls to free.

There may be other strategies too, though we can't tell you which one
might be suitable since the choice depends on various factors of your
program and it's host machine and what's expected of them.

Generally speaking, if you want realtime performance then malloc/free is
pretty much ruled out, but I would suggest that you actually verify
that they *are* the problem and that the time consumed *is*
unacceptable before considering other strategies.

[vivek]

Of course everything else is ok with the program
functionalities ...except for the time...If time is ok...thats
it..project over...

and thank u so much santhosh

[Nick Keighley]

On 5 Mar, 08:47, vivek <gvivek2...@gma il.comwrote:

I have a pointer to a main structure which again consists of
structures, enums, char, int, float and again complex structures.

are these nested structures or pointed to?

/* headers ommitted */

struct Main1_s
{
struct Nested_s nested;
};

struct Main2_s
{
struct Pointed_s *pointed;
};

void func (void)
{
struct Main1_s *main1_s;
struct Main2_s *main2_s;

/* should check for malloc() failures */
main1_s = malloc(sizeof *main1_s);
main2_s = malloc(sizeof *main2_s);
main2_s->pointed = malloc(sizeof (*main2_s->pointed));

/* do stuff */

/* cleanup */
delete (main1_s);
/* nested freed automatically */

delete (main2_s->pointed);
delete (main2_s);
}

When i free all the contents of the main structure, it takes me a lot
of time (since i have to loop determining the data type and freeing
it).

what sort of time? Do you mean the program takes a long time?
How do you know, have you timed it? Or is it taking a long
time to write the program? Why do you need a loop to determine the
data type. We need to see some code!

Is there any idea to free all the contents of the structure in
shortest possible time.

not sure what you mean. Could you use automatic storage?

void func (void)
{
struct Main1_s main1_s;

/* do stuff */
}

no mallocs therefore no deletes

and then vivek wrote:

Or probably should i switch to static memory instead??? In that case
what care should be taken.

I'm not sure. What lifetime does your structure need? Statics can
occupy storage unnecessarily (they go away only when the program
ends).
You may make them accessible from too much of the program.
You might have problems that there is only one copy of the struct
when logically you need many.

I need to know more about what you are doing.
Can you post a simpified example?
--
Nick Keighley

The Dinosaurs have come and gone, we Theriodonts remain

[vivek]

The structures are nested.

I have measured the time taken for this specific code section to run.

The lifetime of the structures would be like this.

Receive some communication data, use these structures to decode data -
allot memory...after decoding, process it ..then free memory..

then prepare a reply, encode the date(create these structures-allot
memory), send the data and free memory.