void TimingTaskDlg::onTimer(UINT message, WPARAM wParam,
LPARAM lParam)
{
switch (wParam)
{
case kTimerId_remain:
{
break;
}
case kTimerId_refresh:
{
m_remainTimeSec--;
if (m_remainTimeSec <= 0)
{
m_remainTimeSec = 0;
timerEnd(message, wParam, lParam);
}
setRemainText(m_remainTimeSec);
break;
}
default:
{
assert(0);
break;
}
}
}
DoubleText::DoubleText( ProgramLogic& c )
: core( c ), input_mode( true )
{
output = new QTextEdit;
output->setReadOnly( true );
output->setFixedHeight( 75 );
input = new QTextEdit;
QFont font;
font.setPixelSize( 25 );
input->setFont( font );
output->setFont( font );
progress = new QProgressBar;
timer = new QProgressBar;
button = new QPushButton( "See results" );
button->setFixedSize( button->sizeHint( ) );
QHBoxLayout* buttonLayout = new QHBoxLayout;
buttonLayout->addStretch( );
buttonLayout->addWidget( button );
buttonLayout->addStretch( );
QVBoxLayout* layout = new QVBoxLayout;
layout->addWidget( output );
layout->addWidget( timer );
layout->addWidget( input );
layout->addWidget( progress );
layout->addLayout( buttonLayout );
setLayout( layout );
connect( button, SIGNAL( clicked( bool ) ),
this, SLOT( buttonReact( ) ) );
connect( input, SIGNAL( textChanged( ) ),
this, SLOT( letterReact( ) ) );
connect( &(core.timer), SIGNAL( timerEnd( ) ),
this, SLOT( buttonReact( ) ) );
setFixedSize( 500, 350 );
core.setGUI( input, output, progress, timer );
}
/// Main function for ADC test firmware
int main(void) {
uint8_t debugAdc, i;
FunctionalState led = DISABLE;
defaultInit();
debugAdc = debugNewSource("ADC");
debugSourceEnable(debugAdc, ENABLE);
debugPrintln(debugAdc, "test start");
timerStartMs(100);
for (;;) {
adcLoop();
if (timerEnd()) {
timerStartMs(500);
ledCmd(0, led);
led = !led;
debugPrintRaw(debugAdc, "ADC:");
for (i = 0; i < ADC_NUMBER; i++) {
debugPrintRaw(debugAdc, " %u", adcRead(i));
}
debugPrintRaw(debugAdc, "\r\n");
}
}
}
int main(int argc, char ** argv)
{
ocd_init(&argc, &argv, NULL);
ocd_initCL();
if (argc < 3)
{
printf("Calculate similarities between two strings.\n");
printf("Maximum length of each string is: %d\n", MAX_LEN);
printf("Usage: %s query database\n", argv[0]);
printf("or: %s query database [openPenalty extensionPenalty block#]\n", argv[0]);
printf("openPenalty (5.0), extensionPenalty (0.5)\n");
return 1;
}
/////////////////////////////////////
// 00 --> 01
// | |
// 10 --> 11
////////////////////////////////////
char queryFilePathName[255], dbDataFilePathName[255], dbLenFilePathName[255];
int querySize, subSequenceNum, subSequenceSize;
float openPenalty, extensionPenalty;
int coalescedOffset = COALESCED_OFFSET;
int nblosumWidth = 23;
size_t blockSize = 64;
size_t setZeroThreadNum, mfThreadNum;
int blockNum = 14;
cl_ulong maxLocalSize;
int arraySize;
struct timeval t1, t2;
float tmpTime;
FILE *pfile;
//record time
memset(&strTime, 0, sizeof(STRUCT_TIME));
timerStart();
openPenalty = 5.0f;
extensionPenalty = 0.5;
if (argc == 6)
{
openPenalty = atof(argv[3]);
extensionPenalty = atof(argv[4]);
blockNum = atoi(argv[5]);
}
//relocated to after MAX_COMPUTE_UNITS check
//mfThreadNum = blockNum * blockSize;
cl_program hProgram;
cl_kernel hMatchStringKernel, hTraceBackKernel, hSetZeroKernel;
size_t sourceFileSize;
char *cSourceCL = NULL;
//err = clGetPlatformIDs(1, &platformID, NULL);
//CHKERR(err, "Get platform ID error!");
cl_int err;
//check to make sure the device supports this block count
//then scale threads appropriately
cl_uint devBlockNum = 0;
CHKERR(clGetDeviceInfo(device_id, CL_DEVICE_MAX_COMPUTE_UNITS,\
sizeof(cl_uint), &devBlockNum, 0), \
"Error while querying CL_DEVICE_MAX_COMPUTE_UNITS.");
if (devBlockNum == MIN(blockNum, devBlockNum)) {
printf("Scaling blocks from %d to %d to fit on device\n",\
blockNum, devBlockNum);
blockNum = devBlockNum;
}
mfThreadNum = blockNum * blockSize;
CHKERR(clGetDeviceInfo(device_id, CL_DEVICE_LOCAL_MEM_SIZE,\
sizeof(cl_ulong), &maxLocalSize, 0), \
"Error while querying CL_DEVICE_LOCAL_MEM_SIZE.");
//load the source file
char kernel_file[] = "kernels.cl";
cSourceCL = loadSource(kernel_file, &sourceFileSize);
hProgram = clCreateProgramWithSource(context, 1, (const char **)&cSourceCL,
&sourceFileSize, &err);
CHKERR(err, "Create program with source error");
err = clBuildProgram(hProgram, 0, 0, 0, 0, 0);
//debug================================
int logSize = 3000, i;
size_t retSize;
char logTxt[3000];
err = clGetProgramBuildInfo(hProgram, device_id, CL_PROGRAM_BUILD_LOG, logSize, logTxt, &retSize);
for (i = 0; i < retSize; i++)
{
printf("%c", logTxt[i]);
}
//===================================
CHKERR(err, "Build program error");
hMatchStringKernel = clCreateKernel(hProgram, "MatchStringGPUSync", &err);
CHKERR(err, "Create MatchString kernel error");
hTraceBackKernel = clCreateKernel(hProgram, "trace_back2", &err);
CHKERR(err, "Create trace_back2 kernel error");
hSetZeroKernel = clCreateKernel(hProgram, "setZero", &err);
CHKERR(err, "Create setZero kernel error");
sprintf(queryFilePathName, "%s", argv[1]);
sprintf(dbDataFilePathName, "%s.data", argv[2]);
sprintf(dbLenFilePathName, "%s.loc", argv[2]);
char *allSequences, *querySequence, *subSequence;
char *seq1, *seq2;
cl_mem seq1D, seq2D;
allSequences = new char[2 * (MAX_LEN)];
if (allSequences == NULL)
{
printf("Allocate sequence buffer error!\n");
return 1;
}
querySequence = allSequences;
seq1D = clCreateBuffer(context, CL_MEM_READ_ONLY, sizeof(cl_char) * MAX_LEN, 0, &err);
CHKERR(err, "Create seq1D memory");
seq2D = clCreateBuffer(context, CL_MEM_READ_ONLY, sizeof(cl_char) * MAX_LEN, 0, &err);
CHKERR(err, "Create seq2D memory");
//read query sequence
querySize = readQuerySequence(queryFilePathName, querySequence);
if (querySize <= 0 || querySize > MAX_LEN)
{
printf("Query size %d is out of range (0, %d)\n",
MAX_LEN,
querySize);
return 1;
}
encoding(querySequence, querySize);
subSequence = allSequences + querySize;
//allocate output sequence buffer
char *outSeq1, *outSeq2;
outSeq1 = new char[2 * MAX_LEN];
outSeq2 = new char[2 * MAX_LEN];
if (outSeq1 == NULL ||
outSeq2 == NULL)
{
printf("Allocate output sequence buffer on host error!\n");
return 1;
}
cl_mem outSeq1D, outSeq2D;
outSeq1D = clCreateBuffer(context, CL_MEM_READ_WRITE, sizeof(cl_char) * MAX_LEN * 2, 0, &err);
CHKERR(err, "Create outSeq1D memory");
outSeq2D = clCreateBuffer(context, CL_MEM_READ_WRITE, sizeof(cl_char) * MAX_LEN * 2, 0, &err);
CHKERR(err, "Create outSeq2D memory");
//allocate thread number per launch and
//location difference information
int *threadNum, *diffPos;
threadNum = new int[2 * MAX_LEN];
diffPos = new int[2 * MAX_LEN];
if (threadNum == NULL ||
diffPos == NULL)
{
printf("Allocate location buffer on host error!\n");
return 1;
}
cl_mem threadNumD, diffPosD;
threadNumD = clCreateBuffer(context, CL_MEM_READ_ONLY, sizeof(cl_int) * (2 * MAX_LEN), 0, &err);
CHKERR(err, "Create threadNumD memory");
diffPosD = clCreateBuffer(context, CL_MEM_READ_ONLY, sizeof(cl_int) * (2 * MAX_LEN), 0, &err);
CHKERR(err, "Create diffPosD memory");
//allocate matrix buffer
char *pathFlag, *extFlag;
float *nGapDist, *hGapDist, *vGapDist;
int maxElemNum = (MAX_LEN + 1) * (MAX_LEN + 1);
pathFlag = new char[maxElemNum];
extFlag = new char[maxElemNum];
nGapDist = new float[maxElemNum];
hGapDist = new float[maxElemNum];
vGapDist = new float[maxElemNum];
if (pathFlag == NULL ||
extFlag == NULL ||
nGapDist == NULL ||
hGapDist == NULL ||
vGapDist == NULL)
{
printf("Allocate DP matrices on host error!\n");
return 1;
}
cl_mem pathFlagD, extFlagD, nGapDistD, hGapDistD, vGapDistD;
pathFlagD = clCreateBuffer(context, CL_MEM_READ_WRITE, sizeof(cl_char) * maxElemNum, 0, &err);
CHKERR(err, "Create pathFlagD memory");
extFlagD = clCreateBuffer(context, CL_MEM_READ_WRITE, sizeof(cl_char) * maxElemNum, 0, &err);
CHKERR(err, "Create extFlagD memory");
nGapDistD = clCreateBuffer(context, CL_MEM_READ_WRITE, sizeof(cl_float) * maxElemNum, 0, &err);
CHKERR(err, "Create nGapDistD memory");
hGapDistD = clCreateBuffer(context, CL_MEM_READ_WRITE, sizeof(cl_float) * maxElemNum, 0, &err);
CHKERR(err, "Create hGapDistD memory");
vGapDistD = clCreateBuffer(context, CL_MEM_READ_WRITE, sizeof(cl_float) * maxElemNum, 0, &err);
CHKERR(err, "Create vGapDistD memory");
//Allocate the MAX INFO structure
MAX_INFO *maxInfo;
maxInfo = new MAX_INFO[1];
if (maxInfo == NULL)
{
printf("Alloate maxInfo on host error!\n");
return 1;
}
cl_mem maxInfoD;
maxInfoD = clCreateBuffer(context, CL_MEM_READ_WRITE, sizeof(MAX_INFO) * mfThreadNum, 0, &err);
CHKERR(err, "Create maxInfoD memory");
//allocate the distance table
cl_mem blosum62D;
int nblosumHeight = 23;
blosum62D = clCreateBuffer(context, CL_MEM_READ_ONLY, sizeof(cl_float) * nblosumWidth * nblosumHeight, 0, &err);
err = clEnqueueWriteBuffer(commands, blosum62D, CL_TRUE, 0,
nblosumWidth * nblosumHeight * sizeof(cl_float), blosum62[0], 0, NULL, &ocdTempEvent);
clFinish(commands);
START_TIMER(ocdTempEvent, OCD_TIMER_H2D, "SWAT Scoring Matrix Copy", ocdTempTimer)
END_TIMER(ocdTempTimer)
CHKERR(err, "copy blosum62 to device");
cl_mem mutexMem;
mutexMem = clCreateBuffer(context, CL_MEM_READ_WRITE, sizeof(cl_int), 0, &err);
CHKERR(err, "create mutex mem error!");
//copy the scoring matrix to the constant memory
//copyScoringMatrixToConstant();
//open the database
pDBDataFile = fopen(dbDataFilePathName, "rb");
if (pDBDataFile == NULL)
{
printf("DB data file %s open error!\n", dbDataFilePathName);
return 1;
}
pDBLenFile = fopen(dbLenFilePathName, "rb");
if (pDBLenFile == NULL)
{
printf("DB length file %s open error!\n", dbLenFilePathName);
return 1;
}
//record time
timerEnd();
strTime.iniTime = elapsedTime();
//read the total number of sequences
fread(&subSequenceNum, sizeof(int), 1, pDBLenFile);
//get the larger and smaller of the row and colum number
int subSequenceNo, launchNum, launchNo;
int rowNum, columnNum, matrixIniNum;
int DPMatrixSize;
int seq1Pos, seq2Pos, nOffset, startPos;
for (subSequenceNo = 0; subSequenceNo < subSequenceNum; subSequenceNo++)
{
//record time
timerStart();
//read subject sequence
fread(&subSequenceSize, sizeof(int), 1, pDBLenFile);
if (subSequenceSize <= 0 || subSequenceSize > MAX_LEN)
{
printf("Size %d of bubject sequence %d is out of range!\n",
subSequenceSize,
subSequenceNo);
break;
}
fread(subSequence, sizeof(char), subSequenceSize, pDBDataFile);
gettimeofday(&t1, NULL);
if (subSequenceSize > querySize)
{
seq1 = subSequence;
seq2 = querySequence;
rowNum = subSequenceSize + 1;
columnNum = querySize + 1;
}
else
{
seq1 = querySequence;
seq2 = subSequence;
rowNum = querySize + 1;
columnNum = subSequenceSize + 1;
}
launchNum = rowNum + columnNum - 1;
//preprocessing for sequences
DPMatrixSize = preProcessing(rowNum,
columnNum,
threadNum,
diffPos,
matrixIniNum);
//record time
timerEnd();
strTime.preprocessingTime += elapsedTime();
//record time
timerStart();
//use a kernel to initialize the matrix
arraySize = DPMatrixSize * sizeof(char);
setZeroThreadNum = ((arraySize - 1) / blockSize + 1) * blockSize;
err = clSetKernelArg(hSetZeroKernel, 0, sizeof(cl_mem), (void *)&pathFlagD);
err |= clSetKernelArg(hSetZeroKernel, 1, sizeof(int), (void *)&arraySize);
err |= clEnqueueNDRangeKernel(commands, hSetZeroKernel, 1, NULL, &setZeroThreadNum,
&blockSize, 0, NULL, &ocdTempEvent);
clFinish(commands);
START_TIMER(ocdTempEvent, OCD_TIMER_KERNEL, "SWAT DP Matrix Init", ocdTempTimer)
END_TIMER(ocdTempTimer)
err |= clSetKernelArg(hSetZeroKernel, 0, sizeof(cl_mem), (void *)&extFlagD);
err |= clEnqueueNDRangeKernel(commands, hSetZeroKernel, 1, NULL, &setZeroThreadNum,
&blockSize, 0, NULL, &ocdTempEvent);
clFinish(commands);
START_TIMER(ocdTempEvent, OCD_TIMER_KERNEL, "SWAT DP Matrix Init", ocdTempTimer)
END_TIMER(ocdTempTimer)
CHKERR(err, "Initialize flag matrice");
arraySize = matrixIniNum * sizeof(float);
setZeroThreadNum = ((arraySize - 1) / blockSize + 1) * blockSize;
err = clSetKernelArg(hSetZeroKernel, 0, sizeof(cl_mem), (void *)&nGapDistD);
err |= clSetKernelArg(hSetZeroKernel, 1, sizeof(int), (void *)&arraySize);
err |= clEnqueueNDRangeKernel(commands, hSetZeroKernel, 1, NULL, &setZeroThreadNum,
&blockSize, 0, NULL, &ocdTempEvent);
clFinish(commands);
START_TIMER(ocdTempEvent, OCD_TIMER_KERNEL, "SWAT Distance Matrix Init", ocdTempTimer)
END_TIMER(ocdTempTimer)
err |= clSetKernelArg(hSetZeroKernel, 0, sizeof(cl_mem), (void *)&hGapDistD);
err |= clEnqueueNDRangeKernel(commands, hSetZeroKernel, 1, NULL, &setZeroThreadNum,
&blockSize, 0, NULL, &ocdTempEvent);
clFinish(commands);
START_TIMER(ocdTempEvent, OCD_TIMER_KERNEL, "SWAT Distance Matrix Init", ocdTempTimer)
END_TIMER(ocdTempTimer)
err |= clSetKernelArg(hSetZeroKernel, 0, sizeof(cl_mem), (void *)&vGapDistD);
err |= clEnqueueNDRangeKernel(commands, hSetZeroKernel, 1, NULL, &setZeroThreadNum,
&blockSize, 0, NULL, &ocdTempEvent);
clFinish(commands);
START_TIMER(ocdTempEvent, OCD_TIMER_KERNEL, "SWAT Distance Matrix Init", ocdTempTimer)
END_TIMER(ocdTempTimer)
CHKERR(err, "Initialize dist matrice");
arraySize = sizeof(MAX_INFO) * mfThreadNum;
setZeroThreadNum = ((arraySize - 1) / blockSize + 1) * blockSize;
err = clSetKernelArg(hSetZeroKernel, 0, sizeof(cl_mem), (void *)&maxInfoD);
err |= clSetKernelArg(hSetZeroKernel, 1, sizeof(int), (void *)&arraySize);
err |= clEnqueueNDRangeKernel(commands, hSetZeroKernel, 1, NULL, &setZeroThreadNum,
&blockSize, 0, NULL, &ocdTempEvent);
clFinish(commands);
START_TIMER(ocdTempEvent, OCD_TIMER_KERNEL, "SWAT Max Info Matrix Init", ocdTempTimer)
END_TIMER(ocdTempTimer)
CHKERR(err, "Initialize max info");
arraySize = sizeof(int);
setZeroThreadNum = ((arraySize - 1) / blockSize + 1) * blockSize;
err = clSetKernelArg(hSetZeroKernel, 0, sizeof(cl_mem), (void *)&mutexMem);
err |= clSetKernelArg(hSetZeroKernel, 1, sizeof(int), (void *)&arraySize);
err |= clEnqueueNDRangeKernel(commands, hSetZeroKernel, 1, NULL, &setZeroThreadNum,
&blockSize, 0, NULL, &ocdTempEvent);
clFinish(commands);
START_TIMER(ocdTempEvent, OCD_TIMER_KERNEL, "SWAT Mutex Init", ocdTempTimer)
END_TIMER(ocdTempTimer)
CHKERR(err, "Initialize mutex variable");
//copy input sequences to device
err = clEnqueueWriteBuffer(commands, seq1D, CL_FALSE, 0, (rowNum - 1) * sizeof(cl_char), seq1, 0, NULL, &ocdTempEvent);
clFinish(commands);
START_TIMER(ocdTempEvent, OCD_TIMER_H2D, "SWAT Sequence Copy", ocdTempTimer)
END_TIMER(ocdTempTimer)
err |= clEnqueueWriteBuffer(commands, seq2D, CL_FALSE, 0, (columnNum - 1) * sizeof(cl_char), seq2, 0, NULL, &ocdTempEvent);
clFinish(commands);
START_TIMER(ocdTempEvent, OCD_TIMER_H2D, "SWAT Sequence Copy", ocdTempTimer)
END_TIMER(ocdTempTimer)
CHKERR(err, "copy input sequence");
err = clEnqueueWriteBuffer(commands, diffPosD, CL_FALSE, 0, launchNum * sizeof(cl_int), diffPos, 0, NULL, &ocdTempEvent);
clFinish(commands);
START_TIMER(ocdTempEvent, OCD_TIMER_H2D, "SWAT Mutex Info Copy", ocdTempTimer)
END_TIMER(ocdTempTimer)
err |= clEnqueueWriteBuffer(commands, threadNumD, CL_FALSE, 0, launchNum * sizeof(cl_int), threadNum, 0, NULL, &ocdTempEvent);
clFinish(commands);
START_TIMER(ocdTempEvent, OCD_TIMER_H2D, "SWAT Mutex Info Copy", ocdTempTimer)
END_TIMER(ocdTempTimer)
CHKERR(err, "copy diffpos and/or threadNum mutexMem info error!");
//record time
timerEnd();
strTime.copyTimeHostToDevice += elapsedTime();
//record time
timerStart();
//set arguments
err = clSetKernelArg(hMatchStringKernel, 0, sizeof(cl_mem), (void *)&pathFlagD);
err |= clSetKernelArg(hMatchStringKernel, 1, sizeof(cl_mem), (void *)&extFlagD);
err |= clSetKernelArg(hMatchStringKernel, 2, sizeof(cl_mem), (void *)&nGapDistD);
err |= clSetKernelArg(hMatchStringKernel, 3, sizeof(cl_mem), (void *)&hGapDistD);
err |= clSetKernelArg(hMatchStringKernel, 4, sizeof(cl_mem), (void *)&vGapDistD);
err |= clSetKernelArg(hMatchStringKernel, 5, sizeof(cl_mem), (void *)&diffPosD);
err |= clSetKernelArg(hMatchStringKernel, 6, sizeof(cl_mem), (void *)&threadNumD);
err |= clSetKernelArg(hMatchStringKernel, 7, sizeof(cl_int), (void *)&rowNum);
err |= clSetKernelArg(hMatchStringKernel, 8, sizeof(cl_int), (void *)&columnNum);
err |= clSetKernelArg(hMatchStringKernel, 9, sizeof(cl_mem), (void *)&seq1D);
err |= clSetKernelArg(hMatchStringKernel, 10, sizeof(cl_mem), (void *)&seq2D);
err |= clSetKernelArg(hMatchStringKernel, 11, sizeof(cl_int), (void *)&nblosumWidth);
err |= clSetKernelArg(hMatchStringKernel, 12, sizeof(cl_float), (void *)&openPenalty);
err |= clSetKernelArg(hMatchStringKernel, 13, sizeof(cl_float), (void *)&extensionPenalty);
err |= clSetKernelArg(hMatchStringKernel, 14, sizeof(cl_mem), (void *)&maxInfoD);
err |= clSetKernelArg(hMatchStringKernel, 15, sizeof(cl_mem), (void *)&blosum62D);
err |= clSetKernelArg(hMatchStringKernel, 16, sizeof(cl_mem), (void *)&mutexMem);
//err |= clSetKernelArg(hMatchStringKernel, 17, maxLocalSize, NULL);
CHKERR(err, "Set match string argument error!");
err = clEnqueueNDRangeKernel(commands, hMatchStringKernel, 1, NULL, &mfThreadNum,
&blockSize, 0, NULL, &ocdTempEvent);
clFinish(commands);
START_TIMER(ocdTempEvent, OCD_TIMER_KERNEL, "SWAT Kernels", ocdTempTimer)
END_TIMER(ocdTempTimer)
CHKERR(err, "Launch kernel match string error");
//record time
timerEnd();
strTime.matrixFillingTime += elapsedTime();
//record time
timerStart();
err = clSetKernelArg(hTraceBackKernel, 0, sizeof(cl_mem), (void *)&pathFlagD);
err |= clSetKernelArg(hTraceBackKernel, 1, sizeof(cl_mem), (void *)&extFlagD);
err |= clSetKernelArg(hTraceBackKernel, 2, sizeof(cl_mem), (void *)&diffPosD);
err |= clSetKernelArg(hTraceBackKernel, 3, sizeof(cl_mem), (void *)&seq1D);
err |= clSetKernelArg(hTraceBackKernel, 4, sizeof(cl_mem), (void *)&seq2D);
err |= clSetKernelArg(hTraceBackKernel, 5, sizeof(cl_mem), (void *)&outSeq1D);
err |= clSetKernelArg(hTraceBackKernel, 6, sizeof(cl_mem), (void *)&outSeq2D);
err |= clSetKernelArg(hTraceBackKernel, 7, sizeof(cl_mem), (void *)&maxInfoD);
err |= clSetKernelArg(hTraceBackKernel, 8, sizeof(int), (void *)&mfThreadNum);
size_t tbGlobalSize[1] = {1};
size_t tbLocalSize[1] = {1};
err = clEnqueueNDRangeKernel(commands, hTraceBackKernel, 1, NULL, tbGlobalSize,
tbLocalSize, 0, NULL, &ocdTempEvent);
clFinish(commands);
START_TIMER(ocdTempEvent, OCD_TIMER_KERNEL, "SWAT Kernels", ocdTempTimer)
END_TIMER(ocdTempTimer)
CHKERR(err, "Launch kernel trace back error");
clFinish(commands);
//record time
timerEnd();
strTime.traceBackTime += elapsedTime();
//record time
timerStart();
//copy matrix score structure back
err = clEnqueueReadBuffer(commands, maxInfoD, CL_FALSE, 0, sizeof(MAX_INFO),
maxInfo, 0, 0, &ocdTempEvent);
clFinish(commands);
START_TIMER(ocdTempEvent, OCD_TIMER_D2H, "SWAT Max Info Copy", ocdTempTimer)
END_TIMER(ocdTempTimer)
CHKERR(err, "Read maxInfo buffer error!");
int maxOutputLen = rowNum + columnNum - 2;
err = clEnqueueReadBuffer(commands, outSeq1D, CL_FALSE, 0, maxOutputLen * sizeof(cl_char),
outSeq1, 0, 0, &ocdTempEvent);
clFinish(commands);
START_TIMER(ocdTempEvent, OCD_TIMER_D2H, "SWAT Sequence Copy", ocdTempTimer)
END_TIMER(ocdTempTimer)
err = clEnqueueReadBuffer(commands, outSeq2D, CL_FALSE, 0, maxOutputLen * sizeof(cl_char),
outSeq2, 0, 0, &ocdTempEvent);
clFinish(commands);
START_TIMER(ocdTempEvent, OCD_TIMER_D2H, "SWAT Sequence Copy", ocdTempTimer)
END_TIMER(ocdTempTimer)
CHKERR(err, "Read output sequence error!");
//record time
clFinish(commands);
gettimeofday(&t2, NULL);
timerEnd();
strTime.copyTimeDeviceToHost += elapsedTime();
//call the print function to print the match result
printf("============================================================\n");
printf("Sequence pair %d:\n", subSequenceNo);
int nlength = maxInfo->noutputlen;
PrintAlignment(outSeq1, outSeq2, nlength, CHAR_PER_LINE, openPenalty, extensionPenalty);
printf("Max alignment score (on device) is %.1f\n", maxInfo->fmaxscore);
//obtain max alignment score on host
//err = clEnqueueReadBuffer(commands, nGapDistD, CL_TRUE, 0, sizeof(cl_float) * DPMatrixSize,
// nGapDist, 0, 0, 0);
//printf("Max alignment score (on host) is %.1f\n", maxScore(nGapDist, DPMatrixSize));
printf("openPenalty = %.1f, extensionPenalty = %.1f\n", openPenalty, extensionPenalty);
printf("Input sequence size, querySize: %d, subSequenceSize: %d\n",
querySize, subSequenceSize);
printf("Max position, seq1 = %d, seq2 = %d\n", maxInfo->nposi, maxInfo->nposj);
}
tmpTime = 1000.0 * (t2.tv_sec - t1.tv_sec) + (t2.tv_usec - t1.tv_usec) / 1000.0;
pfile = fopen("../kernelTime.txt", "at");
fprintf(pfile, "verOpencl4:\t%.3f\n", tmpTime);
fclose(pfile);
//print time
printTime_toStandardOutput();
printTime_toFile();
fclose(pDBLenFile);
fclose(pDBDataFile);
clReleaseKernel(hMatchStringKernel);
clReleaseKernel(hTraceBackKernel);
clReleaseKernel(hSetZeroKernel);
delete allSequences;
clReleaseMemObject(seq1D);
clReleaseMemObject(seq2D);
delete outSeq1;
delete outSeq2;
clReleaseMemObject(outSeq1D);
clReleaseMemObject(outSeq2D);
delete threadNum;
clReleaseMemObject(threadNumD);
delete diffPos;
clReleaseMemObject(diffPosD);
delete pathFlag;
delete extFlag;
delete nGapDist;
delete hGapDist;
delete vGapDist;
clReleaseMemObject(pathFlagD);
clReleaseMemObject(extFlagD);
clReleaseMemObject(nGapDistD);
clReleaseMemObject(hGapDistD);
clReleaseMemObject(vGapDistD);
delete maxInfo;
clReleaseMemObject(maxInfoD);
free(cSourceCL);
clReleaseMemObject(blosum62D);
clReleaseMemObject(mutexMem);
clReleaseProgram(hProgram);
clReleaseCommandQueue(commands);
clReleaseContext(context);
ocd_finalize();
return 0;
}
