ROM size with int1 vs int8

[rbarbali]

CCS V5.083, PIC16F18875

Hi. I am trying to reduce the rom size of a program. I decide to use int1 vars instead of int8 vars thinking the ROM size will be reduced. But I get that using 8 bits vars consumes less ROM than using 1 bit vars. What am I missing?

The int1 version:

[gaugeguy]

Array access on bits takes more program commands. An array of 16 bits spans two bytes so it first has to determine which byte to access and then which bit inside that byte. With an array if int8, it is just starting address and offset.

[temtronic]

gee, you used less than 1% of ROM, I wouldn't worry until you used 80+%, THEN look at space saving tricks....

[rbarbali]

Thanks gaugeguy & temtronic!
Actually I am using 97% of the 16f18875, so I am looking for methods of reducing the size of the program even more. One way I found is replacing INT1s for INT8s definitions, but I wanted to know if I was doing something bad.

As per your suggestion I found: https://www.ccsinfo.com/forum/viewtopic.php?t=43389&highlight=space+saving+tricks

I will continue searching for more tricks...

[PrinceNai]

Bigger PIC, like 16f18877?

[Ttelmah]

The 'key' that has been mentioned, is the 'array access'.

int1 fred;

Then
fred=1;

or
fred=0;

Generates very efficient code, and you can have eight such variables only
using one byte of RAM.

However as soon as you introduce arrays, the compiler starts having to do
lots of work. On the int8 variables, it'll have to add the index, to the
start of the array, and do indirect accesses to this. On the int1, instead
of just being able to use bit set and bit clear on the predefined bit, it
has to do the same indexed access to the bytes, but also add the extra
complexity of having to generate a mask to access the actual bit. Also
with an extra division by eight. So in your case the extra code to do this
'costs more ROM', but of course the saving is in RAM. Note 31bytes for
the int1 version, versus 118 for the int8 version.

So using int1, adds an extra level of complexity to the code for array
accesses. Costs ROM for these. However saves RAM.

Remember you can save ROM, generally by putting all the code reading
and writing to the same variables, into one place. So if you have ten
locations in your code that write a value into a particular array, then
have a single routine to do this and call this from all the locations. The
'overhead' of the call, will be less than the cost of having ten sets of
the array access code.

[temtronic]

silly 'cheat'...
instead of
flag_open_tamper_sent[k] = 0;
use
flag_open_tamper_sent_01 = 0;
flag_open_tamper_sent_02 = 0;
...
...
...
flag_open_tamper_sent_16 = 0;
where all of them are int1.

compiler will save 8 of them per byte .
if you can, rename them for their 'use'
flag_open_tamper_switch_01_sent = 0;

[rbarbali]

PrinceNai,