END_TEST
START_TEST (test_config_lists_excl) {
char *list_ops[] = { "sources", NULL };
tn_hash *cnf, *s;
tn_array *lines, *list;
int i, maxno = 0;
lines = n_array_new(16, 0, 0);
i = 0;
while (list_ops[i]) {
maxno = 3;
while (maxno >= 0) {
n_array_push(lines, make_conf_line(list_ops[i], maxno, ' '));
maxno--;
}
i++;
}
cnf = poldek_conf_addlines(NULL, "source", lines);
fail_if(cnf == NULL, "load config failed");
s = poldek_conf_get_section(cnf, "source");
fail_if(s == NULL, "no source section?");
i = 0;
while (list_ops[i]) {
list = poldek_conf_get_multi(s, list_ops[i]);
fail_if(list == NULL, "no %s?", list_ops[i]);
verify_list(list, 1, list_ops[i]); /* maxno = 1 */
i++;
}
}
static void load_balance(int n, int non_zero, int *row_ind_tmp) {
int proc_id, i, local_nz, local_nz_acc, A, B;
local_nz = local_nz_acc = non_zero/nproc;
/* number of rows owned by each process is stored in proc_row_list. This
is supposed to be well load balanced, so that each process has almost
same number of non-zero elements */
proc_id = 0;
if(me==0) printf("local_nz = %d\n", local_nz);
for(i=0; i<n; i++) { /* as # of entries in row_ind_tmp = n+1 */
if(row_ind_tmp[i] < local_nz_acc && row_ind_tmp[i+1] >= local_nz_acc) {
proc_row_list[proc_id++] = i+1;
local_nz_acc = local_nz*(proc_id+1);
if(proc_id == nproc-1) local_nz_acc = non_zero;
if(me==0 && proc_id<nproc) printf("local_nz = %d\n", local_nz_acc);
}
}
proc_row_list[nproc-1] = n;
for(i=0; i<nproc; i++) {
A = (i==0) ? 0: proc_row_list[i-1];/* # of entries in row_ind_tmp is n+1*/
B = proc_row_list[i];
proc_nz_list[i] = row_ind_tmp[B]-row_ind_tmp[A];
}
if(proc_id != nproc)
ARMCI_Error("Error while preparing Process Row list", proc_id-1);
#if 1
if(me==0) verify_list(proc_row_list);
#endif
}
/**
* @ingroup DBusListInternals
* Unit test for DBusList
* @returns #TRUE on success.
*/
dbus_bool_t
_dbus_list_test (void)
{
DBusList *list1;
DBusList *list2;
DBusList *link1;
DBusList *link2;
DBusList *copy1;
DBusList *copy2;
int i;
list1 = NULL;
list2 = NULL;
/* Test append and prepend */
i = 0;
while (i < 10)
{
if (!_dbus_list_append (&list1, _DBUS_INT_TO_POINTER (i)))
_dbus_assert_not_reached ("could not allocate for append");
if (!_dbus_list_prepend (&list2, _DBUS_INT_TO_POINTER (i)))
_dbus_assert_not_reached ("count not allocate for prepend");
++i;
verify_list (&list1);
verify_list (&list2);
_dbus_assert (_dbus_list_get_length (&list1) == i);
_dbus_assert (_dbus_list_get_length (&list2) == i);
}
_dbus_assert (is_ascending_sequence (&list1));
_dbus_assert (is_descending_sequence (&list2));
/* Test list clear */
_dbus_list_clear (&list1);
_dbus_list_clear (&list2);
verify_list (&list1);
verify_list (&list2);
/* Test get_first, get_last, pop_first, pop_last */
i = 0;
while (i < 10)
{
_dbus_list_append (&list1, _DBUS_INT_TO_POINTER (i));
_dbus_list_prepend (&list2, _DBUS_INT_TO_POINTER (i));
++i;
}
--i;
while (i >= 0)
{
void *got_data1;
void *got_data2;
void *data1;
void *data2;
got_data1 = _dbus_list_get_last (&list1);
got_data2 = _dbus_list_get_first (&list2);
data1 = _dbus_list_pop_last (&list1);
data2 = _dbus_list_pop_first (&list2);
_dbus_assert (got_data1 == data1);
_dbus_assert (got_data2 == data2);
_dbus_assert (_DBUS_POINTER_TO_INT (data1) == i);
_dbus_assert (_DBUS_POINTER_TO_INT (data2) == i);
verify_list (&list1);
verify_list (&list2);
_dbus_assert (is_ascending_sequence (&list1));
_dbus_assert (is_descending_sequence (&list2));
--i;
}
_dbus_assert (list1 == NULL);
_dbus_assert (list2 == NULL);
/* Test get_first_link, get_last_link, pop_first_link, pop_last_link */
i = 0;
while (i < 10)
{
_dbus_list_append (&list1, _DBUS_INT_TO_POINTER (i));
_dbus_list_prepend (&list2, _DBUS_INT_TO_POINTER (i));
++i;
}
--i;
while (i >= 0)
{
DBusList *got_link1;
DBusList *got_link2;
DBusList *link1;
DBusList *link2;
void *data1;
void *data2;
got_link1 = _dbus_list_get_last_link (&list1);
got_link2 = _dbus_list_get_first_link (&list2);
link1 = _dbus_list_pop_last_link (&list1);
link2 = _dbus_list_pop_first_link (&list2);
_dbus_assert (got_link1 == link1);
_dbus_assert (got_link2 == link2);
data1 = link1->data;
data2 = link2->data;
_dbus_list_free_link (link1);
_dbus_list_free_link (link2);
_dbus_assert (_DBUS_POINTER_TO_INT (data1) == i);
_dbus_assert (_DBUS_POINTER_TO_INT (data2) == i);
verify_list (&list1);
verify_list (&list2);
_dbus_assert (is_ascending_sequence (&list1));
_dbus_assert (is_descending_sequence (&list2));
--i;
}
_dbus_assert (list1 == NULL);
_dbus_assert (list2 == NULL);
/* Test iteration */
i = 0;
while (i < 10)
{
_dbus_list_append (&list1, _DBUS_INT_TO_POINTER (i));
_dbus_list_prepend (&list2, _DBUS_INT_TO_POINTER (i));
++i;
verify_list (&list1);
verify_list (&list2);
_dbus_assert (_dbus_list_get_length (&list1) == i);
_dbus_assert (_dbus_list_get_length (&list2) == i);
}
_dbus_assert (is_ascending_sequence (&list1));
_dbus_assert (is_descending_sequence (&list2));
--i;
link2 = _dbus_list_get_first_link (&list2);
while (link2 != NULL)
{
verify_list (&link2); /* pretend this link is the head */
_dbus_assert (_DBUS_POINTER_TO_INT (link2->data) == i);
link2 = _dbus_list_get_next_link (&list2, link2);
--i;
}
i = 0;
link1 = _dbus_list_get_first_link (&list1);
while (link1 != NULL)
{
verify_list (&link1); /* pretend this link is the head */
_dbus_assert (_DBUS_POINTER_TO_INT (link1->data) == i);
link1 = _dbus_list_get_next_link (&list1, link1);
++i;
}
--i;
link1 = _dbus_list_get_last_link (&list1);
while (link1 != NULL)
{
verify_list (&link1); /* pretend this link is the head */
_dbus_assert (_DBUS_POINTER_TO_INT (link1->data) == i);
link1 = _dbus_list_get_prev_link (&list1, link1);
--i;
}
_dbus_list_clear (&list1);
_dbus_list_clear (&list2);
/* Test remove */
i = 0;
while (i < 10)
{
_dbus_list_append (&list1, _DBUS_INT_TO_POINTER (i));
_dbus_list_prepend (&list2, _DBUS_INT_TO_POINTER (i));
++i;
}
--i;
while (i >= 0)
{
if ((i % 2) == 0)
{
if (!_dbus_list_remove (&list1, _DBUS_INT_TO_POINTER (i)))
_dbus_assert_not_reached ("element should have been in list");
if (!_dbus_list_remove (&list2, _DBUS_INT_TO_POINTER (i)))
_dbus_assert_not_reached ("element should have been in list");
verify_list (&list1);
verify_list (&list2);
}
--i;
}
_dbus_assert (all_odd_values (&list1));
_dbus_assert (all_odd_values (&list2));
_dbus_list_clear (&list1);
_dbus_list_clear (&list2);
/* test removing the other half of the elements */
i = 0;
while (i < 10)
{
_dbus_list_append (&list1, _DBUS_INT_TO_POINTER (i));
_dbus_list_prepend (&list2, _DBUS_INT_TO_POINTER (i));
++i;
}
--i;
while (i >= 0)
{
if ((i % 2) != 0)
{
if (!_dbus_list_remove (&list1, _DBUS_INT_TO_POINTER (i)))
_dbus_assert_not_reached ("element should have been in list");
if (!_dbus_list_remove (&list2, _DBUS_INT_TO_POINTER (i)))
_dbus_assert_not_reached ("element should have been in list");
verify_list (&list1);
verify_list (&list2);
}
--i;
}
_dbus_assert (all_even_values (&list1));
_dbus_assert (all_even_values (&list2));
/* clear list using remove_link */
while (list1 != NULL)
{
_dbus_list_remove_link (&list1, list1);
verify_list (&list1);
}
while (list2 != NULL)
{
_dbus_list_remove_link (&list2, list2);
verify_list (&list2);
}
/* Test remove link more generally */
i = 0;
while (i < 10)
{
_dbus_list_append (&list1, _DBUS_INT_TO_POINTER (i));
_dbus_list_prepend (&list2, _DBUS_INT_TO_POINTER (i));
++i;
}
--i;
link2 = _dbus_list_get_first_link (&list2);
while (link2 != NULL)
{
DBusList *next = _dbus_list_get_next_link (&list2, link2);
_dbus_assert (_DBUS_POINTER_TO_INT (link2->data) == i);
if ((i % 2) == 0)
_dbus_list_remove_link (&list2, link2);
verify_list (&list2);
link2 = next;
--i;
}
_dbus_assert (all_odd_values (&list2));
_dbus_list_clear (&list2);
i = 0;
link1 = _dbus_list_get_first_link (&list1);
while (link1 != NULL)
{
DBusList *next = _dbus_list_get_next_link (&list1, link1);
_dbus_assert (_DBUS_POINTER_TO_INT (link1->data) == i);
if ((i % 2) != 0)
_dbus_list_remove_link (&list1, link1);
verify_list (&list1);
link1 = next;
++i;
}
_dbus_assert (all_even_values (&list1));
_dbus_list_clear (&list1);
/* Test copying a list */
i = 0;
while (i < 10)
{
_dbus_list_append (&list1, _DBUS_INT_TO_POINTER (i));
_dbus_list_prepend (&list2, _DBUS_INT_TO_POINTER (i));
++i;
}
/* bad pointers, because they are allowed in the copy dest */
copy1 = _DBUS_INT_TO_POINTER (0x342234);
copy2 = _DBUS_INT_TO_POINTER (23);
_dbus_list_copy (&list1, ©1);
verify_list (&list1);
verify_list (©1);
_dbus_assert (lists_equal (&list1, ©1));
_dbus_list_copy (&list2, ©2);
verify_list (&list2);
verify_list (©2);
_dbus_assert (lists_equal (&list2, ©2));
/* Now test copying empty lists */
_dbus_list_clear (&list1);
_dbus_list_clear (&list2);
_dbus_list_clear (©1);
_dbus_list_clear (©2);
/* bad pointers, because they are allowed in the copy dest */
copy1 = _DBUS_INT_TO_POINTER (0x342234);
copy2 = _DBUS_INT_TO_POINTER (23);
_dbus_list_copy (&list1, ©1);
verify_list (&list1);
verify_list (©1);
_dbus_assert (lists_equal (&list1, ©1));
_dbus_list_copy (&list2, ©2);
verify_list (&list2);
verify_list (©2);
_dbus_assert (lists_equal (&list2, ©2));
_dbus_list_clear (&list1);
_dbus_list_clear (&list2);
/* insert_before on empty list */
_dbus_list_insert_before (&list1, NULL,
_DBUS_INT_TO_POINTER (0));
verify_list (&list1);
/* inserting before first element */
_dbus_list_insert_before (&list1, list1,
_DBUS_INT_TO_POINTER (2));
verify_list (&list1);
_dbus_assert (is_descending_sequence (&list1));
/* inserting in the middle */
_dbus_list_insert_before (&list1, list1->next,
_DBUS_INT_TO_POINTER (1));
verify_list (&list1);
_dbus_assert (is_descending_sequence (&list1));
/* using insert_before to append */
_dbus_list_insert_before (&list1, NULL,
_DBUS_INT_TO_POINTER (-1));
verify_list (&list1);
_dbus_assert (is_descending_sequence (&list1));
_dbus_list_clear (&list1);
/* insert_after on empty list */
_dbus_list_insert_after (&list1, NULL,
_DBUS_INT_TO_POINTER (0));
verify_list (&list1);
/* inserting after first element */
_dbus_list_insert_after (&list1, list1,
_DBUS_INT_TO_POINTER (1));
verify_list (&list1);
_dbus_assert (is_ascending_sequence (&list1));
/* inserting at the end */
_dbus_list_insert_after (&list1, list1->next,
_DBUS_INT_TO_POINTER (2));
verify_list (&list1);
_dbus_assert (is_ascending_sequence (&list1));
/* using insert_after to prepend */
_dbus_list_insert_after (&list1, NULL,
_DBUS_INT_TO_POINTER (-1));
verify_list (&list1);
_dbus_assert (is_ascending_sequence (&list1));
_dbus_list_clear (&list1);
/* using remove_last */
_dbus_list_append (&list1, _DBUS_INT_TO_POINTER (2));
_dbus_list_append (&list1, _DBUS_INT_TO_POINTER (1));
_dbus_list_append (&list1, _DBUS_INT_TO_POINTER (3));
_dbus_list_remove_last (&list1, _DBUS_INT_TO_POINTER (2));
verify_list (&list1);
_dbus_assert (is_ascending_sequence (&list1));
_dbus_list_clear (&list1);
return TRUE;
}
/*
* Walk aggregate inode table marking blocks:
* - For inode map structures
* - For inode extents belonging to this table
* - For blocks belonging to inode's belonging to this table
*/
int32 walk_ait( int device,
struct dinode *inode_buffer,
boolean_t is_primary )
{
int32 rc = 0;
xtpage_t *btree_page;
int32 index, lastindex;
uint64 cur_block, last_block;
dinomap_t control_page, disk_cp;
struct list_item *top_freeiag = NULL;
struct list_item *top_inofree[MAXAG];
struct list_item *top_extfree[MAXAG];
/*
* Initialize control page and lists
*/
memset( &control_page, 0, sizeof(dinomap_t) );
memset( &top_inofree, 0, MAXAG * sizeof(struct list_item*) );
memset( &top_extfree, 0, MAXAG * sizeof(struct list_item*) );
btree_page = (xtpage_t *)&inode_buffer->di_btroot;
/*
* Mark blocks for the inode map structures (i.e. IAG's)
*/
lastindex = btree_page->header.nextindex;
for( index = XTENTRYSTART; index < lastindex; index++ ) {
if( btree_page->header.flag & BT_LEAF ) {
/*
* Read the extent as IAG's and mark its blocks
*/
walk_iag_extent( device, &(btree_page->xad[index]), is_primary,
&control_page, &disk_cp, &top_freeiag,
top_inofree, top_extfree,
inode_buffer->di_inostamp );
} else {
/*
* This is an internal page of the b-tree. Mark these blocks and
* then walk that page
*/
walk_internal_iag( device, &(btree_page->xad[index]), is_primary,
&control_page, &disk_cp, &top_freeiag,
top_inofree, top_extfree,
inode_buffer->di_inostamp );
}
}
/*
* Now compare the computed control page to the on-disk one.
* Right now we are only checking inode number counts, so we can't do a
* straight memory comparison
*/
if( is_primary ) {
#if 0
rc = memcmp( &control_page, &disk_cp, sizeof(dinomap_t));
if( rc != 0 ) {
error++;
printf("Miscompare of control page.\n");
}
#else
if( control_page.in_numinos != disk_cp.in_numinos) {
error++;
printf("Miscompare on in_numinos; found: %d\tdisk: %d\n",
control_page.in_numinos, disk_cp.in_numinos );
}
if( control_page.in_numfree != disk_cp.in_numfree) {
error++;
printf("Miscompare on in_numfree; found: %d\tdisk: %d\n",
control_page.in_numfree, disk_cp.in_numfree );
}
for( index = 0; index < MAXAG; index++ ) {
if( control_page.in_agctl[index].numinos !=
disk_cp.in_agctl[index].numinos) {
error++;
printf("Miscompare on AG (%d) numinos; found: %d\tdisk: %d\n",
index, control_page.in_agctl[index].numinos,
disk_cp.in_agctl[index].numinos );
}
if( control_page.in_agctl[index].numfree !=
disk_cp.in_agctl[index].numfree) {
error++;
printf("Miscompare on AG (%d) numfree; found: %d\tdisk: %d\n",
index, control_page.in_agctl[index].numfree,
disk_cp.in_agctl[index].numfree );
}
}
if( control_page.in_nextiag != disk_cp.in_nextiag) {
error++;
printf("Miscompare on in_nextiag; found: %d\tdisk: %d\n",
control_page.in_nextiag, disk_cp.in_nextiag );
}
#endif
/*
* Add the on-disk start of the lists from the control page
*/
rc = search_and_add(&top_freeiag, disk_cp.in_freeiag, DISK_LIST);
if( rc != 0 ) {
error++;
printf("Bad iagfree item on-disk: %d\n", disk_cp.in_freeiag);
}
for( index = 0; index < MAXAG; index++ ) {
rc = search_and_add(&(top_extfree[index]),
disk_cp.in_agctl[index].extfree, DISK_LIST);
if( rc != 0 ) {
error++;
printf("Bad extfree[%d] item on-disk: %d\n", index,
disk_cp.in_agctl[index].extfree);
}
rc = search_and_add(&(top_inofree[index]),
disk_cp.in_agctl[index].inofree, DISK_LIST);
if( rc != 0 ) {
error++;
printf("Bad inofree[%d] item on-disk: %d\n", index,
disk_cp.in_agctl[index].inofree);
}
}
/*
* Verify the lists
*/
verify_list(top_freeiag, "IAG free");
for( index = 0; index < MAXAG; index++ ) {
verify_list(top_extfree[index], "AG Extent free");
verify_list(top_inofree[index], "AG Inode free");
}
}
return 0;
}
