As a short follow-up, that's the skeleton for a DSP function that can get auto-vectorized (under gcc 4.0.1/PPC at least):
#include <stdlib.h>
#define VECELEMS 4 #define ALIGNMENT (sizeof(float)*(VECELEMS)) #define ALIGNED(ptr) (((size_t)(ptr)&((ALIGNMENT)-1)) == 0)
typedef float *__restrict__ __attribute__((aligned(ALIGNMENT))) aligned_float_ptr;
void addfun(int n,float *dst,const float *src1,const float *src2) { int i,j; if(ALIGNED(dst) && ALIGNED(src1) && ALIGNED(src2)) { aligned_float_ptr d = (aligned_float_ptr)dst; aligned_float_ptr s1 = (aligned_float_ptr)src1; aligned_float_ptr s2 = (aligned_float_ptr)src2;
int nv = n/VECELEMS; /* this loop will be auto-vectorized */ for(i = 0; i < nv; ++i,d += VECELEMS,s1 += VECELEMS,s2 += VECELEMS) for(int a = 0; a < VECELEMS; ++a) d[a] = s1[a]+s2[a];
n -= nv*VECELEMS; for(i = 0; i < n; ++i) d[i] = s1[i]+s2[i]; } else { for(i = 0; i < n; ++i) dst[i] = src1[i]+src2[i]; } }
Of course, in C++ this can be made much more flexible using templates. Looking at the assembly output is not recommended - it's a mess. It's much better to code similar functionality using the vector primitives that gcc and MSVC provide.
best greetings, Thomas
Am 20.11.2006 um 00:16 schrieb Thomas Grill:
Am 19.11.2006 um 22:57 schrieb Mathieu Bouchard:
On Sun, 19 Nov 2006, Thomas Grill wrote:
Am 18.11.2006 um 22:16 schrieb Mathieu Bouchard:
perhaps it would be a good start to reimplement newbytes(n) using memalign(16,n) instead of malloc(n).
A few years ago i introduced aligned memory allocation in the pd- devel branch.
I see how you did it. Is it because posix_memalign() isn't as portable as we'd like it to be? (I wrote "memalign" by mistake, which is the name of a deprecated function that does a similar job)
It seems like a lot of memory is allocated unaligned. Is that normal? If the memory allocations you've align cover the most speed-critical memory, then why did Tim say that about memory alignment?
The point is that i only introduced and used the aligned memory functions for the SIMD codelets, which are used for DSP and array processing. I'm sure that there are aligned memory allocation functions for either platform (maybe not necessarily posix_memalign...), but i wanted to stay as close as possible to the original PD memory functions. I don't think it makes much sense to use aligned memory for anything else than DSP and tables. If one wanted to use it with auto-vectorization the header code would be much the same as the one in the DSP perform functions, with some casting to aligned pointers, so that the compiler knows about it. Aliasing is another thing, though.
greetings, Thomas
PD-dev mailing list PD-dev@iem.at http://lists.puredata.info/listinfo/pd-dev