/* Inserts strings into a map in ascending order, then delete in ascending
order. */
static void
test_insert_ordered (void)
{
const int max_elems = 64;
int *values;
struct string_map map;
int i;
string_map_init (&map);
values = xnmalloc (max_elems, sizeof *values);
for (i = 0; i < max_elems; i++)
{
values[i] = i | random_value (i, 4);
string_map_insert_nocopy (&map, xstrdup (make_key (values[i])),
xstrdup (make_value (values[i])));
check_string_map (&map, values, i + 1);
}
for (i = 0; i < max_elems; i++)
{
string_map_delete (&map, make_key (i));
check_string_map (&map, values + i + 1, max_elems - i - 1);
}
string_map_destroy (&map);
free (values);
}
void output_global_data(PERF_DATA_BLOCK *data, RuntimeSettings rt, int tdb_flags)
{
int i;
char key[NAME_LEN];
char sdata[NAME_LEN];
/* Initialize BaseIndex */
make_key(key, NAME_LEN, 1, NULL);
memset(sdata, 0, NAME_LEN);
sprintf(sdata, "%d", data->num_counters);
add_key(rt.cnames, key, sdata, tdb_flags);
/* Initialize PerfTime, PerfFreq and PerfTime100nSec */
memset(sdata, 0, NAME_LEN);
make_key(key, NAME_LEN, 0, "PerfTime");
sprintf(sdata, "%Lu", data->PerfTime);
add_key(rt.cdata, key, sdata, tdb_flags);
make_key(key, NAME_LEN, 0, "PerfTime100nSec");
memset(sdata, 0, NAME_LEN);
sprintf(sdata, "%Lu", data->PerfTime100nSec);
add_key(rt.cdata, key, sdata, tdb_flags);
memset(sdata, 0, NAME_LEN);
make_key(key, NAME_LEN, 0, "PerfFreq");
sprintf(sdata, "%Lu", data->PerfFreq);
add_key(rt.cnames, key, sdata, tdb_flags);
return;
}
void output_perf_desc(PerfCounter counter, RuntimeSettings rt)
{
char key[NAME_LEN];
char sdata[NAME_LEN];
/* First insert the counter name */
make_key(key, NAME_LEN, counter.index, NULL);
add_key(rt.cnames, key, counter.name, TDB_INSERT);
/* Add the help string */
make_key(key, NAME_LEN, counter.index + 1, NULL);
add_key(rt.cnames, key, counter.help, TDB_INSERT);
/* Add the relationships */
make_key(key, NAME_LEN, counter.index, "rel");
add_key(rt.cnames, key, counter.relationships, TDB_INSERT);
/* Add type data if not PERF_OBJECT or PERF_INSTANCE */
if(counter.record_type == PERF_COUNTER)
{
make_key(key, NAME_LEN, counter.index, "type");
memset(sdata, 0, NAME_LEN);
sprintf(sdata, "%d", counter.counter_type);
add_key(rt.cnames, key, sdata, TDB_INSERT);
}
return;
}
IPv4Reassembler::packet_status IPv4Reassembler::process(PDU &pdu) {
IP *ip = pdu.find_pdu<IP>();
if(ip && ip->inner_pdu()) {
// There's fragmentation
if(ip->is_fragmented()) {
// Create it or look it up, it's the same
Internals::IPv4Stream &stream = streams[make_key(ip)];
stream.add_fragment(ip);
if(stream.is_complete()) {
PDU *pdu = stream.allocate_pdu();
// The packet is corrupt
if(!pdu) {
streams.erase(make_key(ip));
return FRAGMENTED;
}
ip->inner_pdu(pdu);
ip->frag_off(0);
return REASSEMBLED;
}
else
return FRAGMENTED;
}
}
return NOT_FRAGMENTED;
}
int main()
{
struct hash_table *ht;
struct hash_entry *entry;
const uint32_t size = 1000;
bool flags[size];
uint32_t i;
ht = _mesa_hash_table_create(NULL, key_hash, key_equal);
for (i = 0; i < size; ++i) {
flags[i] = false;
_mesa_hash_table_insert(ht, make_key(i), &flags[i]);
}
_mesa_hash_table_clear(ht, delete_function);
assert(_mesa_hash_table_next_entry(ht, NULL) == NULL);
/* Check that delete_function was called and that repopulating the table
* works. */
for (i = 0; i < size; ++i) {
assert(flags[i]);
flags[i] = false;
_mesa_hash_table_insert(ht, make_key(i), &flags[i]);
}
/* Check that exactly the right set of entries is in the table. */
for (i = 0; i < size; ++i) {
assert(_mesa_hash_table_search(ht, make_key(i)));
}
hash_table_foreach(ht, entry) {
assert(key_id(entry->key) < size);
}
/*
* Using random tcam entries and lookup keys (but unique priorities), compare
* the tcam to a reference implementation.
*/
static void
test_random(void)
{
const int num_entries = 10000;
const int num_lookups = 10000;
const int num_masks = 128;
struct tcam *tcam = tcam_create(sizeof(struct tcam_key), 42);
struct tcam_entry *es = calloc(num_entries, sizeof(*es));
assert(es);
int i;
struct tcam_key key, mask;
/* Add entries */
for (i = 0; i < num_entries; i++) {
uint64_t mask_pattern = rand() % num_masks;
key = make_key(rand() & mask_pattern);
mask = make_key(mask_pattern);
tcam_insert(tcam, &es[i], &key, &mask, i);
assert(tcam_match(tcam, &key) == &es[i]);
}
/* Random lookups */
for (i = 0; i < num_lookups; i++) {
key = make_key(rand());
struct tcam_entry *tcam_result = tcam_match(tcam, &key);
/* Linear search to find highest priority match */
int j;
struct tcam_entry *ref_result = NULL;
for (j = num_entries-1; j >= 0; j--) {
uint64_t key_pattern = ((struct tcam_key *)es[j].key)->data[0];
uint64_t mask_pattern = ((struct tcam_key *)es[j].mask)->data[0];
if ((key.data[0] & mask_pattern) == key_pattern) {
ref_result = &es[j];
break;
}
}
AIM_ASSERT(tcam_result == ref_result, "mismatch with reference");
}
/* Remove entries */
for (i = 0; i < num_entries; i++) {
tcam_remove(tcam, &es[i]);
}
tcam_destroy(tcam);
free(es);
}
int
db_put_script(int node_no, const char *app, const char *buffer, size_t size)
{
struct databases db;
char *key;
int e, ret = -1;
if (open_env(&db, APP_DB | MODEL_DB | CODE_DB)) goto out;
key = make_key(node_no, app);
if (!key) goto out;
e = append_item(db.app, app, model_get_path(node_no));
if (e) goto out;
e = put_data(db.code, key, buffer, size);
if (e) goto out;
e = append_item(db.model, model_get_path(node_no), app);
if (e) goto out;
ret = 0;
out:
close_env(&db);
return ret;
}
/**
* @brief Populates database given a .csv file.
*
* @return Returns 0 on success, -1 otherwise.
*/
int populate_database(char* table)
{
int error_occurred = 0;
char data_file[MAX_PATH_LEN] = {0};
sprintf(data_file, "%s%s.csv", UP_FOLDER, table);
// Open file for reading.
FILE *file = fopen(data_file, "r");
if (file == NULL)
error_occurred = 1;
// Process the config file.
while (!error_occurred && !feof(file))
{
// Read a line from the file.
char key[MAX_KEY_LEN] = {0}, value[MAX_VALUE_LEN] = {0};
fscanf(file, "%[^,],%s", key, value);
make_key(key);
make_value(value);
// Send some data.
char buf[MAX_CMD_LEN] = {0};
snprintf(buf, sizeof buf, "SET #%.19s #%.19s #%.799s\0", table, key, value);
error_occurred = server_set(buf);
}
return error_occurred ? -1 : 0;
}
bool FileRecord::Modify(const std::string& id, const std::string& owner, const std::list<std::string>& meta) {
if(!valid_) return false;
Glib::Mutex::Lock lock(lock_);
Dbt key;
Dbt data;
make_key(id,owner,key);
void* pkey = key.get_data();
if(!dberr("Failed to retrieve record from database",db_rec_->get(NULL,&key,&data,0))) {
::free(pkey);
return false;
};
std::string uid;
std::string id_tmp;
std::string owner_tmp;
std::list<std::string> meta_tmp;
parse_record(uid,id_tmp,owner_tmp,meta_tmp,key,data);
::free(pkey);
make_record(uid,id,owner,meta,key,data);
if(!dberr("Failed to store record to database",db_rec_->put(NULL,&key,&data,0))) {
::free(key.get_data());
::free(data.get_data());
return false;
};
db_rec_->sync(0);
::free(key.get_data());
::free(data.get_data());
return true;
}
static rc_t write_to_sorter( struct sorter * sorter, int64_t seq_spot_id, uint32_t seq_read_id,
const String * unpacked_bases )
{
/* we write it to the store...*/
rc_t rc;
const String * to_store;
pack_4na( unpacked_bases, &sorter->buf );
rc = StringCopy( &to_store, &sorter->buf.S );
if ( rc != 0 )
ErrMsg( "StringCopy() -> %R", rc );
else
{
uint64_t key = make_key( seq_spot_id, seq_read_id );
rc = KVectorSetPtr( sorter->store, key, (const void *)to_store );
if ( rc != 0 )
ErrMsg( "KVectorSetPtr() -> %R", rc );
else
{
size_t item_size = ( sizeof key ) + ( sizeof *to_store ) + to_store->size;
sorter->bytes_in_store += item_size;
}
}
if ( rc == 0 &&
sorter->params.mem_limit > 0 &&
sorter->bytes_in_store >= sorter->params.mem_limit )
rc = save_store( sorter );
return rc;
}
char *
confsection_t::get_string(const char *name, const char *deflt)
{
char *val;
string_var key = make_key(name);
#if HAVE_LIBGCONF
GError *e = 0;
GConfValue *gcv = gconf_client_get(gconf_client_get_default(), key, &e);
handle_error(secname_, e);
if (gcv == 0)
{
val = (deflt == 0 ? 0 : g_strdup(deflt));
}
else
{
val = g_strdup(gconf_value_get_string(gcv));
gconf_value_free(gcv);
}
#else
gboolean defaulted = FALSE;
val = gnome_config_get_string_with_default(key.data(), &defaulted);
if (defaulted)
val = (deflt == 0 ? 0 : g_strdup(deflt));
#endif
return val;
}
passwand_error_t hmac(const m_t *master, const data_t *data, const salt_t *salt, mac_t *mac,
int work_factor) {
assert(master != NULL);
assert(data != NULL);
assert(salt != NULL);
assert(mac != NULL);
AUTO_K_T(k);
if (k == NULL)
return PW_NO_MEM;
passwand_error_t err = make_key(master, salt, work_factor, *k);
if (err != PW_OK)
return err;
const EVP_MD *sha512 = EVP_sha512();
mac->data = malloc(EVP_MAX_MD_SIZE);
if (mac->data == NULL)
return PW_NO_MEM;
unsigned md_len;
unsigned char *r = HMAC(sha512, *k, AES_KEY_SIZE, data->data, data->length, mac->data, &md_len);
if (r == NULL) {
free(mac->data);
return PW_CRYPTO;
}
mac->length = md_len;
return PW_OK;
}
EXPORTED char *jmapauth_tokenid(const struct jmapauth_token *tok)
{
struct buf buf = BUF_INITIALIZER;
unsigned mdlen, hexlen;
char macbuf[EVP_MAX_MD_SIZE];
char hexbuf[(JMAPAUTH_KEY_LEN + EVP_MAX_MD_SIZE)*2];
int r;
/* Build the key */
r = make_key(&buf, tok);
if (r) return NULL;
/* Sign the extended key */
if (!(HMAC(EVP_sha1(), tok->secret, JMAPAUTH_SECRET_LEN,
(unsigned char*) buf.s, buf.len,
(unsigned char*) macbuf, &mdlen))) {
buf_free(&buf);
return NULL;
}
buf_appendmap(&buf, macbuf, mdlen);
/* And return it hex-encoded */
hexlen = bin_to_hex(buf.s, buf.len, hexbuf, 0);
if (hexlen != (mdlen + JMAPAUTH_KEY_LEN)*2) {
buf_free(&buf);
return NULL;
}
buf_free(&buf);
return xstrndup(hexbuf, hexlen);
}
void del_entry_to_dhcpr_table()
{
of_list_bsn_tlv_t *key;
dhc_relay_t *dhc_relay;
uint32_t vlan_id = 1;
uint32_t vlan_ret = 0;
printf("\nVlan %d Delete to dhcp table\n", vlan_id);
if (! (dhc_relay = dhcpr_get_dhcpr_entry_from_vlan_table(vlan_id))) {
printf("Error get_dhcp_conf Vlan %d\n", vlan_id);
}
key = make_key(vlan_id);
ops->del(table_priv, dhc_relay, key);
/* Test 3: routerip -> vlan
* invalid vlan, no need to check circuit
*/
dhcpr_virtual_router_key_to_vlan(&vlan_ret, dummy_dhcp_opt_info.vrouter_ip, dummy_dhcp_opt_info.vrouter_mac.addr);
printf("router_ip_to_vlan = %d\n", vlan_ret);
AIM_TRUE_OR_DIE(vlan_ret==INVALID_VLAN);
printf("\nVlan %d Delete entry\n", vlan_id);
}
bool FileRecord::Remove(const std::string& id, const std::string& owner) {
if(!valid_) return false;
Glib::Mutex::Lock lock(lock_);
Dbt key;
Dbt data;
make_key(id,owner,key);
void* pkey = key.get_data();
if(dberr("",db_locked_->get(NULL,&key,&data,0))) {
::free(pkey);
error_str_ = "Record has active locks";
return false; // have locks
};
if(!dberr("Failed to retrieve record from database",db_rec_->get(NULL,&key,&data,0))) {
::free(pkey);
return false; // No such record?
};
std::string uid;
std::string id_tmp;
std::string owner_tmp;
std::list<std::string> meta;
parse_record(uid,id_tmp,owner_tmp,meta,key,data);
if(!uid.empty()) {
::unlink(uid_to_path(uid).c_str()); // TODO: handle error
};
if(!dberr("Failed to delete record from database",db_rec_->del(NULL,&key,0))) {
// TODO: handle error
::free(pkey);
return false;
};
db_rec_->sync(0);
::free(pkey);
return true;
}
IPv4Reassembler::PacketStatus IPv4Reassembler::process(PDU& pdu) {
IP* ip = pdu.find_pdu<IP>();
if (ip && ip->inner_pdu()) {
// There's fragmentation
if (ip->is_fragmented()) {
key_type key = make_key(ip);
// Create it or look it up, it's the same
Internals::IPv4Stream& stream = streams_[key];
stream.add_fragment(ip);
if (stream.is_complete()) {
PDU* pdu = stream.allocate_pdu();
// Use all field values from the first fragment
*ip = stream.first_fragment();
// Erase this stream, since it's already assembled
streams_.erase(key);
// The packet is corrupt
if (!pdu) {
return FRAGMENTED;
}
ip->inner_pdu(pdu);
ip->fragment_offset(0);
ip->flags(static_cast<IP::Flags>(0));
return REASSEMBLED;
}
else {
return FRAGMENTED;
}
}
}
return NOT_FRAGMENTED;
}
static rinteger add_method(Env* env, rtable methods, Method* meth,
KeyMap& keys)
{
rinteger key = make_key(env, meth, keys);
// We already have the method, skip this.
bool fetched = false;
env->table_fetch(methods, key, &fetched);
if(fetched) return env->cast_to_rinteger(key);
rsymbol cumulative_sym = env->symbol("cumulative");
rsymbol total_sym = env->symbol("total");
rsymbol called_sym = env->symbol("called");
rtable method = env->table_new();
env->table_store(methods, key, method);
env->table_store(method, env->symbol("name"), meth->to_s(env));
env->table_store(method, cumulative_sym, env->integer_new(meth->timer.total()));
env->table_store(method, total_sym, env->integer_new(meth->total()));
env->table_store(method, called_sym, env->integer_new(meth->timer.count()));
if(meth->file()) {
if(env->is_nil(meth->file())) {
env->table_store(method, env->symbol("file"), env->string_new("unknown file"));
} else {
env->table_store(method, env->symbol("file"),
env->symbol_to_string(meth->file()));
}
env->table_store(method, env->symbol("line"), env->integer_new(meth->line()));
}
return key;
}
EXPORTED void duplicate_mark(const duplicate_key_t *dkey, time_t mark, unsigned long uid)
{
struct buf key = BUF_INITIALIZER;
char data[100];
int r;
if (!duplicate_dbopen) return;
r = make_key(&key, dkey);
if (r) return;
memcpy(data, &mark, sizeof(mark));
memcpy(data + sizeof(mark), &uid, sizeof(uid));
do {
r = cyrusdb_store(dupdb, key.s, key.len,
data, sizeof(mark)+sizeof(uid), NULL);
} while (r == CYRUSDB_AGAIN);
#if DEBUG
syslog(LOG_DEBUG, "duplicate_mark: %-40s %-20s %-40s %ld %lu",
dkey->id, dkey->to, dkey->date, mark, uid);
#endif
buf_free(&key);
}
Arr *build_stachan_list(Pf *pf, int *nchan,int verbose)
{
char sta[10], chan[10];
char *key;
Arr *a;
int i;
Tbl *t;
char *line;
int *channel_number; /* value stored in arr */
if(verbose)
elog_notify(0,"Station Channel_code Channel_number\n");
a = newarr(0);
t = pfget_tbl(pf,"channels");
if(t==NULL) elog_die(0,"Parameter file error: no channels table\n");
for(i=0;i<maxtbl(t);++i)
{
line = gettbl(t,i);
sscanf(line,"%s %s",sta,chan);
key = make_key(sta,chan);
channel_number = (int *) malloc(sizeof(int));
if(channel_number == NULL)
elog_die(0,"malloc error for channel_number\n");
*channel_number = i;
setarr(a,key,(void *)channel_number);
if(verbose)
elog_notify(0,"%s %s %d\n",sta,chan,(*channel_number)+1);
free(key);
}
*nchan = maxtbl(t);
freetbl(t,free);
return(a);
}
const char* BBP_read_string(struct plugin_info *PI, char *dest, const char *rcs, const char *def)
{
char buffer[256];
const char *p = ReadString(PI->rcpath, make_key(buffer, PI, rcs), def);
if (p && dest) return strcpy(dest, p);
return p;
}
static void write_default_font(void)
{
HKEY key = make_key(REGISTRY_PATH);
RegSetValueEx(key, "DefaultFont", 0,
REG_BINARY,
(LPBYTE) &fontlf, sizeof(fontlf));
RegCloseKey(key);
}
faction *gm_addfaction(const char *email, plane * p, region * r)
{
attrib *a;
unit *u;
faction *f = calloc(1, sizeof(faction));
assert(p != NULL);
/* GM faction */
a_add(&f->attribs, make_key(atoi36("quest")));
f->banner = _strdup("quest faction");
f->name = _strdup("quest faction");
f->passw = _strdup(itoa36(rng_int()));
if (set_email(&f->email, email) != 0) {
log_error("Invalid email address for faction %s: %s\n", itoa36(f->no), email);
}
f->race = new_race[RC_TEMPLATE];
f->age = 0;
f->lastorders = turn;
f->alive = true;
f->locale = default_locale;
f->options =
want(O_COMPRESS) | want(O_REPORT) | want(O_COMPUTER) | want(O_ADRESSEN);
{
faction *xist;
int id = atoi36("gm00") - 1;
do {
xist = findfaction(++id);
} while (xist);
f->no = id;
addlist(&factions, f);
fhash(f);
}
/* generic permissions */
a = a_add(&f->attribs, a_new(&at_permissions));
if (a) {
attrib *ap = (attrib *) a->data.v;
const char *keys[] =
{ "gmterf", "gmtele", "gmgive", "gmskil", "gmtake", "gmmsgr", "gmmsgu",
"gmgate", 0 };
const char **key_p = keys;
while (*key_p) {
add_key(&ap, atoi36(*key_p));
++key_p;
}
a_add(&ap, make_atgmcreate(resource2item(r_silver)));
a->data.v = ap;
}
/* one initial unit */
u = create_unit(r, f, 1, new_race[RC_TEMPLATE], 1, "quest master", NULL);
u->irace = new_race[RC_GNOME];
return f;
}
smthread_scanner_t(
const vid_t &v, int _id, int n, int sz) :
// not append-only unless persistent info says it should be
smthread_main_t(0,0, false, "smthread_scanner_t"),
num_rec(n),
rec_size(sz)
{ vid = v;
key = make_key(_id, n);
}
void VTermMM::invalidate(VTermPos p)
{
boost::mutex::scoped_lock lock(m_mutex);
VTCell *c = &cells[p.row][p.col];
std::string k = make_key(p.col, p.row);
InvalidRegionPair v = InvalidRegionPair(k, c);
if(invalid_region.find(k) == invalid_region.end())
invalid_region.insert(v);
}
SkPDFIndirectReference SkPDFGradientShader::Make(SkPDFDocument* doc,
SkShader* shader,
const SkMatrix& canvasTransform,
const SkIRect& bbox) {
SkASSERT(shader);
SkASSERT(SkShader::kNone_GradientType != shader->asAGradient(nullptr));
SkPDFGradientShader::Key key = make_key(shader, canvasTransform, bbox);
bool alpha = gradient_has_alpha(key);
return find_pdf_shader(doc, std::move(key), alpha);
}
/* This is the routine that uses the Arr produced by build_stachan_list.
It returns and integer index of the station/channel defined by sta,chan.
If that station and channel are not found in the Arr, it returns -1.
*/
int get_channel_index(Arr *a, char *sta, char *chan)
{
char *key;
int *ichan;
key = make_key(sta,chan);
ichan = (int *)getarr(a,key);
if(ichan == NULL)
return(-1);
else
return(*ichan);
}
int
db_del_app(const char *app)
{
struct databases db;
char *list, *list2, *t, *s;
int e, ret = -1;
if (open_env(&db, APP_DB | MODEL_DB | CODE_DB)) goto out;
list = get_data(db.app, app, NULL, &e);
if (!list) goto out;
for (t = list; t; t = s) {
s = strchr(t, '/');
if (s) {
*s = '\0';
++s;
}
list2 = get_data(db.model, t, NULL, &e);
if (list2) {
char *k;
int sa = strlen(app);
k = strstr(list2, app);
if (k) {
if (k[sa] == '/') ++sa;
memmove(k, k + sa, strlen(k) - sa + 1);
sa = strlen(list2);
if (sa > 0) {
if (list2[sa-1] == '/')
list2[sa-1] = '\0';
}
e = put_data(db.model, t, list2, strlen(list2) + 1);
if (e) goto out;
}
}
free(list2);
e = db_delete_code(model_lookup_class(t), app);
e = del_data(db.code, make_key(model_lookup_class(t), app));
//if (e) goto out;
}
free(list);
e = del_data(db.app, app);
if (e) goto out;
ret = 0;
out:
close_env(&db);
return ret;
}
void
db_put_dn(char *data_dn)
{
int ret;
DBT key = {0};
DBT data = {0};
if(db_lock == NULL){
db_lock = PR_NewLock();
}
PR_Lock(db_lock);
create_db();
if ((ret = DB_OPEN(dbp, NULL, DATABASE, NULL, DB_BTREE, DB_CREATE, 0664)) != 0) {
dbp->err(dbp, ret, "%s", DATABASE);
}
memset(&key, 0, sizeof(key));
memset(&data, 0, sizeof(data));
key.data = (char *)malloc(key_buffer_size);
/* make_key will set up the key and the data */
make_key(&key);
data.data = slapi_ch_strdup(data_dn);
data.size = strlen(data_dn);
switch (ret =
dbp->put(dbp, NULL, &key, &data, DB_NOOVERWRITE)) {
case 0:
slapi_log_error(SLAPI_LOG_PLUGIN, DB_PLUGIN_NAME, "db: %s: key stored.\n", (char *)key.data);
break;
case DB_KEYEXIST:
slapi_log_error(SLAPI_LOG_PLUGIN, DB_PLUGIN_NAME, "db: %s: key previously stored.\n",
(char *)key.data);
break;
default:
dbp->err(dbp, ret, "DB->put");
goto err;
}
err:
if(ret){
slapi_log_error(SLAPI_LOG_PLUGIN, DB_PLUGIN_NAME, "db: Error detected in db_put \n");
}
free(key.data);
if (dbp){
dbp->close(dbp,0);
dbp=NULL;
}
PR_Unlock(db_lock);
}
static struct ptr_descr *find_ptr(unsigned long long ptr)
{
struct ptr_descr *ptrd;
int key = make_key(&ptr, sizeof(ptr)) & HASH_MASK;
for (ptrd = ptr_hash[key]; ptrd; ptrd = ptrd->next) {
if (ptrd->ptr == ptr)
return ptrd;
}
return NULL;
}
void output_num_instances(PerfCounter obj, int numInst, RuntimeSettings rt)
{
char key[NAME_LEN];
char sdata[NAME_LEN];
make_key(key, NAME_LEN, obj.index, "inst");
memset(sdata, 0, NAME_LEN);
sprintf(sdata, "%d", numInst);
add_key(rt.cnames, key, sdata, TDB_INSERT);
return;
}
