TEST(SorterTest, Update) { DRFSorter sorter; sorter.add("a"); sorter.add("b"); sorter.add(Resources::parse("cpus:10;mem:10;disk:10").get()); sorter.allocated("a", Resources::parse("cpus:10;mem:10;disk:10").get()); // Construct an offer operation. Resource volume = Resources::parse("disk", "5", "*").get(); volume.mutable_disk()->mutable_persistence()->set_id("ID"); volume.mutable_disk()->mutable_volume()->set_container_path("data"); Offer::Operation create; create.set_type(Offer::Operation::CREATE); create.mutable_create()->add_volumes()->CopyFrom(volume); // Compute the updated allocation. Resources allocation = sorter.allocation("a"); Try<Resources> newAllocation = allocation.apply(create); ASSERT_SOME(newAllocation); // Update the resources for the client. sorter.update("a", allocation, newAllocation.get()); EXPECT_EQ(newAllocation.get(), sorter.allocation("a")); }
LookAndFeel LookAndFeel::create(const std::string& fileName){ auto root(createRoot<LafParserRoot>(fileName)); Resources* r = Game::getResources(); r->load(root.lookAndFeel->resources, fileName, true); return LookAndFeel(root.lookAndFeel,r); }
void example_destroy() { _tests->detach(); _tests = 0; resources.free(); resourcesUI.free(); }
void STLRepository::create( const Resources values, const shared_ptr< Query > query, const function< void ( const shared_ptr< Query > ) >& callback ) { unique_lock< mutex> lock( m_resources_lock ); for ( const auto value : values ) { bool conflict = any_of( m_resources.begin( ), m_resources.end( ), [ &value ]( const Resource & resource ) { const auto lhs = String::to_string( value.lower_bound( "key" )->second ); const auto rhs = String::to_string( resource.lower_bound( "key" )->second ); return String::lowercase( lhs ) == String::lowercase( rhs ); } ); if ( conflict ) { query->set_error_code( 40009 ); return callback( query ); } } m_resources.insert( m_resources.end( ), values.begin( ), values.end( ) ); lock.unlock( ); auto results = fields( values, query ); query->set_resultset( results ); callback( query ); }
void MaterialAsset::__loadTextureToGFXCard( void ) { if ( !__isTextureLoaded ) { Resources* r = DWIngine::singleton()->resources(); TextureAsset* tex = r->getTexture( __textureUniqueName ); GLuint textureID; glGenTextures( 1, &textureID ); glBindTexture( GL_TEXTURE_2D, textureID ); unsigned char * data = new unsigned char [tex->width() * tex->height() * 3]; data = &tex->imageData()[ 68 ]; glTexImage2D( GL_TEXTURE_2D, 0, GL_RGB, tex->width(), tex->height(), 0, GL_BGR, GL_UNSIGNED_BYTE, data ); //glTexImage2D( GL_TEXTURE_2D, 0, GL_BGR, tex->width(), tex->height(), 0, GL_RGB, GL_UNSIGNED_BYTE, data ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR ); glGenerateMipmap( GL_TEXTURE_2D ); __texture = textureID; __isTextureLoaded = !__isTextureLoaded; } }
TEST(SorterTest, UpdateAllocation) { DRFSorter sorter; SlaveID slaveId; slaveId.set_value("agentId"); sorter.add("a"); sorter.add("b"); sorter.add(slaveId, Resources::parse("cpus:10;mem:10;disk:10").get()); sorter.allocated( "a", slaveId, Resources::parse("cpus:10;mem:10;disk:10").get()); // Construct an offer operation. Resource volume = Resources::parse("disk", "5", "*").get(); volume.mutable_disk()->mutable_persistence()->set_id("ID"); volume.mutable_disk()->mutable_volume()->set_container_path("data"); // Compute the updated allocation. Resources oldAllocation = sorter.allocation("a", slaveId); Try<Resources> newAllocation = oldAllocation.apply(CREATE(volume)); ASSERT_SOME(newAllocation); // Update the resources for the client. sorter.update("a", slaveId, oldAllocation, newAllocation.get()); hashmap<SlaveID, Resources> allocation = sorter.allocation("a"); EXPECT_EQ(1u, allocation.size()); EXPECT_EQ(newAllocation.get(), allocation[slaveId]); EXPECT_EQ(newAllocation.get(), sorter.allocation("a", slaveId)); }
void RandomSorter::remove(const SlaveID& slaveId, const Resources& resources) { if (!resources.empty()) { CHECK(total_.resources.contains(slaveId)); CHECK(total_.resources[slaveId].contains(resources)) << total_.resources[slaveId] << " does not contain " << resources; total_.resources[slaveId] -= resources; // Remove shared resources from the total quantities when there // are no instances of same resources left in the total. const Resources absentShared = resources.shared() .filter([this, slaveId](const Resource& resource) { return !total_.resources[slaveId].contains(resource); }); const ResourceQuantities scalarQuantities = ResourceQuantities::fromScalarResources( (resources.nonShared() + absentShared).scalars()); CHECK(total_.totals.contains(scalarQuantities)); total_.totals -= scalarQuantities; if (total_.resources[slaveId].empty()) { total_.resources.erase(slaveId); } } }
int Environment::loadSkin(char *fSkinDirectory) { Elements *fOldElements = mElements; Resources *fOldResources = mResources; struct stat sbuf; char buf[255]; sprintf(buf, "%sskin.xml", fSkinDirectory); printf("Loading %s\n", buf); if (stat(buf, &sbuf)) { return 0; } xmlDoc *theDoc = 0; xmlNode *theRoot = 0; theDoc = xmlReadFile(buf, NULL, 0); if (theDoc == NULL) { return 0; } theRoot = xmlDocGetRootElement(theDoc); xmlNode *fNode = theRoot->children; while (fNode) { if (!strcmp((char *) fNode->name, "Resources") && fNode->children) { Resources *t = new Resources(); t->xmlConfigure(fNode->children); setResources(t); } else if (!strcmp((char *) fNode->name, "Elements") && fNode->children) { Elements *t = new Elements(); t->xmlConfigure(fNode->children); setElements(t); } fNode = fNode->next; } if (fOldElements != mElements && fOldElements) { delete fOldElements; } if (fOldResources != mResources && fOldResources) { delete fOldResources; } setSkinPath(fSkinDirectory); debugPrint(" Loading resources\n"); mResources->loadResources(); debugPrint(" Associating resources & elements\n"); mElements->associateResources(mResources); xmlFreeDoc(theDoc); return 1; }
void Environment::xmlConfigure(xmlNode *fNode) { int fEmbeddedSkin = 0; while (fNode) { if (!strcmp((char *) fNode->name, "Menu")) { SubMenuNode *t = new SubMenuNode(); t->xmlConfigure(fNode->children); setTopMenu(t); setCurrentMenu(t); } else if (!strcmp((char *) fNode->name, "Resources")) { Resources *t = new Resources(); t->xmlConfigure(fNode->children); setResources(t); fEmbeddedSkin = 1; } else if (!strcmp((char *) fNode->name, "Elements")) { Elements *t = new Elements(); t->xmlConfigure(fNode->children); setElements(t); fEmbeddedSkin = 1; } else if (!strcmp((char *) fNode->name, "Dialog")) { Generic *t = new Generic(); t->xmlConfigure(fNode->children); setDialog(t); } else if (!strcmp((char *) fNode->name, "LogFile")) { setLogFileName((char *) fNode->children->content); } fNode = fNode->next; } if (fEmbeddedSkin) { mResources->loadResources(); mElements->associateResources(mResources); } }
ResourceMark::~ResourceMark() { if (!enabled) return; # ifdef ASSERT assert(area->nesting> 0, "nesting must be positive"); area->nesting--; # endif if (PrintResourceAllocation) { lprintf("deallocating to mark %#lx\n", top); } ResourceAreaChunk* prevc; ResourceAreaChunk* c; for (c = area->chunk; c != chunk; c = prevc) { // deallocate all chunks behind marked chunk prevc = c->prev; resources.addToFreeList(c); } area->chunk = c; if (c == NULL) { top = NULL; return; } c->freeTo(top); if (top == c->bottom) { // this chunk is completely unused - deallocate it area->chunk = c->prev; resources.addToFreeList(c); } }
int main(int argc, char *argv[]) { Q_INIT_RESOURCE(resources); QGuiApplication app(argc, argv); app.setApplicationName("osmand-qt"); app.setApplicationVersion("0.1"); __CoreResourcesEmbeddedBundle__FakeReferences(); shared_ptr<const CoreResourcesEmbeddedBundle> bundle = CoreResourcesEmbeddedBundle::loadFromCurrentExecutable(); InitializeCore(bundle); qmlRegisterType<MapCanvas>("OsmAndQt", 1, 0, "MapCanvas"); qmlRegisterUncreatableType<Resources>("OsmAndQt", 1, 0, "Resources", ""); qmlRegisterUncreatableType<ResourceModel>("OsmAndQt", 1, 0, "ResourceModel", ""); Resources resources; resources.downloadIfNecessary(QList<QString>() << "world_basemap.map.obf" << "austria_europe.map.obf" ); QQmlApplicationEngine engine; engine.rootContext()->setContextProperty("contextResources", &resources); engine.load(QUrl("qrc:/src/Main.qml")); qobject_cast<QQuickWindow *>(engine.rootObjects().value(0))->show(); return app.exec(); }
Resources JSONFormatter::parse( const Bytes& value ) { auto json = json::parse( String::to_string( value ) ); if ( json.count( "data" ) == 0 ) { throw domain_error( "Root property must be named 'data'." ); } auto data = json[ "data" ]; Resources resources; if ( data.is_array( ) ) { for ( const auto object : data ) { if ( not object.is_object( ) ) { throw domain_error( "Root array child elements must be objects." ); } resources.push_back( parse_object( object ) ); } } else if ( data.is_object( ) ) { resources.push_back( parse_object( data ) ); } else { throw domain_error( "Root property must be unordered set or object." ); } return resources; }
TEST(ResourcesTest, ScalarSubtraction) { Resource cpus1 = Resources::parse("cpus", "50", "*").get(); Resource mem1 = Resources::parse("mem", "4096", "*").get(); Resource cpus2 = Resources::parse("cpus", "0.5", "*").get(); Resource mem2 = Resources::parse("mem", "1024", "*").get(); Resources r1; r1 += cpus1; r1 += mem1; Resources r2; r2 += cpus2; r2 += mem2; Resources diff = r1 - r2; EXPECT_FALSE(diff.empty()); EXPECT_EQ(49.5, diff.get<Value::Scalar>("cpus").get().value()); EXPECT_EQ(3072, diff.get<Value::Scalar>("mem").get().value()); Resources r = r1; r -= r2; EXPECT_EQ(49.5, diff.get<Value::Scalar>("cpus").get().value()); EXPECT_EQ(3072, diff.get<Value::Scalar>("mem").get().value()); r = r1; r -= r1; EXPECT_TRUE(r.empty()); }
TEST(ResourcesTest, ScalarAddition) { Resource cpus1 = Resources::parse("cpus", "1", "*").get(); Resource mem1 = Resources::parse("mem", "5", "*").get(); Resource cpus2 = Resources::parse("cpus", "2", "*").get(); Resource mem2 = Resources::parse("mem", "10", "*").get(); Resources r1; r1 += cpus1; r1 += mem1; Resources r2; r2 += cpus2; r2 += mem2; Resources sum = r1 + r2; EXPECT_FALSE(sum.empty()); EXPECT_EQ(3, sum.get<Value::Scalar>("cpus").get().value()); EXPECT_EQ(15, sum.get<Value::Scalar>("mem").get().value()); Resources r = r1; r += r2; EXPECT_FALSE(r.empty()); EXPECT_EQ(3, r.get<Value::Scalar>("cpus").get().value()); EXPECT_EQ(15, r.get<Value::Scalar>("mem").get().value()); }
void SFMLInputs::init( EntityManager &em) { Inputs::init( em); Resources *resources = em.getComponent<Resources>(); SFMLVisualContext &vc = (SFMLVisualContext &) resources->getVisualContext(); window_ = &vc.getRenderWindow(); state_ = new SFMLInputState(vc, window_); }
void newMatch(void) { buildMaze(glmaze, Graph_Space, tileSpace, Tilesize, Resources_Manager.texture("wall.tga"), Resources_Manager.texture("floor.tga"), Resources_Manager.texture("ceil.tga"), &Config_Info); restartMatch(); }
Resources* assign(int n) { Resources* r = new Resources; for(int i = 0; i < n; ++i) { r->push_back(mResources->back()); mResources->pop_back(); } return r; }
TEST(ResourcesTest, RangesSubtraction4) { Resources resources = Resources::parse("ports:[50000-60000]").get(); Resources resourcesOffered; resourcesOffered += resources; resourcesOffered -= resources; EXPECT_TRUE(resourcesOffered.empty()); EXPECT_NONE(resourcesOffered.get<Value::Ranges>("ports")); }
void resourceOffers(const vector<Offer>& offers) { foreach (const Offer& offer, offers) { cout << "Received offer " << offer.id() << " with " << Resources(offer.resources()) << endl; static const Resources TASK_RESOURCES = Resources::parse( "cpus:" + stringify(CPUS_PER_TASK) + ";mem:" + stringify(MEM_PER_TASK)).get(); Resources remaining = offer.resources(); // Launch tasks. vector<TaskInfo> tasks; while (tasksLaunched < totalTasks && remaining.flatten().contains(TASK_RESOURCES)) { int taskId = tasksLaunched++; cout << "Launching task " << taskId << " using offer " << offer.id() << endl; TaskInfo task; task.set_name("Task " + lexical_cast<string>(taskId)); task.mutable_task_id()->set_value( lexical_cast<string>(taskId)); task.mutable_agent_id()->MergeFrom(offer.agent_id()); task.mutable_executor()->MergeFrom(executor); Option<Resources> resources = remaining.find(TASK_RESOURCES.flatten(framework.role())); CHECK_SOME(resources); task.mutable_resources()->CopyFrom(resources.get()); remaining -= resources.get(); tasks.push_back(task); } Call call; CHECK(framework.has_id()); call.mutable_framework_id()->CopyFrom(framework.id()); call.set_type(Call::ACCEPT); Call::Accept* accept = call.mutable_accept(); accept->add_offer_ids()->CopyFrom(offer.id()); Offer::Operation* operation = accept->add_operations(); operation->set_type(Offer::Operation::LAUNCH); foreach (const TaskInfo& taskInfo, tasks) { operation->mutable_launch()->add_task_infos()->CopyFrom(taskInfo); }
void restartMatch(void) { gettimeofday(&Initial_Timer, NULL); MatrixCoord startGraphCoord = MatrixCoord(0, 0); MatrixCoord goalGraphCoord = MatrixCoord(Graph_Space.size().x-1, Graph_Space.size().y-1); for (unsigned int i=0; i<Player_List.size(); ++i) { if (Player_List[i]) { delete Player_List[i]; } } Player_List.clear(); Player_List = std::vector<PlayerBase*>(Config_Info.playerConfigs.size()); float runSpeed = 0.2f; for (unsigned int i=0; i<Config_Info.playerConfigs.size(); ++i) { if (Config_Info.playerConfigs[i].type == HUMAN) { human = new Human(Config_Info.playerConfigs[i].name, Config_Info.playerConfigs[i].color, runSpeed, startGraphCoord, goalGraphCoord, Resources_Manager.mesh("robot.obj"), Resources_Manager.texture("comp.tga"), glmaze.aabb, Tilesize); Player_List[i] = human; humanIndex = i; } else if (Config_Info.playerConfigs[i].type == AI_DFS) { Player_List[i] = new AIRobot(Config_Info.playerConfigs[i].name, Config_Info.playerConfigs[i].color, runSpeed, Resources_Manager.mesh("robot.obj"), Resources_Manager.texture("comp.tga"), randomDFSPath(Graph_Space, startGraphCoord, goalGraphCoord), Tilesize); } else if (Config_Info.playerConfigs[i].type == AI_SMART) { Player_List[i] = new AIRobot(Config_Info.playerConfigs[i].name, Config_Info.playerConfigs[i].color, runSpeed, Resources_Manager.mesh("robot.obj"), Resources_Manager.texture("comp.tga"), smartEnhancePath(randomDFSPath(Graph_Space, startGraphCoord, goalGraphCoord)), Tilesize); } else if (Config_Info.playerConfigs[i].type == AI_DUMB) { Player_List[i] = new AIRobot(Config_Info.playerConfigs[i].name, Config_Info.playerConfigs[i].color, runSpeed, Resources_Manager.mesh("robot.obj"), Resources_Manager.texture("comp.tga"), dumbPath(Graph_Space, startGraphCoord, goalGraphCoord), Tilesize); } } finishedPlayers = std::vector<int>(Config_Info.playerConfigs.size(), 0); glm::vec3 startcone = tileSpaceToWorldSpace(MatrixCoord(1,1), Tilesize, Tilesize/2.0f); glm::vec3 endcone = tileSpaceToWorldSpace(tileSpace.size()-MatrixCoord(2,2), Tilesize, Tilesize/2.0f); cone1 = Cone(Resources_Manager.mesh("cone.obj"), Resources_Manager.texture("startmark.tga"), startcone); cone2 = Cone(Resources_Manager.mesh("cone.obj"), Resources_Manager.texture("finishmark.tga"), endcone); winners.clear(); toggleCameraButton->show = false; Camera_Mode = humanIndex; }
MainActor() { //create simple Sprite spSprite button = new Sprite(); //setup it: //set button.png image. Resource 'button' defined in 'res.xml' button->setResAnim(gameResources.getResAnim("button")); //centered button at screen Vector2 pos = getStage()->getSize() / 2 - button->getSize() / 2; button->setPosition(pos); //handle click to button EventCallback cb = CLOSURE(this, &MainActor::buttonClicked); button->addEventListener(TouchEvent::CLICK, cb); #ifdef CLOSURE_FUNCTION //if your compiler supports lambda button->addEventListener(TouchEvent::CLICK, [](Event * e)->void { log::messageln("button clicked"); }); #endif //attach button as child to current actor addChild(button); _button = button; //second part //create TextField Actor spTextField text = new TextField(); //attach it as child to button text->addTo(button); //centered in button text->setPosition(button->getSize() / 2); //initialize text style TextStyle style; style.font = gameResources.getResFont("main")->getFont(); style.color = Color::White; style.vAlign = TextStyle::VALIGN_MIDDLE; style.hAlign = TextStyle::HALIGN_CENTER; text->setStyle(style); text->setText("Click\nMe!"); _text = text; }
virtual void resourceOffers(SchedulerDriver* driver, const vector<Offer>& offers) { for (size_t i = 0; i < offers.size(); i++) { const Offer& offer = offers[i]; Resources remaining = offer.resources(); static Resources TASK_RESOURCES = Resources::parse( "cpus:" + stringify<float>(CPUS_PER_TASK) + ";mem:" + stringify<size_t>(MEM_PER_TASK)).get(); size_t maxTasks = 0; while (remaining.flatten().contains(TASK_RESOURCES)) { maxTasks++; remaining -= TASK_RESOURCES; } // Launch tasks. vector<TaskInfo> tasks; for (size_t i = 0; i < maxTasks / 2 && crawlQueue.size() > 0; i++) { string url = crawlQueue.front(); crawlQueue.pop(); string urlId = "C" + stringify<size_t>(processed[url]); TaskInfo task; task.set_name("Crawler " + urlId); task.mutable_task_id()->set_value(urlId); task.mutable_slave_id()->MergeFrom(offer.slave_id()); task.mutable_executor()->MergeFrom(crawler); task.mutable_resources()->MergeFrom(TASK_RESOURCES); task.set_data(url); tasks.push_back(task); tasksLaunched++; cout << "Crawler " << urlId << " " << url << endl; } for (size_t i = maxTasks/2; i < maxTasks && renderQueue.size() > 0; i++) { string url = renderQueue.front(); renderQueue.pop(); string urlId = "R" + stringify<size_t>(processed[url]); TaskInfo task; task.set_name("Renderer " + urlId); task.mutable_task_id()->set_value(urlId); task.mutable_slave_id()->MergeFrom(offer.slave_id()); task.mutable_executor()->MergeFrom(renderer); task.mutable_resources()->MergeFrom(TASK_RESOURCES); task.set_data(url); tasks.push_back(task); tasksLaunched++; cout << "Renderer " << urlId << " " << url << endl; } driver->launchTasks(offer.id(), tasks); } }
// Test that the changes made by the resources decorator hook are correctly // propagated to the resource offer. TEST_F(HookTest, VerifySlaveResourcesAndAttributesDecorator) { Try<PID<Master>> master = StartMaster(CreateMasterFlags()); ASSERT_SOME(master); MockExecutor exec(DEFAULT_EXECUTOR_ID); TestContainerizer containerizer(&exec); // Start a mock slave since we aren't testing the slave hooks yet. Try<PID<Slave>> slave = StartSlave(&containerizer); ASSERT_SOME(slave); MockScheduler sched; MesosSchedulerDriver driver( &sched, DEFAULT_FRAMEWORK_INFO, master.get(), DEFAULT_CREDENTIAL); EXPECT_CALL(sched, registered(&driver, _, _)); Future<vector<Offer>> offers; EXPECT_CALL(sched, resourceOffers(&driver, _)) .WillOnce(FutureArg<1>(&offers)) .WillRepeatedly(Return()); // Ignore subsequent offers. driver.start(); AWAIT_READY(offers); EXPECT_NE(0u, offers.get().size()); Resources resources = offers.get()[0].resources(); // The test hook sets "cpus" to 4. EXPECT_EQ(4, resources.cpus().get()); // The test hook adds a resource named "foo" of type set with values "bar" // and "baz". EXPECT_EQ(Resources::parse("foo:{bar,baz}").get(), resources.get("foo")); // The test hook does not modify "mem", the default value must still be // present. EXPECT_SOME(resources.mem()); // The test hook adds an attribute named "rack" with value "rack1". Attributes attributes = offers.get()[0].attributes(); ASSERT_EQ(attributes.get(0).name(), "rack"); ASSERT_EQ(attributes.get(0).text().value(), "rack1"); driver.stop(); driver.join(); Shutdown(); }
void DRFSorter::add(const SlaveID& slaveId, const Resources& resources) { if (!resources.empty()) { total_.resources[slaveId] += resources; total_.scalarQuantities += resources.createStrippedScalarQuantity(); // We have to recalculate all shares when the total resources // change, but we put it off until sort is called so that if // something else changes before the next allocation we don't // recalculate everything twice. dirty = true; } }
// ------------------------------------------------------ // show resources // ------------------------------------------------------ void show_resources(const ResourceRegistry& reg,const Resources& res,bool complete) { //printf("Resources:\n"); for ( int i = 0; i <reg.size(); ++i ) { if ( complete) { printf("%10s : %d\n",reg.getName(i),res.get(i)); } else { if ( res.get(i) > 0 ) { printf("%10s : %d\n",reg.getName(i),res.get(i)); } } } }
SpaceObject::SpaceObject(sf::Texture &t, Resources &res, int health, int speed) : explosionTexture(res.getImg()->getExplosion_t()) { //Create graphical object this->sprite.setTexture(t); //Set properties values this->health = health; this->speed = speed; //Set the explosion sound buffer this->explosionSound.setBuffer(res.getExplosionSnd()); this->explosionSound.setVolume(res.getConfigXML()->getSettings()->getVolumeSound()); }
TEST(ResourcesTest, BadResourcesNotAllocatable) { Resource cpus; cpus.set_type(Resource::SCALAR); cpus.mutable_scalar()->set_value(1); Resources r; r += cpus; EXPECT_EQ(0, r.allocatable().size()); cpus.set_name("cpus"); cpus.mutable_scalar()->set_value(0); r += cpus; EXPECT_EQ(0, r.allocatable().size()); }
TEST(ResourcesTest, FlattenRoles) { Resource cpus1 = Resources::parse("cpus", "1", "role1").get(); Resource cpus2 = Resources::parse("cpus", "2", "role2").get(); Resource mem1 = Resources::parse("mem", "5", "role1").get(); Resources r; r += cpus1; r += cpus2; r += mem1; EXPECT_EQ(r.flatten(), Resources::parse("cpus:3;mem:5").get()); }
TEST(ResourcesTest, ScalarSubtraction) { Resource cpus1 = Resources::parse("cpus", "50"); Resource mem1 = Resources::parse("mem", "4096"); Resource cpus2 = Resources::parse("cpus", "0.5"); Resource mem2 = Resources::parse("mem", "1024"); Resources r1; r1 += cpus1; r1 += mem1; Resources r2; r2 += cpus2; r2 += mem2; Resources diff = r1 - r2; EXPECT_EQ(2, diff.size()); EXPECT_EQ(49.5, diff.get("cpus", Resource::Scalar()).value()); EXPECT_EQ(3072, diff.get("mem", Resource::Scalar()).value()); Resources r = r1; r -= r2; EXPECT_EQ(49.5, diff.get("cpus", Resource::Scalar()).value()); EXPECT_EQ(3072, diff.get("mem", Resource::Scalar()).value()); r = r1; r -= r1; EXPECT_EQ(0, r.allocatable().size()); }
void ThreadLoader::unload() { for (resources::iterator i = _resources.begin(); i != _resources.end(); ++i) { Resources* res = *i; res->unload(); } for (ress::iterator i = _ress.begin(); i != _ress.end(); ++i) { Resource* res = *i; res->unload(); } }