topic Could you possibly post a in Software Archive

Data alignment problem

Nick_L_1 — Tue, 16 Jun 2015 13:52:26 GMT

Hi there

I was trying to offload some computation to MIC using "pragma", sending data addressed by a pointer p, then how to ensure the alignment of data on MIC after MIC recieved it? Does" __assume(p, 64)" work?I was trying to use instrinsics to load data to the vector RF, which requires the alignment of data.

Another problem, that I was trying to active lots of threads for the calculation using "#pragma omp parallel for", and some arrays inside the loop must be thread private while also 64-byte aligned.

I was using "_mm_malloc()" inside the loop to ensure these, but this leads to reduplicated and unnecessary allocation.

Thanks.

Could you possibly post a

Frances_R_Intel — Tue, 16 Jun 2015 16:34:25 GMT

Could you possibly post a small sample code? Thanks.

Quote:Frances Roth (Intel)

Nick_L_1 — Wed, 17 Jun 2015 09:05:38 GMT

Frances Roth (Intel) wrote:

Could you possibly post a small sample code? Thanks.

In the main function:

.......

double * p;

p = (double * )malloc(sizeof(double)*1024);

#pragma offload target(mic:0) in(p:length(128)

foo(p);

.......

The data addressed by p is transfered into MIC And the function foo is defined like this:

__attribute__((target(mic)))void foo( double * p)

{

#ifdef __MIC__

......

long long iter;

#pragma omp parallel for private(iter)

for(iter = 0 ; iter < N ; iter ++)

{

__m512d _A, _B;

double * p1;

p1 = (double * )_mm_malloc(sizeof(double)*1024, 512); //p1 has to be thread-private

......

_A = _mm512_load_pd((void*)p); //p has to be aligned

_B = _mm512_load_pd((void*)p1); //p1 has to be aligned

......

/* Calculations */

......

_mm_free(p1);

}

#endif

}

Thus p1 is allocated repeatedly inside the loop to make sure it's thread-private, while p1 has to be aligned.

At the very least you should

James_C_Intel2 — Wed, 17 Jun 2015 09:26:38 GMT

At the very least you should structure that more like this (which allocates once per thread, rather than once per iteration)

#pragma omp parallel
{
    long long iter;     // Though does it *really* need to be 64 bits!? How many iterations do you have?
                        // 64bit indexes are likely inefficient.
    double * p1 = (double *) _mm_malloc (sizeof(double)*1024, 512);

#pragma omp for
    for (iter=0; iter<N; iter++)
    {
        _mm_512d _A;
       ... etc ...
    }

    _mm_free (p1);
}

Quote:James Cownie (Intel)

Nick_L_1 — Wed, 17 Jun 2015 23:42:45 GMT

James Cownie (Intel) wrote:

At the very least you should structure that more like this (which allocates once per thread, rather than once per iteration)

#pragma omp parallel
{
    long long iter;     // Though does it *really* need to be 64 bits!? How many iterations do you have?
                        // 64bit indexes are likely inefficient.
    double * p1 = (double *) _mm_malloc (sizeof(double)*1024, 512);

#pragma omp for
    for (iter=0; iter<N; iter++)
    {
        _mm_512d _A;
       ... etc ...
    }

    _mm_free (p1);
}

I really have that many iterations. Reconstructing the code helps ,thanks~