//ARM Supervisor Code

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

#include <unistd.h>

#include <inttypes.h>

#include <e-hal.h>

#define _BufSize (128)

#define _BufOffset (0x01000000)

#define _SeqLen (20)

typedef struct {

    float x, y, z, vx, vy, vz;

} Body;

static inline void nano_wait(uint32_t sec, uint32_t nsec)

{

    struct timespec ts;

    ts.tv_sec = sec;

    ts.tv_nsec = nsec;

    nanosleep(&ts, NULL);

}

void randomizeBodies(Body *data, int n) {

    int i;

    for (i = 0; i < n; i++) {

        data[i].x = 2.0f * (rand() / (float)RAND_MAX) - 1.0f;

        data[i].y = 2.0f * (rand() / (float)RAND_MAX) - 1.0f;

        data[i].z = 2.0f * (rand() / (float)RAND_MAX) - 1.0f;

        data[i].vx = 2.0f * (rand() / (float)RAND_MAX) - 1.0f;

        data[i].vy = 2.0f * (rand() / (float)RAND_MAX) - 1.0f;

        data[i].vz = 2.0f * (rand() / (float)RAND_MAX) - 1.0f;

    }

}

int main(int argc, char *argv[])

{

    unsigned row, col, core;

    e_platform_t platform;

    e_epiphany_t dev;

    e_mem_t emem;

    char emsg[_BufSize];

    int all_done, core_done;

    int i, x;

    srand(1);

    int nBodies = 30000;

    int startFlag = 0x00000001;

    if (argc > 1) nBodies = atoi(argv[1]);

    const float dt = 0.01f;

    // time step

    const int iters = 1000;

    // simulation iterations

    Body *buf = (Body *) malloc(sizeof(Body) * nBodies);

    Body *bufOutput = (Body *) malloc(sizeof(Body) * nBodies);

    randomizeBodies(buf, nBodies);

    // Init pos / vel data

    e_init(NULL);

    e_reset_system();

    e_get_platform_info(&platform);

    e_open(&dev, 0, 0, 4, 4);

    e_reset_group(&dev);

    e_load_group("e_rob_nbody.srec", &dev, 0, 0, 4, 4, E_FALSE);

    for (row = 0; row < platform.rows; row++){

        for (col = 0; col < platform.cols; col++){

            e_write(&dev, row, col, 0x0004, &nBodies, sizeof(int));

            // No longer needed, not suming on ARM any more

            // e_write(&dev, row, col, 0x1000, (Body *) buf, sizeof(Body) * nBodies);

        }

    }

    e_write(&dev, 0, 0, 0x1000, (Body *) buf, sizeof(Body) * nBodies);

    for(x = 0; x < iters; x++){

        fprintf(stderr, "Iter %dn", x);

        for (row = 0; row < platform.rows; row++){

            for (col = 0; col < platform.cols; col++){

                e_write(&dev, row, col, 0x0008, &startFlag, sizeof(int));

            }

        }

        e_start_group(&dev);

        //Check if all cores are done

        while(1){

            all_done = 0;

            for (row = 0; row < platform.rows; row++){

                for (col = 0; col < platform.cols; col++){

                    e_read(&dev, row, col, 0x0008, &core_done, sizeof(int));

                    all_done += core_done;

                }

            }

            if(all_done == 0){

                break;

            }

        }

        e_read(&dev, 0, 0, 0x1000, (Body *) bufOutput, sizeof(Body) * nBodies);

        fprintf(stderr, "buf[0].x = %fn", bufOutput[0].x);

    }

    e_close(&dev);

    // Release the allocated buffer and finalize the

    // e-platform connection.

    e_finalize();

    return 0;

Epiphany parallel computing code



#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include "e_lib.h"

#define SOFTENING 1e-9f

float Q_rsqrt(float number);



typedef struct {

    float x, y, z, vx, vy, vz;

} Body;



void sync_isr(int);



int main(void) {

    e_coreid_t coreid;

    unsigned row, col, *done;

    char *outbuf;

    int core;

    Body *q = (Body *) 0x1000;

    Body *p = (Body *) e_get_global_address(0, 0, q); // All 16 cores read / write to core 0,0 mem

    int *n = (int *) 0x0004; //numBodies

    int *o = (int *) 0x0008; //Done

    const float dt = 0.01f; // time step

    outbuf = (char *) 0x0000;



    while(1){

        e_irq_attach(E_SYNC, sync_isr);

        e_irq_mask(E_SYNC, E_FALSE);

        e_irq_global_mask(E_FALSE);

        // Who am I? Query the CoreID from hardware.

        coreid = e_get_coreid();

        e_coords_from_coreid(coreid, &row, &col);

        core = (4 * row) + (col + 1);



        int i, j;

        float dx;

        float dy;

        float dz;

        float distSqr;

        float invDist;

        float invDist3;

        // only work on this core's slice of the data array

        for (i = core - 1; i < *n; i += 16) {

            float Fx = 0.0f; float Fy = 0.0f; float Fz = 0.0f;

            for (j = 0; j < *n; j++) {

                dx = p[j].x - p[i].x;

                dy = p[j].y - p[i].y;

                dz = p[j].z - p[i].z;

                distSqr = dx*dx + dy*dy + dz*dz + SOFTENING;

                // Bad performance

                //invDist = 1.0f / sqrtf(distSqr);

                invDist = Q_rsqrt(distSqr);

                invDist3 = invDist * invDist * invDist;

                Fx += dx * invDist3;

                Fy += dy * invDist3;

                Fz += dz * invDist3;

            }

            p[i].vx += dt*Fx;

            p[i].vy += dt*Fy;

            p[i].vz += dt*Fz;

        }

        if(core == 1){  // Core 1 holds all data

            int *z[16];

            int num = 0;

            int all_done;

            for(i = 0; i < 4; i++){

                for(j = 0; j < 4; j++){

                    z[num++] = e_get_global_address(i, j, o);

                }

            }

            while(1){

                all_done = 0;

                for (i = 1; i < 16; i++){

                    all_done += *z[i];

                }

                if(all_done == 0){

                    break;

                }

            }

            // all cores done processing this iterations, calculate new x, y, z coordinates for next iteration

            for (i = 0; i < *n; i++) {

                p[i].x += p[i].vx * dt;

                p[i].y += p[i].vy * dt;

                p[i].z += p[i].vz * dt;

            }

        }

        (*(o)) = 0x00000000;

        while(((*(o)) == 0x00000000))

        __asm__ __volatile__ ("idle");

    }

}

void __attribute__((interrupt)) sync_isr(int x)

{

    return;

}

float Q_rsqrt(float number)

{

    long i;

    float x2, y;

    const float threehalfs = 1.5F;

    x2 = number * 0.5F;

    y = number;

    i = * ( long * ) &y;

    i = 0x5f3759df - ( i >> 1 );

    y = * (float *) &i;

    // 3 Iterations give good result, even # iterations don't work properly

    y = y * ( threehalfs - ( x2 * y * y ));

    y = y * ( threehalfs - ( x2 * y * y ));

    y = y * ( threehalfs - ( x2 * y * y ));

    return y;

}

            // all cores done processing this iterations, calculate new x, y, z coordinates for next iteration



            for (i = 0; i < *n; i++) {



                p[i].x += p[i].vx * dt;



                p[i].y += p[i].vy * dt;



                p[i].z += p[i].vz * dt;



            }

 for(i = 0; i < 4; i++){



                for(j = 0; j < 4; j++){



                    z[num++] = e_get_global_address(i, j, o);