How to reduce Zero Initialised region.

[Ajai Jose]

Hi ,
I work on an ARM processor based embedded system. Code is mainly in
C language. The project has a huge source base. We are supposed to
optimise it. Most datastructures are declared as static and which
directly go into the Zero Initialised region. We need to cut the size
of this ZI region by at least 30%.
The one way i see of doing this is by removing these static arrays
and passing a pointer to the data structure whenever required. but
since these global arrays are used through out the code. A re-write
seems inevitable!

two questions I had.
1. Am I right in doing this(passing pointer instead of making the data
structure static) ?
2. Is there any alternative to this ?
Thanks in Advance,
Ajai.

[Christopher Layne]

Ajai Jose wrote:

two questions I had.
1. Am I right in doing this(passing pointer instead of making the data
structure static) ?

Yes. Better design, IMO.

2. Is there any alternative to this ?

Hard work yields better rewards.

[jacob navia]

Ajai Jose a écrit :

Hi ,
I work on an ARM processor based embedded system. Code is mainly in
C language. The project has a huge source base. We are supposed to
optimise it. Most datastructures are declared as static and which
directly go into the Zero Initialised region. We need to cut the size
of this ZI region by at least 30%.
The one way i see of doing this is by removing these static arrays
and passing a pointer to the data structure whenever required. but
since these global arrays are used through out the code. A re-write
seems inevitable!

two questions I had.
1. Am I right in doing this(passing pointer instead of making the data
structure static) ?
2. Is there any alternative to this ?
Thanks in Advance,
Ajai.

Why do you think that this is the problem?

Did you measure the program's performance to see where the
hot spots are? What data leads you to your conclusion that
the static data is the problem?

If you pass pointers around it can be a better design but it will
be slightly slower, since global data needs nothing to be passed, it is
always there.

Before doing anything MEASURE FIRST!

jacob

[Christopher Layne]

jacob navia wrote:

Why do you think that this is the problem?

Did you measure the program's performance to see where the
hot spots are? What data leads you to your conclusion that
the static data is the problem?

If you pass pointers around it can be a better design but it will
be slightly slower, since global data needs nothing to be passed, it is
always there.

He did mention he was on an embedded system. This could be a space rather than
speed issue.

[Samuel Stearley]

1. Am I right in doing this (passing pointer instead of making the data structure static) ?

That will make the executable larger. How much increase can be
tolerated?

2. Is there any alternative to this ?

In my experience people use UINT32s everywhere because they don't want
to look old fashioned. I suggest studying the values assigned to
datums in these structures. Maybe a UINT16 would work equally well.
But don't go around sticking UINT8s in the middle of a data structure.
-Samuel S

[Ajai Jose]

On Jan 31, 4:29 pm, Christopher Layne <[e-mail] dizedwrote:

jacob navia wrote:

Why do you think that this is the problem?

Did you measure the program's performance to see where the
hot spots are? What data leads you to your conclusion that
the static data is the problem?

If you pass pointers around it can be a better design but it will
be slightly slower, since global data needs nothing to be passed, it is
always there.

He did mention he was on an embedded system. This could be a space rather than
speed issue.

Yes Chrisopher is rgt. The problem we have is real estate we do not
have enough RAM and performance is not an issue.

Thanks,
Ajai.

[Ajai Jose]

On Jan 31, 4:48 pm, "Samuel Stearley" <nya...@gmail.c omwrote:

1. Am I right in doing this (passing pointer instead of making the data structure static) ?

That will make the executable larger. How much increase can be
tolerated?

I mean passing an extra parameter to a function might increase code
size(text segment). Some additional code for sending the parameter
during function prolog. that is all the penalty right ?
but it will free some space of the ZI region when it comes to big
arrays.

>

2. Is there any alternative to this ?

In my experience people use UINT32s everywhere because they don't want
to look old fashioned. I suggest studying the values assigned to
datums in these structures. Maybe a UINT16 would work equally well.
But don't go around sticking UINT8s in the middle of a data structure.

-Samuel S

I understand what you are pointing at but I am particularly looking at
some huge global arrays which eat into the ZI region in a big way.
Small structures I have seen that the original developer has done a
good job.

Thx,
Ajai.

[Samuel Stearley]

I mean passing an extra parameter to a function might increase code

size(text segment). Some additional code for sending the parameter
during function prolog. that is all the penalty right ?
but it will free some space of the ZI region when it comes to big
arrays.

Where else would the large array of structures be stored? In the
stack frame of caller so many levels up? How large is you stack?

[Eric Sosman]

Ajai Jose wrote:

Hi ,
I work on an ARM processor based embedded system. Code is mainly in
C language. The project has a huge source base. We are supposed to
optimise it. Most datastructures are declared as static and which
directly go into the Zero Initialised region. We need to cut the size
of this ZI region by at least 30%.
The one way i see of doing this is by removing these static arrays
and passing a pointer to the data structure whenever required. but
since these global arrays are used through out the code. A re-write
seems inevitable!

two questions I had.
1. Am I right in doing this(passing pointer instead of making the data
structure static) ?

Yes. Or maybe No. We don't know enough about the
constraints and circumstances of your situation to be able
to say with certainty.

2. Is there any alternative to this ?

You might consider a sort of intermediate strategy: Make
the pointer(s) global and static, and initialize them to
point to dynamically-zeroed memory when the program starts.
That is, if the program as it stands now has

int BigArray[LARGE]; /* static and zeroed */

you might change it to

int *BigArray; /* only the pointer is static */
...
void initialize(void ) {
BigArray = calloc(LARGE, sizeof *BigArray);
if (BigArray == NULL)
die_horribly();
}

.... and arrange to call initialize() before BigArray is needed
elsewhere in the code.

--
Eric Sosman
es*****@acm-dot-org.invalid

[Thad Smith]

Ajai Jose wrote:

On Jan 31, 4:48 pm, "Samuel Stearley" <nya...@gmail.c omwrote:

>>>1. Am I right in doing this (passing pointer instead of making the data structure static) ?

That will make the executable larger. How much increase can be
tolerated?

I mean passing an extra parameter to a function might increase code
size(text segment). Some additional code for sending the parameter
during function prolog. that is all the penalty right ?
but it will free some space of the ZI region when it comes to big
arrays.

Why do you want to reduce the size of only zero-initialized RAM?

I assume that code and data are in separate memory spaces. Usually,
though, the zero-initialized static data area, data area allocated to
automatic variables (normally on a stack), and the heap all share the
same physical memory, which is divided according to the program usage
(although there are cases in which some memory is battery-backed, which
other is not).

You can reduce RAM requirements by replacing local static variables with
automatic variables if the value does not need to be carried from one
invocation to another. That allows the memory to be shared among
several functions that execute at different times. There is no need to
pass pointers if there is no data involved.

--
Thad