void initBoxCapacitated(std::vector<Box*> &vectorBox, Data &data, std::vector<int> & sorted_fac) { // sorted_fac is sorted by decreasing capacities std::sort( sorted_fac.begin(), sorted_fac.end(), compare_capacity(data) ); // Compute the total demand double dtotal( 0 ); for ( unsigned int i = 0; i < data.getnbCustomer(); ++i ) { dtotal += data.getCustomer(i).getDemand(); } // Compute the minimum number of facilities to open (left). double qminsum( 0 ); unsigned int minfac( 0 ); while ( minfac < sorted_fac.size() && qminsum < dtotal ) { qminsum += data.getFacility(sorted_fac[minfac]).getCapacity(); ++minfac; } // Check if the problem can be feasible if ( qminsum < dtotal ) { std::cerr << "The problem is infeasible !" << std::endl; return; } // Compute the minimum number of facilities to open (right). double qmaxsum( 0 ); unsigned int maxfac( sorted_fac.size() ); while ( maxfac >= 0 && qmaxsum < dtotal ) { --maxfac; qmaxsum += data.getFacility(sorted_fac[maxfac]).getCapacity(); } for ( int it = 0; it < Argument::paving_directions; ++it ) { // GRASP std::vector<bool> facilityOpen(data.getnbFacility(), false); std::vector<int> not_open( sorted_fac ); double qsum( 0 ), alpha( 0.5 ), dir( (double)it / (double)(Argument::paving_directions - 1.) ); while ( qsum < dtotal ) { std::vector<double> u( not_open.size() ); std::vector<int> RCL; double umin( std::numeric_limits<double>::infinity() ), umax( -std::numeric_limits<double>::infinity() ), ulimit; // Build utility function for ( unsigned int j = 0; j < not_open.size(); ++j ) { double cost( 0 ); if ( data.getNbObjective() > 2 ) { for ( int k = 0; k < data.getNbObjective(); ++k ) { cost += data.getFacility( not_open[j] ).getLocationObjCost( k ); } } else { cost = dir * data.getFacility( not_open[j] ).getLocationObjCost( 0 ) + ( 1. - dir ) * data.getFacility( not_open[j] ).getLocationObjCost( 1 ); } u[j] = data.getFacility( not_open[j] ).getCapacity() / cost; if ( u[j] < umin ) umin = u[j]; if ( u[j] > umax ) umax = u[j]; } ulimit = umin + alpha * ( umax - umin ); // Build RCL for ( unsigned int j = 0; j < u.size(); ++j ) { if ( u[j] >= ulimit ) { RCL.push_back( j ); } } // Select a random facility int r = std::rand() % RCL.size(); // Open it facilityOpen[not_open[RCL[r]]] = true; qsum += data.getFacility( not_open[RCL[r]] ).getCapacity(); not_open.erase( not_open.begin() + RCL[r] ); } vectorBox.push_back( new Box(data, facilityOpen) ); } }
void process_utilization(resource_t * rsc, node_t ** prefer, pe_working_set_t * data_set) { int alloc_details = scores_log_level + 1; if (safe_str_neq(data_set->placement_strategy, "default")) { GListPtr gIter = NULL; GListPtr colocated_rscs = NULL; gboolean any_capable = FALSE; colocated_rscs = find_colocated_rscs(colocated_rscs, rsc, rsc); if (colocated_rscs) { GHashTable *unallocated_utilization = NULL; char *rscs_id = crm_concat(rsc->id, "and its colocated resources", ' '); node_t *most_capable_node = NULL; unallocated_utilization = sum_unallocated_utilization(rsc, colocated_rscs); for (gIter = data_set->nodes; gIter != NULL; gIter = gIter->next) { node_t *node = (node_t *) gIter->data; if (have_enough_capacity(node, rscs_id, unallocated_utilization)) { any_capable = TRUE; } if (most_capable_node == NULL || compare_capacity(node, most_capable_node) < 0) { /* < 0 means 'node' is more capable */ most_capable_node = node; } } if (any_capable) { for (gIter = data_set->nodes; gIter != NULL; gIter = gIter->next) { node_t *node = (node_t *) gIter->data; if (have_enough_capacity(node, rscs_id, unallocated_utilization) == FALSE) { pe_rsc_debug(rsc, "Resource %s and its colocated resources cannot be allocated to node %s: no enough capacity", rsc->id, node->details->uname); resource_location(rsc, node, -INFINITY, "__limit_utilization__", data_set); } } } else if (*prefer == NULL) { *prefer = most_capable_node; } if (unallocated_utilization) { g_hash_table_destroy(unallocated_utilization); } g_list_free(colocated_rscs); free(rscs_id); } if (any_capable == FALSE) { for (gIter = data_set->nodes; gIter != NULL; gIter = gIter->next) { node_t *node = (node_t *) gIter->data; if (have_enough_capacity(node, rsc->id, rsc->utilization) == FALSE) { pe_rsc_debug(rsc, "Resource %s cannot be allocated to node %s: no enough capacity", rsc->id, node->details->uname); resource_location(rsc, node, -INFINITY, "__limit_utilization__", data_set); } } } dump_node_scores(alloc_details, rsc, "Post-utilization", rsc->allowed_nodes); } }