int main(int argc, char* argv[])
{
int i = 0;
int n = 10000;
int ret_data = 0;
HashTable* hash_table = hash_table_create(NULL, NULL, hash_int, 31);
for(i = 0; i < n; i++)
{
assert(hash_table_length(hash_table) == i);
assert(hash_table_insert(hash_table, (void*)i) == RET_OK);
assert(hash_table_length(hash_table) == (i + 1));
assert(hash_table_find(hash_table, cmp_int, (void*)i, (void**)&ret_data) == RET_OK);
assert(ret_data == i);
}
for(i = 0; i < n; i++)
{
assert(hash_table_delete(hash_table, cmp_int, (void*)i) == RET_OK);
assert(hash_table_length(hash_table) == (n - i -1));
assert(hash_table_find(hash_table, cmp_int, (void*)i, (void**)&ret_data) != RET_OK);
}
hash_table_destroy(hash_table);
return 0;
}
TEST_F(link_varyings, one_interface_and_one_simple_input)
{
ir_variable *const v =
new(mem_ctx) ir_variable(glsl_type::vec(4),
"a",
ir_var_shader_in);
ir.push_tail(v);
ir_variable *const iface =
new(mem_ctx) ir_variable(simple_interface->fields.structure[0].type,
simple_interface->fields.structure[0].name,
ir_var_shader_in);
iface->init_interface_type(simple_interface);
ir.push_tail(iface);
ASSERT_TRUE(linker::populate_consumer_input_sets(mem_ctx,
&ir,
consumer_inputs,
consumer_interface_inputs,
junk));
char *const iface_field_name = interface_field_name(simple_interface);
EXPECT_EQ((void *) iface, hash_table_find(consumer_interface_inputs,
iface_field_name));
EXPECT_EQ(1u, num_elements(consumer_interface_inputs));
EXPECT_EQ((void *) v, hash_table_find(consumer_inputs, "a"));
EXPECT_EQ(1u, num_elements(consumer_inputs));
}
void
ir_coalesce_floats_replacing_visitor::handle_rvalue(ir_rvalue **rvalue)
{
ir_rvalue *ir = *rvalue;
if(!ir) return;
ir_dereference *dv;
ir_swizzle *swiz;
ir_swizzle *outerswiz = ir->as_swizzle();
if( outerswiz ) {
dv = outerswiz->val->as_dereference();
if(dv) {
//fprintf(stderr, "var1: %s\n", dv->variable_referenced()->name);
swiz = (ir_swizzle*)hash_table_find(promotions, dv->variable_referenced());
if(swiz) {
//fprintf(stderr, "// replacing[1] %p %p\n", ir, swiz);
*rvalue = swiz->clone(ralloc_parent(swiz), NULL);
return;
}
}
}
dv = ir->as_dereference();
if(!dv) return;
swiz = (ir_swizzle*)hash_table_find(promotions, dv->variable_referenced());
//fprintf(stderr, "var2: %s %p\n", dv->variable_referenced()->name, dv->variable_referenced());
if (!swiz) return;
//fprintf(stderr, "// replacing[2] %p %p\n", ir, swiz);
*rvalue = swiz->clone(ralloc_parent(swiz), NULL);
}
void ir_remap_agalvars_visitor::handleDeref(ir_variable **varloc)
{
ir_variable *glvar = *varloc;
ir_variable *agalvar = (ir_variable*)hash_table_find(varhash, glvar->name);
if(agalvar) {
*varloc = agalvar;
//fprintf(stderr, "remapping deref -- %s\n", glvar->name);
} else if(glvar->name[0] == 'g' && glvar->name[1] == 'l' && glvar->name[2] == '_') {
computeAgalName(glvar);
agalvar = new (glvar) ir_variable(glvar->type, ralloc_strdup(glvar, &agalName[0]), (ir_variable_mode)glvar->mode, (glsl_precision)glvar->precision);
hash_table_insert(varhash, agalvar, ralloc_strdup(agalvar, glvar->name));
hash_table_insert(varhash, agalvar, ralloc_strdup(agalvar, &agalName[0]));
hash_table_insert(renamedvars, glvar, glvar);
varbase->insert_before(agalvar);
*varloc = agalvar;
//fprintf(stderr, "renaming: %s -> %s\n", glvar->name, &agalName[0]);
} else if (hash_table_find(renamedvars, glvar)) {
// already renamed
} else {
computeAgalName(glvar);
glvar->name = ralloc_strdup(glvar, agalName);
hash_table_insert(renamedvars, glvar, glvar);
}
}
ir_visitor_status
ir_shorten_liveranges_visitor::visit(ir_dereference_variable *ir)
{
ir_variable *v = ir->variable_referenced();
//printf("ir_shorten_liveranges_visitor: ir_dereference_variable %s\n", v ? v->name : "NULL");
if(hash_table_find(varhash, v) == (void*)VAR_UNHANDLED) {
hash_table_insert(varhash, (void*)VAR_HANDLED, v); // used before assigned?!
} else if(hash_table_find(varhash, v) > (void*)VAR_PTR) {
referencedVars.push_back(ir->variable_referenced());
}
return visit_continue;
}
foreach_list_safe(node, instructions)
{
ir_instruction *ir = (ir_instruction *)node;
if (ir->ir_type == ir_type_assignment)
{
ir_assignment *assign = (ir_assignment *)ir;
if (hash_table_find(ht, assign) == NULL)
{
hash_table_insert(ht, assign, assign);
/* If the LHS of the assignment is a condition variable that was
* previously added, insert an additional assignment of false to
* the variable.
*/
const bool assign_to_cv =
hash_table_find(ht, assign->lhs->variable_referenced()) != NULL;
if (!assign->condition)
{
if (assign_to_cv)
{
assign->rhs =
new(mem_ctx)ir_expression(ir_binop_logic_and,
glsl_type::bool_type,
cond_expr->clone(mem_ctx, NULL),
assign->rhs);
}
else
{
assign->condition = cond_expr->clone(mem_ctx, NULL);
}
}
else
{
assign->condition =
new(mem_ctx)ir_expression(ir_binop_logic_and,
glsl_type::bool_type,
cond_expr->clone(mem_ctx, NULL),
assign->condition);
}
}
}
/* Now, move from the if block to the block surrounding it. */
ir->remove();
if_ir->insert_before(ir);
}
void handle_user_login(Bank* bank, char* args) {
char send_msg[MAX_LINE_SIZE + 1];
memset(send_msg, 0, MAX_LINE_SIZE);
if ((char*)hash_table_find(bank->user_balance_ht, args) == NULL ||
(char*)hash_table_find(bank->logged_user_ht, args) != NULL) {
strcat(send_msg, "NA");
} else {
strcat(send_msg, "OK");
hash_table_add(bank->logged_user_ht, args, "1");
}
bank_encrypt(bank, send_msg, strlen(send_msg));
bank_send(bank, send_msg, strlen(send_msg));
}
/** Process pending wait requests */
void process_pending_wait(void)
{
task_exit_t texit;
loop:
list_foreach(pending_wait, cur) {
pending_wait_t *pr = list_get_instance(cur, pending_wait_t, link);
unsigned long keys[2] = {
LOWER32(pr->id),
UPPER32(pr->id)
};
link_t *link = hash_table_find(&task_hash_table, keys);
if (!link)
continue;
hashed_task_t *ht = hash_table_get_instance(link, hashed_task_t, link);
if (!ht->finished)
continue;
if (!(pr->callid & IPC_CALLID_NOTIFICATION)) {
texit = ht->have_rval ? TASK_EXIT_NORMAL :
TASK_EXIT_UNEXPECTED;
ipc_answer_2(pr->callid, EOK, texit,
ht->retval);
}
hash_table_remove(&task_hash_table, keys, 2);
list_remove(cur);
free(pr);
goto loop;
}
void slang_sym_type_add(const char* in_sym) {
if (!hash_table_find(symTable, &in_sym)) {
char* str = malloc(strlen(in_sym)+1);
strcpy(str, in_sym);
hash_table_insert(symTable, &str, str);
}
}
unsigned num_space_collapser_get (num_space_collapser_t *nsc, unsigned key)
{
unsigned *val;
char key_str[1024];
pthread_mutex_lock(&nsc->mutex);
sprintf(key_str, "%u", key);
if ((val = (unsigned *)hash_table_find(nsc->hash_table, key_str)))
{
printf("returning mapping %s -> %u\n", key_str, *val);
}
else
{
val = (unsigned *)malloc(sizeof(unsigned));
*val = next_value++;
printf("adding mapping %s -> %u\n", key_str, *val);
hash_table_add(nsc->hash_table, strdup(key_str), (void *)val);
}
pthread_mutex_unlock(&nsc->mutex);
return *val;
}
int slang_sym_table_check(const char* in_sym) {
const char* sym = hash_table_find(symTable, &in_sym);
if (!sym)
return IDENTIFIER;
else
return TYPE_NAME;
}
/* void close_database(id) */
static int cc_close_database(lua_State* L)
{
int id;
database_handler_t* database_handler;
worker_handler_t* handler = find_handler_by_stack(L);
int args = lua_gettop(L);
if (args < 1)
{
error_log("`%s` parameter lack:%d\n", __FUNCTION__, args);
return 0;
}
if (!lua_isnumber(L, -args))
{
error_log("`%s` parameter error:%s\n", __FUNCTION__, lua_typename(L, lua_type(L, -args)));
return 0;
}
id = lua_tointeger(L, -args);
database_handler = hash_table_find(handler->database_table, id);
if (!database_handler)
{
error_log("`%s` not found database:%d\n", __FUNCTION__, id);
return 0;
}
hash_table_remove(handler->database_table, id);
database_handler_delete(database_handler);
return 0;
}
/** Process pending wait requests */
void process_pending_wait(void)
{
task_exit_t texit;
loop:
list_foreach(pending_wait, link, pending_wait_t, pr) {
ht_link_t *link = hash_table_find(&task_hash_table, &pr->id);
if (!link)
continue;
hashed_task_t *ht = hash_table_get_inst(link, hashed_task_t, link);
if (!ht->finished)
continue;
if (!(pr->callid & IPC_CALLID_NOTIFICATION)) {
texit = ht->have_rval ? TASK_EXIT_NORMAL :
TASK_EXIT_UNEXPECTED;
ipc_answer_2(pr->callid, EOK, texit,
ht->retval);
}
list_remove(&pr->link);
free(pr);
goto loop;
}
const glsl_type *
glsl_type::get_array_instance(const glsl_type *base, unsigned array_size)
{
if (array_types == NULL) {
array_types = hash_table_ctor(64, hash_table_string_hash,
hash_table_string_compare);
}
/* Generate a name using the base type pointer in the key. This is
* done because the name of the base type may not be unique across
* shaders. For example, two shaders may have different record types
* named 'foo'.
*/
char key[128];
snprintf(key, sizeof(key), "%p[%u]", (void *) base, array_size);
const glsl_type *t = (glsl_type *) hash_table_find(array_types, key);
if (t == NULL) {
t = new glsl_type(base, array_size);
hash_table_insert(array_types, (void *) t, ralloc_strdup(mem_ctx, key));
}
assert(t->base_type == GLSL_TYPE_ARRAY);
assert(t->length == array_size);
assert(t->fields.array == base);
return t;
}
const glsl_type *
glsl_type::get_interface_instance(const glsl_struct_field *fields,
unsigned num_fields,
enum glsl_interface_packing packing,
const char *name)
{
const glsl_type key(fields, num_fields, packing, name);
if (interface_types == NULL) {
interface_types = hash_table_ctor(64, record_key_hash, record_key_compare);
}
const glsl_type *t = (glsl_type *) hash_table_find(interface_types, & key);
if (t == NULL) {
t = new glsl_type(fields, num_fields, packing, name);
hash_table_insert(interface_types, (void *) t, t);
}
assert(t->base_type == GLSL_TYPE_INTERFACE);
assert(t->length == num_fields);
assert(strcmp(t->name, name) == 0);
return t;
}
int hash_table_insert(struct hash_table_t *table, char *key, void *data)
{
struct hash_table_elem_t *elem;
int index;
/* No find operation */
table->find_op = 0;
/* Data cannot be null */
if (!data)
return 0;
/* Rehashing */
if (table->count >= table->size / 2)
hash_table_grow(table);
/* Element must not exists */
elem = hash_table_find(table, key, &index);
if (elem)
return 0;
/* Create element and insert at the head of collision list */
elem = hash_table_elem_create(key, data);
elem->next = table->elem_vector[index];
table->elem_vector[index] = elem;
/* One more element */
table->count++;
assert(table->count < table->size);
/* Success */
return 1;
}
ir_visitor_status
ir_set_program_inouts_visitor::visit_enter(ir_dereference_array *ir)
{
ir_dereference_variable *deref_var;
ir_constant *index = ir->array_index->as_constant();
deref_var = ir->array->as_dereference_variable();
ir_variable *var = NULL;
/* Check that we're dereferencing a shader in or out */
if (deref_var)
var = (ir_variable *)hash_table_find(this->ht, deref_var->var);
if (index && var) {
int width = 1;
if (deref_var->type->is_array() &&
deref_var->type->fields.array->is_matrix()) {
width = deref_var->type->fields.array->matrix_columns;
}
mark(this->prog, var, index->value.i[0] * width, width,
this->is_fragment_shader);
return visit_continue_with_parent;
}
return visit_continue;
}
partychan_t *partychan_lookup_cid(int cid)
{
partychan_t *chan = NULL;
hash_table_find(cid_ht, (void *)cid, &chan);
if (chan && chan->flags & PARTY_DELETED) chan = NULL;
return(chan);
}
/* bool update_record(id, table_name, sid, o) */
static int cc_update_record(lua_State* L)
{
int id;
int64_t sid;
size_t len;
const char* data;
const char* table_name;
bool retcode;
database_handler_t* database_handler;
worker_handler_t* handler = find_handler_by_stack(L);
int args = lua_gettop(L);
if (args < 4)
{
error_log("`%s` parameter lack:%d\n", __FUNCTION__, args);
return 0;
}
if (!lua_isnumber(L, -args))
{
error_log("`%s` parameter error:%s\n", __FUNCTION__, lua_typename(L, lua_type(L, -args)));
return 0;
}
if (!lua_isstring(L, -(args-1)))
{
error_log("`%s` parameter error:%s\n", __FUNCTION__, lua_typename(L, lua_type(L, -(args-1))));
return 0;
}
if (!lua_isnumber(L, -(args-2)))
{
error_log("`%s` parameter error:%s\n", __FUNCTION__, lua_typename(L, lua_type(L, -(args-2))));
return 0;
}
if (!lua_isstring(L, -(args-3)))
{
error_log("`%s` parameter error:%s\n", __FUNCTION__, lua_typename(L, lua_type(L, -(args-3))));
return 0;
}
id = lua_tointeger(L, -args);
table_name = lua_tostring(L, -(args-1));
sid = lua_tonumber(L, -(args-2));
len = 0;
data = lua_tolstring(L, -(args-3), &len);
database_handler = hash_table_find(handler->database_table, id);
if (!database_handler)
{
error_log("`%s` not found database:%d\n", __FUNCTION__, id);
return 0;
}
retcode = record_update(database_handler, table_name, sid, data, len);
lua_pushboolean(L, retcode ? 1 : 0);
return 1;
}
ir_visitor_status
ir_remap_agalvars_visitor::visit(ir_dereference_variable *ir)
{
ir_variable *glvar = ir->variable_referenced();
ir_variable *agalvar = (ir_variable*)hash_table_find(varhash, glvar->name);
handleDeref(&ir->var);
return visit_continue;
}
void delete_process_ht(hash_table_t * fd_mappings, int32_t pid) {
item_t * process_ht_item;
if ( (process_ht_item = hash_table_find(fd_mappings, &pid)) != NULL ) {
hash_table_remove(fd_mappings, &pid);
} else {
ERRORPRINTF("Can not find pid %"PRIi32" when removing delete_process_ht\n", pid);
}
}
ir_visitor_status ir_float_liverange_visitor::handleDereference(ir_dereference *d)
{
ir_variable *var = d->variable_referenced();
if(!var)
abort();
if(!hash_table_find(firstUse, var)) {
hash_table_insert(firstUse, d, var);
//fprintf(stderr, "=== ir_dereference_variable firstUse %p %p : %s ===\n", var, d, var->name);
}
if(hash_table_find(lastUse, var))
hash_table_remove(lastUse, var);
hash_table_insert(lastUse, d, var);
//fprintf(stderr, "=== ir_dereference_variable lastUse %p %p : %s ===\n", var, d, var->name);
return visit_continue;
}
function *get_function(ir_function_signature *sig)
{
function *f = (function *) hash_table_find(this->function_hash, sig);
if (f == NULL) {
f = new(mem_ctx) function(sig);
hash_table_insert(this->function_hash, f, sig);
}
return f;
}
static uhost_cache_entry_t *cache_lookup(const char *nick)
{
char buf[64], *lnick;
uhost_cache_entry_t *cache = NULL;
lnick = egg_msprintf(buf, sizeof(buf), NULL, "%s", nick);
str_tolower(lnick);
hash_table_find(uhost_cache_ht, lnick, &cache);
if (lnick != buf) free(lnick);
return(cache);
}
ir_visitor_status ir_lower_conditional_assigns_to_agal_visitor::visit(ir_variable *v)
{
if(!varbase)
varbase = base_ir;
bool previouslywritten = hash_table_find(assignedvars, v) != NULL;
if(!previouslywritten)
hash_table_insert(assignedvars, (void*)0x1, v);
return visit_continue;
}
void bank_deposit(Bank* bank, char* name, char* amt) {
if (!name || !amt) {
printf("Usage: deposit <user-name> <amt>\n");
return;
}
if (check_username(name) || check_amt(amt)) {
printf("Usage: deposit <user-name> <amt>\n");
return;
}
if (!hash_table_find(bank->user_balance_ht, name)) {
printf("No such user\n");
return;
}
// handle name
char card_name[MAX_CARD_NAME_SIZE + 1];
memset(card_name, 0, MAX_CARD_NAME_SIZE);
strcat(card_name, name);
strcat(card_name, ".card");
// handle balance
int amount = 0;
int balance = 0;
sscanf(amt, "%d", &amount);
sscanf((char*)hash_table_find(bank->user_balance_ht, name), "%d", &balance);
if (balance + amount < 0) {
printf("Too rich for this program\n");
return;
}
balance += amount;
char* tmp;
tmp = (char*)malloc(64);
sprintf(tmp, "%d", balance);
hash_table_del(bank->user_balance_ht, name);
hash_table_add(bank->user_balance_ht, name, tmp);
printf("$%d added to %s's account\n", amount, name);
}
// Return 1 if changed; 0 otherwise
bool infer_pop_edges(const BinaryKmer node_bkey, Edges *edges,
const Covg *covgs, const dBGraph *db_graph)
{
Edges uedges = 0, iedges = 0xf, add_edges, edge;
size_t orient, nuc, col, kmer_size = db_graph->kmer_size;
const size_t ncols = db_graph->num_of_cols;
BinaryKmer bkey, bkmer;
hkey_t next;
Edges newedges[ncols];
// char tmp[MAX_KMER_SIZE+1];
// binary_kmer_to_str(node_bkey, db_graph->kmer_size, tmp);
// status("Inferring %s", tmp);
for(col = 0; col < ncols; col++) {
uedges |= edges[col]; // union of edges
iedges &= edges[col]; // intersection of edges
newedges[col] = edges[col];
}
add_edges = uedges & ~iedges;
if(!add_edges) return 0;
for(orient = 0; orient < 2; orient++)
{
bkmer = (orient == FORWARD ? binary_kmer_left_shift_one_base(node_bkey, kmer_size)
: binary_kmer_right_shift_one_base(node_bkey));
for(nuc = 0; nuc < 4; nuc++)
{
edge = nuc_orient_to_edge(nuc, orient);
if(add_edges & edge)
{
// get next bkmer, look up in graph
if(orient == FORWARD) binary_kmer_set_last_nuc(&bkmer, nuc);
else binary_kmer_set_first_nuc(&bkmer, dna_nuc_complement(nuc), kmer_size);
bkey = bkmer_get_key(bkmer, kmer_size);
next = hash_table_find(&db_graph->ht, bkey);
ctx_assert(next != HASH_NOT_FOUND);
for(col = 0; col < ncols; col++)
if(covgs[col] > 0 && db_node_has_col(db_graph, next, col))
newedges[col] |= edge;
}
}
}
int cmp = memcmp(edges, newedges, sizeof(Edges)*ncols);
memcpy(edges, newedges, sizeof(Edges)*ncols);
return (cmp != 0);
}
void handle_balance_atm(Bank* bank, char* args) {
char* tmp;
char send_msg[MAX_LINE_SIZE + 1];
memset(send_msg, 0, MAX_LINE_SIZE);
tmp = (char*)hash_table_find(bank->user_balance_ht, args);
printf("balance:%s\n", tmp);
strcat(send_msg, tmp);
bank_encrypt(bank, send_msg, strlen(send_msg));
bank_send(bank, send_msg, strlen(send_msg));
}
void *hash_table_get(struct hash_table_t *table, char *key)
{
struct hash_table_elem_t *elem;
/* Find element */
elem = hash_table_find(table, key, NULL);
if (!elem)
return NULL;
/* Return data */
return elem->data;
}
hash_table_t * get_process_ht(hash_table_t * fd_mappings, int32_t pid) {
process_hash_item_t * p_item;
item_t * process_ht_item;
if ( (process_ht_item = hash_table_find(fd_mappings, &pid)) != NULL ) {
p_item = hash_table_entry(process_ht_item, process_hash_item_t, item);
if ( pid == p_item->pid) {
return (p_item->ht);
}
}
return NULL;
}
