Hello everyone,

Apologies in the case this subject has been already discussed. I require that some global variables be cache-line aligned. This is a requirement for per-CPU variables that are statically defined to prevent cache ping-pong. Is there any way to do this at fpc when the record is declared? This would tell compiler to align every definition. Currently, I can simply allocate memory and do the alignment afterwards, however, I can't do this for all the cases.

Thanks, Matias.

{$push}
{$codealign varmin=16}
{$codealign constmin=16}
const
   constdata: array[0..3] of longint = (1,2,3,4);
var
   x: array[0..15] of longint;
{$pop}

However, the maximum alignment you can specify this way is limited per target (hardcoded in the compiler). In 3.2.x, it's 16 bytes for most desktop targets. On 3.3.x, it's 64 bytes for most desktop targets.

Jonas

But it's still not possible to attach alignment to type itself instead of variable, right?

-- Regards,
Denis Golovan

denisgolovan wrote

But it's still not possible to attach alignment to type itself instead of variable, right?

It is possible
(https://gitlab.com/freepascal.org/fpc/source/-/blob/main/tests/test/talignrec1.pp), but it is subject to the same limitations when declaring variables of those types.

Jonas

Aha. Nice!
Does it work recursively? I mean - does it work when aligned record is itself a field within other record?

-- Regards,
Denis Golovan

Hello,

Thanks, this is what I was looking for, however, when the type is defined as an array, only the [0] element is aligned. I was expecting that each element in the array would be aligned.

Matias

Matias Ezequiel Vara Larsen via fpc-pascal
schrieb am Mi., 29. März 2023, 00:27:

No, array types are defined as never having padding between the elements. You need to make sure that the element is appropriately sized then.

Regards,
Sven

Thanks for the comment. I will pad those records used for per-cpu variables so they fit in different cache-lines when defined as an array.

Matias

I've tried this (fpc 3.2.0) and it correctly aligns to 64 bytes (x86 cacheline):

{$push}
{$codealign varmin=64}
var
   x: array[0..15] of longint;
{$pop}

The generated assembler is:

.section .bss
.balign 64
.type U_$P$PROGRAM_$$_X,@object
.size U_$P$PROGRAM_$$_X,64
U_$P$PROGRAM_$$_X:
.zero 64

Is it possible to define "varmin" as a constant or symbol instead of using the actual value each time?

Matias

On Mar 29, 2023, at 1:33 PM, Sven Barth via fpc-pascal wrote: No, array types are defined as never having padding between the elements. You need to make sure that the element is appropriately sized then.

Wouldn’t that be better for performance if each element was padded to align with the cache? That seems like something the compiler could do easily for you behind the scenes. I may not understand the need to "align the elements on the cache” though.

Regards,
Ryan Joseph

So if I have a type like:

test = record
  r: DWord;
  s: Word;
end;

Then, I define the variable `nada` as an array of `test` type:

var
  nada: array[0..2] of test;

Is the element aligned to 4-bytes?

Thanks, Matias.

I do not think you would like to have everything aligned to the cacheline. This use-case requires it because each element in the array will be accessed from a different CPU and you would try to prevent cache ping-pong, i.e., sharing the same cacheline between different cpu's cache.

Matias

Records always get padded to a multiple of their internal alignment requirement. Unless you're on a system where the default packrecords value is 2 (msdos-i8086 has that probably), the above record's internal field alignment is 4 and hence its size will also be padded to a multiple of 4.

Jonas

Hello,

Ok for the records for internal calculations. But sometimes, records are used for reading/writing structured files. Does "packed" in "packed array" and "packed record" always forbid the compiler to play with alignments ?

Kindest regards, Ched'

Le 29.03.23 à 21:07, Jonas Maebe via fpc-pascal a écrit :

If that record/array is specifically defined as "packed", then yes, of course. However, arrays/records that are no so defined should be aligned...

Ralf

Thanks for the clarification,

Matias