Question

I would like to use the FFTW C library from Delphi 2009 and according to this documentation;

http://www.fftw.org/install/fftw_usage_from_delphi.txt

to increase the performance inside the FFTW library (such that it can use SIMD extensions) arrays passed in of either Single (float) or Double (double) need to be aligned either at 4 or 8 byte boundaries. I found documentation talking about alignment of record structures, but nothing specific about arrays. Is there a way to do this in Delphi 2009.

So the code (copied from the above documentation) would look like this;

var
      in, out : Array of Single; // Array aligned at 4 byte boundary
      plan : Pointer;

    {$APPTYPE CONSOLE}

    begin

      ...  

      SetLength(in, N);
      SetLength(out, N);

      plan := _fftwf_plan_dft_1d(dataLength, @in[0], @out[0],
                                 FFTW_FORWARD, FFTW_ESTIMATE);

Also in the above documentation they talk about 8 and 16 byte boundaries but it looks to me it should be 4 and 8 byte boundaries, if any could clear that up to that would be great.

Thanks,
Bruce

Answer 1

Delphi provides no way to control the alignment of any memory it allocates. You’re left to either rely on the documented behavior for the memory manager currently installed, or allocate memory with some slack space and then align it yourself, as Mghie demonstrates.

If you’re concerned that Delphi’s memory manager is not providing the desired alignment for dynamic arrays, then you can go ahead and use the memory functions provided by the DLL. The note you cite mentions _fftwf_malloc and _fftwf_free, but then it gives some kind of warning that memory allocated from _fftwf_malloc “may not be accessed directly from Delphi.” That can’t be what the authors meant to say, though, because that’s not how memory works in Windows. The authors probably meant to say that memory allocated by _fftwf_malloc cannot be freed by Delphi’s FreeMem, and memory allocated by Delphi’s GetMem cannot be freed by _fftwf_free. That’s nothing special, though; you always need to keep your memory-management functions paired together.

If you use _fftwf_malloc to get your array, then you can access it through an ordinary pointer type. For example:

var
  dataIn, dataOut: PDouble;
begin
  dataIn := _fftwf_malloc(...);
  dataOut := _fftwf_malloc(...);
  _fftwf_plan_dft_1d(dataLength, dataIn, dataOut,
                     FFTW_FORWARD, FFTW_ESTIMATE);

As of Delphi 2009, you can even use array syntax on those pointers:

dataIn[0] := 3.5;
dataIn[2] := 7.3;

In order to enable that, use the {$POINTERMATH ON} compiler directive; it’s not enabled by default except for the character-pointer types.

The disadvantage to manually allocating arrays like this is that you lose range checking. If you index beyond the end of an array, you won’t get an easy-to-recognize ERangeError exception anymore. You’ll get corrupted memory, access violations, or mysteriously crashing programs instead.