CF::AllocationManager::AllocationResponseSequence* AllocationManager_impl::allocateDevices(const CF::AllocationManager::AllocationRequestSequence &requests, ossie::DeviceList& devices, const std::string& domainName) { LOG_TRACE(AllocationManager_impl, "Servicing " << requests.length() << " allocation request(s)"); CF::AllocationManager::AllocationResponseSequence_var response = new CF::AllocationManager::AllocationResponseSequence(); typedef std::list<ossie::AllocationType*> LocalAllocationList; LocalAllocationList local_allocations; for (unsigned int request_idx=0; request_idx<requests.length(); request_idx++) { const CF::AllocationManager::AllocationRequestType& request = requests[request_idx]; const std::string requestID(request.requestID); LOG_TRACE(AllocationManager_impl, "Allocation request " << requestID << " contains " << request.allocationProperties.length() << " properties"); // Get device identifiers, and ensure that no device references are nil std::vector<std::string> requestedDeviceIDs; for (unsigned int device_idx = 0; device_idx < request.requestedDevices.length(); ++device_idx) { CF::Device_ptr device = request.requestedDevices[device_idx]; if (!CORBA::is_nil(device)) { requestedDeviceIDs.push_back(ossie::corba::returnString(device->identifier())); } } if (requestedDeviceIDs.size() != request.requestedDevices.length()) { // At least one requested device was nil continue; } // If a requested device list was given, skip devices not in list ossie::DeviceList requestedDevices = devices; if (!requestedDeviceIDs.empty()) { for (ossie::DeviceList::iterator node = requestedDevices.begin(); node != requestedDevices.end(); ++node) { if (std::find(requestedDeviceIDs.begin(), requestedDeviceIDs.end(), (*node)->identifier) == requestedDeviceIDs.end()) { node = requestedDevices.erase(node); } } } std::pair<ossie::AllocationType*,ossie::DeviceList::iterator> result = allocateRequest(requestID, request.allocationProperties, requestedDevices, std::vector<std::string>(), std::vector<ossie::SPD::NameVersionPair>(), domainName); if (result.first) { local_allocations.push_back(result.first); ossie::AllocationType* allocation(result.first); const std::string requestID(request.requestID); ossie::corba::push_back(response, ossie::assembleResponse(requestID, allocation->allocationID, allocation->allocationProperties, allocation->allocatedDevice, allocation->allocationDeviceManager)); } } // Update the database boost::recursive_mutex::scoped_lock lock(allocationAccess); for (LocalAllocationList::iterator alloc = local_allocations.begin(); alloc != local_allocations.end(); ++alloc) { this->_allocations[(*alloc)->allocationID] = **alloc; delete *alloc; } if (response->length() != 0) { this->_domainManager->updateLocalAllocations(this->_allocations); } return response._retn(); }
ossie::AllocationResult AllocationManager_impl::allocateDeployment(const std::string& requestID, const CF::Properties& allocationProperties, ossie::DeviceList& devices, const std::vector<std::string>& processorDeps, const std::vector<ossie::SPD::NameVersionPair>& osDeps) { const std::string domainName = this->_domainManager->getDomainManagerName(); std::pair<ossie::AllocationType*,ossie::DeviceList::iterator> result = allocateRequest(requestID, allocationProperties, devices, processorDeps, osDeps, domainName); if (result.first) { // Update the allocation table, including the persistence store const std::string allocationID = result.first->allocationID; boost::recursive_mutex::scoped_lock lock(allocationAccess); this->_allocations[allocationID] = *(result.first); this->_domainManager->updateLocalAllocations(this->_allocations); // Delete the temporary delete result.first; return ossie::AllocationResult(allocationID, *result.second); } return std::make_pair(std::string(), boost::shared_ptr<ossie::DeviceNode>()); }
void obtainOptimalStateValue(multimap<double,cEvent>& _event_multimap,vector<cServer>& _server_vec) { multimap<double,cEvent>::iterator iter_event_multimap; counting = -1; //store the number of accepted requests corresponding to each type of requests map<requesttype,unsigned int> hosted_requests_type_num_map; map<requesttype,unsigned int>::iterator iter_find_hosted_request_num_map; map<ID,cRequest*> hosted_request_map; map<ID,cRequest*>::iterator iter_find_request_map; for (iter_event_multimap = _event_multimap.begin();iter_event_multimap != _event_multimap.end();iter_event_multimap++) { if (iter_event_multimap->second.getEventType() == DEPARTURE) { //set current time current_time = iter_event_multimap->first; //delete the request from the hosting list iter_find_request_map = hosted_request_map.find((iter_event_multimap->second.getRequest())->getID()); if (iter_find_request_map == hosted_request_map.end()) { cout<<"Error!!!Can not locate the request that should exist in the hosting list!"<<endl; exit(0); } hosted_request_map.erase(iter_find_request_map); //minus 1 from the entry corresponding the type of currently departing requests in the counting list of hosting requests iter_find_hosted_request_num_map = hosted_requests_type_num_map.find((iter_event_multimap->second.getRequest())->getRequestType()); if (iter_find_hosted_request_num_map == hosted_requests_type_num_map.end()) { cout<<"Error!!!Can not locate the request that should exist in the counting list of types of the hosting requests!"<<endl; exit(0); } else (iter_find_hosted_request_num_map->second)--; //release the resources allocated to the request releaseRequest(iter_event_multimap->second.getRequest()); //update the value of current system state after any request departure //system_state.first = NONE; //updateStateValueRequDepar(_server_vec,hosted_request_map,hosted_requests_type_num_map); //system_state.second = calculateRequestDepartureStateIndicator(_server_vec,iter_event_multimap->second.getRequest()); } else { //set current time current_time = iter_event_multimap->first; //a request is arriving counting++; //update the system state system_state.first = (iter_event_multimap->second.getRequest())->getRequestType(); //we should determine which action should be take base on the purpose of maximizing the expected profits //if(obtainOptimalAction(&(iter_event_multimap->second),_server_vec,hosted_requests_type_num_map,hosted_request_map)) if(obtainOptimalAction(&(iter_event_multimap->second),_server_vec,hosted_requests_type_num_map,hosted_request_map)) { //if the arriving request is accepted, we should allocate physical resources for it and insert a departure event into the event list (iter_event_multimap->second.getRequest())->setAccepted(true); allocateRequest(iter_event_multimap->second.getRequest()); insertDepartureEvent(iter_event_multimap->second.getRequest(),_event_multimap); accepted_requests_num++; hosted_request_map.insert(make_pair((iter_event_multimap->second.getRequest())->getID(),iter_event_multimap->second.getRequest())); iter_find_hosted_request_num_map = hosted_requests_type_num_map.find((iter_event_multimap->second.getRequest())->getRequestType()); if (iter_find_hosted_request_num_map == hosted_requests_type_num_map.end()) { //there is no request in the system which has the same type as currently arriving request hosted_requests_type_num_map.insert(make_pair((iter_event_multimap->second.getRequest())->getRequestType(),1)); } else (iter_find_hosted_request_num_map->second)++; } else { //do nothing //the arriving request is rejected due to 1) having not enough residual resources, or 2) maximizing profits policy (iter_event_multimap->second.getRequest())->setAccepted(false); //update the value of current system state after any request departure system_state.first = NONE; updateStateValueRequDepar(_server_vec,hosted_request_map,hosted_requests_type_num_map); } } } return ; }