int main(int argc, char *argv[])
{
ros::init(argc, argv, "epiphany_node");
unsigned row, col, coreid, i;
e_platform_t platform;
e_epiphany_t dev;
e_mem_t mbuf;
srand(1);
e_set_loader_verbosity(L_D0);
e_set_host_verbosity(H_D0);
// initialize system, read platform params from
// default HDF. Then, reset the platform and
// get the actual system parameters.
e_init(NULL);
e_reset_system();
e_get_platform_info(&platform);
// Allocate a buffer in shared external memory
// for message passing from eCore to host.
if ( E_OK != e_shm_alloc(&mbuf, ShmName, ShmSize) ) {
fprintf(stderr, "Failed to allocate shared memory. Error is %s\n",
strerror(errno));
return EXIT_FAILURE;
}
for (i=0; i<SeqLen; i++)
{
char buf[ShmSize];
// Draw a random core
row = rand() % platform.rows;
col = rand() % platform.cols;
coreid = (row + platform.row) * 64 + col + platform.col;
fprintf(stderr, "%3d: Message from eCore 0x%03x (%2d,%2d): ", i, coreid, row, col);
// Open the single-core workgroup and reset the core, in
// case a previous process is running. Note that we used
// core coordinates relative to the workgroup.
e_open(&dev, row, col, 1, 1);
e_reset_group(&dev);
// Load the device program onto the selected eCore
// and launch after loading.
if ( E_OK != e_load("e_hello_world.srec", &dev, 0, 0, E_TRUE) ) {
fprintf(stderr, "Failed to load e_hello_world.srec\n");
return EXIT_FAILURE;
}
// Wait for core program execution to finish, then
// read message from shared buffer.
usleep(10000);
e_read(&mbuf, 0, 0, 0, buf, ShmSize);
// Print the message and close the workgroup.
printf("\"%s\"\n", buf);
e_close(&dev);
}
// Release the allocated buffer and finalize the
// e-platform connection.
e_shm_release(ShmName);
e_finalize();
return 0;
}
int main(int argc, char *argv[])
{
char eprog[255];
e_bool_t istart;
e_epiphany_t dev;
e_platform_t plat;
unsigned row, col, rows, cols;
int iarg, iiarg;
if (E_OK != e_init(NULL))
{
fprintf(stderr, "Epiphany HAL initialization failed\n");
exit(EXIT_FAILURE);
}
if (E_OK != e_get_platform_info(&plat))
{
fprintf(stderr, "Failed to get Epiphany platform info\n");
exit(EXIT_FAILURE);
}
istart = E_FALSE;
row = 0;
col = 0;
rows = cols = 1;
iarg = iiarg = 1;
while (iiarg < argc)
{
if (!strcmp(argv[iiarg], "-h") || !strcmp(argv[iiarg], "--help"))
{
usage();
return 0;
} else if (!strcmp(argv[iiarg], "-r") || !strcmp(argv[iiarg], "--reset"))
{
/* Deprecated: no-op */
iarg++;
} else if (!strcmp(argv[iiarg], "-s") || !strcmp(argv[iiarg], "--start"))
{
istart = E_TRUE;
iarg++;
}
iiarg++;
}
switch (argc - iarg)
{
case 5:
rows = atoi(argv[iarg+3]);
cols = atoi(argv[iarg+4]);
case 3:
row = atoi(argv[iarg+1]);
col = atoi(argv[iarg+2]);
case 1:
strncpy(eprog, argv[iarg], 254);
break;
default:
usage();
exit(1);
}
if (E_OK != e_reset_system()) {
fprintf(stderr, "Failed to reset Epiphany system\n");
exit(EXIT_FAILURE);
}
if (E_OK != e_open(&dev, row, col, rows, cols))
{
fprintf(stderr, "Failed to open Epiphany workgroup\n");
exit(EXIT_FAILURE);
}
printf("Loading program \"%s\" on cores (%d,%d)-(%d,%d)\n", eprog, row, col, (row+rows-1), (col+cols-1));
e_set_loader_verbosity(L_D1);
if (E_OK != e_load_group(eprog, &dev, 0, 0, rows, cols, istart))
{
fprintf(stderr, "Failed loading program to group\n");
exit(EXIT_FAILURE);
}
e_close(&dev);
return 0;
}
int main(int argc, char *argv[])
{
e_epiphany_t Epiphany, *pEpiphany;
e_mem_t DRAM, *pDRAM;
unsigned int msize;
int row, col, cnum;
ILuint ImgId;
// ILenum Error;
ILubyte *imdata;
ILuint imsize, imBpp;
unsigned int addr;
size_t sz;
timeval_t timer[4];
uint32_t time_p[TIMERS];
uint32_t time_d[TIMERS];
FILE *fo;
// FILE *fi;
int result;
pEpiphany = &Epiphany;
pDRAM = &DRAM;
msize = 0x00400000;
get_args(argc, argv);
// fi = fopen(ifname, "rb");
// fo = stdout;
fo = fopen("matprt.m", "w");
if ((fo == NULL)) // || (fi == NULL))
{
fprintf(stderr, "Could not open Octave file \"%s\" ...exiting.\n", "matprt.m");
exit(4);
}
// fo = stderr;
// Connect to device for communicating with the Epiphany system
// Prepare device
e_set_loader_verbosity(ar.verbose);
e_init(NULL);
e_reset_system();
e_get_platform_info(&platform);
if (e_open(pEpiphany, 0, 0, platform.rows, platform.cols))
{
fprintf(fo, "\nERROR: Can't establish connection to Epiphany device!\n\n");
exit(1);
}
if (e_alloc(pDRAM, 0x00000000, msize))
{
fprintf(fo, "\nERROR: Can't allocate Epiphany DRAM!\n\n");
exit(1);
}
// Initialize Epiphany "Ready" state
addr = offsetof(shared_buf_t, core.ready);
Mailbox.core.ready = 0;
e_write(pDRAM, 0, 0, addr, (void *) &(Mailbox.core.ready), sizeof(Mailbox.core.ready));
printf("Loading program on Epiphany chip...\n");
strcpy(ar.srecFile, "../../device/Release/e_fft2d.srec");
result = e_load_group(ar.srecFile, pEpiphany, 0, 0, platform.rows, platform.cols, (e_bool_t) (ar.run_target));
if (result == E_ERR) {
printf("Error loading Epiphany program.\n");
exit(1);
}
// Check if the DevIL shared lib's version matches the executable's version.
if (ilGetInteger(IL_VERSION_NUM) < IL_VERSION)
{
fprintf(stderr, "DevIL version is different ...exiting!\n");
exit(2);
}
// Initialize DevIL.
ilInit();
#ifdef ILU_ENABLED
iluInit();
#endif
// create the coreID list
init_coreID(pEpiphany, coreID, _Nside, _Nside, 0x808);
// Generate the main image name to use, bind it and load the image file.
ilGenImages(1, &ImgId);
ilBindImage(ImgId);
printf("\n");
printf("Loading original image from file \"%s\".\n\n", ar.ifname);
if (!ilLoadImage(ar.ifname))
{
fprintf(stderr, "Could not open input image file \"%s\" ...exiting.\n", ar.ifname);
exit(3);
}
// Display the image's dimensions to the end user.
printf("Width: %d Height: %d Depth: %d Bpp: %d\n\n",
ilGetInteger(IL_IMAGE_WIDTH),
ilGetInteger(IL_IMAGE_HEIGHT),
ilGetInteger(IL_IMAGE_DEPTH),
ilGetInteger(IL_IMAGE_BITS_PER_PIXEL));
imdata = ilGetData();
imsize = ilGetInteger(IL_IMAGE_WIDTH) * ilGetInteger(IL_IMAGE_HEIGHT);
imBpp = ilGetInteger(IL_IMAGE_BYTES_PER_PIXEL);
if (imsize != (_Sfft * _Sfft))
{
printf("Image file size is different from %dx%d ...exiting.\n", _Sfft, _Sfft);
exit(5);
}
// Extract image data into the A matrix.
for (unsigned int i=0; i<imsize; i++)
{
Mailbox.A[i] = (float) imdata[i*imBpp] + 0.0 * I;
}
fprintf(fo, "\n");
// Generate operand matrices based on a provided seed
matrix_init(0);
#ifdef _USE_DRAM_
// Copy operand matrices to Epiphany system
addr = DRAM_BASE + offsetof(shared_buf_t, A[0]);
sz = sizeof(Mailbox.A);
printf( "Writing A[%ldB] to address %08x...\n", sz, addr);
fprintf(fo, "%% Writing A[%ldB] to address %08x...\n", sz, addr);
e_write(addr, (void *) Mailbox.A, sz);
addr = DRAM_BASE + offsetof(shared_buf_t, B[0]);
sz = sizeof(Mailbox.B);
printf( "Writing B[%ldB] to address %08x...\n", sz, addr);
fprintf(fo, "%% Writing B[%ldB] to address %08x...\n", sz, addr);
e_write(addr, (void *) Mailbox.B, sz);
#else
// Copy operand matrices to Epiphany cores' memory
printf( "Writing image to Epiphany\n");
fprintf(fo, "%% Writing image to Epiphany\n");
sz = sizeof(Mailbox.A) / _Ncores;
for (row=0; row<(int) platform.rows; row++)
for (col=0; col<(int) platform.cols; col++)
{
addr = BankA_addr;
printf(".");
fflush(stdout);
cnum = e_get_num_from_coords(pEpiphany, row, col);
// printf( "Writing A[%uB] to address %08x...\n", sz, addr);
fprintf(fo, "%% Writing A[%uB] to address %08x...\n", sz, (coreID[cnum] << 20) | addr); fflush(fo);
e_write(pEpiphany, row, col, addr, (void *) &Mailbox.A[cnum * _Score * _Sfft], sz);
}
printf("\n");
#endif
// Call the Epiphany fft2d() function
printf( "GO!\n");
fprintf(fo, "%% GO!\n");
fflush(stdout);
fflush(fo);
gettimeofday(&timer[0], NULL);
fft2d_go(pDRAM);
gettimeofday(&timer[1], NULL);
printf( "Done!\n\n");
fprintf(fo, "%% Done!\n\n");
fflush(stdout);
fflush(fo);
// Read time counters
// printf( "Reading time count...\n");
fprintf(fo, "%% Reading time count...\n");
addr = 0x7128+0x4*2 + offsetof(core_t, time_p[0]);
sz = TIMERS * sizeof(uint32_t);
e_read(pEpiphany, 0, 0, addr, (void *) (&time_p[0]), sz);
// for (int i=0; i<TIMERS; i++)
// printf("time_p[%d] = %u\n", i, time_p[i]);
time_d[2] = time_p[7] - time_p[2]; // FFT setup
time_d[3] = time_p[2] - time_p[3]; // bitrev (x8)
time_d[4] = time_p[3] - time_p[4]; // FFT-1D (x8)
time_d[5] = time_p[4] - time_p[5]; // corner-turn
time_d[6] = time_p[7] - time_p[8]; // FFT-2D
time_d[7] = time_p[6] - time_p[7]; // LPF
time_d[9] = time_p[0] - time_p[9]; // Total cycles
printf( "Finished calculation in %u cycles (%5.3f msec @ %3.0f MHz)\n\n", time_d[9], (time_d[9] * 1000.0 / eMHz), (eMHz / 1e6));
fprintf(fo, "%% Finished calculation in %u cycles (%5.3f msec @ %3.0f MHz)\n\n", time_d[9], (time_d[9] * 1000.0 / eMHz), (eMHz / 1e6));
printf( "FFT2D - %7u cycles (%5.3f msec)\n", time_d[6], (time_d[6] * 1000.0 / eMHz));
printf( " FFT Setup - %7u cycles (%5.3f msec)\n", time_d[2], (time_d[2] * 1000.0 / eMHz));
printf( " BITREV - %7u cycles (%5.3f msec)\n", time_d[3], (time_d[3] * 1000.0 / eMHz));
printf( " FFT1D - %7u cycles (%5.3f msec x2)\n", time_d[4], (time_d[4] * 1000.0 / eMHz));
printf( " Corner Turn - %7u cycles (%5.3f msec)\n", time_d[5], (time_d[5] * 1000.0 / eMHz));
printf( "LPF - %7u cycles (%5.3f msec)\n", time_d[7], (time_d[7] * 1000.0 / eMHz));
printf( "\n");
printf( "Reading processed image back to host\n");
fprintf(fo, "%% Reading processed image back to host\n");
// Read result matrix
#ifdef _USE_DRAM_
addr = DRAM_BASE + offsetof(shared_buf_t, B[0]);
sz = sizeof(Mailbox.B);
printf( "Reading B[%ldB] from address %08x...\n", sz, addr);
fprintf(fo, "%% Reading B[%ldB] from address %08x...\n", sz, addr);
blknum = sz / RdBlkSz;
remndr = sz % RdBlkSz;
for (i=0; i<blknum; i++)
{
printf(".");
fflush(stdout);
e_read(addr+i*RdBlkSz, (void *) ((long unsigned)(Mailbox.B)+i*RdBlkSz), RdBlkSz);
}
printf(".");
fflush(stdout);
e_read(addr+i*RdBlkSz, (void *) ((long unsigned)(Mailbox.B)+i*RdBlkSz), remndr);
#else
// Read result matrix from Epiphany cores' memory
sz = sizeof(Mailbox.A) / _Ncores;
for (row=0; row<(int) platform.rows; row++)
for (col=0; col<(int) platform.cols; col++)
{
addr = BankA_addr;
printf(".");
fflush(stdout);
cnum = e_get_num_from_coords(pEpiphany, row, col);
// printf( "Reading A[%uB] from address %08x...\n", sz, addr);
fprintf(fo, "%% Reading A[%uB] from address %08x...\n", sz, (coreID[cnum] << 20) | addr); fflush(fo);
e_read(pEpiphany, row, col, addr, (void *) &Mailbox.B[cnum * _Score * _Sfft], sz);
}
#endif
printf("\n");
// Convert processed image matrix B into the image file date.
for (unsigned int i=0; i<imsize; i++)
{
for (unsigned int j=0; j<imBpp; j++)
imdata[i*imBpp+j] = cabs(Mailbox.B[i]);
}
// Save processed image to the output file.
ilEnable(IL_FILE_OVERWRITE);
printf("\nSaving processed image to file \"%s\".\n\n", ar.ofname);
if (!ilSaveImage(ar.ofname))
{
fprintf(stderr, "Could not open output image file \"%s\" ...exiting.\n", ar.ofname);
exit(7);
}
// We're done with the image, so let's delete it.
ilDeleteImages(1, &ImgId);
// Simple Error detection loop that displays the Error to the user in a human-readable form.
// while ((Error = ilGetError()))
// PRINT_ERROR_MACRO;
// Close connection to device
if (e_close(pEpiphany))
{
fprintf(fo, "\nERROR: Can't close connection to Epiphany device!\n\n");
exit(1);
}
if (e_free(pDRAM))
{
fprintf(fo, "\nERROR: Can't release Epiphany DRAM!\n\n");
exit(1);
}
fflush(fo);
fclose(fo);
//Returnin success if test runs expected number of clock cycles
//Need to add comparison with golden reference image!
if(time_d[9]>50000){
return EXIT_SUCCESS;
}
else{
return EXIT_FAILURE;
}
}
int main(int argc, char *argv[])
{
char eprog[255];
e_bool_t ireset, istart;
e_epiphany_t dev;
e_platform_t plat;
unsigned row, col, rows, cols;
int iarg, iiarg;
e_get_platform_info(&plat);
ireset = E_FALSE;
istart = E_FALSE;
row = plat.row;
col = plat.col;
rows = cols = 1;
iarg = iiarg = 1;
while (iiarg < argc)
{
if (!strcmp(argv[iiarg], "-h") || !strcmp(argv[iiarg], "--help"))
{
usage();
return 0;
} else if (!strcmp(argv[iiarg], "-r") || !strcmp(argv[iiarg], "--reset"))
{
ireset = E_TRUE;
iarg++;
} else if (!strcmp(argv[iiarg], "-s") || !strcmp(argv[iiarg], "--start"))
{
istart = E_TRUE;
iarg++;
}
iiarg++;
}
switch (argc - iarg)
{
case 5:
rows = atoi(argv[iarg+3]);
cols = atoi(argv[iarg+4]);
case 3:
row = atoi(argv[iarg+1]);
col = atoi(argv[iarg+2]);
case 1:
strncpy(eprog, argv[iarg], 254);
break;
default:
usage();
exit(1);
}
e_init(NULL);
if (ireset)
e_reset_system();
e_open(&dev, row, col, rows, cols);
printf("Loading program \"%s\" on cores (%d,%d)-(%d,%d)\n", eprog, row, col, (row+rows-1), (col+cols-1));
e_set_loader_verbosity(L_D1);
e_load_group(eprog, &dev, 0, 0, rows, cols, istart);
e_close(&dev);
e_finalize();
return 0;
}
int main(int argc, char *argv[])
{
e_epiphany_t Epiphany, *pEpiphany;
e_mem_t DRAM, *pDRAM;
unsigned int msize;
float seed;
unsigned int addr; //, clocks;
size_t sz;
double tdiff[4];
int result, rerval;
pEpiphany = &Epiphany;
pDRAM = &DRAM;
msize = 0x00400000;
get_args(argc, argv);
fo = stderr;
fi = stdin;
printf("\nMatrix: C[%d][%d] = A[%d][%d] * B[%d][%d]\n\n", _Smtx, _Smtx, _Smtx, _Smtx, _Smtx, _Smtx);
printf("Using %d x %d cores\n\n", _Nside, _Nside);
seed = 0.0;
printf("Seed = %f\n", seed);
// Connect to device for communicating with the Epiphany system
// Prepare device
e_set_host_verbosity(H_D0);
e_init(NULL);
e_reset_system();
if (e_alloc(pDRAM, 0x00000000, msize))
{
printf("\nERROR: Can't allocate Epiphany DRAM!\n\n");
exit(1);
}
if (e_open(pEpiphany, 0, 0, e_platform.chip[0].rows, e_platform.chip[0].cols))
{
printf("\nERROR: Can't establish connection to Epiphany device!\n\n");
exit(1);
}
// Initialize Epiphany "Ready" state
addr = offsetof(shared_buf_t, core.ready);
Mailbox.core.ready = 0;
e_write(pDRAM, 0, 0, addr, &Mailbox.core.ready, sizeof(Mailbox.core.ready));
printf("Loading program on Epiphany chip...\n");
e_set_loader_verbosity(ar.verbose);
result = e_load_group(ar.srecFile, pEpiphany, 0, 0, pEpiphany->rows, pEpiphany->cols, ar.run_target);
if (result == E_ERR) {
printf("Error loading Epiphany program.\n");
exit(1);
}
// Generate operand matrices based on a provided seed
matrix_init(seed);
#ifdef __WIPE_OUT_RESULT_MATRIX__
// Wipe-out any previous remains in result matrix (for verification)
addr = offsetof(shared_buf_t, C[0]);
sz = sizeof(Mailbox.C);
printf("Writing C[%uB] to address %08x...\n", sz, addr);
e_write(pDRAM, 0, 0, addr, (void *) Mailbox.C, sz);
#endif
clock_gettime(CLOCK_MONOTONIC, &timer[0]);
// Copy operand matrices to Epiphany system
addr = offsetof(shared_buf_t, A[0]);
sz = sizeof(Mailbox.A);
printf("Writing A[%uB] to address %08x...\n", sz, addr);
e_write(pDRAM, 0, 0, addr, (void *) Mailbox.A, sz);
addr = offsetof(shared_buf_t, B[0]);
sz = sizeof(Mailbox.B);
printf("Writing B[%uB] to address %08x...\n", sz, addr);
e_write(pDRAM, 0, 0, addr, (void *) Mailbox.B, sz);
// Call the Epiphany matmul() function
printf("GO Epiphany! ... ");
clock_gettime(CLOCK_MONOTONIC, &timer[1]);
matmul_go(pDRAM);
clock_gettime(CLOCK_MONOTONIC, &timer[2]);
printf("Finished calculating Epiphany result.\n");
// Read result matrix and timing
addr = offsetof(shared_buf_t, C[0]);
sz = sizeof(Mailbox.C);
printf("Reading result from address %08x...\n", addr);
e_read(pDRAM, 0, 0, addr, (void *) Mailbox.C, sz);
clock_gettime(CLOCK_MONOTONIC, &timer[3]);
// Calculate a reference result
printf("Calculating result on Host ... ");
clock_gettime(CLOCK_THREAD_CPUTIME_ID, &timer[4]);
#ifndef __DO_STRASSEN__
matmul(Mailbox.A, Mailbox.B, Cref, _Smtx);
#else
matmul_strassen(Mailbox.A, Mailbox.B, Cref, _Smtx);
#endif
clock_gettime(CLOCK_THREAD_CPUTIME_ID, &timer[5]);
printf("Finished calculating Host result.\n");
addr = offsetof(shared_buf_t, core.clocks);
sz = sizeof(Mailbox.core.clocks);
printf("Reading time from address %08x...\n", addr);
e_read(pDRAM,0, 0, addr, &Mailbox.core.clocks, sizeof(Mailbox.core.clocks));
// clocks = Mailbox.core.clocks;
// Calculate the difference between the Epiphany result and the reference result
printf("\n*** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***\n");
printf("Verifying result correctness ... ");
matsub(Mailbox.C, Cref, Cdiff, _Smtx);
tdiff[0] = (timer[2].tv_sec - timer[1].tv_sec) * 1000 + ((double) (timer[2].tv_nsec - timer[1].tv_nsec) / 1000000.0);//total
tdiff[1] = (timer[1].tv_sec - timer[0].tv_sec) * 1000 + ((double) (timer[1].tv_nsec - timer[0].tv_nsec) / 1000000.0);//write
tdiff[2] = (timer[3].tv_sec - timer[2].tv_sec) * 1000 + ((double) (timer[3].tv_nsec - timer[2].tv_nsec) / 1000000.0);//read
tdiff[3] = (timer[5].tv_sec - timer[4].tv_sec) * 1000 + ((double) (timer[5].tv_nsec - timer[4].tv_nsec) / 1000000.0);//ref
// If the difference is 0, then the matrices are identical and the
// calculation was correct
if (iszero(Cdiff, _Smtx))
{
printf("C_epiphany == C_host\n");
rerval = 0;
} else {
printf("\n\nERROR: C_epiphany is different from C_host !!!\n");
rerval = 1;
}
printf("*** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***\n");
printf("\n");
printf("Epiphany (compute): %9.1f msec (@ %03d MHz)\n" , tdiff[0], eMHz);
printf(" (write) : %9.1f msec \n" , tdiff[1]);
printf(" (read) : %9.1f msec\n" , tdiff[2]);
printf(" (*total*): %9.1f msec\n\n" , tdiff[2]+tdiff[1]+tdiff[0]);
printf("Host (*total*): %9.1f msec (@ %03d MHz)\n" , tdiff[3], aMHz);
#ifdef __DUMP_MATRICES__
printf("\n\n\n");
printf("A[][] = \n");
matprt(Mailbox.A, _Smtx);
printf("B[][] = \n");
matprt(Mailbox.B, _Smtx);
printf("C[][] = \n");
matprt(Mailbox.C, _Smtx);
printf("Cref[][] = \n");
matprt(Cref, _Smtx);
int i, j;
for (i=0; i<_Nside; i++)
for (j=0; j<_Nside; j++)
{
e_read(pEpiphany, i, j, 0x2000+0*sizeof(float), &Aepi[(i*_Score+0)*_Smtx + j*_Score], 2*sizeof(float));
e_read(pEpiphany, i, j, 0x2000+2*sizeof(float), &Aepi[(i*_Score+1)*_Smtx + j*_Score], 2*sizeof(float));
e_read(pEpiphany, i, j, 0x4000+0*sizeof(float), &Bepi[(i*_Score+0)*_Smtx + j*_Score], 2*sizeof(float));
e_read(pEpiphany, i, j, 0x4000+2*sizeof(float), &Bepi[(i*_Score+1)*_Smtx + j*_Score], 2*sizeof(float));
}
printf("Aepi[][] = \n");
matprt(Aepi, _Smtx);
printf("Bepi[][] = \n");
matprt(Bepi, _Smtx);
#endif
printf("\n* * * EPIPHANY FTW !!! * * *\n");
// Close connection to device
if (e_close(pEpiphany))
{
printf("\nERROR: Can't close connection to Epiphany device!\n\n");
exit(1);
}
if (e_free(pDRAM))
{
printf("\nERROR: Can't release Epiphany DRAM!\n\n");
exit(1);
}
e_finalize();
return rerval;
}
