/**
* Save a hashtable to disk
*
* @param table Hashtable to save
* @param filename Filename to write hashtable into
* @param keywrite Pointer to function that writes a single key
* @param valuewrite Pointer to function that writes a single value
* @return Number of entries written or -1 on error
*/
int
hashtable_save(HASHTABLE *table, char *filename,
int (*keywrite)(int, void*),
int (*valuewrite)(int, void*))
{
int fd, rval = 0;
HASHITERATOR *iter;
void *key, *value;
if ((fd = open(filename, O_WRONLY|O_CREAT|O_TRUNC, 0666)) == -1)
{
return -1;
}
if (write(fd, "HASHTABLE", 7) != 7) // Magic number
{
close(fd);
return -1;
}
write(fd, &rval, sizeof(rval)); // Write zero counter, will be overrwriten at end
if ((iter = hashtable_iterator(table)) != NULL)
{
while ((key = hashtable_next(iter)) != NULL)
{
if (!(*keywrite)(fd, key))
{
close(fd);
hashtable_iterator_free(iter);
return -1;
}
if ((value = hashtable_fetch(table, key)) == NULL ||
(*valuewrite)(fd, value) == 0)
{
close(fd);
hashtable_iterator_free(iter);
return -1;
}
rval++;
}
}
/* Now go back and write the count of entries */
if (lseek(fd, 7L, SEEK_SET) != -1)
{
write(fd, &rval, sizeof(rval));
}
close(fd);
hashtable_iterator_free(iter);
return rval;
}
void
amibis_iterator_free(amibis_iterator_t itr)
{
switch (itr->type) {
case HASHTABLE_ITERATOR:
hashtable_iterator_free(itr->ptr);
break;
}
free(itr);
}
/**
* test1 spinlock_acquire_nowait tests
*
* Test that spinlock_acquire_nowait returns false if the spinlock
* is already taken.
*
* Test that spinlock_acquire_nowait returns true if the spinlock
* is not taken.
*
* Test that spinlock_acquire_nowait does hold the spinlock.
*/
static bool do_hashtest(
int argelems,
int argsize)
{
bool succp = true;
HASHTABLE* h;
int nelems;
int i;
int* val_arr;
int hsize;
int longest;
int* iter;
ss_dfprintf(stderr,
"testhash : creating hash table of size %d, including %d "
"elements in total, at time %g.",
argsize,
argelems,
(double)clock()-start);
val_arr = (int *)malloc(sizeof(void *)*argelems);
h = hashtable_alloc(argsize, hfun, cmpfun);
ss_dfprintf(stderr, "\t..done\nAdd %d elements to hash table.", argelems);
for (i=0; i<argelems; i++) {
val_arr[i] = i;
hashtable_add(h, (void *)&val_arr[i], (void *)&val_arr[i]);
}
if (argelems > 1000) ss_dfprintf(stderr, "\t..done\nOperation took %g", (double)clock()-start);
ss_dfprintf(stderr, "\t..done\nRead hash table statistics.");
hashtable_get_stats((void *)h, &hsize, &nelems, &longest);
ss_dfprintf(stderr, "\t..done\nValidate read values.");
ss_info_dassert(hsize == (argsize > 0 ? argsize: 1), "Invalid hash size");
ss_info_dassert((nelems == argelems) || (nelems == 0 && argsize == 0),
"Invalid element count");
ss_info_dassert(longest <= nelems, "Too large longest list value");
if (argelems > 1000) ss_dfprintf(stderr, "\t..done\nOperation took %g", (double)clock()-start);
ss_dfprintf(stderr, "\t..done\nValidate iterator.");
HASHITERATOR *iterator = hashtable_iterator(h);
read_lock(h);
for (i=0; i < (argelems+1); i++) {
iter = (int *)hashtable_next(iterator);
if (iter == NULL) break;
if (argelems < 100) ss_dfprintf(stderr, "\nNext item, iter = %d, i = %d", *iter, i);
}
read_unlock(h);
ss_info_dassert((i == argelems) || (i == 0 && argsize == 0), "\nIncorrect number of elements from iterator");
hashtable_iterator_free(iterator);
if (argelems > 1000) ss_dfprintf(stderr, "\t..done\nOperation took %g", (double)clock()-start);
ss_dfprintf(stderr, "\t\t..done\n\nTest completed successfully.\n\n");
CHK_HASHTABLE(h);
hashtable_free(h);
free(val_arr);
return succp;
}
