void Port::acquireInputBuffer (BufferProvider &provider, nframes_t len) { int numConnections = dependencies().count(); switch (numConnections) { case 0: if (type() == AudioPort) { // Use silence m_buffer = provider.zeroAudioBuffer(); return; } break; case 1: { // Use the other port's buffer // type should match due to validation on connect Port *other = static_cast<Port *>( *(dependencies().begin()) ); m_buffer = other->buffer(); break; } default: qFatal("Internal mixing is not yet supported"); return; } if (!m_buffer) { // Return internal port m_buffer = provider.acquire(type(), len); updateBufferValue(); } }
void MapListExtractInner::takeControl( ) { if (freeARCs() > 0){ if (arcer.takeControl()){ SMList<Map>* smo = new SMList<Map>(theList.getGroup(), arcer.getData(), Text("Inner automorphisms from ") + Name(theList) ); ListOf<OID> dependencies( smo->getGroup() ); CheckinMessage( *smo, "", dependencies ).send(); LogMessage msg( *smo ); msg << Link( Chars("Click here to see the contents of ") + Text( Name( *smo) ), "RandomAutomorphisms", smo->getData().getDataFileName() ); msg << "."; msg.send(); adminTerminate(); return; } else usedOneARC(); } }
TEST_F(DocumentSourceMatchTest, TextSearchShouldRequireWholeDocumentAndTextScore) { auto match = DocumentSourceMatch::create(fromjson("{$text: {$search: 'hello'} }"), getExpCtx()); DepsTracker dependencies(DepsTracker::MetadataAvailable::kTextScore); ASSERT_EQUALS(DepsTracker::State::EXHAUSTIVE_FIELDS, match->getDependencies(&dependencies)); ASSERT_EQUALS(true, dependencies.needWholeDocument); ASSERT_EQUALS(true, dependencies.getNeedsMetadata(DepsTracker::MetadataType::TEXT_SCORE)); }
void SMListExtractProperPowerInFree::takeControl( ) { if ( freeARCs() > 0 ) { if ( arcer.takeControl() ){ SMList<Word>* smo = new SMList<Word>(theList.getGroup(), arcer.getData(), Text("Proper powers from") + Name(theList) ); ListOf<OID> dependencies( smo->getGroup() ); CheckinMessage( *smo, "", dependencies ).send(); LogMessage msg( *smo ); msg << Link( Chars("Click here to see the contents of ") + Text( Name( *smo) ), "WEnumerator", smo->getData().getDataFileName() ); msg << "."; msg.send(); adminTerminate(); return; } else usedOneARC(); } }
int main (void) { matrix_t r = read_matrix (); matrix_t mayw; matrix_t mustw; dm_copy(&r, &mayw); dm_copy(&r, &mustw); printf ("matrix:\n"); dm_print (stdout, &r); // nub dm_sort_rows (&r, &mayw, &mustw, &max_row_first); dm_nub_rows (&r, &mayw, &mustw, &eq_rows, NULL); // optimize dm_optimize (&r, &mayw, &mustw); // sort again dm_sort_rows (&r, &mayw, &mustw, &max_row_first); printf ("matrix:\n"); dm_print (stdout, &r); printf ("state mapping:\n"); state_mapping (&r); printf ("transition mapping:\n"); transition_mapping (&r); printf ("dependencies:\n"); dependencies (&r); return 0; }
void SGListExtractOfRank::takeControl( ) { if (freeARCs() > 0){ int min = getParameters().getValue("minRank"); int max = getParameters().getValue("maxRank"); if (arcer.takeControl()){ SMList<Subgroup>* smo = new SMList<Subgroup>(theList.getGroup(), arcer.getData(), Text("Subgroups of rank from ") + Text(Chars(min)+Chars(" to ")+Chars(max)+ Chars(" in ")) + Name(theList) ); ListOf<OID> dependencies( smo->getGroup() ); CheckinMessage( *smo, "", dependencies ).send(); LogMessage msg( *smo ); msg << Link( Chars("Click here to see the contents of ") + Text( Name( *smo) ), "SGEnumerator", smo->getData().getDataFileName() ); msg << "."; msg.send(); adminTerminate(); return; } else usedOneARC(); } }
// // Reclaim all unused buckets. // void DependencyContext::expunge_stale_entries() { assert_locked_or_safepoint(CodeCache_lock); if (!has_stale_entries()) { assert(!find_stale_entries(), "inconsistent info"); return; } nmethodBucket* first = dependencies(); nmethodBucket* last = NULL; int removed = 0; for (nmethodBucket* b = first; b != NULL;) { assert(b->count() >= 0, "bucket count: %d", b->count()); nmethodBucket* next = b->next(); if (b->count() == 0) { if (last == NULL) { first = next; } else { last->set_next(next); } removed++; delete b; // last stays the same. } else { last = b; } b = next; } set_dependencies(first); set_has_stale_entries(false); if (UsePerfData && removed > 0) { _perf_total_buckets_deallocated_count->inc(removed); _perf_total_buckets_stale_count->dec(removed); } }
void SGListExtractNormal::takeControl( ) { if (freeARCs() > 0){ if (arcer.takeControl()){ SMList<Subgroup>* smo = new SMList<Subgroup>(theList.getGroup(), arcer.getData(), Text("Normal subgroups in ") + Name(theList) ); ListOf<OID> dependencies( smo->getGroup() ); CheckinMessage( *smo, "", dependencies ).send(); LogMessage msg( *smo ); msg << Link( Chars("Click here to see the contents of ") + Text( Name( *smo) ), "SGEnumerator", smo->getData().getDataFileName() ); msg << "."; msg.send(); adminTerminate(); return; } else usedOneARC(); } }
// // Add an nmethod to the dependency context. // It's possible that an nmethod has multiple dependencies on a klass // so a count is kept for each bucket to guarantee that creation and // deletion of dependencies is consistent. // void DependencyContext::add_dependent_nmethod(nmethod* nm, bool expunge) { assert_lock_strong(CodeCache_lock); for (nmethodBucket* b = dependencies(); b != NULL; b = b->next()) { if (nm == b->get_nmethod()) { b->increment(); return; } } set_dependencies(new nmethodBucket(nm, dependencies())); if (UsePerfData) { _perf_total_buckets_allocated_count->inc(); } if (expunge) { // Remove stale entries from the list. expunge_stale_entries(); } }
void DependencyContext::wipe() { assert_locked_or_safepoint(CodeCache_lock); nmethodBucket* b = dependencies(); set_dependencies(NULL); set_has_stale_entries(false); while (b != NULL) { nmethodBucket* next = b->next(); delete b; b = next; } }
bool DependencyContext::is_dependent_nmethod(nmethod* nm) { for (nmethodBucket* b = dependencies(); b != NULL; b = b->next()) { if (nm == b->get_nmethod()) { #ifdef ASSERT int count = b->count(); assert(count >= 0, "count shouldn't be negative: %d", count); #endif return true; } } return false; }
void send_to_flash(const std::wstring& data) { if (!clock_loaded_) { core::frame_producer_dependencies dependencies( channel_->frame_factory(), channels_, channel_->video_format_desc(), producer_registry_, cg_registry_); cg_registry_ ->get_or_create_proxy(channel_, dependencies, core::cg_proxy::DEFAULT_LAYER, L"hawrysklocka/clock") ->add(0, L"hawrysklocka/clock", true, L"", data); clock_loaded_ = true; } else { cg_registry_->get_proxy(channel_, core::cg_proxy::DEFAULT_LAYER)->update(0, data); } CASPAR_LOG(info) << L"CLK: Clockdata sent: " << data; }
void DependencyContext::print_dependent_nmethods(bool verbose) { int idx = 0; for (nmethodBucket* b = dependencies(); b != NULL; b = b->next()) { nmethod* nm = b->get_nmethod(); tty->print("[%d] count=%d { ", idx++, b->count()); if (!verbose) { nm->print_on(tty, "nmethod"); tty->print_cr(" } "); } else { nm->print(); nm->print_dependencies(); tty->print_cr("--- } "); } } }
void PluginListWidgetItemDelegate::slotAboutClicked() { auto const index = focusedIndex(); auto const model = index.model(); auto info = QString{}; info += tr("Plugin name: %1").arg(model->data(index, PluginModel::NameRole).toString()) + "\n"; auto pluginMetadata = model->data(index, PluginModel::MetadataRole).value<PluginMetadata>(); info += tr("Author: %1").arg(pluginMetadata.author()) + "\n"; info += tr("Version: %1").arg(pluginMetadata.version()) + "\n"; info += tr("Description: %1").arg(pluginMetadata.description()) + "\n"; info += tr("Dependencies: %1").arg(pluginMetadata.dependencies().join(", ")) + "\n"; info += tr("Provides: %1").arg(pluginMetadata.provides()); MessageDialog::show(m_iconsManager->iconByPath(KaduIcon("dialog-information")), tr("Plugin information"), info, QMessageBox::Ok, itemView()); }
// Add a new class loader data node to the list. Assign the newly created // ClassLoaderData into the java/lang/ClassLoader object as a hidden field ClassLoaderData* ClassLoaderDataGraph::add(Handle loader, bool is_anonymous, TRAPS) { // We need to allocate all the oops for the ClassLoaderData before allocating the // actual ClassLoaderData object. ClassLoaderData::Dependencies dependencies(CHECK_NULL); No_Safepoint_Verifier no_safepoints; // we mustn't GC until we've installed the // ClassLoaderData in the graph since the CLD // contains unhandled oops ClassLoaderData* cld = new ClassLoaderData(loader, is_anonymous, dependencies); if (!is_anonymous) { ClassLoaderData** cld_addr = java_lang_ClassLoader::loader_data_addr(loader()); // First, Atomically set it ClassLoaderData* old = (ClassLoaderData*) Atomic::cmpxchg_ptr(cld, cld_addr, NULL); if (old != NULL) { delete cld; // Returns the data. return old; } } // We won the race, and therefore the task of adding the data to the list of // class loader data ClassLoaderData** list_head = &_head; ClassLoaderData* next = _head; do { cld->set_next(next); ClassLoaderData* exchanged = (ClassLoaderData*)Atomic::cmpxchg_ptr(cld, list_head, next); if (exchanged == next) { if (TraceClassLoaderData) { ResourceMark rm; tty->print("[ClassLoaderData: "); tty->print("create class loader data " INTPTR_FORMAT, p2i(cld)); tty->print(" for instance " INTPTR_FORMAT " of %s", p2i((void *)cld->class_loader()), cld->loader_name()); tty->print_cr("]"); } return cld; } next = exchanged; } while (true); }
DependenciesSolvingResult ComponentInstaller::tryToInstall(const QStringList &componentNames) { deleteComponents(); // Add existed componens to resolve componens for install IComponentDependenciesPtr dependencies(createDependencies()); for (IComponent *comp : m_existedComponents) dependencies->addComponent(comp); QList<IComponent *> discoveredComponents = discoverComponents(); // Select components to install from the all discovered components QList<IComponent *> toInstall; for (IComponent *comp : discoveredComponents) { dependencies->addComponent(comp); if (componentNames.contains(comp->name())) toInstall.push_back(comp); } // Find all parents for components to install DependenciesSolvingResult result = dependencies->completeListWithChildren(toInstall); if (!result.orphans().isEmpty()) { qDeleteAll(toInstall); return result; } // Return only components that have to be installed for (IComponent *comp : result.ordered()) { if (toInstall.contains(comp)) continue; if (discoveredComponents.contains(comp)) toInstall.push_back(comp); } // Delete unused components for (IComponent *comp : discoveredComponents) { if (!toInstall.contains(comp)) delete comp; } m_componentsToInstall = toInstall; return DependenciesSolvingResult(m_componentsToInstall); }
// // Remove an nmethod dependency from the context. // Decrement count of the nmethod in the dependency list and, optionally, remove // the bucket completely when the count goes to 0. This method must find // a corresponding bucket otherwise there's a bug in the recording of dependencies. // Can be called concurrently by parallel GC threads. // void DependencyContext::remove_dependent_nmethod(nmethod* nm, bool expunge) { assert_locked_or_safepoint(CodeCache_lock); nmethodBucket* first = dependencies(); nmethodBucket* last = NULL; for (nmethodBucket* b = first; b != NULL; b = b->next()) { if (nm == b->get_nmethod()) { int val = b->decrement(); guarantee(val >= 0, "Underflow: %d", val); if (val == 0) { if (expunge) { if (last == NULL) { set_dependencies(b->next()); } else { last->set_next(b->next()); } delete b; if (UsePerfData) { _perf_total_buckets_deallocated_count->inc(); } } else { // Mark the context as having stale entries, since it is not safe to // expunge the list right now. set_has_stale_entries(true); if (UsePerfData) { _perf_total_buckets_stale_count->inc(); _perf_total_buckets_stale_acc_count->inc(); } } } if (expunge) { // Remove stale entries from the list. expunge_stale_entries(); } return; } last = b; } #ifdef ASSERT tty->print_raw_cr("### can't find dependent nmethod"); nm->print(); #endif // ASSERT ShouldNotReachHere(); }
// // Walk the list of dependent nmethods searching for nmethods which // are dependent on the changes that were passed in and mark them for // deoptimization. Returns the number of nmethods found. // int DependencyContext::mark_dependent_nmethods(DepChange& changes) { int found = 0; for (nmethodBucket* b = dependencies(); b != NULL; b = b->next()) { nmethod* nm = b->get_nmethod(); // since dependencies aren't removed until an nmethod becomes a zombie, // the dependency list may contain nmethods which aren't alive. if (b->count() > 0 && nm->is_alive() && !nm->is_marked_for_deoptimization() && nm->check_dependency_on(changes)) { if (TraceDependencies) { ResourceMark rm; tty->print_cr("Marked for deoptimization"); changes.print(); nm->print(); nm->print_dependencies(); } changes.mark_for_deoptimization(nm); found++; } } return found; }
package* load_package(std::string path) { extract_archive(path, std::string("./temp/")); package* pkg = new package; std::ifstream description("./temp/DESCRIPTION"); std::getline(description, pkg->description); // licencja może być wielolinijkowa, póki co nie jest to obsługiwane std::ifstream licence("./temp/LICENCE"); std::getline(licence, pkg->licence); std::ifstream version("./temp/VERSION"); std::getline(version, pkg->version); std::ifstream name("./temp/NAME"); std::getline(name, pkg->name); std::ifstream dependencies("./temp/DEPENDENCIES"); std::string dep; while(std::getline(dependencies, dep)) pkg->dependencies.push_back(dep); std::ifstream files("./temp/INSTALL"); std::string ins; while(std::getline(files, ins)) { std::string::iterator eq_sign = std::find(ins.begin(), ins.end(), '='); std::string::iterator eq_sign_min1 = eq_sign - 1; std::string::iterator eq_sign_plus2 = eq_sign + 2; std::string file = std::string(ins.begin(), eq_sign_min1); std::string destination = std::string(eq_sign_plus2, ins.end()); pkg->files.push_back(make_pair(file, destination)); } return pkg; }
// // Invalidate all dependencies in the context int DependencyContext::remove_all_dependents() { assert_locked_or_safepoint(CodeCache_lock); nmethodBucket* b = dependencies(); set_dependencies(NULL); int marked = 0; int removed = 0; while (b != NULL) { nmethod* nm = b->get_nmethod(); if (b->count() > 0 && nm->is_alive() && !nm->is_marked_for_deoptimization()) { nm->mark_for_deoptimization(); marked++; } nmethodBucket* next = b->next(); removed++; delete b; b = next; } set_has_stale_entries(false); if (UsePerfData && removed > 0) { _perf_total_buckets_deallocated_count->inc(removed); } return marked; }
void AnalysisScheduler::runAnalysisWithDependencies(Analysis *analysis, Program *program) { // First, run the dependencies recursively. std::vector<Analysis *> &deps = dependencies(analysis); std::vector<Analysis *>::iterator d; for (d = deps.begin(); d != deps.end(); ++d) { TimingPerformance timer("Run of dependency " + (*d)->identifier() + ":"); runAnalysisWithDependencies(*d, program); } // Finally, run the argument analysis itself, if necessary. std::pair<Analysis *, Program *> entry = std::make_pair(analysis, program); if (p_impl->runHistory.find(entry) == p_impl->runHistory.end()) { TimingPerformance timer("Run of analysis " + analysis->identifier() + ":"); analysis->run(program); } }
bool BinaryDependenciesLdd::findDependencies(const QString& binaryFilePath) { Console::info(2) << " searching dependencies for " << binaryFilePath; LddWrapper ldd; if(!ldd.execFindDependencies(binaryFilePath)){ setLastError(ldd.lastError()); return false; } LddDependenciesParser parser; if( !parser.parse( ldd.readAllStandardOutputString() ) ){ const QString msg = tr("Parsing ldd output for file '%1' failed.").arg(binaryFilePath); auto error = mdtErrorNewQ(msg, Mdt::Error::Critical, this); setLastError(error); return false; } auto list = parser.rawDependencies(); fillAndSetDependencies(list); if(!mNotFoundDependencies.isEmpty()){ const QString msg = tr("Some dependencies have not been found for file '%1': %2") .arg( binaryFilePath, stringRecordListToStringNameList(mNotFoundDependencies).join(", ") ); auto error = mdtErrorNewQ(msg, Mdt::Error::Critical, this); setLastError(error); return false; } if(Console::level() >= 3){ Console::info(3) << " found dependencies:"; for(const auto & library : dependencies() ){ Console::info(3) << " " << library.libraryName().fullName(); } } return true; }
// Compute the dependencies of a given event. Returns a list of (thread,kind,event) triples. vector<Tuple<int,int,history_t>> event_dependencies(const vector<vector<Array<const history_t>>>& event_sorted_history, const int direction, const int thread, const int kind, const history_t source) { vector<Tuple<int,int,history_t>> deps; for (const auto kind_event : dependencies(direction,time_kind_t(kind),source.event)) { const int dep_kind = kind_event.x; const event_t dep_event = kind_event.y; // Search for event in each thread bool found = false; for (const int t : range((int)event_sorted_history.size())) { const auto& sorted_events = event_sorted_history.at(t).at(dep_kind); for (const int i : range(find_event(sorted_events,dep_event),sorted_events.size())) { const history_t& event = sorted_events[i]; if (event.event != dep_event) break; GEODE_ASSERT(!found || dep_kind==compute_kind); found = true; deps.push_back(tuple(t,dep_kind,event)); } } if (!found) { int count = 0; for (const int t : range((int)event_sorted_history.size())) { const auto& events = event_sorted_history[t].at(dep_kind); for (const int i : range(max(0,events.size()-1))) if (events[i].event > events[i+1].event) THROW(RuntimeError,"event_dependencies: order failure: thread %d, kind %d, i %d (%d), events %lld %lld",t,dep_kind,i,events.size(),events[i].event,events[i+1].event); for (auto& e : events) if (e.event==dep_event) count++; } THROW(RuntimeError,"event_dependencies: dependency not found, direction = %d, count %d, source = %d %s %s, dependency = %s %s", direction,count, thread,time_kind_names().at(kind),str_event(source.event), time_kind_names().at(dep_kind),str_event(dep_event)); } } return deps; }
dogen::formatters::artefact stitch_formatter:: format(const artefact_formatter_interface& stock_formatter, const context& ctx, const yarn::element& e) const { const auto al(stock_formatter.archetype_location()); const auto needs_guard(is_header(stock_formatter.inclusion_support_type())); const auto id(e.name().id()); assistant a(ctx, al, needs_guard, id); const auto& fp(a.artefact_properties().file_path()); auto stitch_template(fp); stitch_template.replace_extension(stitch_extension); /* * If the template does not yet exist, we should just create an * empty artefact. * * This scenario happens when creating a new model or when adding * a new artefact formatter for the first time. */ if (!boost::filesystem::exists(stitch_template)) { BOOST_LOG_SEV(lg, debug) << "Stitch template not found: " << fp.generic_string(); dogen::formatters::artefact r; r.overwrite(a.artefact_properties().overwrite()); return r; } /* * Since the template exists, we can instantiate it. */ auto r(instantiator_.instantiate(stitch_template)); r.overwrite(a.artefact_properties().overwrite()); r.dependencies().push_back(stitch_template); return r; }
bool DependencyContext::find_stale_entries() { for (nmethodBucket* b = dependencies(); b != NULL; b = b->next()) { if (b->count() == 0) return true; } return false; }
std::string tokenpaths::functors(const std::map<std::string,std::map<std::string,std::string> >& functors_of_words,const std::map<std::string,std::vector<lexicon> >& words_analyses,const unsigned int& id_index,std::string& related_semantics){ std::set<std::string> functor_ids_of_words,functor_ids_of_dependencies; std::map<std::pair<std::string,std::string>,std::string> functor_dkey_id_of_dependencies; std::string functors; std::vector<std::pair<std::pair<std::string,std::string>,std::string> > functor_dkey_ids; for(auto&& word_functors:functors_of_words){ std::set<query_result *> functor_dependencies; auto word_analyses=words_analyses.find(word_functors.first); for(auto&& word:word_analyses->second){ if(word.dependencies!=NULL) functor_dependencies.insert(word.dependencies); } for(auto&& functor:word_functors.second){ auto&& functor_inserted=functor_ids_of_words.insert(functor.first); if(functor_inserted.second==true){ functors+="{"; functors+="\"functor id\":\""+functor.first+"\","; functors+="\"definition\":\""+functor.second+"\""; if(functor_dependencies.empty()==false){ functors+=",\"dependencies\":["; for(auto&& dependency:functor_dependencies){ functors+=dependencies(*dependency,functor_dkey_id_of_dependencies); } if(functors.back()==',') functors.pop_back(); functors+="]"; } functors+="},"; } } } for(auto&& functor:functor_dkey_id_of_dependencies){ //convert the map into a vector so that new elements can be added //to the end of it while iterating over itself functor_dkey_ids.push_back(functor); } unsigned int id=id_index; db *sqlite=db_factory::get_instance(); for(unsigned int i=0;i<functor_dkey_ids.size();++i){ auto functor=functor_dkey_ids[i];//keep this variable as copy, as reference it'd get invalidated due to the functor_dkey_ids.push_back() within the loop if(functor_ids_of_words.find(functor.second)==functor_ids_of_words.end() &&functor_ids_of_dependencies.find(functor.second)==functor_ids_of_dependencies.end()){ functor_ids_of_dependencies.insert(functor.second); query_result *functor_def_entry=sqlite->exec_sql("SELECT * FROM FUNCTOR_DEFS WHERE FUNCTOR_ID = '"+functor.second+"';"); if(functor_def_entry==NULL){ throw std::runtime_error("No entries found for functor id "+functor.second+" in FUNCTOR_DEFS db table."); } const std::string functor_def=*functor_def_entry->field_value_at_row_position(0,"definition"); functors+="{"; functors+="\"functor id\":\""+functor.second+"\","; functors+="\"definition\":\""+transgraph::apply_json_escapes(functor_def)+"\""; query_result *functor_dependencies=lexer::dependencies_read_for_functor(functor.first.first); if(functor_dependencies!=NULL){ functors+=",\"dependencies\":["; std::map<std::pair<std::string,std::string>,std::string> new_functor_dkeys_ids; functors+=dependencies(*functor_dependencies,new_functor_dkeys_ids); for(auto&& new_functor:new_functor_dkeys_ids){ if(functor_ids_of_words.find(new_functor.second)==functor_ids_of_words.end() &&functor_ids_of_dependencies.find(new_functor.second)==functor_ids_of_dependencies.end()){ functor_dkey_ids.push_back(new_functor); } } if(functors.back()==',') functors.pop_back(); functors+="]"; } functors+="},"; ++id; related_semantics+="{"; related_semantics+="\"id\":\""+std::to_string(id)+"\","; related_semantics+="\"functor\":\""+functor.first.first+"\","; related_semantics+="\"d_key\":\""+functor.first.second+"\","; related_semantics+="\"functor id\":\""+functor.second+"\""; related_semantics+="},"; } } return functors; }
HResource Resources::loadInternal(const String& UUID, const Path& filePath, bool synchronous, bool loadDependencies, bool keepInternalReference) { HResource outputResource; bool alreadyLoading = false; bool loadInProgress = false; { // Check if resource is already being loaded on a worker thread Lock inProgressLock(mInProgressResourcesMutex); auto iterFind2 = mInProgressResources.find(UUID); if (iterFind2 != mInProgressResources.end()) { LoadedResourceData& resData = iterFind2->second->resData; outputResource = resData.resource.lock(); if (keepInternalReference) { resData.numInternalRefs++; outputResource.addInternalRef(); } alreadyLoading = true; loadInProgress = true; } // Previously being loaded as async but now we want it synced, so we wait if (loadInProgress && synchronous) outputResource.blockUntilLoaded(); if (!alreadyLoading) { Lock loadedLock(mLoadedResourceMutex); auto iterFind = mLoadedResources.find(UUID); if (iterFind != mLoadedResources.end()) // Resource is already loaded { LoadedResourceData& resData = iterFind->second; outputResource = resData.resource.lock(); if (keepInternalReference) { resData.numInternalRefs++; outputResource.addInternalRef(); } alreadyLoading = true; } } } // Not loaded and not in progress, start loading of new resource // (or if already loaded or in progress, load any dependencies) if (!alreadyLoading) { // Check if the handle already exists Lock lock(mLoadedResourceMutex); auto iterFind = mHandles.find(UUID); if (iterFind != mHandles.end()) outputResource = iterFind->second.lock(); else { outputResource = HResource(UUID); mHandles[UUID] = outputResource.getWeak(); } } // We have nowhere to load from, warn and complete load if a file path was provided, // otherwise pass through as we might just want to load from memory. if (filePath.isEmpty()) { if (!alreadyLoading) { LOGWRN_VERBOSE("Cannot load resource. Resource with UUID '" + UUID + "' doesn't exist."); // Complete the load as that the depedency counter is properly reduced, in case this // is a dependency of some other resource. loadComplete(outputResource); return outputResource; } } else if (!FileSystem::isFile(filePath)) { LOGWRN_VERBOSE("Cannot load resource. Specified file: " + filePath.toString() + " doesn't exist."); // Complete the load as that the depedency counter is properly reduced, in case this // is a dependency of some other resource. loadComplete(outputResource); assert(!loadInProgress); // Resource already being loaded but we can't find its path now? return outputResource; } // Load dependency data if a file path is provided SPtr<SavedResourceData> savedResourceData; if (!filePath.isEmpty()) { FileDecoder fs(filePath); savedResourceData = std::static_pointer_cast<SavedResourceData>(fs.decode()); } // If already loading keep the old load operation active, otherwise create a new one if (!alreadyLoading) { { Lock lock(mInProgressResourcesMutex); ResourceLoadData* loadData = bs_new<ResourceLoadData>(outputResource.getWeak(), 0); mInProgressResources[UUID] = loadData; loadData->resData = outputResource.getWeak(); if (keepInternalReference) { loadData->resData.numInternalRefs++; outputResource.addInternalRef(); } loadData->remainingDependencies = 1; loadData->notifyImmediately = synchronous; // Make resource listener trigger before exit if loading synchronously // Register dependencies and count them so we know when the resource is fully loaded if (loadDependencies && savedResourceData != nullptr) { for (auto& dependency : savedResourceData->getDependencies()) { if (dependency != UUID) { mDependantLoads[dependency].push_back(loadData); loadData->remainingDependencies++; } } } } if (loadDependencies && savedResourceData != nullptr) { const Vector<String>& dependencyUUIDs = savedResourceData->getDependencies(); UINT32 numDependencies = (UINT32)dependencyUUIDs.size(); Vector<HResource> dependencies(numDependencies); for (UINT32 i = 0; i < numDependencies; i++) dependencies[i] = loadFromUUID(dependencyUUIDs[i], !synchronous, true, false); // Keep dependencies alive until the parent is done loading { Lock lock(mInProgressResourcesMutex); // At this point the resource is guaranteed to still be in-progress, so it's safe to update its dependency list mInProgressResources[UUID]->dependencies = dependencies; } } } else if (loadDependencies && savedResourceData != nullptr) // Queue dependencies in case they aren't already loaded { const Vector<String>& dependencies = savedResourceData->getDependencies(); if (!dependencies.empty()) { { Lock lock(mInProgressResourcesMutex); ResourceLoadData* loadData = nullptr; auto iterFind = mInProgressResources.find(UUID); if (iterFind == mInProgressResources.end()) // Fully loaded { loadData = bs_new<ResourceLoadData>(outputResource.getWeak(), 0); loadData->resData = outputResource.getWeak(); loadData->remainingDependencies = 0; loadData->notifyImmediately = synchronous; // Make resource listener trigger before exit if loading synchronously mInProgressResources[UUID] = loadData; } else { loadData = iterFind->second; } // Register dependencies and count them so we know when the resource is fully loaded for (auto& dependency : dependencies) { if (dependency != UUID) { bool registerDependency = true; auto iterFind2 = mDependantLoads.find(dependency); if (iterFind2 != mDependantLoads.end()) { Vector<ResourceLoadData*>& dependantData = iterFind2->second; auto iterFind3 = std::find_if(dependantData.begin(), dependantData.end(), [&](ResourceLoadData* x) { return x->resData.resource.getUUID() == outputResource.getUUID(); }); registerDependency = iterFind3 == dependantData.end(); } if (registerDependency) { mDependantLoads[dependency].push_back(loadData); loadData->remainingDependencies++; loadData->dependencies.push_back(_getResourceHandle(dependency)); } } } } for (auto& dependency : dependencies) loadFromUUID(dependency, !synchronous, true, false); } } // Actually start the file read operation if not already loaded or in progress if (!alreadyLoading && !filePath.isEmpty()) { // Synchronous or the resource doesn't support async, read the file immediately if (synchronous || !savedResourceData->allowAsyncLoading()) { loadCallback(filePath, outputResource); } else // Asynchronous, read the file on a worker thread { String fileName = filePath.getFilename(); String taskName = "Resource load: " + fileName; SPtr<Task> task = Task::create(taskName, std::bind(&Resources::loadCallback, this, filePath, outputResource)); TaskScheduler::instance().addTask(task); } } else // File already loaded or in progress { // Complete the load unless its in progress in which case we wait for its worker thread to complete it. // In case file is already loaded this will only decrement dependency count in case this resource is a dependency. if (!loadInProgress) loadComplete(outputResource); else { // In case loading finished in the meantime we cannot be sure at what point ::loadComplete was triggered, // so trigger it manually so that the dependency count is properly decremented in case this resource // is a dependency. Lock lock(mLoadedResourceMutex); auto iterFind = mLoadedResources.find(UUID); if (iterFind != mLoadedResources.end()) loadComplete(outputResource); } } return outputResource; }
void jacobi( crs_matrix<double> const & A , std::vector<double> const & b , std::size_t iterations , std::size_t block_size ) { typedef std::vector<double> vector_type; boost::shared_ptr<vector_type> dst(new vector_type(b)); boost::shared_ptr<vector_type> src(new vector_type(b)); std::vector<range> block_ranges; // pre-computing ranges for the different blocks for(std::size_t i = 0; i < dst->size(); i += block_size) { block_ranges.push_back( range(i, std::min<std::size_t>(dst->size(), i + block_size))); } // pre-computing dependencies std::vector<std::vector<std::size_t> > dependencies(block_ranges.size()); for(std::size_t b = 0; b < block_ranges.size(); ++b) { for(std::size_t i = block_ranges[b].begin(); i < block_ranges[b].end(); ++i) { std::size_t begin = A.row_begin(i); std::size_t end = A.row_end(i); for(std::size_t ii = begin; ii < end; ++ii) { std::size_t idx = A.indices[ii]; for(std::size_t j = 0; j < block_ranges.size(); ++j) { if(block_ranges[j].begin() <= idx && idx < block_ranges[j].end()) { if(std::find(dependencies[b].begin(), dependencies[b].end(), j) == dependencies[b].end()) { dependencies[b].push_back(j); } break; } } } } } typedef std::vector<hpx::shared_future<void> > future_vector; boost::shared_ptr<future_vector> deps_dst(new future_vector(dependencies.size(), hpx::make_ready_future())); boost::shared_ptr<future_vector> deps_src(new future_vector(dependencies.size(), hpx::make_ready_future())); hpx::util::high_resolution_timer t; for(std::size_t iter = 0; iter < iterations; ++iter) { for(std::size_t block = 0; block < block_ranges.size(); ++block) { std::vector<std::size_t> const & deps(dependencies[block]); std::vector<hpx::shared_future<void> > trigger; trigger.reserve(deps.size()); for (std::size_t dep : deps) { trigger.push_back((*deps_src)[dep]); } (*deps_dst)[block] = hpx::when_all(boost::move(trigger)).then( hpx::launch::async, hpx::util::bind( jacobi_kernel_wrap , block_ranges[block] , boost::cref(A) , boost::ref(*dst) , boost::cref(*src) , boost::cref(b) ) ); } std::swap(dst, src); std::swap(deps_dst, deps_src); } hpx::wait_all(*deps_dst); hpx::wait_all(*deps_src); double time_elapsed = t.elapsed(); std::cout << dst->size() << " " << ((double(dst->size() * iterations)/1e6)/time_elapsed) << " MLUPS/s\n" << std::flush; }
string getDBStructure() { return "----------------------------------------------------------------------\n\ --\n\ -- MOPSLinux package system\n\ -- Database creation script\n\ -- $Id: dbstruct.cpp,v 1.3 2007/11/02 20:19:45 i27249 Exp $\n\ --\n\ ----------------------------------------------------------------------\n\ \n\ create table packages (\n\ package_id INTEGER PRIMARY KEY AUTOINCREMENT UNIQUE,\n\ package_name TEXT NOT NULL,\n\ package_version TEXT NOT NULL,\n\ package_arch TEXT NOT NULL,\n\ package_build TEXT NULL,\n\ package_compressed_size TEXT NOT NULL,\n\ package_installed_size TEXT NOT NULL,\n\ package_short_description TEXT NULL,\n\ package_description TEXT NULL, \n\ package_changelog TEXT NULL,\n\ package_packager TEXT NULL,\n\ package_packager_email TEXT NULL,\n\ package_installed INTEGER NOT NULL,\n\ package_configexist INTEGER NOT NULL,\n\ package_action INTEGER NOT NULL,\n\ package_md5 TEXT NOT NULL,\n\ package_filename TEXT NOT NULL,\n\ package_betarelease TEXT NOT NULL,\n\ package_installed_by_dependency INTEGER NOT NULL DEFAULT '0',\n\ package_type INTEGER NOT NULL DEFAULT '0'\n\ );\n\ create index ppname on packages (package_id, package_name, package_version, package_action, package_installed, package_md5);\n\ \n\ create table files (\n\ file_id INTEGER PRIMARY KEY AUTOINCREMENT UNIQUE,\n\ file_name TEXT NOT NULL,\n\ file_type INTEGER NOT NULL,\n\ packages_package_id INTEGER NOT NULL\n\ );\n\ create index pname on files (file_name, packages_package_id);\n\ \n\ create table conflicts (\n\ conflict_id INTEGER PRIMARY KEY AUTOINCREMENT UNIQUE,\n\ conflict_file_name TEXT NOT NULL,\n\ backup_file TEXT NOT NULL,\n\ conflicted_package_id INTEGER NOT NULL\n\ );\n\ \n\ create table locations (\n\ location_id INTEGER PRIMARY KEY AUTOINCREMENT UNIQUE,\n\ packages_package_id INTEGER NOT NULL,\n\ server_url TEXT NOT NULL,\n\ location_path TEXT NOT NULL\n\ );\n\ create index locpid on locations(packages_package_id, location_path, server_url);\n\ create table tags (\n\ tags_id INTEGER PRIMARY KEY AUTOINCREMENT UNIQUE,\n\ tags_name TEXT NOT NULL\n\ );\n\ create index ptag on tags (tags_id, tags_name);\n\ \n\ create table tags_links (\n\ tags_link_id INTEGER PRIMARY KEY AUTOINCREMENT UNIQUE,\n\ packages_package_id INTEGER NOT NULL,\n\ tags_tag_id INTEGER NOT NULL\n\ );\n\ create index ptaglink on tags_links (packages_package_id, tags_tag_id);\n\ \n\ create table dependencies (\n\ dependency_id INTEGER PRIMARY KEY AUTOINCREMENT UNIQUE,\n\ packages_package_id INTEGER NOT NULL,\n\ dependency_condition INTEGER NOT NULL DEFAULT '1',\n\ dependency_type INTEGER NOT NULL DEFAULT '1',\n\ dependency_package_name TEXT NOT NULL,\n\ dependency_package_version TEXT NULL,\n\ dependency_build_only INTEGER NOT NULL DEFAULT '0' \ );\n\ \n\ create index pdeps on dependencies (packages_package_id, dependency_id, dependency_package_name, dependency_package_version, dependency_condition);\n\ \n\ -- INTERNATIONAL SUPPORT\n\ \n\ --create table descriptions (\n\ -- description_id INTEGER PRIMARY KEY AUTOINCREMENT UNIQUE,\n\ -- packages_package_id INTEGER NOT NULL,\n\ -- description_language TEXT NOT NULL,\n\ -- description_text TEXT NOT NULL,\n\ -- short_description_text TEXT NOT NULL\n\ --);\n\ \n\ --create table changelogs (\n\ -- changelog_id INTEGER PRIMARY KEY AUTOINCREMENT UNIQUE,\n\ -- packages_package_id INTEGER NOT NULL,\n\ -- changelog_language TEXT NOT NULL,\n\ -- changelog_text TEXT NOT NULL\n\ --);\n\ \n\ -- RATING SYSTEM - SUPPORT FOR FUTURE\n\ --create table ratings (\n\ -- rating_id INTEGER PRIMARY KEY AUTOINCREMENT UNIQUE,\n\ -- rating_value INTEGER NOT NULL,\n\ -- packages_package_name TEXT NOT NULL\n\ --);\n\ "; }
void ParanoidSolver::postConstraints(void) { provides(*this,install_,provides_,virtuals_); dependencies(*this,install_,deps_); conflicts(*this,install_,conflicts_); }