static int get_prio_m1( void ) { if( !coper ) { return( 0 ); } return( get_prio( oper_stack[coper - 1] ) ); }
static void push_op( char op ) { if( !get_prio( op ) ) { nparens++; } oper_stack[coper++] = op; }
unsigned mt_task_queue::get_default_prio() { if (g_current_task && get_imp(*g_current_task)) { return get_prio(*g_current_task); } else { return 0; } }
bool mt_task_queue::check_deps(gtask const & t) { check_stack("mt_task_queue::check_deps"); lean_always_assert(get_data(t)); buffer<gtask> deps; try { get_data(t)->m_imp->get_dependencies(deps); } catch (...) {} auto prio = get_prio(t); for (auto & dep : deps) { if (dep) { submit_core(dep, prio); bump_prio(dep, prio); } } for (auto & dep : deps) { if (!dep) continue; switch (get_state(dep).load()) { case task_state::Waiting: case task_state::Queued: case task_state::Running: lean_always_assert(get_imp(dep)); get_sched_info(dep).m_reverse_deps.push_back(t); return false; case task_state::Success: break; case task_state::Failed: break; default: lean_unreachable(); } } return true; }
char get_operator( char op ) { /* if op is right op, then return op */ if( get_prio(op) >= 0 ) return op; return -1; }
void mt_task_queue::bump_prio(gtask const & t, unsigned new_prio) { switch (get_state(t).load()) { case task_state::Queued: if (new_prio < get_prio(t)) { auto prio = get_prio(t); auto &q = m_queue[prio]; auto it = std::find(q.begin(), q.end(), t); lean_always_assert(it != q.end()); q.erase(it); if (q.empty()) m_queue.erase(prio); get_prio(t) = std::min(get_prio(t), new_prio); check_deps(t); enqueue(t); } break; case task_state::Waiting: if (new_prio < get_prio(t)) { get_prio(t) = std::min(get_prio(t), new_prio); check_deps(t); } break; case task_state::Running: case task_state::Failed: case task_state::Success: break; default: lean_unreachable(); } }
void mt_task_queue::enqueue(gtask const & t) { lean_always_assert(get_state(t).load() < task_state::Running); lean_always_assert(get_imp(t)); get_state(t) = task_state::Queued; m_queue[get_prio(t)].push_back(t); if (m_required_workers > 0) { spawn_worker(); } else { m_queue_added.notify_one(); } notify_queue_changed(); }
static int do_paren( void ) { int op; if( 1 > nparens-- ) { return( not_ok ); } do { op = do_expr(); if( op < ok ) { break; } } while( get_prio( (char)op ) ); return( op ); }
int main(void) { pthread_attr_t attr; pthread_t th; struct params p; int ret; unsigned int i; ret = set_affinity_single(); if (ret) { n_threads = get_ncpu(); if (n_threads == -1) { printf("Cannot get number of CPUs\n"); return PTS_UNRESOLVED; } printf("INFO: Affinity not supported, running %i threads.\n", n_threads); } else { printf("INFO: Affinity works, will use only one thread.\n"); n_threads = 1; } for (i = 0; i < ARRAY_SIZE(tcases); i++) { p.sched_policy = tcases[i].sched_policy; p.sched_priority = get_prio(&tcases[i]); init_attr(&attr, p.sched_policy, p.sched_priority); printf("INFO: Testing %s prio %i\n", sched_policy_name(p.sched_policy), p.sched_priority); ret = pthread_create(&th, &attr, do_test, &p); if (ret) { fprintf(stderr, "pthread_create(): %s\n", strerror(ret)); return PTS_UNRESOLVED; } pthread_join(th, NULL); pthread_attr_destroy(&attr); } printf("Test PASSED\n"); return 0; }
t_tree *split_prio(char *cmd) { t_tree *p_tree; t_tree *tmp; short n_node; char *current_prio; p_tree = NULL; n_node = get_total_node(cmd, 0, -1, 0); while (n_node > 0) { get_current_id_prio(1); current_prio = cmd; cmd += get_prio(&cmd, 0, -1, 0); tmp = get_end_null_tree(p_tree); tmp = create_tree(get_end_tree(p_tree), current_prio, \ get_current_id_prio(0)); if (!p_tree) p_tree = tmp; n_node--; } return (p_tree); }
void pfunction::compile_infix(const std::vector<pstring> &inputs, const pstring &expr) { // Shunting-yard infix parsing std::vector<pstring> sep = {"(", ")", ",", "*", "/", "+", "-", "^"}; std::vector<pstring> sexpr(plib::psplit(expr.replace_all(" ",""), sep)); std::stack<pstring> opstk; std::vector<pstring> postfix; //printf("dbg: %s\n", expr.c_str()); for (unsigned i = 0; i < sexpr.size(); i++) { pstring &s = sexpr[i]; if (s=="(") opstk.push(s); else if (s==")") { pstring x = pop_check(opstk, expr); while (x != "(") { postfix.push_back(x); x = pop_check(opstk, expr); } if (opstk.size() > 0 && get_prio(opstk.top()) == 0) postfix.push_back(pop_check(opstk, expr)); } else if (s==",") { pstring x = pop_check(opstk, expr); while (x != "(") { postfix.push_back(x); x = pop_check(opstk, expr); } opstk.push(x); } else { int p = get_prio(s); if (p>0) { if (opstk.size() == 0) opstk.push(s); else { if (get_prio(opstk.top()) >= get_prio(s)) postfix.push_back(pop_check(opstk, expr)); opstk.push(s); } } else if (p == 0) // Function or variable { if (sexpr[i+1] == "(") opstk.push(s); else postfix.push_back(s); } else postfix.push_back(s); } } while (opstk.size() > 0) { postfix.push_back(opstk.top()); opstk.pop(); } compile_postfix(inputs, postfix, expr); }
int main( int argc, char * argv[] ) { int tmp; int i = 0; int num1; int num2; int new_num; char op; char * src; char cur_op; char top_op; printf( "expression value demo begin !\n" ); #if 0 push_int( 100 ); push_int( 200 ); tmp = pop_int(); printf( "pop is %d \n", tmp ); tmp = pop_int(); printf( "pop is %d \n", tmp ); #endif if( argc > 1 ) printf( "input expression string is %s \n", argv[1] ); else exit(0); src = argv[1]; push_char( '\0'); while( 1 ) { printf( "src[%d] = %c \n", i, src[i] ); get_num: /* get a number */ num1 = get_number( src[i] ); if( num1 >= 0 ) printf( "get a number : %d \n", num1 ); else break; /* push this number */ printf( "push current int : %d \n", num1 ); push_int( num1 ); /* get the next op */ i++; cur_op = get_operator( src[i] ); if( cur_op > 0 ) printf( "get a operator: %c \n", cur_op ); else if( cur_op == '\0' ) { printf( "get a operator == 0: %c \n", cur_op ); } cmp_op: top_op = get_top_char(); printf( "get top stack operator: %c \n", top_op ); /* if current op > stack top op, then push current op */ if( get_prio( cur_op ) > get_prio( top_op ) ) { printf( "<push> push current op : %c \n", cur_op ); push_char( cur_op ); printf( "<push> push ok!\n" ); } else { op = pop_char(); num2 = pop_int(); if( op == '\0' ) { printf( "op == 0, last result = %d \n", num2 ); exit( 0 ); } num1 = pop_int(); printf( "<calc> pop 2 num and 1 op, do calc: %d %c %d \n", num1, op, num2 ); new_num = calc( num1, num2, op ); printf( "get calc result: %d \n", new_num ); /* push this new number */ printf( "push new int : %d \n", new_num ); push_int( new_num ); goto cmp_op; } /* get the next op */ i++; } return 0; }