void saveCharVector(byte_vector *vector, const char *directory, const char *name) {
size_t err=0;
FILE *fp;
char path[500];
path[0]='\0';
strcat(path, directory);
strcat(path, "/");
strcat(path, name);
strcat(path, ".vec");
fp = fopen(path, "wb+");
checkFileOpen(fp, path);
err = fwrite(&vector->n, sizeof(size_t), 1, fp);
checkFileWrite(err, 1, path);
err = fwrite(vector->vector, sizeof(char), vector->n, fp);
checkFileWrite(err, vector->n, path);
fclose(fp);
}
void readUIntVector(vector *vector, const char *directory, const char *name) {
size_t err=0;
FILE *fp;
char path[500];
path[0]='\0';
strcat(path, directory);
strcat(path, "/");
strcat(path, name);
strcat(path, ".vec");
fp = fopen(path, "rb+");
checkFileOpen(fp, path);
err = fread(&vector->n, sizeof(size_t), 1, fp);
checkFileRead(err, 1, path);
vector->vector = (unsigned int *) malloc(vector->n * sizeof(unsigned int));
checkMalloc(vector->vector, path);
err = fread(vector->vector, sizeof(unsigned int), vector->n, fp);
checkFileRead(err, vector->n, path);
fclose(fp);
}
void saveUIntCompVector(comp_vector *vector, const char *directory, const char *name) {
size_t err=0;
FILE *fp;
char path[500];
path[0]='\0';
strcat(path, directory);
strcat(path, "/");
strcat(path, name);
strcat(path, ".vec");
fp = fopen(path, "wb+");
checkFileOpen(fp, path);
err = fwrite(&vector->n, sizeof(size_t), 1, fp);
checkFileWrite(err, 1, path);
err = fwrite(&vector->siz, sizeof(size_t), 1, fp);
checkFileWrite(err, 1, path);
err = fwrite(&vector->ratio, sizeof(size_t), 1, fp);
checkFileWrite(err, 1, path);
err = fwrite(vector->vector, sizeof(unsigned int), vector->n, fp);
checkFileWrite(err, vector->n, path);
fclose(fp);
}
void save_exome_file(exome *ex, const char *directory) {
FILE *fp;
char path[500];
path[0]='\0';
strcat(path, directory);
strcat(path, "/index");
fp = fopen(path, "w");
checkFileOpen(fp, path);
for(size_t i=0; i<ex->size; i++) {
fprintf(fp, ">%s %u %u\n", ex->chromosome + i*IDMAX, ex->start[i], ex->end[i]);
}
}
void load_exome_file(exome *ex, const char *directory) {
FILE *fp;
char path[strlen(directory) + 512];
path[0]='\0';
strcat(path, directory);
strcat(path, "/index");
fp = fopen(path, "r");
checkFileOpen(fp, path);
char c;
char line[MAXLINE];
ex->offset[0]=0;
ex->size = 0;
while (fgets(line, MAXLINE, fp) ) {
if (line[0]=='>') {
int j;
for(j=0; j<IDMAX-1; j++) {
c = line[j+1];
if (c==' ') break;
ex->chromosome[ex->size*IDMAX+j] = c;
}
ex->chromosome[ex->size*IDMAX+j] = '\0';
sscanf(line + j + 2,"%u %u %*s", &ex->start[ex->size], &ex->end[ex->size]);
//printf(">%u %s %u %u\n", ex->offset[ex->size], ex->chromosome + ex->size*IDMAX, ex->start[ex->size], ex->end[ex->size]);
ex->size++;
ex->offset[ex->size] = ex->offset[ex->size-1] + (ex->end[ex->size-1] - ex->start[ex->size-1]+1);
}
}
fclose(fp);
}
int main(int argc, char **argv) {
char *h_Worig, *h_We, *d_We;
unsigned int *h_nWe;
vector h_C, d_C, h_C1, d_C1;
comp_matrix h_O, d_O, h_Oi, d_Oi;
comp_vector h_S, h_Si, h_R, h_Ri;
blocked_results_lists rl_prev_cpu, rl_next_cpu, rl_prev_i_cpu, rl_next_i_cpu, rl_final_cpu;
blocked_results_lists rl_prev_gpu, rl_next_gpu, rl_prev_i_gpu, rl_next_i_gpu, rl_final_gpu;
results_list rl_prev, rl_next, rl_prev_i, rl_next_i, rl_final;
unsigned int read_index=0;
FILE *queries_file, *output_file;
int RESULTS, FRAGSIZE;
cudaError_t error;
if (argc!=7) {
printf("Syntax:\n\t%s search_file input_dir output_file results_buffer frag_size nucleotides\n", argv[0]);
return 1;
}
cudaSetDevice(0);
timevars();
initReplaceTable(argv[6]);
queries_file = fopen(argv[1], "r");
checkFileOpen(queries_file, argv[1]);
output_file = fopen(argv[3], "w");
checkFileOpen(output_file, argv[3]);
RESULTS = atoi(argv[4]);
FRAGSIZE = atoi(argv[5]);
if (FRAGSIZE <= 0) {
fprintf(stderr, "Fragsize must be greater than 0\n");
exit(1);
}
tic("Loading FM-Index");
readUIntVector(&h_C, argv[2], "C");
readUIntVector(&h_C1, argv[2], "C1");
readCompMatrixGPU(&h_O, argv[2], "O");
readCompMatrixGPU(&h_Oi, argv[2], "Oi");
readUIntCompVector(&h_S, argv[2], "Scomp");
readUIntCompVector(&h_Si, argv[2], "Scompi");
readUIntCompVector(&h_R, argv[2], "Rcomp");
readUIntCompVector(&h_Ri, argv[2], "Rcompi");
copyVectorGPU(&d_C, &h_C, sizeof(unsigned int));
copyVectorGPU(&d_C1, &h_C1, sizeof(unsigned int));
copyCompMatrixGPU(&d_O, &h_O);
copyCompMatrixGPU(&d_Oi, &h_Oi);
toc();
tic("Preparing search space");
load_exome_file(&ex, argv[2]);
declare_blocked_results_list_cpu(&rl_prev_cpu, RESULTS, MAX_BUS_GPU);
declare_blocked_results_list_cpu(&rl_prev_i_cpu, RESULTS, MAX_BUS_GPU);
declare_blocked_results_list_cpu(&rl_next_cpu, RESULTS, MAX_BUS_GPU);
declare_blocked_results_list_cpu(&rl_next_i_cpu, RESULTS, MAX_BUS_GPU);
declare_blocked_results_list_cpu(&rl_final_cpu, RESULTS, MAX_BUS_GPU);
declare_blocked_results_list_gpu(&rl_prev_gpu, RESULTS, MAX_BUS_GPU);
declare_blocked_results_list_gpu(&rl_prev_i_gpu, RESULTS, MAX_BUS_GPU);
declare_blocked_results_list_gpu(&rl_next_gpu, RESULTS, MAX_BUS_GPU);
declare_blocked_results_list_gpu(&rl_next_i_gpu, RESULTS, MAX_BUS_GPU);
declare_blocked_results_list_gpu(&rl_final_gpu, RESULTS, MAX_BUS_GPU);
toc();
h_Worig = (char*)malloc(MAX_BUS_GPU * MAXLINE * sizeof(char));
cudaMallocHost((void**) &h_We, MAX_BUS_GPU * MAXLINE * sizeof(char));
cudaMallocHost((void**) &h_nWe, MAX_BUS_GPU * sizeof(unsigned int));
cudaMalloc((void**) &d_We, MAX_READ_GPU * MAXLINE * sizeof(char));
manageCudaError();
int TAM_BUS_GPU=0, NUM_BLOQUES_GPU=0;
tic("Read mappings from disk");
while(nextFASTAToken(queries_file, h_Worig + TAM_BUS_GPU * MAXLINE, h_We + TAM_BUS_GPU * MAXLINE, h_nWe + TAM_BUS_GPU)) {
TAM_BUS_GPU++;
if (TAM_BUS_GPU == MAX_BUS_GPU) break;
}
toc();
NUM_BLOQUES_GPU = (TAM_BUS_GPU / TAM_BLOQUE_GPU);
if (TAM_BUS_GPU % TAM_BLOQUE_GPU) NUM_BLOQUES_GPU++;
cudaThreadSynchronize();
tic("CPU -> GPU");
cudaMemcpy(d_We, h_We, TAM_BUS_GPU * MAXLINE * sizeof(char), cudaMemcpyHostToDevice);
manageCudaError();
cudaThreadSynchronize();
toc();
cudaThreadSynchronize();
tic("GPU Kernel");
//cudaPrintfInit();
printf("%d %d\n", NUM_BLOQUES_GPU, TAM_BLOQUE_GPU);
BWSearchGPU(NUM_BLOQUES_GPU, TAM_BLOQUE_GPU, d_We, h_We, h_nWe[0], &d_C, &h_C, &d_C1, &h_C1, &d_O, &h_O, &d_Oi, &h_Oi, &h_S, &h_R, &h_Si, &h_Ri, &rl_prev_cpu, &rl_next_cpu, &rl_prev_i_cpu, &rl_next_i_cpu, &rl_final_cpu, &rl_prev_gpu, &rl_next_gpu, &rl_prev_i_gpu, &rl_next_i_gpu, &rl_final_gpu, FRAGSIZE, RESULTS);
/* cudaPrintfDisplay(stdout, true); */
/* cudaPrintfEnd(); */
cudaThreadSynchronize();
toc();
cudaThreadSynchronize();
tic("GPU -> CPU");
copy_blocked_results_list_cpu(&rl_final_cpu, &rl_final_gpu, RESULTS, TAM_BUS_GPU);
cudaThreadSynchronize();
toc();
//printf("%d\n", rl_final_cpu.num_results[0]);
write_blocked_results(&rl_final_cpu, &ex, &h_S, &h_Si, &h_C, &h_O, &h_Oi, h_Worig, h_nWe[0], 1, output_file, RESULTS, TAM_BUS_GPU, 0);
new_results_list(&rl_prev, RESULTS); new_results_list(&rl_prev_i, RESULTS);
new_results_list(&rl_next, RESULTS); new_results_list(&rl_next_i, RESULTS);
new_results_list(&rl_final, RESULTS);
tic("CPU kernel");
for(int i=0; i<MAX_BUS_GPU; i++) {
rl_prev.num_results = 0; rl_prev_i.num_results = 0;
rl_next.num_results = 0; rl_next_i.num_results = 0;
rl_final.num_results = 0;
rl_prev.read_index = read_index; rl_prev_i.read_index = read_index;
rl_next.read_index = read_index; rl_next_i.read_index = read_index;
rl_final.read_index = read_index;
BWSearchCPU(h_We + i*MAXLINE, h_nWe[0], &h_C, &h_C1, &h_O, &h_Oi, &h_S, &h_R, &h_Si, &h_Ri, &rl_prev, &rl_next, &rl_prev_i, &rl_next_i, &rl_final, FRAGSIZE, 1);
read_index++;
}
toc();
/*
for (int i=0; i<TAM_BUS_GPU; i++) {
for (int j=0; j<h_nWe[i]; j++) {
if (h_k[i*MAXLINE + j] != h_k2[i*MAXLINE + j]) {
printf("Diferente %d %d\n", i, j);
goto salir;
}
}
}
salir:
*/
/*
for (int i=0; i<h_nWe[0]; i++) {
printf("%u ", h_k[i]);
}
printf("\n");
printf("\n");
for (int i=0; i<h_nWe[0]; i++) {
printf("%u ", h_k2[i]);
}
printf("\n");
*/
cudaFreeHost(h_We);
cudaFreeHost(h_nWe);
cudaFree(d_We);
free(h_C.vector);
cudaFree(d_C.vector);
free(h_C1.vector);
cudaFree(d_C1.vector);
freeCompMatrixGPUHost(&h_O);
freeCompMatrixGPUDevice(&d_O);
freeCompMatrixGPUHost(&h_Oi);
freeCompMatrixGPUDevice(&d_Oi);
fclose(queries_file);
fclose(output_file);
return 0;
}
void Controller::notify(Message &msg)
{
switch(msg.type)
{
// From GUI to Model: msg.content is set to path from file that user opens
case Message::FileOpen :
{
checkFileOpen(msg);
break;
}
// From GUI to Model: msg.content contains the user input for a new PC value
case Message::UserInputPC :
{
checkUserInputPC(msg);
break;
}
// From GUI to Model: msg.content contains the user input for a new OpCode value in the IR
case Message::UserInputOpCode :
{
checkUserInputOpCode(msg);
break;
}
// From GUI to Model: msg.content contains the user input for a new address value in the IR
case Message::UserInputAddress :
{
checkUserInputAddress(msg);
break;
}
// From GUI to Model: msg.content contains the user input for a new Accu value
case Message::UserInputAccu :
{
checkUserInputAccu(msg);
break;
}
// From GUI to Model: msg.content contains the user input for a new RAM value and RAM cell number
case Message::UserInputRAM :
{
checkUserInputRAM(msg);
break;
}
// no content - simply calls method "step"
case Message::SingleStep :
{
emit(sendMessage(msg));
break;
}
case Message::HalfCycle :
{
emit(sendMessage(msg));
break;
}
case Message::Cycle :
{
emit(sendMessage(msg));
break;
}
case Message::Automatic :
{
emit(sendMessage(msg));
break;
}
// no content - model resets itself with old parser array
case Message::Reset :
{
emit(sendMessage(msg));
break;
}
//no content - model stops automode and all other modes
case Message::Stop :
{
emit(sendMessage(msg));
break;
}
case Message::Speed :
{
emit(sendMessage(msg));
break;
}
// all other messages get sent directly from the Model to the GUI
default:
break;
}
this->ok = false;
}
void load_reference(byte_vector *X, int duplicate, exome *ex, const char *path) {
FILE *ref_file;
ref_file = fopen(path, "r");
checkFileOpen(ref_file, path);
size_t read=0, size;
unsigned int nX;
fseek(ref_file, 0, SEEK_END);
read = ftell(ref_file);
fseek(ref_file, 0, SEEK_SET);
if (duplicate) size = 2*read + 1000;
else size = read + 1000;
X->vector = (char *) malloc( size * sizeof(char) );
checkMalloc(X->vector, path);
nX=0;
if (ex !=NULL) ex->size=0;
//char line[MAXLINE];
unsigned int length, partial_length, total_length;
total_length=0;
partial_length=0;
while ( fgets(X->vector + total_length, MAXLINE, ref_file) ) {
if ( (X->vector + total_length)[0] == '>') {
if (ex!=NULL) {
if (total_length == 0) {
sscanf(X->vector + total_length, ">%s ", ex->chromosome + ex->size * IDMAX);
ex->start[ex->size] = 0;
} else {
ex->end[ex->size] = partial_length - 1;
partial_length=0;
if (ex->size==0)
ex->offset[0] = 0;
else
ex->offset[ex->size] = ex->offset[ex->size-1] + (ex->end[ex->size-1] - ex->start[ex->size-1] + 1);
ex->size++;
sscanf(X->vector + total_length, ">%s ", ex->chromosome + ex->size * IDMAX);
ex->start[ex->size] = 0;
}
}
continue;
}
length = strlen(X->vector + total_length);
if ((X->vector + total_length)[length-1]=='\n')
length--;
partial_length += length;
total_length += length;
}
if (ex != NULL) {
ex->end[ex->size] = partial_length - 1;
partial_length=0;
if (ex->size==0)
ex->offset[0] = 0;
else
ex->offset[ex->size] = ex->offset[ex->size-1] + (ex->end[ex->size-1] - ex->start[ex->size-1] + 1);
ex->size++;
}
replaceBases(X->vector, X->vector, total_length);
X->vector[total_length] = DDD;
X->n = total_length;
fclose(ref_file);
if (duplicate) duplicate_reference(X);
}
void saveCompMatrix(comp_matrix *matrix, const char *directory, const char *name) {
size_t err=0;
FILE *fp;
char path[500];
path[0]='\0';
strcat(path, directory);
strcat(path, "/");
strcat(path, name);
strcat(path, ".desp");
fp = fopen(path, "wb+");
checkFileOpen(fp, path);
err = fwrite(&matrix->siz, sizeof(size_t), 1, fp);
checkFileWrite(err, 1, path);
err = fwrite(&matrix->n_desp, sizeof(size_t), 1, fp);
checkFileWrite(err, 1, path);
err = fwrite(&matrix->m_desp, sizeof(size_t), 1, fp);
checkFileWrite(err, 1, path);
for (size_t i=0; i<matrix->n_desp; i++) {
err = fwrite(matrix->desp[i], sizeof(unsigned int), matrix->m_desp, fp);
checkFileWrite(err, matrix->m_desp, path);
}
fclose(fp);
#if defined VECTOR_O_32BIT_COMPRESSION
path[0]='\0';
strcat(path, directory);
strcat(path, "/");
strcat(path, name);
strcat(path, ".count");
fp = fopen(path, "wb+");
checkFileOpen(fp, path);
err = fwrite(&matrix->n_count, sizeof(size_t), 1, fp);
checkFileWrite(err, 1, path);
err = fwrite(&matrix->m_count, sizeof(size_t), 1, fp);
checkFileWrite(err, 1, path);
for (size_t i=0; i<matrix->n_count; i++) {
err = fwrite(matrix->count[i], sizeof(unsigned int), matrix->m_count, fp);
checkFileWrite(err, matrix->m_count, path);
}
fclose(fp);
#elif defined VECTOR_O_64BIT_COMPRESSION
path[0]='\0';
strcat(path, directory);
strcat(path, "/");
strcat(path, name);
strcat(path, ".count");
fp = fopen(path, "wb+");
checkFileOpen(fp, path);
err = fwrite(&matrix->n_count, sizeof(size_t), 1, fp);
checkFileWrite(err, 1, path);
err = fwrite(&matrix->m_count, sizeof(size_t), 1, fp);
checkFileWrite(err, 1, path);
for (size_t i=0; i<matrix->n_count; i++) {
err = fwrite(matrix->count[i], sizeof(unsigned long long), matrix->m_count, fp);
checkFileWrite(err, matrix->m_count, path);
}
fclose(fp);
#endif
}
