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; }