bool is_one(Expr e) {
if (const IntImm *int_imm = e.as<IntImm>()) return int_imm->value == 1;
if (const FloatImm *float_imm = e.as<FloatImm>()) return float_imm->value == 1.0f;
if (const Cast *c = e.as<Cast>()) return is_one(c->value);
if (const Broadcast *b = e.as<Broadcast>()) return is_one(b->value);
return false;
}
int main() {
d = 0x00800000;
f00800000();
if( is_one( c ) == 0 ) fail(__LINE__);
d = 0x01000000;
f01000000();
if( is_one( c ) == 0 ) fail(__LINE__);
d = 0x02000000;
f02000000();
if( is_one( c ) == 0 ) fail(__LINE__);
d = 0x04000000;
f04000000();
if( is_one( c ) == 0 ) fail(__LINE__);
d = 0x08000000;
f08000000();
if( is_one( c ) == 0 ) fail(__LINE__);
d = 0x10000000;
f10000000();
if( is_one( c ) == 0 ) fail(__LINE__);
d = 0x20000000;
f20000000();
if( is_one( c ) == 0 ) fail(__LINE__);
d = 0x40000000;
f40000000();
if( is_one( c ) == 0 ) fail(__LINE__);
d = 0x80000000;
f80000000();
if( is_one( c ) == 0 ) fail(__LINE__);
_PASS;
}
bool is_one(const Expr &e) {
if (const IntImm *int_imm = e.as<IntImm>()) return int_imm->value == 1;
if (const UIntImm *uint_imm = e.as<UIntImm>()) return uint_imm->value == 1;
if (const FloatImm *float_imm = e.as<FloatImm>()) return float_imm->value == 1.0;
if (const Cast *c = e.as<Cast>()) return is_one(c->value);
if (const Broadcast *b = e.as<Broadcast>()) return is_one(b->value);
if (const Call *c = e.as<Call>()) {
return (c->is_intrinsic(Call::bool_to_mask) || c->is_intrinsic(Call::cast_mask)) &&
is_one(c->args[0]);
}
return false;
}
static bool is_coprime(T first, T second) {
T zero = T();
while (true) {
second %= first;
if (second == zero) {
return is_one(first);
}
first %= second;
if (first == zero) {
return is_one(second);
}
}
}
void
Exclusive::dump()
{
const char * state =
(event::is_one(waiters.head->next) ?
"empty [1]"
: (waiters.head->next == NULL ?
"held0 [2]" :
"heldM [3]"));
printf(" atomic[%d] in state %s\n"
, index
, state);
printf(" head = ");
event::Event * e = waiters.head;
while(e != NULL && !is_one(e)) {
printf("%d->",e->id);
e = e->next;
}
if(e == NULL) {
printf("(0x0)\n");
} else if(event::is_one(e)) {
printf("(0x1)\n");
} else {
printf("\n");
}
printf(" tail = %d\n",waiters.tail->id);
}
optional<expr> unfold_num_app(environment const & env, expr const & e) {
if (is_zero(e) || is_one(e) || is_bit0(e) || is_bit1(e)) {
return unfold_app(env, e);
} else {
return none_expr();
}
}
static inline bool
equals(const fixed a, const fixed b)
{
if (is_zero(a) || is_zero(b))
return is_zero(a) && is_zero(b);
return is_one(a / b);
}
static inline bool
equals(const double a, const double b, const int accuracy=ACCURACY)
{
if (is_zero(a, accuracy) || is_zero(b, accuracy))
return is_zero(a, accuracy) && is_zero(b, accuracy);
return is_one(a / b, accuracy);
}
bool ARingTower::is_one(int level, const poly f) const
{
if (f == 0) return false;
if (f->deg != 0) return false;
if (level == 0)
return 1 == f->coeffs[0];
else
return is_one(level - 1, f->polys[0]);
}
INT base::is_one()
{
if (s_kind() != BASE) {
// cout << "is_one() not implemented for class ";
// printobjectkindln(cout);
// exit(1);
return is_one();
}
NOT_EXISTING_FUNCTION("base::is_one");
exit(1);
}
void split_into_ands(const Expr &cond, std::vector<Expr> &result) {
if (!cond.defined()) {
return;
}
internal_assert(cond.type().is_bool()) << "Should be a boolean condition\n";
if (const And *a = cond.as<And>()) {
split_into_ands(a->a, result);
split_into_ands(a->b, result);
} else if (!is_one(cond)) {
result.push_back(cond);
}
}
bool
EventList::push(Event * e)
{
e->next = NULL;
Event * t = NULL;
if(!e->id) {
oflux::lockfree::store_load_barrier();
}
int id = e->id;
assert(id);
int w_on = e->waiting_on;
int hs = e->has;
e->id = 0;
e->waiting_on = -1;
e->has = -1;
Event * h = NULL;
Event * hn = NULL;
while(1) {
h = head;
hn = h->next;
if(is_one(hn) && __sync_bool_compare_and_swap(
&(head->next)
, 0x0001
, NULL)) {
// 1->2
tail = head;
e->id = id;
e->waiting_on = w_on;
e->has = hs;
return true;
} else {
// (2,3)->3
t = tail;
Event * old_t = t;
while(unmk(t) && unmk(t->next)) {
t = t->next;
}
if(t != tail && t->next == NULL) {
__sync_bool_compare_and_swap(&tail,old_t,t);
}
//check_tail(h,t);
if(unmk(t) && __sync_bool_compare_and_swap(&(t->next),NULL,e)) {
tail = e;
t->id = id;
t->waiting_on = w_on;
t->has = hs;
break;
}
}
}
return false;
}
uint64_t inverse_mod2to64(uint64_t n)
{
uint64_t inv = 1ull;
uint64_t inv_times_n = n;
int last_pos = 1;
while (!is_one(inv_times_n,last_pos, &last_pos)) {
inv += 1ull << last_pos;
inv_times_n += n << last_pos;
}
return inv;
}
/*
* infrom:
* reads a card, supposedly in hand, accepting unambigous brief
* input, returns the index of the card found...
*/
int
infrom(const CARD hand[], int n, const char *prompt)
{
int i, j;
CARD crd;
if (n < 1) {
printf("\nINFROM: %d = n < 1!!\n", n);
exit(74);
}
for (;;) {
msg("%s", prompt);
if (incard(&crd)) { /* if card is full card */
if (!is_one(crd, hand, n))
msg("That's not in your hand");
else {
for (i = 0; i < n; i++)
if (hand[i].rank == crd.rank &&
hand[i].suit == crd.suit)
break;
if (i >= n) {
printf("\nINFROM: is_one or something messed up\n");
exit(77);
}
return (i);
}
} else /* if not full card... */
if (crd.rank != EMPTY) {
for (i = 0; i < n; i++)
if (hand[i].rank == crd.rank)
break;
if (i >= n)
msg("No such rank in your hand");
else {
for (j = i + 1; j < n; j++)
if (hand[j].rank == crd.rank)
break;
if (j < n)
msg("Ambiguous rank");
else
return (i);
}
} else
msg("Sorry, I missed that");
}
/* NOTREACHED */
}
static optional<mpz> to_num(expr const & e, bool first) {
if (is_zero(e)) {
return first ? some(mpz(0)) : optional<mpz>();
} else if (is_one(e)) {
return some(mpz(1));
} else if (auto a = is_bit0(e)) {
if (auto r = to_num(*a, false))
return some(2*(*r));
} else if (auto a = is_bit1(e)) {
if (auto r = to_num(*a, false))
return some(2*(*r)+1);
} else if (auto a = is_neg(e)) {
if (auto r = to_num(*a, false))
return some(neg(*r));
}
return optional<mpz>();
}
void mpq_manager<SYNCH>::gcd(unsigned sz, mpq const * as, mpq & g) {
switch (sz) {
case 0:
reset(g);
return;
case 1:
set(g, as[0]);
abs(g);
return;
default:
break;
}
gcd(as[0], as[1], g);
for (unsigned i = 2; i < sz; i++) {
if (is_one(g))
return;
gcd(g, as[i], g);
}
}
Event *
EventList::pop()
{
Event * r = NULL;
Event * h = NULL;
Event * hn = NULL;
Event * t = NULL;
while(1) {
h = head;
hn = h->next;
t = tail;
Event * old_t = t;
while(unmk(t) && unmk(t->next)) {
t = t->next;
}
if(t != tail && t->next == NULL) {
__sync_bool_compare_and_swap(&tail,old_t,t);
}
//check_tail(h,t);
if(h != tail && hn != NULL
&& !is_one(hn)
&& h->id != 0
&& __sync_bool_compare_and_swap(
&head
, h
, hn)) {
// 3->(2,3)
r = h;
assert(r->id);
r->next = NULL;
break;
} else if(hn==NULL && __sync_bool_compare_and_swap(
&(head->next)
, hn
, 0x0001)) {
// 2->1
break; //empty
}
}
return r;
}
elem elem::operator*(const elem& other) const
{
if (is_zero() || other.is_zero())
{
return elem { "0" };
}
if (is_one())
{
return elem { other.value };
}
if (other.is_one())
{
return elem { value };
}
if (is_unknown() || other.is_unknown())
{
return elem { "X" };
}
std::stringstream ss;
ss << value << '*' << other.value;
return elem { ss.str() };
}
static environment mk_below(environment const & env, name const & n, bool ibelow) {
if (!is_recursive_datatype(env, n))
return env;
if (is_inductive_predicate(env, n))
return env;
inductive::inductive_decls decls = *inductive::is_inductive_decl(env, n);
type_checker tc(env);
name_generator ngen;
unsigned nparams = std::get<1>(decls);
declaration ind_decl = env.get(n);
declaration rec_decl = env.get(inductive::get_elim_name(n));
unsigned nindices = *inductive::get_num_indices(env, n);
unsigned nminors = *inductive::get_num_minor_premises(env, n);
unsigned ntypeformers = length(std::get<2>(decls));
level_param_names lps = rec_decl.get_univ_params();
bool is_reflexive = is_reflexive_datatype(tc, n);
level lvl = mk_param_univ(head(lps));
levels lvls = param_names_to_levels(tail(lps));
level_param_names blvls; // universe level parameters of ibelow/below
level rlvl; // universe level of the resultant type
// The arguments of below (ibelow) are the ones in the recursor - minor premises.
// The universe we map to is also different (l+1 for below of reflexive types) and (0 fo ibelow).
expr ref_type;
expr Type_result;
if (ibelow) {
// we are eliminating to Prop
blvls = tail(lps);
rlvl = mk_level_zero();
ref_type = instantiate_univ_param(rec_decl.get_type(), param_id(lvl), mk_level_zero());
} else if (is_reflexive) {
blvls = lps;
rlvl = get_datatype_level(ind_decl.get_type());
// if rlvl is of the form (max 1 l), then rlvl <- l
if (is_max(rlvl) && is_one(max_lhs(rlvl)))
rlvl = max_rhs(rlvl);
rlvl = mk_max(mk_succ(lvl), rlvl);
ref_type = instantiate_univ_param(rec_decl.get_type(), param_id(lvl), mk_succ(lvl));
} else {
// we can simplify the universe levels for non-reflexive datatypes
blvls = lps;
rlvl = mk_max(mk_level_one(), lvl);
ref_type = rec_decl.get_type();
}
Type_result = mk_sort(rlvl);
buffer<expr> ref_args;
to_telescope(ngen, ref_type, ref_args);
if (ref_args.size() != nparams + ntypeformers + nminors + nindices + 1)
throw_corrupted(n);
// args contains the below/ibelow arguments
buffer<expr> args;
buffer<name> typeformer_names;
// add parameters and typeformers
for (unsigned i = 0; i < nparams; i++)
args.push_back(ref_args[i]);
for (unsigned i = nparams; i < nparams + ntypeformers; i++) {
args.push_back(ref_args[i]);
typeformer_names.push_back(mlocal_name(ref_args[i]));
}
// we ignore minor premises in below/ibelow
for (unsigned i = nparams + ntypeformers + nminors; i < ref_args.size(); i++)
args.push_back(ref_args[i]);
// We define below/ibelow using the recursor for this type
levels rec_lvls = cons(mk_succ(rlvl), lvls);
expr rec = mk_constant(rec_decl.get_name(), rec_lvls);
for (unsigned i = 0; i < nparams; i++)
rec = mk_app(rec, args[i]);
// add type formers
for (unsigned i = nparams; i < nparams + ntypeformers; i++) {
buffer<expr> targs;
to_telescope(ngen, mlocal_type(args[i]), targs);
rec = mk_app(rec, Fun(targs, Type_result));
}
// add minor premises
for (unsigned i = nparams + ntypeformers; i < nparams + ntypeformers + nminors; i++) {
expr minor = ref_args[i];
expr minor_type = mlocal_type(minor);
buffer<expr> minor_args;
minor_type = to_telescope(ngen, minor_type, minor_args);
buffer<expr> prod_pairs;
for (expr & minor_arg : minor_args) {
buffer<expr> minor_arg_args;
expr minor_arg_type = to_telescope(tc, mlocal_type(minor_arg), minor_arg_args);
if (is_typeformer_app(typeformer_names, minor_arg_type)) {
expr fst = mlocal_type(minor_arg);
minor_arg = update_mlocal(minor_arg, Pi(minor_arg_args, Type_result));
expr snd = Pi(minor_arg_args, mk_app(minor_arg, minor_arg_args));
prod_pairs.push_back(mk_prod(tc, fst, snd, ibelow));
}
}
expr new_arg = foldr([&](expr const & a, expr const & b) { return mk_prod(tc, a, b, ibelow); },
[&]() { return mk_unit(rlvl, ibelow); },
prod_pairs.size(), prod_pairs.data());
rec = mk_app(rec, Fun(minor_args, new_arg));
}
// add indices and major premise
for (unsigned i = nparams + ntypeformers; i < args.size(); i++) {
rec = mk_app(rec, args[i]);
}
name below_name = ibelow ? name{n, "ibelow"} : name{n, "below"};
expr below_type = Pi(args, Type_result);
expr below_value = Fun(args, rec);
bool use_conv_opt = true;
declaration new_d = mk_definition(env, below_name, blvls, below_type, below_value,
use_conv_opt);
environment new_env = module::add(env, check(env, new_d));
new_env = set_reducible(new_env, below_name, reducible_status::Reducible);
if (!ibelow)
new_env = add_unfold_hint(new_env, below_name, nparams + nindices + ntypeformers);
return add_protected(new_env, below_name);
}
static environment mk_brec_on(environment const & env, name const & n, bool ind) {
if (!is_recursive_datatype(env, n))
return env;
if (is_inductive_predicate(env, n))
return env;
inductive::inductive_decls decls = *inductive::is_inductive_decl(env, n);
type_checker tc(env);
name_generator ngen;
unsigned nparams = std::get<1>(decls);
declaration ind_decl = env.get(n);
declaration rec_decl = env.get(inductive::get_elim_name(n));
// declaration below_decl = env.get(name(n, ind ? "ibelow" : "below"));
unsigned nindices = *inductive::get_num_indices(env, n);
unsigned nminors = *inductive::get_num_minor_premises(env, n);
unsigned ntypeformers = length(std::get<2>(decls));
level_param_names lps = rec_decl.get_univ_params();
bool is_reflexive = is_reflexive_datatype(tc, n);
level lvl = mk_param_univ(head(lps));
levels lvls = param_names_to_levels(tail(lps));
level rlvl;
level_param_names blps;
levels blvls; // universe level parameters of brec_on/binduction_on
// The arguments of brec_on (binduction_on) are the ones in the recursor - minor premises.
// The universe we map to is also different (l+1 for below of reflexive types) and (0 fo ibelow).
expr ref_type;
if (ind) {
// we are eliminating to Prop
blps = tail(lps);
blvls = lvls;
rlvl = mk_level_zero();
ref_type = instantiate_univ_param(rec_decl.get_type(), param_id(lvl), mk_level_zero());
} else if (is_reflexive) {
blps = lps;
blvls = cons(lvl, lvls);
rlvl = get_datatype_level(ind_decl.get_type());
// if rlvl is of the form (max 1 l), then rlvl <- l
if (is_max(rlvl) && is_one(max_lhs(rlvl)))
rlvl = max_rhs(rlvl);
rlvl = mk_max(mk_succ(lvl), rlvl);
// inner_prod, inner_prod_intro, pr1, pr2 do not use the same universe levels for
// reflective datatypes.
ref_type = instantiate_univ_param(rec_decl.get_type(), param_id(lvl), mk_succ(lvl));
} else {
// we can simplify the universe levels for non-reflexive datatypes
blps = lps;
blvls = cons(lvl, lvls);
rlvl = mk_max(mk_level_one(), lvl);
ref_type = rec_decl.get_type();
}
buffer<expr> ref_args;
to_telescope(ngen, ref_type, ref_args);
if (ref_args.size() != nparams + ntypeformers + nminors + nindices + 1)
throw_corrupted(n);
// args contains the brec_on/binduction_on arguments
buffer<expr> args;
buffer<name> typeformer_names;
// add parameters and typeformers
for (unsigned i = 0; i < nparams; i++)
args.push_back(ref_args[i]);
for (unsigned i = nparams; i < nparams + ntypeformers; i++) {
args.push_back(ref_args[i]);
typeformer_names.push_back(mlocal_name(ref_args[i]));
}
// add indices and major premise
for (unsigned i = nparams + ntypeformers + nminors; i < ref_args.size(); i++)
args.push_back(ref_args[i]);
// create below terms (one per datatype)
// (below.{lvls} params type-formers)
// Remark: it also creates the result type
buffer<expr> belows;
expr result_type;
unsigned k = 0;
for (auto const & decl : std::get<2>(decls)) {
name const & n1 = inductive::inductive_decl_name(decl);
if (n1 == n) {
result_type = ref_args[nparams + k];
for (unsigned i = nparams + ntypeformers + nminors; i < ref_args.size(); i++)
result_type = mk_app(result_type, ref_args[i]);
}
k++;
name bname = name(n1, ind ? "ibelow" : "below");
expr below = mk_constant(bname, blvls);
for (unsigned i = 0; i < nparams; i++)
below = mk_app(below, ref_args[i]);
for (unsigned i = nparams; i < nparams + ntypeformers; i++)
below = mk_app(below, ref_args[i]);
belows.push_back(below);
}
// create functionals (one for each type former)
// Pi idxs t, below idxs t -> C idxs t
buffer<expr> Fs;
name F_name("F");
for (unsigned i = nparams, j = 0; i < nparams + ntypeformers; i++, j++) {
expr const & C = ref_args[i];
buffer<expr> F_args;
to_telescope(ngen, mlocal_type(C), F_args);
expr F_result = mk_app(C, F_args);
expr F_below = mk_app(belows[j], F_args);
F_args.push_back(mk_local(ngen.next(), "f", F_below, binder_info()));
expr F_type = Pi(F_args, F_result);
expr F = mk_local(ngen.next(), F_name.append_after(j+1), F_type, binder_info());
Fs.push_back(F);
args.push_back(F);
}
// We define brec_on/binduction_on using the recursor for this type
levels rec_lvls = cons(rlvl, lvls);
expr rec = mk_constant(rec_decl.get_name(), rec_lvls);
// add parameters to rec
for (unsigned i = 0; i < nparams; i++)
rec = mk_app(rec, ref_args[i]);
// add type formers to rec
// Pi indices t, prod (C ... t) (below ... t)
for (unsigned i = nparams, j = 0; i < nparams + ntypeformers; i++, j++) {
expr const & C = ref_args[i];
buffer<expr> C_args;
to_telescope(ngen, mlocal_type(C), C_args);
expr C_t = mk_app(C, C_args);
expr below_t = mk_app(belows[j], C_args);
expr prod = mk_prod(tc, C_t, below_t, ind);
rec = mk_app(rec, Fun(C_args, prod));
}
// add minor premises to rec
for (unsigned i = nparams + ntypeformers, j = 0; i < nparams + ntypeformers + nminors; i++, j++) {
expr minor = ref_args[i];
expr minor_type = mlocal_type(minor);
buffer<expr> minor_args;
minor_type = to_telescope(ngen, minor_type, minor_args);
buffer<expr> pairs;
for (expr & minor_arg : minor_args) {
buffer<expr> minor_arg_args;
expr minor_arg_type = to_telescope(tc, mlocal_type(minor_arg), minor_arg_args);
if (auto k = is_typeformer_app(typeformer_names, minor_arg_type)) {
buffer<expr> C_args;
get_app_args(minor_arg_type, C_args);
expr new_minor_arg_type = mk_prod(tc, minor_arg_type, mk_app(belows[*k], C_args), ind);
minor_arg = update_mlocal(minor_arg, Pi(minor_arg_args, new_minor_arg_type));
if (minor_arg_args.empty()) {
pairs.push_back(minor_arg);
} else {
expr r = mk_app(minor_arg, minor_arg_args);
expr r_1 = Fun(minor_arg_args, mk_pr1(tc, r, ind));
expr r_2 = Fun(minor_arg_args, mk_pr2(tc, r, ind));
pairs.push_back(mk_pair(tc, r_1, r_2, ind));
}
}
}
expr b = foldr([&](expr const & a, expr const & b) { return mk_pair(tc, a, b, ind); },
[&]() { return mk_unit_mk(rlvl, ind); },
pairs.size(), pairs.data());
unsigned F_idx = *is_typeformer_app(typeformer_names, minor_type);
expr F = Fs[F_idx];
buffer<expr> F_args;
get_app_args(minor_type, F_args);
F_args.push_back(b);
expr new_arg = mk_pair(tc, mk_app(F, F_args), b, ind);
rec = mk_app(rec, Fun(minor_args, new_arg));
}
// add indices and major to rec
for (unsigned i = nparams + ntypeformers + nminors; i < ref_args.size(); i++)
rec = mk_app(rec, ref_args[i]);
name brec_on_name = name(n, ind ? "binduction_on" : "brec_on");
expr brec_on_type = Pi(args, result_type);
expr brec_on_value = Fun(args, mk_pr1(tc, rec, ind));
bool use_conv_opt = true;
declaration new_d = mk_definition(env, brec_on_name, blps, brec_on_type, brec_on_value,
use_conv_opt);
environment new_env = module::add(env, check(env, new_d));
new_env = set_reducible(new_env, brec_on_name, reducible_status::Reducible);
if (!ind)
new_env = add_unfold_hint(new_env, brec_on_name, nparams + nindices + ntypeformers);
return add_protected(new_env, brec_on_name);
}
void CodeGen_GPU_Host<CodeGen_CPU>::visit(const For *loop) {
if (CodeGen_GPU_Dev::is_gpu_var(loop->name)) {
// We're in the loop over innermost thread dimension
debug(2) << "Kernel launch: " << loop->name << "\n";
ExtractBounds bounds;
loop->accept(&bounds);
debug(2) << "Kernel bounds: ("
<< bounds.num_threads[0] << ", "
<< bounds.num_threads[1] << ", "
<< bounds.num_threads[2] << ", "
<< bounds.num_threads[3] << ") threads, ("
<< bounds.num_blocks[0] << ", "
<< bounds.num_blocks[1] << ", "
<< bounds.num_blocks[2] << ", "
<< bounds.num_blocks[3] << ") blocks\n";
// compute a closure over the state passed into the kernel
GPU_Host_Closure c(loop, loop->name);
// compile the kernel
string kernel_name = unique_name("kernel_" + loop->name, false);
for (size_t i = 0; i < kernel_name.size(); i++) {
if (!isalnum(kernel_name[i])) {
kernel_name[i] = '_';
}
}
vector<GPU_Argument> closure_args = c.arguments();
for (size_t i = 0; i < closure_args.size(); i++) {
if (closure_args[i].is_buffer && allocations.contains(closure_args[i].name)) {
closure_args[i].size = allocations.get(closure_args[i].name).constant_bytes;
}
}
cgdev->add_kernel(loop, kernel_name, closure_args);
// get the actual name of the generated kernel for this loop
kernel_name = cgdev->get_current_kernel_name();
debug(2) << "Compiled launch to kernel \"" << kernel_name << "\"\n";
Value *entry_name_str = builder->CreateGlobalStringPtr(kernel_name, "entry_name");
llvm::Type *target_size_t_type = (target.bits == 32) ? i32 : i64;
// build the kernel arguments array
llvm::PointerType *arg_t = i8->getPointerTo(); // void*
int num_args = (int)closure_args.size();
// NULL-terminated list
Value *gpu_args_arr =
create_alloca_at_entry(ArrayType::get(arg_t, num_args+1),
num_args+1,
kernel_name + "_args");
// NULL-terminated list of size_t's
Value *gpu_arg_sizes_arr =
create_alloca_at_entry(ArrayType::get(target_size_t_type, num_args+1),
num_args+1,
kernel_name + "_arg_sizes");
for (int i = 0; i < num_args; i++) {
// get the closure argument
string name = closure_args[i].name;
Value *val;
if (closure_args[i].is_buffer) {
// If it's a buffer, dereference the dev handle
val = buffer_dev(sym_get(name + ".buffer"));
} else {
// Otherwise just look up the symbol
val = sym_get(name);
}
// allocate stack space to mirror the closure element. It
// might be in a register and we need a pointer to it for
// the gpu args array.
Value *ptr = builder->CreateAlloca(val->getType(), NULL, name+".stack");
// store the closure value into the stack space
builder->CreateStore(val, ptr);
// store a void* pointer to the argument into the gpu_args_arr
Value *bits = builder->CreateBitCast(ptr, arg_t);
builder->CreateStore(bits,
builder->CreateConstGEP2_32(gpu_args_arr, 0, i));
// store the size of the argument
int size_bits = (closure_args[i].is_buffer) ? target.bits : closure_args[i].type.bits;
builder->CreateStore(ConstantInt::get(target_size_t_type, size_bits/8),
builder->CreateConstGEP2_32(gpu_arg_sizes_arr, 0, i));
}
// NULL-terminate the lists
builder->CreateStore(ConstantPointerNull::get(arg_t),
builder->CreateConstGEP2_32(gpu_args_arr, 0, num_args));
builder->CreateStore(ConstantInt::get(target_size_t_type, 0),
builder->CreateConstGEP2_32(gpu_arg_sizes_arr, 0, num_args));
// TODO: only three dimensions can be passed to
// cuLaunchKernel. How should we handle blkid[3]?
internal_assert(is_one(bounds.num_threads[3]) && is_one(bounds.num_blocks[3]));
Value *launch_args[] = {
get_user_context(),
builder->CreateLoad(get_module_state()),
entry_name_str,
codegen(bounds.num_blocks[0]), codegen(bounds.num_blocks[1]), codegen(bounds.num_blocks[2]),
codegen(bounds.num_threads[0]), codegen(bounds.num_threads[1]), codegen(bounds.num_threads[2]),
codegen(bounds.shared_mem_size),
builder->CreateConstGEP2_32(gpu_arg_sizes_arr, 0, 0, "gpu_arg_sizes_ar_ref"),
builder->CreateConstGEP2_32(gpu_args_arr, 0, 0, "gpu_args_arr_ref")
};
llvm::Function *dev_run_fn = module->getFunction("halide_dev_run");
internal_assert(dev_run_fn) << "Could not find halide_dev_run in module\n";
Value *result = builder->CreateCall(dev_run_fn, launch_args);
Value *did_succeed = builder->CreateICmpEQ(result, ConstantInt::get(i32, 0));
CodeGen_CPU::create_assertion(did_succeed, "Failure inside halide_dev_run");
} else {
CodeGen_CPU::visit(loop);
}
}
inline bool on_end() const
{
// e.g. 0/4 or 4/4
return is_zero() || is_one();
}
inline bool marked() const
{ return is_one(head->next); }
void DPoly::elem_text_out(buffer &o,
int level,
const poly f,
bool p_one,
bool p_plus,
bool p_parens,
M2_ArrayString names) const
{
//o << to_string(level, f);
if (f == 0)
{
o << "0";
return;
}
int nterms = n_nonzero_terms(level,f);
bool needs_parens = p_parens && (nterms >= 2);
if (needs_parens)
{
if (p_plus) o << '+';
o << '(';
p_plus = false;
}
bool one = is_one(level, f);
if (one)
{
if (p_plus) o << "+";
if (p_one) o << "1";
return;
}
M2_string this_varname = names->array[level];
if (level == 0)
{
bool firstterm = true;
for (int i=f->deg; i>=0; i--)
if (f->arr.ints[i] != 0)
{
if (!firstterm || p_plus) o << "+";
firstterm = false;
if (i == 0 || f->arr.ints[i] != 1)
o << f->arr.ints[i];
if (i > 0)
o << this_varname;
if (i > 1)
o << i;
}
if (needs_parens) o << ")";
}
else
{
bool firstterm = true;
for (int i=f->deg; i>=0; i--)
if (f->arr.polys[i] != 0)
{
bool this_p_parens = p_parens || (i > 0);
if (i == 0 || !is_one(level-1,f->arr.polys[i]))
elem_text_out(o, level-1,f->arr.polys[i], p_one, p_plus || !firstterm, this_p_parens, names);
else if (p_plus || !firstterm)
o << "+";
if (i > 0)
o << this_varname;
if (i > 1)
o << i;
firstterm = false;
}
if (needs_parens) o << ")";
}
}
void ARingTower::elem_text_out(buffer &o,
int level,
const poly f,
bool p_one,
bool p_plus,
bool p_parens) const
{
// o << to_string(level, f);
if (f == 0)
{
o << "0";
return;
}
int nterms = n_nonzero_terms(level, f);
bool needs_parens = p_parens && (nterms >= 2);
if (needs_parens)
{
if (p_plus) o << '+';
o << '(';
p_plus = false;
}
bool one = is_one(level, f);
if (one)
{
if (p_plus) o << "+";
if (p_one) o << "1";
return;
}
const std::string &this_varname = varNames()[level];
if (level == 0)
{
bool firstterm = true;
for (int i = f->deg; i >= 0; i--)
if (f->coeffs[i] != 0)
{
if (!firstterm || p_plus) o << "+";
firstterm = false;
if (i == 0 || f->coeffs[i] != 1)
mBaseRing.elem_text_out(o, f->coeffs[i], p_one, p_plus, p_parens);
if (i > 0) o << this_varname;
if (i > 1) o << i;
}
if (needs_parens) o << ")";
}
else
{
bool firstterm = true;
for (int i = f->deg; i >= 0; i--)
if (f->polys[i] != 0)
{
bool this_p_parens = p_parens || (i > 0);
if (i == 0 || !is_one(level - 1, f->polys[i]))
elem_text_out(o,
level - 1,
f->polys[i],
p_one,
p_plus || !firstterm,
this_p_parens);
else if (p_plus || !firstterm)
o << "+";
if (i > 0) o << this_varname;
if (i > 1) o << i;
firstterm = false;
}
if (needs_parens) o << ")";
}
}
