int main(void) { int table_size; int first; int increment; /* loop until sentinel is reached */ table_size = get_table_size(); while (table_size != 0) { first = get_first(); increment = get_increment(); show_table(table_size, first, increment); table_size = get_table_size(); } return 0; }
FullZone::~FullZone() { if (routing_table_) { unsigned int table_size = get_table_size(); /* Delete routing table */ for (unsigned int i = 0; i < table_size; i++) for (unsigned int j = 0; j < table_size; j++) delete TO_ROUTE_FULL(i, j); delete[] routing_table_; } }
void FullZone::get_local_route(NetPoint* src, NetPoint* dst, RouteCreationArgs* res, double* lat) { XBT_DEBUG("full getLocalRoute from %s[%u] to %s[%u]", src->get_cname(), src->id(), dst->get_cname(), dst->id()); unsigned int table_size = get_table_size(); RouteCreationArgs* e_route = TO_ROUTE_FULL(src->id(), dst->id()); if (e_route != nullptr) { res->gw_src = e_route->gw_src; res->gw_dst = e_route->gw_dst; for (auto const& link : e_route->link_list) { res->link_list.push_back(link); if (lat) *lat += link->get_latency(); } } }
int main() { Table *table_ptr; int x, y, table_size = 5; void *value; /***** Starting memory checking *****/ start_memory_check(); /***** Starting memory checking *****/ create_table(&table_ptr, table_size, NULL); x = 2; put(table_ptr, "Peggy", &x); y = 1; put(table_ptr, "John", &y); printf("Table size: %d\n", get_table_size(table_ptr)); if (is_empty(table_ptr)) { printf("Empty table\n"); } else { printf("Not empty\n"); } get_value(table_ptr, "John", &value); printf("Value for John %d\n", *(int *) value); printf("Removing Peggy: %d\n", remove_entry(table_ptr, "Peggy")); printf("Displaying Table\n"); display_table(table_ptr); clear_table(table_ptr); printf("After clearing\n"); if (is_empty(table_ptr)) { printf("Empty table\n"); } else { printf("Not empty\n"); } printf("Displaying Table\n"); display_table(table_ptr); destroy_table(table_ptr); /****** Gathering memory checking info *****/ stop_memory_check(); /****** Gathering memory checking info *****/ return 0; }
static HRESULT parse_clr_tables(ASSEMBLY *assembly, ULONG offset) { DWORD i, count; ULONG currofs; ULONGLONG mask; currofs = offset; assembly->tableshdr = assembly_data_offset(assembly, currofs); if (!assembly->tableshdr) return E_FAIL; assembly->stringsz = (assembly->tableshdr->HeapOffsetSizes & MD_STRINGS_BIT) ? sizeof(DWORD) : sizeof(WORD); assembly->guidsz = (assembly->tableshdr->HeapOffsetSizes & MD_GUIDS_BIT) ? sizeof(DWORD) : sizeof(WORD); assembly->blobsz = (assembly->tableshdr->HeapOffsetSizes & MD_BLOBS_BIT) ? sizeof(DWORD) : sizeof(WORD); currofs += sizeof(METADATATABLESHDR); assembly->numrows = assembly_data_offset(assembly, currofs); if (!assembly->numrows) return E_FAIL; memset(assembly->tables, -1, MAX_CLR_TABLES * sizeof(CLRTABLE)); for (i = count = 0, mask = 1; i < MAX_CLR_TABLES; i++, mask <<= 1) { if (assembly->tableshdr->MaskValid.QuadPart & mask) assembly->tables[i].rows = assembly->numrows[count++]; } assembly->numtables = count; currofs += assembly->numtables * sizeof(DWORD); for (i = 0, mask = 1; i < MAX_CLR_TABLES; i++, mask <<= 1) { if (assembly->tableshdr->MaskValid.QuadPart & mask) { assembly->tables[i].offset = currofs; currofs += get_table_size(assembly, i) * assembly->tables[i].rows; } } return S_OK; }
void FullZone::add_route(NetPoint* src, NetPoint* dst, NetPoint* gw_src, NetPoint* gw_dst, std::vector<resource::LinkImpl*>& link_list, bool symmetrical) { addRouteCheckParams(src, dst, gw_src, gw_dst, link_list, symmetrical); unsigned int table_size = get_table_size(); if (not routing_table_) routing_table_ = new RouteCreationArgs*[table_size * table_size](); /* Check that the route does not already exist */ if (gw_dst) // inter-zone route (to adapt the error message, if any) xbt_assert(nullptr == TO_ROUTE_FULL(src->id(), dst->id()), "The route between %s@%s and %s@%s already exists (Rq: routes are symmetrical by default).", src->get_cname(), gw_src->get_cname(), dst->get_cname(), gw_dst->get_cname()); else xbt_assert(nullptr == TO_ROUTE_FULL(src->id(), dst->id()), "The route between %s and %s already exists (Rq: routes are symmetrical by default).", src->get_cname(), dst->get_cname()); /* Add the route to the base */ TO_ROUTE_FULL(src->id(), dst->id()) = newExtendedRoute(hierarchy_, src, dst, gw_src, gw_dst, link_list, symmetrical, true); if (symmetrical == true && src != dst) { if (gw_dst && gw_src) { NetPoint* gw_tmp = gw_src; gw_src = gw_dst; gw_dst = gw_tmp; } if (gw_dst && gw_src) // inter-zone route (to adapt the error message, if any) xbt_assert( nullptr == TO_ROUTE_FULL(dst->id(), src->id()), "The route between %s@%s and %s@%s already exists. You should not declare the reverse path as symmetrical.", dst->get_cname(), gw_dst->get_cname(), src->get_cname(), gw_src->get_cname()); else xbt_assert(nullptr == TO_ROUTE_FULL(dst->id(), src->id()), "The route between %s and %s already exists. You should not declare the reverse path as symmetrical.", dst->get_cname(), src->get_cname()); TO_ROUTE_FULL(dst->id(), src->id()) = newExtendedRoute(hierarchy_, src, dst, gw_src, gw_dst, link_list, symmetrical, false); } }
void FullZone::seal() { unsigned int table_size = get_table_size(); /* Create table if needed */ if (not routing_table_) routing_table_ = new RouteCreationArgs*[table_size * table_size](); /* Add the loopback if needed */ if (surf_network_model->loopback_ && hierarchy_ == RoutingMode::base) { for (unsigned int i = 0; i < table_size; i++) { RouteCreationArgs* e_route = TO_ROUTE_FULL(i, i); if (not e_route) { e_route = new RouteCreationArgs(); e_route->link_list.push_back(surf_network_model->loopback_); TO_ROUTE_FULL(i, i) = e_route; } } } }
/*Tests creating a table, placing key/value pairs in it, getting values from the table, clearing the entire table, then reinserting some key/value pairs and getting their values. Also tests get_table_size */ static int test2() { int table_size = 4, x = 1, y = 3, z = 4, w = 5, a = 10, b = 2, c = 7, d = 8, e = 9, f = 12, g = 13; Table *t; void *value1, *value2, *value3, *value4, *value5, *value6, *value7, *value8, *value9, *value10, *value11; create_table(&t, table_size, NULL); /*Insert 4 keys into the table.*/ put(t, "Spongebob", &x); put(t, "Patrick", &y); put(t, "Squidward", &z); put(t, "Sandy", &w); /*Check that each key has the correct value, and that get_value is operating correctly.*/ get_value(t, "Spongebob", &value1); get_value(t, "Patrick", &value2); get_value(t, "Squidward", &value3); get_value(t, "Sandy", &value4); printf("Value for Spongebob: %d\n", *(int *) value1); printf("Value for Patrick: %d\n", *(int *) value2); printf("Value for Squidward: %d\n", *(int *) value3); printf("Value for Sandy: %d\n", *(int *) value4); printf("\n"); /*Check the State of the entire table.*/ display_table(t); /*Clear the entire table.*/ clear_table(t); /*Check that get_table_size and get_key_count are workign correctly.*/ if(get_table_size(t) != 4 || get_key_count(t) != 0){ return FAILURE; } /*Make sure the table is empty.*/ display_table(t); /*Reinsert 7 keys.*/ put(t, "Krabs", &a); put(t, "Larry", &b); put(t, "Herminator", &c); put(t, "Brian", &d); put(t, "Steve", &e); put(t, "Nelson", &f); put(t, "Corwin", &g); /*Check that these keys have the correct values associated witht hem.*/ get_value(t, "Krabs", &value5); get_value(t, "Larry", &value6); get_value(t, "Herminator", &value7); get_value(t, "Brian", &value8); get_value(t, "Steve", &value9); get_value(t, "Nelson", &value10); get_value(t, "Corwin", &value11); printf("Value for Krabs: %d\n", *(int *) value5); printf("Value for Larry: %d\n", *(int *) value6); printf("Value for Herminator: %d\n", *(int *) value7); printf("Value for Brian: %d\n", *(int *) value8); printf("Value for Steve: %d\n", *(int *) value9); printf("Value for Nelson: %d\n", *(int *) value10); printf("Value for Corwin: %d\n", *(int *) value11); /*Check the state of the entire table, especially to see if any keys from before clear_table was called are left over. */ display_table(t); printf("\n\n"); destroy_table(t); return SUCCESS; }
/*Tests null and failure cases for create_table, destroy_table, put, get_value, get_key_count*/ static int test3(){ int table_size =5, x =5; Table *t, *p; void *value1, *value2, *value3 = NULL; /*Tests NULL cases for create_table.*/ if(create_table(NULL, table_size, NULL ) != -1){ return FAILURE; }else if(create_table(&t, 0, NULL) != -1){ return FAILURE; }/*Tests NULL case for destroy_table.*/ if (destroy_table(NULL) != -1){ return FAILURE; }/*Tests NULL cases for put.*/ if (put(NULL, "Krabs", &x) != -1){ return FAILURE; }else if (put(t, NULL, &x) != -1){ return FAILURE; } /*Creates one empty table, and one table with two keys.*/ create_table(&t, table_size, NULL); create_table(&p, table_size, NULL); put(t, "Art thou feeling it now,", NULL); put(t, "Mr. Krabs?", &x); /*Tests NULL and FAILURE cases for get_value.*/ if(get_value(NULL, "Mr. Krabs?", &value1) != -1){ return FAILURE; } else if(get_value(t, NULL, &value1) != -1){ return FAILURE; } else if(get_value(t, "Spongebob", &value1) != -1){ return FAILURE; } /*Tests get_value for cases where the value stored is NULL and where the input parameter value is NULL. */ get_value(t, "Mr. Krabs?", &value1); get_value(t, "Art thou feeling it now,", &value2); get_value(t, "Mr. Krabs?", &value3); if(value2 != NULL){ return FAILURE; } printf("How much is Mr. Krabs feeling it: %d/10\n", *(int *) value1); printf("Key Count: %d\n", get_key_count(t)); /*Tests NULL case for get_key_count.*/ if(get_key_count(NULL) != -1){ return FAILURE; } /*Tests NULL and FAILURE cases for remove_entry.*/ if(remove_entry(NULL, "Mr. Krabs?") != -1){ return FAILURE; } else if (remove_entry(t, NULL) != -1){ return FAILURE; } else if (remove_entry(t, "Brian") != -1){ return FAILURE; } /*Tests NULL case for clear_table. */ if (clear_table(NULL) != -1){ return FAILURE; } /*Tests is_empty with NULL, empty, and non-empty table.*/ if (is_empty(t) != 0 || is_empty(NULL) != 1 || is_empty(p) != 1){ return FAILURE; } /*Tests NULL case of get_table_size.*/ if(get_table_size(NULL) != -1){ return FAILURE; } destroy_table(t); destroy_table(p); return SUCCESS; }