void make_loop(int n, int* last_pipe, char* grammar) {
/* last_pipe[0] = input of the recently created pipe *
* last_pipe[1] = output of the first pipe */
pid_t pid;
if (n == 1) {
prepare_input(last_pipe);
prepare_output(last_pipe);
close_pipe(last_pipe);
return;
}
int next_pipe[2];
create_pipe(next_pipe);
switch (pid = fork()) {
case -1:
syserr("Error in fork()\n");
case 0:
prepare_input(last_pipe);
close_pipe(last_pipe);
prepare_output(next_pipe);
close_pipe(next_pipe);
execl("./worker", "./worker", grammar, NULL);
syserr("Error in execl()\n");
default:
last_pipe[0] = next_pipe[0];
make_loop(n - 1, last_pipe, grammar);
return;
}
}
static PyObject*
automaton_search_iter_new(
Automaton* automaton,
PyObject* object,
int start,
int end
) {
AutomatonSearchIter* iter;
iter = (AutomatonSearchIter*)PyObject_New(AutomatonSearchIter, &automaton_search_iter_type);
if (iter == NULL)
return NULL;
if (!prepare_input((PyObject*)automaton, object, &iter->input)) {
return NULL;
}
iter->automaton = automaton;
iter->version = automaton->version;
iter->state = automaton->root;
iter->output= NULL;
iter->shift = 0;
iter->index = start - 1; // -1 because the first instruction in next() increments index
iter->end = end;
Py_INCREF(iter->automaton);
return (PyObject*)iter;
}
int gmmreg_base::initialize(const char* f_config) {
if (prepare_input(f_config) < 0) {
return -1;
}
set_init_params(f_config);
prepare_common_options(f_config);
prepare_own_options(f_config);
prepare_basis_kernel();
return 0;
}
static PyObject*
automaton_search_iter_set(PyObject* self, PyObject* args) {
PyObject* object;
PyObject* flag;
ssize_t len;
bool reset;
struct Input new_input;
// first argument - required string or buffer
object = PyTuple_GetItem(args, 0);
if (object) {
if (!prepare_input((PyObject*)iter->automaton, object, &new_input)) {
return NULL;
}
}
else
return NULL;
// second argument - optional bool
flag = PyTuple_GetItem(args, 1);
if (flag) {
switch (PyObject_IsTrue(flag)) {
case 0:
reset = false;
break;
case 1:
reset = true;
break;
default:
return NULL;
}
}
else {
PyErr_Clear();
reset = false;
}
destroy_input(&iter->input);
assign_input(&iter->input, &new_input);
if (!reset)
iter->shift += (iter->index >= 0) ? iter->index : 0;
iter->index = -1;
iter->end = (int)len;
if (reset) {
iter->state = iter->automaton->root;
iter->shift = 0;
iter->output = NULL;
}
Py_RETURN_NONE;
}
// ------------------------------------------------------------------ process --
void SpectacleBase::process(const float *buf, const int)
{
DPRINT("SpectacleBase::process");
if (_reading_input) {
prepare_input(buf);
_fft->r2c();
}
modify_analysis(_reading_input);
_fft->c2r();
prepare_output();
}
// ------------------------------------------------------------------ process --
void SPECTACLE2_BASE::process(const float *buf, const int)
{
DPRINT("SPECTACLE2_BASE::process\n");
const bool reading_input = (currentFrame() < _input_end_frame);
if (reading_input) {
DPRINT1("taking input...currentFrame()=%d\n", currentFrame());
prepare_input(buf);
_fft->r2c();
cartesian_to_polar();
}
modify_analysis(reading_input);
polar_to_cartesian();
_fft->c2r();
prepare_output();
}
std::vector<std::vector<ticks>> Timing_Test::execute_evaluation(
const std::vector<std::string>& raw_inputs,
size_t warmup_runs, size_t measurement_runs)
{
std::vector<std::vector<ticks>> all_results(raw_inputs.size());
std::vector<std::vector<uint8_t>> inputs(raw_inputs.size());
for(auto& result : all_results)
{
result.reserve(measurement_runs);
}
for(size_t i = 0; i != inputs.size(); ++i)
{
inputs[i] = prepare_input(raw_inputs[i]);
}
// arbitrary upper bounds of 1 and 10 million resp
if(warmup_runs > 1000000 || measurement_runs > 100000000)
{
throw CLI_Error("Requested execution counts too large, rejecting");
}
size_t total_runs = 0;
while(total_runs < (warmup_runs + measurement_runs))
{
std::vector<ticks> results(inputs.size());
for(size_t i = 0; i != inputs.size(); ++i)
{
results[i] = measure_critical_function(inputs[i]);
}
total_runs++;
if(total_runs >= warmup_runs)
{
for(size_t i = 0; i != results.size(); ++i)
{
all_results[i].push_back(results[i]);
}
}
}
return all_results;
}
int tools_main(error_monitor_t em) {
struct cpe_dr_generate_ctx ctx;
struct mem_buffer buffer;
int rv;
ctx.m_builder = NULL;
ctx.m_metalib = NULL;
ctx.m_em = em;
rv = 0;
ctx.m_builder = dr_metalib_builder_create(NULL, em);
if (ctx.m_builder == NULL) {
CPE_ERROR(em, "create metalib builder fail!");
return -1;
}
prepare_input(ctx.m_builder, em);
dr_metalib_builder_analize(ctx.m_builder);
mem_buffer_init(&buffer, 0);
if (dr_inbuild_build_lib(
&buffer,
dr_metalib_bilder_lib(ctx.m_builder),
em) == 0)
{
ctx.m_metalib = (LPDRMETALIB)mem_buffer_make_continuous(&buffer, 0), mem_buffer_size(&buffer);
if (ctx.m_metalib) {
if (do_validate(&ctx) != 0) rv = -1;
if (do_generate_h(&ctx) != 0) rv = -1;
if (do_generate_lib_bin(&ctx) != 0) rv = -1;
if (do_generate_lib_c(&ctx) != 0) rv = -1;
}
}
else {
rv = -1;
}
mem_buffer_clear(&buffer);
dr_metalib_builder_free(ctx.m_builder);
return rv;
}
int main()
{
struct sigaction sa;
memset(&sa, 0, sizeof(struct sigaction));
sa.sa_handler = sigint;
sigaction(SIGINT, &sa, NULL);
atexit(quit);
prepare_input(&org);
erase_display();
srand(time(NULL));
game_init();
draw();
pthread_mutex_init(&mut, NULL);
pthread_cond_init(&cond, NULL);
pthread_t tid;
pthread_create(&tid, NULL, trd_timer, NULL);
pthread_detach(tid);
pthread_create(&tid, NULL, trd_draw, NULL);
pthread_detach(tid);
int c;
while(EOF != (c=getchar())) {
if(c == 'j') {
move_down();
} else if(c == 'k') {
rotate();
} else if(c == 'h') {
move_left();
} else if(c == 'l') {
move_right();
} else if(c == 32) {
drop_down();
} else if(c == 'q') {
quit();
} else {
continue;
}
}
return 0;
}
int main() {
int i;
uint512 in0[100];
uint512 tree0[100];
uint512 out0[200];
uint512 answer[200];
int out_size;
char *in_char, *tree_char, *answer_char, *out_char;
in_char = (char*) in0;
tree_char = (char*) tree0;
answer_char = (char*) answer;
out_char = (char*) out0;
prepare_input(in_char, tree_char);
for (i=0; i<NT+N; i++) {
if (i < NT) {
answer_char[i] = 2;
} else {
answer_char[i] = 1;
}
}
deflate259(in0, N, tree0, 8*NT, out0, &out_size);
for (i=0; i<N; i++) {
if (answer_char[i] != out_char[i]) {
printf("Mismatch at position %d, expected %d, got %d.\n",
i, answer_char[i], out_char[i]);
return 1;
}
}
if (out_size != (NT+N)) {
fprintf(stderr, "Output size mismatch, expected %d, got %d.\n",
NT+N, out_size);
return 1;
}
return 0;
}
int main(int argc, char *argv[])
{
prepare_input(argc, argv);
string header;
/*
if(argc == 2)
{
SEED = 40;
//MAXREAD = 100;
MAXTHREAD = (int) atol(argv[1]);
}
if(argc == 3)
{
SEED = 40;
MAXREAD = (int) atol(argv[1]);
MAXTHREAD = (int) atol(argv[2]);
//cout << "Given MAX number of READ = " << MAXREAD << endl;
}
if(argc == 4)
{
SEED = (int) atol(argv[1]);
MAXREAD = (int) atol(argv[2]);
MAXTHREAD = (int) atol(argv[3]);
}
*/
cout << "KMER = " << KMER << ", SEED = " << SEED << ", MAXREAD = " << MAXREAD << endl;
fp_meta.open(meta_file.c_str(), ifstream::in);
getline(fp_meta, header);
//cout << header << endl;
/*
ostringstream logstr;
string log = "detail_alignment-";
logstr << SEED << "-" << MINREAD << "-" << MAXREAD;
log = log + logstr.str() + ".txt";
FILE* freop = freopen(log.c_str(), "w", stdout);
*/
/*
//thread_function();//single thread
thread thread_test(thread_function);
thread_test.join();
*/
/*
std::thread thread_object[MAXTHREAD];
//Launch a group of threads
for (int i = 0; i < MAXTHREAD; ++i)
{
thread_object[i] = std::thread(thread_function, i);
}
std::cout << "Launched from the main\n";
//Join the threads with the main thread
for (int i = 0; i < MAXTHREAD; ++i) {
thread_object[i].join();
}
*/
int x, y, z, novalue;
FILE* fstream1 = fopen("matching_score.txt", "r");
for(int i = 0; i < 51; i++)
{
for(int k = 0; k < 51; k++)
{
novalue = fscanf(fstream1, "%d,%d,%d", &x, &y, &z);
//cout << "x = " << x << ", y = " << y << ", z = " << z << endl;
matching_score[x][y] = z;
}
}
fclose(fstream1);
FILE* fstream2 = fopen("mismatch_score.txt", "r");
for(int i = 0; i < 51; i++)
{
for(int k = 0; k < 51; k++)
{
novalue = fscanf(fstream2, "%d,%d,%d", &x, &y, &z);
//cout << "x = " << x << ", y = " << y << ", z = " << z << endl;
mismatch_score[x][y] = z;
}
}
fclose(fstream2);
//return 0;
thread_function(0);
//fp_blastn.close();
fp_meta.close();
return 0;
}
void sha256(char *pInput, unsigned int iInputLength, _hash *p_hash)
{
//printf("length:%d\n",iInputLength);
unsigned long h1 = 0x6a09e667;
unsigned long h2 = 0xbb67ae85;
unsigned long h3 = 0x3c6ef372;
unsigned long h4 = 0xa54ff53a;
unsigned long h5 = 0x510e527f;
unsigned long h6 = 0x9b05688c;
unsigned long h7 = 0x1f83d9ab;
unsigned long h8 = 0x5be0cd19;
//print8longs(h1, h2, h3, h4, h5, h6, h7, h8);
unsigned int isize = (iInputLength / 64 > 0) ? (iInputLength / 64 * 64 + 64) : 64;
isize = iInputLength % 64 >= 56 ? isize + 64 : isize;
//printf("size:%d\n", isize);
unsigned long *pPreparedInput = (unsigned long*)malloc(isize);
prepare_input(pPreparedInput, isize/4, pInput, iInputLength);
//printstr((char*)pPreparedInput, isize);
for (int i = 0; i < isize/4; i = i + 16)
{
unsigned long W[64] = {0};
for (int j = 0; j < 16; j++)
W[j] = pPreparedInput[i+j];
for (int j = 16; j < 64; j++)
W[j] = Q1(W[j-2]) + W[j-7] + Q0(W[j-15]) + W[j-16];
unsigned long a = h1;
unsigned long b = h2;
unsigned long c = h3;
unsigned long d = h4;
unsigned long e = h5;
unsigned long f = h6;
unsigned long g = h7;
unsigned long h = h8;
for (int j = 0; j < 64; j++)
{
unsigned long t1 = h + E1(e) + CH(e, f, g) + K[j] + W[j];
unsigned long t2 = E0(a) + MAJ(a, b, c);
/*
printf("h:");
printlong(h);
printf("\n");
printf("E1(e):");
printlong(E1(e));
printf("\n");
printf("CH(e,f,g):");
printlong(CH(e,f,g));
printf("\n");
printf("K[%d]:", j);
printlong(K[j]);
printf("\n");
printf("W[%d]:", j);
printlong(W[j]);
printf("\n");
printf("T1");
printlong(t1);
printf("\n");
*/
h = g;
g = f;
f = e;
e = d + t1;
d = c;
c = b;
b = a;
a = t1 + t2;
//printf("%d:", j);
//print8longs(a, b, c, d, e, f, g, h);
}
h1 += a;
h2 += b;
h3 += c;
h4 += d;
h5 += e;
h6 += f;
h7 += g;
h8 += h;
}
//print8longs(h1, h2, h3, h4, h5, h6, h7, h8);
long2char4(h1, p_hash->X);
long2char4(h2, p_hash->X+4);
long2char4(h3, p_hash->X+8);
long2char4(h4, p_hash->X+12);
long2char4(h5, p_hash->X+16);
long2char4(h6, p_hash->X+20);
long2char4(h7, p_hash->X+24);
long2char4(h8, p_hash->X+28);
free(pPreparedInput);
}
