Memory alignment

The first time, almost 20 years ago, that I heard the OS/400 Operating
System is written in C++, lead me to the conclusion that the most powerful
programming language has always been C. And as C++ is a superset of C,
want it or not, it's still the king.

Before I learned RPG and all its branches, I was already programming in C,
and not surprisingly, I was also programming in CLIPPER. I wrote programs
yielding .obj coming from CLIPPER, and other C modules which I bound very
well with MS LINK.EXE.

When I started programming with RPG in 1995, I said "hey, this is more or
less like CLIPPER". LOL if you want. And yes, do it really loud. CLIPPER
was for me a programming language that did not respect my lexicography in
terms of uppercase and lowercase differentiation. When this was something
very strict when writing C code. So is RPG. You can write programs
pretending writing strict upper- and lower-case respect, and when errors
come around you will read your spool with your variables converted to
uppercase. I read lots of programs where the authors in one line wrote one
variable name with all kinds of combinations of uppercase and lowercase
characters and in another line completely different, for which I did LOL,
and in one single program! And it would compile!

Well, this is not my subject here. Although this is something "I always
wanted to do that". What I would very much like to address is the fact
that, when declaring variables in RPG, is very important to look after the
size we give to them.

C and C++ have their efficiency in that their compilers most of the time
take care of doing something you don't get aware of. And it is memory
alignment. Processor access to memory variables have some work to do when
going for them. Processors love that variables be naturally aligned to
some address pattern of residency.

This is very simple. Processors love byte-multiple-wise orientation of
memory variables declarations. This means: don't think decimal-sized
variable delcarations, but think of hexadecimal -wise variable sized
declarations.

I have been writing a lot of programs with lots of system API calls, and
when I have to go to look for the declaration of the parameters, for
example most of them residing in the QSYSINC library, I learned that they
are really very C-like variable-alignment-wise.

And this is not an accident. The efficiency of the IBM i OS is that it's
written in C++. So, RPG programmers have to keep an eye on this. RPG
programs are actually converted into several calls to service programs
which are written in C or C++.

In general, when declaring variables in RPG nevertheless kind of, try to
always give it a size compatible with a binary equivalent to at least a
16-byte-multiple size.

For example, if you want to declare a variable as CHAR(10), consider giving
it a size of either CHAR(8) or CHAR(16). Let me tell you, the RPG compiler
won't let you know it, but it would very much like to do it, that you did a
smart decision if you did so.

Give stand-alone variables sizes that are multiple of 4-, 8-, 16-, or
32-bit sizes. In terms of performance, you will get a reward.

CHAR variable types, give them sizes of 8, 16, 24, 32, 64 and son on, sizes.

When declaring structures, give them sizes for wich, in between, you would
have to pad some dummy variables in order to fit the size of compatible
memory alignment.

Javier Sanchez