static WS *get_workspace(WS *workspace_cache, const size_t n) {
if (!n) {
fprintf(stderr, "Zero size workspace requested\n");
abort();
}
/* if n already in cache, return it */
WS *ptr = workspace_cache;
while (ptr->n) {
if (ptr->n == n) return ptr;
if (++ptr - workspace_cache > MAX_NUM_WS) return NULL; /* out of space! */
}
/* if n not in cache, ptr now points at first blank entry */
ptr->zf = XLALCreateCOMPLEX8Vector(n);
CHECK_OOM(ptr->zf->data, "unable to allocate workspace array zf\n");
memset(ptr->zf->data, 0, n * sizeof(COMPLEX8));
ptr->zt = XLALCreateCOMPLEX8Vector(n);
CHECK_OOM(ptr->zf->data, "unable to allocate workspace array zt\n");
memset(ptr->zt->data, 0, n * sizeof(COMPLEX8));
ptr->n = n;
ptr->plan = XLALCreateReverseCOMPLEX8FFTPlan(n, 1);
CHECK_OOM(ptr->plan, "unable to allocate plan");
return ptr;
}
void bf_run(BF_Code code, BF_Options options)
{
int* data = calloc(options.data_length, sizeof(int));
CHECK_OOM(data);
int* skips = calloc(options.data_length, sizeof(int));
CHECK_OOM(skips);
BF_Code* code_copy = malloc(sizeof(BF_Code));
CHECK_OOM(code_copy);
BF_State* state = malloc(sizeof(BF_State));
CHECK_OOM(state);
memcpy(code_copy, &code, sizeof(BF_Code));
*state = (BF_State){0, options.data_length, data, skips};
strip_comments(code_copy);
bf_run_code(code_copy, state, options.debug);
free(state->data);
free(state->skips);
free(state);
free(code_copy->data);
free(code_copy);
}
static void track(const upb_refcounted *r, const void *owner, bool ref2) {
assert(owner);
if (owner == UPB_UNTRACKED_REF) return;
upb_lock();
upb_value v;
if (upb_inttable_lookupptr(r->refs, owner, &v)) {
trackedref *ref = upb_value_getptr(v);
// Since we allow multiple ref2's for the same to/from pair without
// allocating separate memory for each one, we lose the fine-grained
// tracking behavior we get with regular refs. Since ref2s only happen
// inside upb, we'll accept this limitation until/unless there is a really
// difficult upb-internal bug that can't be figured out without it.
assert(ref2);
assert(ref->is_ref2);
ref->count++;
} else {
trackedref *ref = trackedref_new(ref2);
bool ok = upb_inttable_insertptr(r->refs, owner, upb_value_ptr(ref));
CHECK_OOM(ok);
if (ref2) {
// We know this cast is safe when it is a ref2, because it's coming from
// another refcounted object.
const upb_refcounted *from = owner;
assert(!upb_inttable_lookupptr(from->ref2s, r, NULL));
ok = upb_inttable_insertptr(from->ref2s, r, upb_value_ptr(NULL));
CHECK_OOM(ok);
}
}
upb_unlock();
}
void strip_comments(BF_Code* code)
{
int i, j;
for (i = j = 0; i < code->length; i++)
{
switch(code->data[i])
{
case '>':
case '<':
case '+':
case '-':
case '.':
case ',':
case '[':
case ']':
case '#':
if (i != j)
{
code->data[j] = code->data[i];
}
j++;
break;
}
}
char* temp = realloc(code->data, j);
CHECK_OOM(temp);
code->data = temp;
code->length = j;
}
static trackedref *trackedref_new(bool is_ref2) {
trackedref *ret = malloc(sizeof(*ret));
CHECK_OOM(ret);
ret->count = 1;
ret->is_ref2 = is_ref2;
return ret;
}
static void visit(const upb_refcounted *r, upb_refcounted_visit *v,
void *closure) {
// In DEBUG_REFS mode we know what existing ref2 refs there are, so we know
// exactly the set of nodes that visit() should visit. So we verify visit()'s
// correctness here.
check_state state;
state.obj = r;
bool ok = upb_inttable_init(&state.ref2, UPB_CTYPE_INT32);
CHECK_OOM(ok);
getref2s(r, &state.ref2);
// This should visit any children in the ref2 table.
if (r->vtbl->visit) r->vtbl->visit(r, visit_check, &state);
// This assertion will fail if the visit() function missed any children.
assert(upb_inttable_count(&state.ref2) == 0);
upb_inttable_uninit(&state.ref2);
if (r->vtbl->visit) r->vtbl->visit(r, v, closure);
}
// Populates the given UPB_CTYPE_INT32 inttable with counts of ref2's that
// originate from the given owner.
static void getref2s(const upb_refcounted *owner, upb_inttable *tab) {
upb_lock();
upb_inttable_iter i;
upb_inttable_begin(&i, owner->ref2s);
for(; !upb_inttable_done(&i); upb_inttable_next(&i)) {
upb_refcounted *to = (upb_refcounted*)upb_inttable_iter_key(&i);
// To get the count we need to look in the target's table.
upb_value v;
bool found = upb_inttable_lookupptr(to->refs, owner, &v);
assert(found);
trackedref *ref = upb_value_getptr(v);
upb_value count = upb_value_int32(ref->count);
bool ok = upb_inttable_insertptr(tab, to, count);
CHECK_OOM(ok);
}
upb_unlock();
}
WS *XLALCreateSBankWorkspaceCache(void) {
WS *workspace_cache = calloc(MAX_NUM_WS, sizeof(WS));
CHECK_OOM(workspace_cache, "unable to allocate workspace\n");
return workspace_cache;
}
