void* stream_read_thread(void* args) {
uint32_t buf[1024];
PicoDrv *pico = ((read_thread_args*)args)->pico;
int stream = ((read_thread_args*)args)->stream;
uint32_t * results_buf = ((read_thread_args*)args)->results_buf;
int num_queries = ((read_thread_args*)args)->num_queries;
int engine_id = ((read_thread_args*)args)->engine_id;
uint32_t* query_ids = ((read_thread_args*)args)->query_ids;
int offset = 0;
uint32_t temp_buf[1024];
int num_queries_done = 0;
while (num_queries_done != num_queries) {
int num_bytes_available = pico->GetBytesAvailable(stream, true);
if (num_bytes_available >= 16) {
int num_bytes_to_read = num_bytes_available > 4096 ? 4096 : (num_bytes_available/16)*16;
// Read full 128-bit packets
pico->ReadStream(stream, temp_buf, num_bytes_to_read);
// For each result location read
for (int i = 0; i < num_bytes_to_read / 16; i++) {
results_buf[offset*2] = temp_buf[i*4];
results_buf[offset*2 + 1] = temp_buf[i*4 + 1];
if (results_buf[offset*2] == EOQ) {
num_queries_done++;
}
offset++;
}
}
}
}
void* stream_write_thread(void* args) {
PicoDrv *pico = ((write_thread_args*)args)->pico;
int stream = ((write_thread_args*)args)->stream;
int num_queries = ((write_thread_args*)args)->num_queries;
int* query_len_bytes = ((write_thread_args*)args)->query_len_bytes;
char** query_buf = ((write_thread_args*)args)->query_buf;
int ref_len_bytes = ((write_thread_args*)args)->ref_len_bytes;
uint32_t cell_score_threshold = ((write_thread_args*)args)->cell_score_threshold;
int engine_id = ((write_thread_args*)args)->engine_id;
uint32_t* query_ids = ((write_thread_args*)args)->query_ids;
uint32_t out_buf[1024];
// For each query
for (int i = 0; i < num_queries; i++) {
out_buf[0] = (ref_len_bytes * 4)/128;
out_buf[1] = 0;
out_buf[2] = (query_ids[i] << 16) + (query_len_bytes[i] * 4-1);
out_buf[3] = cell_score_threshold;
// For each query block of the query
for (int j = 0; j < (query_len_bytes[i] * 4)/64; j++) {
// For each 32-bit chunk of the 128-bit query block
for (int k = 0; k < 4; k++) {
out_buf[j*4 + k + 4] = ((unsigned char) query_buf[i][j*16 + k*4]) +
((unsigned char) query_buf[i][j*16 + k*4 + 1] << 8) +
((unsigned char) query_buf[i][j*16 + k*4 + 2] << 16) +
((unsigned char) query_buf[i][j*16 + k*4 + 3] << 24);
}
}
fprintf(stderr, "Engine %i, Writing query %i with %i bytes\n", engine_id, query_ids[i], 16+query_len_bytes[i]);
pico->WriteStream(stream, out_buf, 16 + query_len_bytes[i]);
}
}
void* stream_write_thread(void* args) {
PicoDrv *pico = ((write_thread_args*)args)->pico;
int stream = ((write_thread_args*)args)->stream;
int query_len_bytes = ((write_thread_args*)args)->query_len_bytes;
char* query_buf = ((write_thread_args*)args)->query_buf;
uint32_t ref_len_bytes = ((write_thread_args*)args)->ref_len_bytes;
uint32_t cell_score_threshold = ((write_thread_args*)args)->cell_score_threshold;
int engine_id = ((write_thread_args*)args)->engine_id;
uint32_t* query_ids = ((write_thread_args*)args)->query_ids;
uint32_t ref_addr = ((write_thread_args*)args)->ref_addr;
uint32_t out_buf[1024];
// For each query
//for (int i = 0; i < ITERATIONS; i++) {
for (int i = 0; i < 1; i++) {
out_buf[0] = ref_len_bytes/32;
out_buf[1] = ref_addr; // Index of 256-bit block
out_buf[2] = ((query_ids[i]) << 16) + (query_len_bytes * 4)/64;
out_buf[3] = cell_score_threshold;
// For each query block of the query
for (int j = 0; j < (query_len_bytes * 4)/64; j++) {
// For each 32-bit chunk of the 128-bit query block
for (int k = 0; k < 4; k++) {
out_buf[j*4 + k + 4] = ((unsigned char) query_buf[j*16 + k*4]) +
((unsigned char) query_buf[j*16 + k*4 + 1] << 8) +
((unsigned char) query_buf[j*16 + k*4 + 2] << 16) +
((unsigned char) query_buf[j*16 + k*4 + 3] << 24);
}
}
pico->WriteStream(stream, out_buf, 16 + query_len_bytes);
}
}
void* stream_read_thread(void* args) {
uint32_t buf[1024];
PicoDrv *pico = ((read_thread_args*)args)->pico;
int stream = ((read_thread_args*)args)->stream;
uint32_t * results_buf = ((read_thread_args*)args)->results_buf;
int num_queries = ((read_thread_args*)args)->num_queries;
int engine_id = ((read_thread_args*)args)->engine_id;
uint32_t * num_bytes_returned = ((read_thread_args*)args)->num_bytes_returned;
int offset = 0;
uint32_t temp_buf[1024];
int num_queries_done = 0;
uint32_t num_bytes_read = 0;
//while (num_queries_done != num_queries) {
while (num_queries_done != 1) {
int num_bytes_available = pico->GetBytesAvailable(stream, true);
if (num_bytes_available >= 16) {
int num_bytes_to_read = num_bytes_available > 4096 ? 4096 : (num_bytes_available/16)*16;
// Read full 128-bit packets
pico->ReadStream(stream, temp_buf, num_bytes_to_read);
num_bytes_read += num_bytes_to_read;
// For each result location read
for (int i = 0; i < num_bytes_to_read / 16; i++) {
results_buf[offset*2] = temp_buf[i*4];
results_buf[offset*2 + 1] = temp_buf[i*4 + 1];
if (results_buf[offset*2] == EOQ) {
num_queries_done++;
}
offset++;
offset%=(RESULT_BUF_SIZE/2);
}
}
}
*num_bytes_returned = num_bytes_read;
// fprintf(stderr, "Read %i bytes\n", num_bytes_read);
}
int main(int argc, char* argv[])
{
int err, num_engines;
int* stream;
uint32_t cell_score_threshold;
uint32_t** query_ids;
char * ref_buf;
char *** query_buf;
int ** query_len;
char ibuf[1024];
uint32_t ** results_buf;
PicoDrv *pico;
const char* bitFileName;
const char* ref_filename;
int num_queries;
pthread_t* read_thread;
pthread_t* write_thread;
read_thread_args* rta;
write_thread_args* wta;
// specify the .bit file name on the command line
if (argc < 6) {
fprintf(stderr, "Usage: ./SmithWatermanAccelerator <BIT FILE> <NUM_ENGINES> <CELL SCORE THRESHOLD> <REF SEQ FILE> <QUERY SEQ FILE 1> [<QUERY SEQ FILE 2> ...]");
exit(1);
}
bitFileName = argv[1];
num_engines = atoi(argv[2]);
cell_score_threshold = (uint32_t) atoi(argv[3]);
ref_filename = argv[4];
num_queries = argc - 5;
const char* query_filenames[num_queries];
for (int i = 0; i < num_queries; i++) {
query_filenames[i] = argv[i+5];
}
// Read ref seq file into memory
std::ifstream ref_file;
std::ifstream::pos_type ref_size;
ref_file.open(ref_filename, std::ios::in | std::ios::binary | std::ios::ate);
if (ref_file.is_open()) {
ref_size = ref_file.tellg();
ref_buf = new char[ref_size];
ref_file.seekg(0, std::ios::beg);
ref_file.read(ref_buf, ref_size);
ref_file.close();
printf("Read ref seq file '%s' of length %iB\n", ref_filename, (int) ref_size);
} else {
fprintf(stderr, "Unable to open ref seq file '%s'", ref_filename);
exit(1);
}
// Read query seq files into memory
query_buf = new char** [num_engines];
query_len = new int* [num_engines];
query_ids = new uint32_t* [num_engines];
int num_queries_per_engine[num_engines];
for (int i = 0; i < num_engines; i++) {
if (i < num_queries % num_engines) {
num_queries_per_engine[i] = (num_queries / num_engines) + 1;
} else {
num_queries_per_engine[i] = num_queries / num_engines;
}
}
for (int i = 0; i < num_engines; i++) {
query_buf[i] = new char* [num_queries_per_engine[i]];
query_len[i] = new int [num_queries_per_engine[i]];
query_ids[i] = new uint32_t [num_queries_per_engine[i]];
}
int cur_engine = 0;
for (int i = 0; i < num_queries; i++) {
std::ifstream query_file;
std::ifstream::pos_type query_size;
query_file.open(query_filenames[i], std::ios::in | std::ios::binary | std::ios::ate);
if (query_file.is_open()) {
query_size = query_file.tellg();
query_len[cur_engine][i/num_engines] = (int) query_size;
query_buf[cur_engine][i/num_engines] = new char[query_size];
query_ids[cur_engine][i/num_engines] = i;
query_file.seekg(0, std::ios::beg);
query_file.read(query_buf[cur_engine][i/num_engines], query_size);
query_file.close();
printf("Read query seq file '%s' of length %iB for engine %i\n", query_filenames[i], (int) query_size, cur_engine);
cur_engine++;
cur_engine %= num_engines;
} else {
fprintf(stderr, "Unable to open query seq file '%s'", query_filenames[i]);
exit(1);
}
}
/*
query_buf = new char* [num_queries];
query_len = new int [num_queries];
for (int i = 0; i < num_queries; i++) {
std::ifstream query_file;
std::ifstream::pos_type query_size;
query_file.open(query_filenames[i], std::ios::in | std::ios::binary | std::ios::ate);
if (query_file.is_open()) {
query_size = query_file.tellg();
query_len[i] = (int) query_size;
query_buf[i] = new char[query_size];
query_file.seekg(0, std::ios::beg);
query_file.read(query_buf[i], query_size);
query_file.close();
printf("Read query seq file '%s' of length %iB\n", query_filenames[i], (int) query_size);
} else {
fprintf(stderr, "Unable to open query seq file '%s'", query_filenames[i]);
exit(1);
}
}*/
// The RunBitFile function will locate a Pico card that can run the given bit file, and is not already
// opened in exclusive-access mode by another program. It requests exclusive access to the Pico card
// so no other programs will try to reuse the card and interfere with us.
printf("Loading FPGA with '%s' ...\n", bitFileName);
err = RunBitFile(bitFileName, &pico);
if (err < 0) {
// We use the PicoErrors_FullError function to decipher error codes from RunBitFile.
// This is more informative than just printing the numeric code, since it can report the name of a
// file that wasn't found, for example.
fprintf(stderr, "RunBitFile error: %s\n", PicoErrors_FullError(err, ibuf, sizeof(ibuf)));
exit(1);
}
// Open streams to engines
printf("Opening streams\n");
stream = new int[num_engines];
for (int i = 0; i < num_engines; i++) {
stream[i] = pico->CreateStream(i+1);
if (stream[i] < 0) {
fprintf(stderr, "couldn't open stream %i! (return code: %i)\n", i+1, stream[i]);
exit(1);
}
}
// Write reference sequence to the DRAM
printf("Writing ref seq to DRAM\n");
err = pico->WriteRam(0, ref_buf, ref_size, PICO_DDR3_0);
if (err < 0) {
fprintf(stderr, "WriteRam error: %s\n", PicoErrors_FullError(err, ibuf, sizeof(ibuf)));
exit(1);
} else if (err != ref_size) {
fprintf(stderr, "WriteRam wrote %i bytes instead of the desire %i bytes\n", err, (int) ref_size);
exit(1);
}
sleep(1);
// Start read/write threads
printf("Starting Smith Waterman tests\n");
results_buf = new uint32_t* [num_engines];
for (int i = 0; i < num_engines; i++) {
results_buf[i] = new uint32_t[RESULT_BUF_SIZE];
for (int j = 0; j < RESULT_BUF_SIZE; j++) {
results_buf[i][j] = 0;
}
}
wta = new write_thread_args[num_engines];
rta = new read_thread_args[num_engines];
for (int i = 0; i < num_engines; i++) {
wta[i].pico = pico;
wta[i].stream = stream[i];
wta[i].num_queries = num_queries_per_engine[i];
wta[i].query_len_bytes = query_len[i];
wta[i].query_buf = query_buf[i];
wta[i].ref_len_bytes = (int) ref_size;
wta[i].cell_score_threshold = cell_score_threshold;
wta[i].engine_id = i;
wta[i].query_ids = query_ids[i];
rta[i].pico = pico;
rta[i].stream = stream[i];
rta[i].results_buf = results_buf[i];
rta[i].num_queries = num_queries_per_engine[i];
rta[i].engine_id = i;
rta[i].query_ids = query_ids[i];
}
read_thread = new pthread_t[num_engines];
write_thread = new pthread_t[num_engines];
for (int i = 0; i < num_engines; i++) {
pthread_create(&(read_thread[i]), NULL, &stream_read_thread, (void*) &(rta[i]));
pthread_create(&(write_thread[i]), NULL, &stream_write_thread, (void*) &(wta[i]));
}
for (int i = 0; i < num_engines; i++) {
pthread_join(read_thread[i], NULL);
pthread_join(write_thread[i], NULL);
}
for (int i = 0; i < num_engines; i++) {
for (int j = 0; j < RESULT_BUF_SIZE; j++) {
printf("%i\t", results_buf[i][j]);
}
printf("\n\n");
}
// streams are automatically closed when the PicoDrv object is destroyed, or on program termination, but
// we can also close a stream manually.
for (int i = 0; i < num_engines; i++) {
pico->CloseStream(stream[i]);
}
return 0;
}
int main(int argc, char* argv[])
{
int err, i, j, stream;
int room;
int *tmp = NULL;
int stream11, stream12, stream13;
int stream21, stream22, stream23;
int stream31, stream32, stream33;
int stream41, stream42, stream43;
int stream51, stream52, stream53;
int stream61, stream62, stream63;
int stream71, stream72, stream73;
int stream81, stream82, stream83;
uint32_t buf[1024], u32, addr;
char ibuf[1024];
PicoDrv *pico;
const char* bitFileName;
printf("Start\r\n");
// specify the .bit file name on the command line
switch(argc) {
case 1: {
if ((err = FindPico(0x505, &pico)) < 0) {
printf("FindPico Error\r\n");
return err;
}
}break;
case 2: {
bitFileName = argv[1];
printf("Loading FPGA with '%s' ...\n", bitFileName);
err = RunBitFile(bitFileName, &pico);
if (err < 0) {
fprintf(stderr, "RunBitFile error: %s\n", PicoErrors_FullError(err, ibuf, sizeof(ibuf)));
exit(1);
}
}break;
}
printf("Opening stream50 (CMD)\r\n");
stream = pico->CreateStream(50);
if (stream < 0) {
fprintf(stderr, "CreateStream error: %s\n", PicoErrors_FullError(stream, ibuf, sizeof(ibuf)));
exit(1);
}
//==============================================================================
int *A = new int[SIZE];
int *B = new int[SIZE];
int *C = new int[SIZE];
int *D = new int[SIZE];
for (i = 0; i < SIZE; i++) {
A[i] = i + 1;
B[i] = i + 1;
C[i] = 0;
D[i] = 0;
}
struct timeval start, end;
gettimeofday(&start, NULL);
for (i = 0; i < SIZE; i++) {
C[i] = A[i] + B[i];
}
gettimeofday(&end, NULL);
int timeuse = 1000000 * (end.tv_sec - start.tv_sec) + end.tv_usec - start.tv_usec;
printf("CPU %4d threads :\t%9d us\r\n", 1, timeuse);
// printf("Opening stream21 (CMD)\r\n");
// stream21 = pico->CreateStream(21);
// if (stream21 < 0) {
// fprintf(stderr, "CreateStream error: %s\n", PicoErrors_FullError(stream21, ibuf, sizeof(ibuf)));
// exit(1);
// }
// printf("Opening stream22 (CMD)\r\n");
// stream22 = pico->CreateStream(22);
// if (stream22 < 0) {
// fprintf(stderr, "CreateStream error: %s\n", PicoErrors_FullError(stream22, ibuf, sizeof(ibuf)));
// exit(1);
// }
// printf("Opening stream23 (CMD)\r\n");
// stream23 = pico->CreateStream(23);
// if (stream23 < 0) {
// fprintf(stderr, "CreateStream error: %s\n", PicoErrors_FullError(stream23, ibuf, sizeof(ibuf)));
// exit(1);
// }
// printf("Opening stream31 (CMD)\r\n");
// stream31 = pico->CreateStream(31);
// if (stream31 < 0) {
// fprintf(stderr, "CreateStream error: %s\n", PicoErrors_FullError(stream31, ibuf, sizeof(ibuf)));
// exit(1);
// }
// printf("Opening stream32 (CMD)\r\n");
// stream32 = pico->CreateStream(32);
// if (stream32 < 0) {
// fprintf(stderr, "CreateStream error: %s\n", PicoErrors_FullError(stream32, ibuf, sizeof(ibuf)));
// exit(1);
// }
// printf("Opening stream33 (CMD)\r\n");
// stream33 = pico->CreateStream(33);
// if (stream33 < 0) {
// fprintf(stderr, "CreateStream error: %s\n", PicoErrors_FullError(stream33, ibuf, sizeof(ibuf)));
// exit(1);
// }
// printf("Opening stream41 (CMD)\r\n");
// stream41 = pico->CreateStream(41);
// if (stream41 < 0) {
// fprintf(stderr, "CreateStream error: %s\n", PicoErrors_FullError(stream41, ibuf, sizeof(ibuf)));
// exit(1);
// }
// printf("Opening stream42 (CMD)\r\n");
// stream42 = pico->CreateStream(42);
// if (stream42 < 0) {
// fprintf(stderr, "CreateStream error: %s\n", PicoErrors_FullError(stream42, ibuf, sizeof(ibuf)));
// exit(1);
// }
// printf("Opening stream43 (CMD)\r\n");
// stream43 = pico->CreateStream(43);
// if (stream43 < 0) {
// fprintf(stderr, "CreateStream error: %s\n", PicoErrors_FullError(stream43, ibuf, sizeof(ibuf)));
// exit(1);
// }
// printf("Opening stream51 (CMD)\r\n");
// stream51 = pico->CreateStream(51);
// if (stream51 < 0) {
// fprintf(stderr, "CreateStream error: %s\n", PicoErrors_FullError(stream51, ibuf, sizeof(ibuf)));
// exit(1);
// }
// printf("Opening stream52 (CMD)\r\n");
// stream52 = pico->CreateStream(52);
// if (stream52 < 0) {
// fprintf(stderr, "CreateStream error: %s\n", PicoErrors_FullError(stream52, ibuf, sizeof(ibuf)));
// exit(1);
// }
// printf("Opening stream53 (CMD)\r\n");
// stream53 = pico->CreateStream(53);
// if (stream53 < 0) {
// fprintf(stderr, "CreateStream error: %s\n", PicoErrors_FullError(stream53, ibuf, sizeof(ibuf)));
// exit(1);
// }
// printf("Opening stream61 (CMD)\r\n");
// stream61 = pico->CreateStream(61);
// if (stream61 < 0) {
// fprintf(stderr, "CreateStream error: %s\n", PicoErrors_FullError(stream61, ibuf, sizeof(ibuf)));
// exit(1);
// }
// printf("Opening stream62 (CMD)\r\n");
// stream62 = pico->CreateStream(62);
// if (stream62 < 0) {
// fprintf(stderr, "CreateStream error: %s\n", PicoErrors_FullError(stream62, ibuf, sizeof(ibuf)));
// exit(1);
// }
// printf("Opening stream63 (CMD)\r\n");
// stream63 = pico->CreateStream(63);
// if (stream63 < 0) {
// fprintf(stderr, "CreateStream error: %s\n", PicoErrors_FullError(stream63, ibuf, sizeof(ibuf)));
// exit(1);
// }
// printf("Opening stream71 (CMD)\r\n");
// stream71 = pico->CreateStream(71);
// if (stream71 < 0) {
// fprintf(stderr, "CreateStream error: %s\n", PicoErrors_FullError(stream71, ibuf, sizeof(ibuf)));
// exit(1);
// }
// printf("Opening stream72 (CMD)\r\n");
// stream72 = pico->CreateStream(72);
// if (stream72 < 0) {
// fprintf(stderr, "CreateStream error: %s\n", PicoErrors_FullError(stream72, ibuf, sizeof(ibuf)));
// exit(1);
// }
// printf("Opening stream73 (CMD)\r\n");
// stream73 = pico->CreateStream(73);
// if (stream73 < 0) {
// fprintf(stderr, "CreateStream error: %s\n", PicoErrors_FullError(stream73, ibuf, sizeof(ibuf)));
// exit(1);
// }
int node;
uint32_t cmd[4]; // {0xC1100000, 0xC1200000, 0xC1300001, 0xB1000000};
//==================================================================================================
// _ ____ ____ _
// / \ / ___/ ___| _ / |
// / _ \| | | | (_) | |
// / ___ \ |__| |___ _ | |
// /_/ \_\____\____| (_) |_|
//==================================================================================================
#ifdef ACC1
printf("Opening stream11 (CMD)\r\n");
stream11 = pico->CreateStream(11);
if (stream11 < 0) {
fprintf(stderr, "CreateStream error: %s\n", PicoErrors_FullError(stream11, ibuf, sizeof(ibuf)));
exit(1);
}
printf("Opening stream12 (CMD)\r\n");
stream12 = pico->CreateStream(12);
if (stream12 < 0) {
fprintf(stderr, "CreateStream error: %s\n", PicoErrors_FullError(stream12, ibuf, sizeof(ibuf)));
exit(1);
}
printf("Opening stream13 (CMD)\r\n");
stream13 = pico->CreateStream(13);
if (stream13 < 0) {
fprintf(stderr, "CreateStream error: %s\n", PicoErrors_FullError(stream13, ibuf, sizeof(ibuf)));
exit(1);
}
cmd[0] = 0xC1100000;
cmd[1] = 0xC1200000 | SIZE;
cmd[2] = 0xC1300001;
cmd[3] = 0xB1000000;
pico->WriteStream(stream, cmd, 16);
// printf("Lanching ACC\r\n");
// cmd[0] = 0xA1000000;
// cmd[1] = 0x00000000;
// cmd[2] = 0x00000000;
// cmd[3] = 0x00000000;
// pico->WriteStream(stream, cmd, 16);
pico->WriteStream(stream11, A, SIZE * 4);
pico->WriteStream(stream12, B, SIZE * 4);
// printf("%i B available to read from firmware.\n", i=pico->GetBytesAvailable(stream13, true));
// if (i < 0){
// fprintf(stderr, "GetBytesAvailable error: %s\n", PicoErrors_FullError(i, ibuf, sizeof(ibuf)));
// exit(1);
// }
i = SIZE * 4;
room = i / 4;
tmp = new int[room];
pico->ReadStream(stream13, tmp, i);
printf("%d\r\n", room);
for (i = 0; i < room; i++) {
printf("[%d] 0x%08x\r\n", i, tmp[i]);
}
// printf("%i B available to read from firmware.\n", i=pico->GetBytesAvailable(stream, true));
// if (i < 0){
// fprintf(stderr, "GetBytesAvailable error: %s\n", PicoErrors_FullError(i, ibuf, sizeof(ibuf)));
// exit(1);
// }
// room = i / 4;
// tmp = new int[room];
// pico->ReadStream(stream, tmp, i);
// printf("%d\r\n", room);
// for (i = 0; i < room; i++) {
// printf("[%d] 0x%08x\r\n", i, tmp[i]);
// }
delete[] tmp;
#endif
//==================================================================================================
// _ ____ ____ ____
// / \ / ___/ ___| _ |___ \
// / _ \| | | | (_) __) |
// / ___ \ |__| |___ _ / __/
// /_/ \_\____\____| (_) |_____|
//==================================================================================================
// cmd[0] = 0xC2100000;
// cmd[1] = 0xC2200000 | SIZE;
// cmd[2] = 0xC2300001;
// cmd[3] = 0xB2000000;
// pico->WriteStream(stream, cmd, 16);
// printf("Lanching ACC\r\n");
// cmd[0] = 0xA2000000;
// cmd[1] = 0x00000000;
// cmd[2] = 0x00000000;
// cmd[3] = 0x00000000;
// pico->WriteStream(stream, cmd, 16);
// err = pico->WriteStream(stream21, A, SIZE * 4);
// err = pico->WriteStream(stream22, B, SIZE * 4);
// printf("%i B available to read from stream23.\n", i=pico->GetBytesAvailable(stream23, true));
// if (i < 0){
// fprintf(stderr, "GetBytesAvailable error: %s\n", PicoErrors_FullError(i, ibuf, sizeof(ibuf)));
// exit(1);
// }
// room = i / 4;
// tmp = new int[room];
// err = pico->ReadStream(stream23, tmp, i);
// if (err < 0) {
// fprintf(stderr, "ReadStream stream23 error: %s\n", PicoErrors_FullError(err, ibuf, sizeof(ibuf)));
// exit(1);
// }
// printf("%d\r\n", room);
// for (i = 0; i < room; i++) {
// printf("[%d] 0x%08x\r\n", i, tmp[i]);
// }
// printf("%i B available to read from stream.\n", i=pico->GetBytesAvailable(stream, true));
// if (i < 0){
// fprintf(stderr, "GetBytesAvailable error: %s\n", PicoErrors_FullError(i, ibuf, sizeof(ibuf)));
// exit(1);
// }
// room = i / 4;
// tmp = new int[room];
// pico->ReadStream(stream, tmp, i);
// printf("%d\r\n", room);
// for (i = 0; i < room; i++) {
// printf("[%d] 0x%08x\r\n", i, tmp[i]);
// }
// delete[] tmp;
//==============================================================================
// _ ____ ____ _____
// / \ / ___/ ___| _ |___ /
// / _ \| | | | (_) |_ \
// / ___ \ |__| |___ _ ___) |
// /_/ \_\____\____| (_) |____/
//==============================================================================
// cmd[0] = 0xC3100000;
// cmd[1] = 0xC3200000 | SIZE;
// cmd[2] = 0xC3300001;
// cmd[3] = 0xB3000000;
// pico->WriteStream(stream, cmd, 16);
// printf("Lanching ACC\r\n");
// cmd[0] = 0xA3000000;
// cmd[1] = 0x00000000;
// cmd[2] = 0x00000000;
// cmd[3] = 0x00000000;
// pico->WriteStream(stream, cmd, 16);
// err = pico->WriteStream(stream31, A, SIZE * 4);
// err = pico->WriteStream(stream32, B, SIZE * 4);
// printf("%i B available to read from stream33.\n", i=pico->GetBytesAvailable(stream33, true));
// if (i < 0){
// fprintf(stderr, "GetBytesAvailable error: %s\n", PicoErrors_FullError(i, ibuf, sizeof(ibuf)));
// exit(1);
// }
// room = i / 4;
// tmp = new int[room];
// err = pico->ReadStream(stream33, tmp, i);
// if (err < 0) {
// fprintf(stderr, "ReadStream stream33 error: %s\n", PicoErrors_FullError(err, ibuf, sizeof(ibuf)));
// exit(1);
// }
// printf("%d\r\n", room);
// for (i = 0; i < room; i++) {
// printf("[%d] 0x%08x\r\n", i, tmp[i]);
// }
// printf("%i B available to read from stream.\n", i=pico->GetBytesAvailable(stream, true));
// if (i < 0){
// fprintf(stderr, "GetBytesAvailable error: %s\n", PicoErrors_FullError(i, ibuf, sizeof(ibuf)));
// exit(1);
// }
// room = i / 4;
// tmp = new int[room];
// pico->ReadStream(stream, tmp, i);
// printf("%d\r\n", room);
// for (i = 0; i < room; i++) {
// printf("[%d] 0x%08x\r\n", i, tmp[i]);
// }
// delete[] tmp;
//==============================================================================
// _ ____ ____ _ _
// / \ / ___/ ___| _ | || |
// / _ \| | | | (_) | || |_
// / ___ \ |__| |___ _ |__ _|
// /_/ \_\____\____| (_) |_|
//==============================================================================
// cmd[0] = 0xC4100000;
// cmd[1] = 0xC4200000 | SIZE;
// cmd[2] = 0xC4300001;
// cmd[3] = 0xB4000000;
// pico->WriteStream(stream, cmd, 16);
// printf("Lanching ACC\r\n");
// cmd[0] = 0xA4000000;
// cmd[1] = 0x00000000;
// cmd[2] = 0x00000000;
// cmd[3] = 0x00000000;
// pico->WriteStream(stream, cmd, 16);
// err = pico->WriteStream(stream41, A, SIZE * 4);
// err = pico->WriteStream(stream42, B, SIZE * 4);
// printf("%i B available to read from stream43.\n", i=pico->GetBytesAvailable(stream43, true));
// if (i < 0){
// fprintf(stderr, "GetBytesAvailable error: %s\n", PicoErrors_FullError(i, ibuf, sizeof(ibuf)));
// exit(1);
// }
// room = i / 4;
// tmp = new int[room];
// err = pico->ReadStream(stream43, tmp, i);
// if (err < 0) {
// fprintf(stderr, "ReadStream stream43 error: %s\n", PicoErrors_FullError(err, ibuf, sizeof(ibuf)));
// exit(1);
// }
// printf("%d\r\n", room);
// for (i = 0; i < room; i++) {
// printf("[%d] 0x%08x\r\n", i, tmp[i]);
// }
// printf("%i B available to read from stream.\n", i=pico->GetBytesAvailable(stream, true));
// if (i < 0){
// fprintf(stderr, "GetBytesAvailable error: %s\n", PicoErrors_FullError(i, ibuf, sizeof(ibuf)));
// exit(1);
// }
// room = i / 4;
// tmp = new int[room];
// pico->ReadStream(stream, tmp, i);
// printf("%d\r\n", room);
// for (i = 0; i < room; i++) {
// printf("[%d] 0x%08x\r\n", i, tmp[i]);
// }
// delete[] tmp;
// //==============================================================================
// // _ ____ ____ ____
// // / \ / ___/ ___| _ | ___|
// // / _ \| | | | (_) |___ \
// // / ___ \ |__| |___ _ ___) |
// // /_/ \_\____\____| (_) |____/
// //==============================================================================
// cmd[0] = 0xC5100000;
// cmd[1] = 0xC5200000 | SIZE;
// cmd[2] = 0xC5300001;
// cmd[3] = 0xB5000000;
// pico->WriteStream(stream, cmd, 16);
// printf("Lanching ACC\r\n");
// cmd[0] = 0xA5000000;
// cmd[1] = 0x00000000;
// cmd[2] = 0x00000000;
// cmd[3] = 0x00000000;
// pico->WriteStream(stream, cmd, 16);
// err = pico->WriteStream(stream51, A, SIZE * 4);
// err = pico->WriteStream(stream52, B, SIZE * 4);
// printf("%i B available to read from stream53.\n", i=pico->GetBytesAvailable(stream53, true));
// if (i < 0){
// fprintf(stderr, "GetBytesAvailable error: %s\n", PicoErrors_FullError(i, ibuf, sizeof(ibuf)));
// exit(1);
// }
// room = i / 4;
// tmp = new int[room];
// err = pico->ReadStream(stream53, tmp, i);
// if (err < 0) {
// fprintf(stderr, "ReadStream stream53 error: %s\n", PicoErrors_FullError(err, ibuf, sizeof(ibuf)));
// exit(1);
// }
// printf("%d\r\n", room);
// for (i = 0; i < room; i++) {
// printf("[%d] 0x%08x\r\n", i, tmp[i]);
// }
// printf("%i B available to read from stream.\n", i=pico->GetBytesAvailable(stream, true));
// if (i < 0){
// fprintf(stderr, "GetBytesAvailable error: %s\n", PicoErrors_FullError(i, ibuf, sizeof(ibuf)));
// exit(1);
// }
// room = i / 4;
// tmp = new int[room];
// pico->ReadStream(stream, tmp, i);
// printf("%d\r\n", room);
// for (i = 0; i < room; i++) {
// printf("[%d] 0x%08x\r\n", i, tmp[i]);
// }
// delete[] tmp;
// //==============================================================================
// // _ ____ ____ __
// // / \ / ___/ ___| _ / /_
// // / _ \| | | | (_) | '_ \
// // / ___ \ |__| |___ _ | (_) |
// // /_/ \_\____\____| (_) \___/
// //==============================================================================
// cmd[0] = 0xC6100000;
// cmd[1] = 0xC6200000 | SIZE;
// cmd[2] = 0xC6300001;
// cmd[3] = 0xB6000000;
// pico->WriteStream(stream, cmd, 16);
// printf("Lanching ACC\r\n");
// cmd[0] = 0xA6000000;
// cmd[1] = 0x00000000;
// cmd[2] = 0x00000000;
// cmd[3] = 0x00000000;
// pico->WriteStream(stream, cmd, 16);
// err = pico->WriteStream(stream61, A, SIZE * 4);
// err = pico->WriteStream(stream62, B, SIZE * 4);
// printf("%i B available to read from stream63.\n", i=pico->GetBytesAvailable(stream63, true));
// if (i < 0){
// fprintf(stderr, "GetBytesAvailable error: %s\n", PicoErrors_FullError(i, ibuf, sizeof(ibuf)));
// exit(1);
// }
// room = i / 4;
// tmp = new int[room];
// err = pico->ReadStream(stream63, tmp, i);
// if (err < 0) {
// fprintf(stderr, "ReadStream stream63 error: %s\n", PicoErrors_FullError(err, ibuf, sizeof(ibuf)));
// exit(1);
// }
// printf("%d\r\n", room);
// for (i = 0; i < room; i++) {
// printf("[%d] 0x%08x\r\n", i, tmp[i]);
// }
// printf("%i B available to read from stream.\n", i=pico->GetBytesAvailable(stream, true));
// if (i < 0){
// fprintf(stderr, "GetBytesAvailable error: %s\n", PicoErrors_FullError(i, ibuf, sizeof(ibuf)));
// exit(1);
// }
// room = i / 4;
// tmp = new int[room];
// pico->ReadStream(stream, tmp, i);
// printf("%d\r\n", room);
// for (i = 0; i < room; i++) {
// printf("[%d] 0x%08x\r\n", i, tmp[i]);
// }
// delete[] tmp;
// //==============================================================================
// // _ ____ ____ _____
// // / \ / ___/ ___| _ |___ |
// // / _ \| | | | (_) / /
// // / ___ \ |__| |___ _ / /
// // /_/ \_\____\____| (_) /_/
// //==============================================================================
// cmd[0] = 0xC7100000;
// cmd[1] = 0xC7200000 | SIZE;
// cmd[2] = 0xC7300001;
// cmd[3] = 0xB7000000;
// pico->WriteStream(stream, cmd, 16);
// printf("Lanching ACC\r\n");
// cmd[0] = 0xA7000000;
// cmd[1] = 0x00000000;
// cmd[2] = 0x00000000;
// cmd[3] = 0x00000000;
// pico->WriteStream(stream, cmd, 16);
// err = pico->WriteStream(stream71, A, SIZE * 4);
// err = pico->WriteStream(stream72, B, SIZE * 4);
// printf("%i B available to read from stream73.\n", i=pico->GetBytesAvailable(stream73, true));
// if (i < 0){
// fprintf(stderr, "GetBytesAvailable error: %s\n", PicoErrors_FullError(i, ibuf, sizeof(ibuf)));
// exit(1);
// }
// room = i / 4;
// tmp = new int[room];
// err = pico->ReadStream(stream73, tmp, i);
// if (err < 0) {
// fprintf(stderr, "ReadStream stream73 error: %s\n", PicoErrors_FullError(err, ibuf, sizeof(ibuf)));
// exit(1);
// }
// printf("%d\r\n", room);
// for (i = 0; i < room; i++) {
// printf("[%d] 0x%08x\r\n", i, tmp[i]);
// }
// printf("%i B available to read from stream.\n", i=pico->GetBytesAvailable(stream, true));
// if (i < 0){
// fprintf(stderr, "GetBytesAvailable error: %s\n", PicoErrors_FullError(i, ibuf, sizeof(ibuf)));
// exit(1);
// }
// room = i / 4;
// tmp = new int[room];
// pico->ReadStream(stream, tmp, i);
// printf("%d\r\n", room);
// for (i = 0; i < room; i++) {
// printf("[%d] 0x%08x\r\n", i, tmp[i]);
// }
// delete[] tmp;
//==============================================================================
// _ ____ ____ ___
// / \ / ___/ ___| _ ( _ )
// / _ \| | | | (_) / _ \
// / ___ \ |__| |___ _ | (_) |
// /_/ \_\____\____| (_) \___/
//==============================================================================
// printf("Opening stream81 (CMD)\r\n");
// stream81 = pico->CreateStream(81);
// if (stream81 < 0) {
// fprintf(stderr, "CreateStream error: %s\n", PicoErrors_FullError(stream81, ibuf, sizeof(ibuf)));
// exit(1);
// }
// printf("Opening stream82 (CMD)\r\n");
// stream82 = pico->CreateStream(82);
// if (stream82 < 0) {
// fprintf(stderr, "CreateStream error: %s\n", PicoErrors_FullError(stream82, ibuf, sizeof(ibuf)));
// exit(1);
// }
// printf("Opening stream83 (CMD)\r\n");
// stream83 = pico->CreateStream(83);
// if (stream83 < 0) {
// fprintf(stderr, "CreateStream error: %s\n", PicoErrors_FullError(stream83, ibuf, sizeof(ibuf)));
// exit(1);
// }
// node = 8;
// cmd[3] = 0xBABEFACE;
// cmd[2] = 0xDEADBEEF;
// cmd[1] = 0xDEADBEEF;
// cmd[0] = 0xD000BEEF | (node << 24); // PR Start CMD
// printf("0x%08x\r\n", cmd[0]);
// pico->WriteStream(stream, cmd, 16);
// cmd[0] = 0xD000DEAD | (node << 24); // PR End CMD
// printf("0x%08x\r\n", cmd[0]);
// pico->WriteStream(stream, cmd, 16);
// cmd[0] = 0xC8100000 | (SIZE >> 16) ;
// cmd[1] = 0xC8200000 | (SIZE & 0x0000FFFF) ;
// cmd[2] = 0xC8300001;
// cmd[3] = 0xB8000000;
// pico->WriteStream(stream, cmd, 16);
// printf("Lanching ACC\r\n");
// cmd[0] = 0xA8000000;
// cmd[1] = 0x00000000;
// cmd[2] = 0x00000000;
// cmd[3] = 0x00000000;
// pico->WriteStream(stream, cmd, 16);
// err = pico->WriteStream(stream81, A, SIZE * 4);
// err = pico->WriteStream(stream82, B, SIZE * 4);
// printf("%i B available to read from stream83.\n", i=pico->GetBytesAvailable(stream83, true));
// if (i < 0){
// fprintf(stderr, "GetBytesAvailable error: %s\n", PicoErrors_FullError(i, ibuf, sizeof(ibuf)));
// exit(1);
// }
// room = i / 4;
// tmp = new int[room];
// err = pico->ReadStream(stream83, tmp, i);
// if (err < 0) {
// fprintf(stderr, "ReadStream stream83 error: %s\n", PicoErrors_FullError(err, ibuf, sizeof(ibuf)));
// exit(1);
// }
// printf("%d\r\n", room);
// // for (i = 0; i < room; i++) {
// // printf("[%d] 0x%08x\r\n", i, tmp[i]);
// // }
// delete[] tmp;
// printf("%i B available to read from stream.\n", i=pico->GetBytesAvailable(stream, true));
// if (i < 0){
// fprintf(stderr, "GetBytesAvailable error: %s\n", PicoErrors_FullError(i, ibuf, sizeof(ibuf)));
// exit(1);
// }
// room = i / 4;
// tmp = new int[room];
// pico->ReadStream(stream, tmp, i);
// printf("%d\r\n", room);
// // for (i = 0; i < room; i++) {
// // printf("[%d] 0x%08x\r\n", i, tmp[i]);
// // }
// delete[] tmp;
//==============================================================================
printf("Closing stream50 (CMD)\r\n");
pico->CloseStream(stream);
// pico->CloseStream(stream11);
// pico->CloseStream(stream12);
// pico->CloseStream(stream13);
// pico->CloseStream(stream21);
// pico->CloseStream(stream22);
// pico->CloseStream(stream23);
// pico->CloseStream(stream31);
// pico->CloseStream(stream32);
// pico->CloseStream(stream33);
// pico->CloseStream(stream41);
// pico->CloseStream(stream42);
// pico->CloseStream(stream43);
// pico->CloseStream(stream51);
// pico->CloseStream(stream52);
// pico->CloseStream(stream53);
// pico->CloseStream(stream61);
// pico->CloseStream(stream62);
// pico->CloseStream(stream63);
// pico->CloseStream(stream71);
// pico->CloseStream(stream72);
// pico->CloseStream(stream73);
// pico->CloseStream(stream81);
// pico->CloseStream(stream82);
// pico->CloseStream(stream83);
printf("Done\r\n");
delete[] A;
delete[] B;
delete[] C;
delete[] D;
return 0;
}
//////////
// MAIN //
//////////
int main(int argc, char* argv[]) {
// command-line arguments
CParams args;
// handles to the Smith-Waterman FPGA systems
PicoDrv* aligner;
fpga_cfg_t cfg;
// query and db FASTA file handlers
gzFile queryFile;
gzFile dbFile;
// kseq pointers for parsing FASTA files
kseq_t* querySeq;
kseq_t* dbSeq;
// alignment score
int score;
// info that we need to create different threads
// 1 thread used to send the query to the FPGA
// 1 thread used to send the db to the FPGA
// the main thread used to read results from the FPGA
StreamInfo_t* query_db_info;
// temporary variables
int err;
char ibuf [1024];
////////////////////////
// PARSE COMMAND LINE //
////////////////////////
if (!args.parseParams(argc, argv)) {
return EXIT_FAILURE;
}
// select a bitfile based upon query length
args.setActiveBitfile(args.getMaxQueryLength(), args.getBitfile().c_str());
//////////////////
// PROGRAM FPGA //
//////////////////
// program the device
printf("Programming FPGA with %s\n", args.getActiveBitfile().c_str());
if ((err = RunBitFile(args.getActiveBitfile().c_str(), &aligner)) < 0) {
fprintf(stderr, "RunBitFile error: %s\n", PicoErrors_FullError(err, ibuf, sizeof(ibuf)));
return EXIT_FAILURE;
}
// read the FPGA configuration info
// here we read some config info about the programming file that we just used, including the max query length, the number of aligners, etc.
if (VERBOSE) printf("Reading the configuration info from the FPGA\n");
if ((err = ReadConfig(aligner, &cfg)) < 0) {
fprintf(stderr, "ReadConfig error: %s\n", PicoErrors_FullError(err, ibuf, sizeof(ibuf)));
return EXIT_FAILURE;
}
// create the right number of StreamInfo structs
query_db_info = new StreamInfo_t[cfg.info[7]];
// create the streams to talk to the separate alignment units
// also, populate the StreamInfo structs w/ the info that we know so far
for (int i=1; i<=cfg.info[8]; ++i) {
if (VERBOSE) printf("Creating stream %i\n", i);
if ((err = aligner->CreateStream(i)) < 0) {
fprintf(stderr, "CreateStream error: %s\n", PicoErrors_FullError(err, ibuf, sizeof(ibuf)));
return EXIT_FAILURE;
}
if (VERBOSE) printf("Stream handle = %i\n", err);
query_db_info[i-1].stream = err;
query_db_info[i-1].cfg = &cfg;
query_db_info[i-1].pico = aligner;
}
////////////////////
// SCORING MATRIX //
////////////////////
if ((err = WriteScoringMatrix(aligner, args.getScoreMatrix(), &cfg)) < 0) {
fprintf(stderr, "WriteScoringMatrix error: %s\n", PicoErrors_FullError(err, ibuf, sizeof(ibuf)));
return EXIT_FAILURE;
}
///////////////////////////
// PARSE QUERY FROM FILE //
///////////////////////////
printf("Reading in the query from %s\n", args.getQueryFile().c_str());
// open the query file
queryFile = gzopen(args.getQueryFile().c_str(), "r");
if (queryFile == Z_NULL) {
fprintf(stderr, "Unable to open query file: %s\n", args.getQueryFile().c_str());
return EXIT_FAILURE;
}
querySeq = kseq_init(queryFile);
// read the query in from the file
err = kseq_read(querySeq);
query_db_info[0].start_info.query_seq = querySeq;
////////////////////////
// PARSE DB FROM FILE //
////////////////////////
// Open the files for the database sequence
dbFile = gzopen(args.getDbFile().c_str(), "r");
if (dbFile == Z_NULL) {
fprintf(stderr, "Unable to open db file: %s\n", args.getQueryFile().c_str());
return EXIT_FAILURE;
}
dbSeq = kseq_init(dbFile);
// read the db in from the file
err = kseq_read(dbSeq);
query_db_info[0].start_info.db_seq = dbSeq;
////////////////////////////////
// SEND THE QUERY/DB TO INPUT //
////////////////////////////////
// send the query and the DB to the FPGA for alignment
printf("Sending the query and the db to the FPGA for alignment\n");
if ((err = AlignQueryToDB(&query_db_info[0])) < 0) {
fprintf(stderr, "AlignQueryToDB error: %s\n", PicoErrors_FullError(err, ibuf, sizeof(ibuf)));
return EXIT_FAILURE;
}
////////////////////////////////
// RECEIVE RESULT FROM OUTPUT //
////////////////////////////////
// Create traceback stream(s)
pthread_t traceback_thread[8];
int stream_count = get_size(query_db_info[0].start_info.query_seq->seq.l);
int buffer_length = (query_db_info[0].start_info.query_seq->seq.l + query_db_info[0].start_info.db_seq->seq.l - 1) *2;
args_t *a = new args_t[stream_count];
for (int n=0; n<stream_count; n++) {
if ((err = aligner->CreateStream(12+n)) < 0) {
fprintf(stderr, "CreateStream error: %s\n", PicoErrors_FullError(err, ibuf, sizeof(ibuf)));
return EXIT_FAILURE;
}
query_db_info[0].traceback_stream[n] = err;
// Create thread to read traceback stream into buffer
a[n].streaminfo = &query_db_info[0];
a[n].thread_index = n;
if (buffer_length <= (64 + query_db_info[0].start_info.db_seq->seq.l - 1)*2)
a[n].buffer_length = buffer_length;
else
a[n].buffer_length = (64 + query_db_info[0].start_info.db_seq->seq.l - 1)*2;
buffer_length -= (64 + query_db_info[0].start_info.db_seq->seq.l - 1)*2;
err = pthread_create(&traceback_thread[n], NULL, ReceiveTracebackData, (void *) &a[n]);
if (err != 0) {
fprintf(stderr, "Thread creation error: %d\n", err);
return EXIT_FAILURE;
}
}
// this just returns the score
// we can add a LOT more functionality here if we want
printf("Reading the resulting score from the FPGA\n");
if ((err = ReceiveScore(&query_db_info[0])) < 0) {
fprintf(stderr, "ReceiveScore error: %s\n", PicoErrors_FullError(err, ibuf, sizeof(ibuf)));
return EXIT_FAILURE;
}
printf("Alignment score = %i at base %i\n",
query_db_info[0].end_info.globalScore,
query_db_info[0].end_info.globalTargetBase);
// Wait for traceback thread to finish reading
for (int n=0; n<stream_count; n++) {
if ((err = pthread_join(traceback_thread[n], NULL)) != 0) {
fprintf(stderr, "Thread join error: %d\n", err);
return EXIT_FAILURE;
}
}
// Combine data from multiple streams into single traceback data array.
if (VERBOSE)
printf("Combining stream data.\n");
int traceback_size = query_db_info[0].start_info.query_seq->seq.l + query_db_info[0].start_info.db_seq->seq.l - 1;
uint64_t *buffer = (uint64_t *)calloc(traceback_size*2*stream_count, sizeof(uint64_t));
combineStreamData(&(query_db_info[0].traceback_buffer[0]), stream_count, traceback_size, buffer);
// print out the data that we just received
if (VERBOSE)
for (int i=0; i < traceback_size*2*stream_count; i++)
printf("index: %d, %lx\n", i, buffer[i]);
printf("Starting traceback calculation.\n");
int * traceback = new int[traceback_size];
// Perform traceback calculations
err = trace_matrix_generate(traceback, buffer,
query_db_info[0].start_info.query_seq->seq.l,
query_db_info[0].start_info.db_seq->seq.l);
if (VERBOSE) {
if(err==0) {
printf("Traceback calculation failed\n");
printf("The trace matrix data received is invalid\n");
}
else {
printf("Traceback calculation successfull\n");
printf("Traceback matrix is:\n");
for(int i=0; i<err; i++)
printf("%d\t",traceback[i]);
printf("\n");
}
}
/////////////
// CLEANUP //
/////////////
// close the input and output files for sequences
kseq_destroy(querySeq);
gzclose(queryFile);
kseq_destroy(dbSeq);
gzclose(dbFile);
// free up allocated memory
for (int n=0; n<get_size(query_db_info[0].start_info.query_seq->seq.l); n++) {
free(query_db_info[0].traceback_buffer[n]);
}
delete aligner;
delete [] query_db_info;
return EXIT_SUCCESS;
}
