void ConnectedModules::addModule(const ModuleDescriptor& md, ConnectedModule* module) { Lock l(m_modulesMutex); // Store modules including identifier. stringstream sstr; sstr << md.getName() << "-" << md.getIdentifier(); const string s = sstr.str(); m_modules[s] = module; }
void ConnectedModules::removeModule(const ModuleDescriptor& md) { Lock l(m_modulesMutex); // Remove module including identifier. stringstream sstr; sstr << md.getName() << "-" << md.getIdentifier(); const string s = sstr.str(); m_modules.erase(s); }
bool ConnectedModules::hasModule(const ModuleDescriptor& md) { Lock l(m_modulesMutex); // Find module including identifier. stringstream sstr; sstr << md.getName() << "-" << md.getIdentifier(); const string s = sstr.str(); return (m_modules.count(s) != 0); }
GMAC_API void APICALL __cudaRegisterTexture(void **fatCubinHandle, const struct textureReference *hostVar, const void ** /*deviceAddress*/, const char *deviceName, int /*dim*/, int /*norm*/, int /*ext*/) { TRACE(GLOBAL, "CUDA Texture"); ModuleDescriptor *mod = (ModuleDescriptor *)fatCubinHandle; ASSERTION(mod != NULL); enterGmac(); TextureDescriptor t = __impl::cuda::hpe::TextureDescriptor(deviceName, hostVar); mod->add(t); exitGmac(); }
const char *ModuleDescriptor::GetName(uint16_t cid, uint16_t id) { noname[0] = 0; ModuleDescriptor *m = ModuleDescriptor::Config[cid][id]; if (m == NULL) { return noname; } else { return m->getName(); } }
GMAC_API void APICALL __cudaRegisterVar(void **fatCubinHandle, char *hostVar, char * deviceAddress, const char *deviceName, int /*ext*/, int /*size*/, int constant, int /*global*/) { TRACE(GLOBAL, "CUDA Variable %s: %p", deviceName, deviceAddress); ModuleDescriptor *mod = (ModuleDescriptor *)fatCubinHandle; ASSERTION(mod != NULL); enterGmac(); VariableDescriptor v = __impl::cuda::hpe::VariableDescriptor(deviceName, hostVar, bool(constant != 0)); mod->add(v); exitGmac(); }
GMAC_API void APICALL __cudaRegisterFunction( void **fatCubinHandle, const char *hostFun, char * /*devFun*/, const char *devName, int /*threadLimit*/, uint3 * /*tid*/, uint3 * /*bid*/, dim3 * /*bDim*/, dim3 * /*gDim*/) { TRACE(GLOBAL, "CUDA Function"); ModuleDescriptor *mod = (ModuleDescriptor *)fatCubinHandle; ASSERTION(mod != NULL); enterGmac(); KernelDescriptor k = __impl::core::hpe::KernelDescriptor(devName, (gmac_kernel_id_t) hostFun); mod->add(k); exitGmac(); }
void EdgeKiller::onModuleUnload( S2EExecutionState* state, const ModuleDescriptor &module ) { DECLARE_PLUGINSTATE(EdgeKillerState, state); //Remove all the polling entries that belong to the module EdgeKillerState::EdgeEntries &entries = plgState->getEntries(); EdgeKillerState::EdgeEntries::iterator it1, it2; it1 = entries.begin(); while(it1 != entries.end()) { const EdgeKillerState::Edge &e = *it1; if (module.Contains(e.source)) { it2 = it1; ++it2; entries.erase(it1); it1 = it2; }else { ++it1; } } }
KeyValueConfiguration GlobalConfigurationProvider::getConfiguration(const ModuleDescriptor& md) { Lock l(m_configurationMutex); if ( (md.getName() == "Monitor") || (md.getName() == "Cockpit") ) { return m_configuration; } // Determine subset of configuration for this client. KeyValueConfiguration globalConfiguration = m_configuration.getSubsetForSection("global."); stringstream module; module << md.getName() << "."; KeyValueConfiguration privateConfigurationBasedOnModuleName = m_configuration.getSubsetForSection(module.str()); KeyValueConfiguration privateConfigurationBasedOnModuleIdentifier; if (md.getIdentifier() != "") { stringstream moduleIdentifier; moduleIdentifier << md.getName() << ":" << md.getIdentifier() << "."; KeyValueConfiguration privateConfigurationBasedOnModuleIdentiferIncludingModuleIdentifier; privateConfigurationBasedOnModuleIdentiferIncludingModuleIdentifier = m_configuration.getSubsetForSection(moduleIdentifier.str()); // Remove string ":" + md.getIdentifier(). const vector<string> keys = privateConfigurationBasedOnModuleIdentiferIncludingModuleIdentifier.getListOfKeys(); vector<string>::const_iterator it = keys.begin(); stringstream moduleIdentifierPart; moduleIdentifierPart << ":" << md.getIdentifier() << "."; stringstream sstrPrivateConfigurationWithoutModuleIdentifier; while (it != keys.end()) { string key = (*it++); stringstream modifiedKey; modifiedKey << key.substr(0, key.find(moduleIdentifierPart.str())) << "." << key.substr(key.find(moduleIdentifierPart.str()) + moduleIdentifierPart.str().length()); sstrPrivateConfigurationWithoutModuleIdentifier << modifiedKey.str() << "=" << privateConfigurationBasedOnModuleIdentiferIncludingModuleIdentifier.getValue<string>(key) << endl; } if (sstrPrivateConfigurationWithoutModuleIdentifier.str().length() > 0) { privateConfigurationBasedOnModuleIdentifier.readFrom(sstrPrivateConfigurationWithoutModuleIdentifier); } } // Prepare configuration. stringstream configurationForClient; globalConfiguration.writeTo(configurationForClient); configurationForClient << endl; privateConfigurationBasedOnModuleName.writeTo(configurationForClient); configurationForClient << endl; privateConfigurationBasedOnModuleIdentifier.writeTo(configurationForClient); configurationForClient << endl; KeyValueConfiguration clientKeyValueConfiguration; clientKeyValueConfiguration.readFrom(configurationForClient); // Set up configuration object. return clientKeyValueConfiguration; }
void SuperComponent::handleChangeState(const ModuleDescriptor& md, const coredata::dmcp::ModuleStateMessage::ModuleState &ms) { string state; switch (ms) { case coredata::dmcp::ModuleStateMessage::NOT_RUNNING: state = "NOT_RUNNING"; break; case coredata::dmcp::ModuleStateMessage::RUNNING: state = "RUNNING"; break; case coredata::dmcp::ModuleStateMessage::UNDEFINED_STATE: state = "UNDEFINED_STATE"; break; } CLOG1 << "[odsupercomponent]: Module " << md.toString() << " changed state to " << state << endl; if (m_modules.hasModule(md)) { m_modules.getModule(md)->setState(ms); } }
void ModuleDescriptor::Init(uint8_t hostID) { ModuleDescriptor *md; for (uint32_t i = 0; i < ModuleDescriptor::Config.count(); i++) // resolve host names into NID for (uint32_t j = 0; j < ModuleDescriptor::Config[i].count(); j++) { Node::Get()->trace(Node::EXECUTION) << "> Info: Module init '" << ModuleDescriptor::Config[i][j]->getName() << "' for host '" << ModuleDescriptor::Config[i][j]->hostName << "'" << std::endl; if (stricmp(ModuleDescriptor::Config[i][j]->hostName, Node::Get()->name()) == 0 || stricmp(ModuleDescriptor::Config[i][j]->hostName, "local") == 0) { md = ModuleDescriptor::Config[i][j]; ModuleDescriptor::Main[hostID][i][j] = md; md->hostID = hostID; md->applyInitialProjections(hostID); if (md->module != NULL) { md->module->_start(); } ModuleDescriptor::Config[i][j] = NULL; } } }
void FunctionMonitorState::disconnect(const ModuleDescriptor &desc, CallDescriptorsMap &descMap) { CallDescriptorsMap::iterator it = descMap.begin(); while (it != descMap.end()) { uint64_t addr = (*it).first; const CallDescriptor &call = (*it).second; if (desc.Contains(addr) && desc.Pid == call.pid) { CallDescriptorsMap::iterator it2 = it; ++it; descMap.erase(it2); }else { ++it; } } }
void SuperComponent::handleConnectionLost(const ModuleDescriptor& md) { // This methods is called when a module terminates not properly. if (m_modules.hasModule(md)) { CLOG1 << "[odsupercomponent]: Connection to module " << md.toString() << " lost" << endl; ConnectedModule* module = m_modules.getModule(md); m_modules.removeModule(md); m_shutdownModules.addModule(md, module); } else { if (m_shutdownModules.hasModule(md)) { if (!m_shutdownModules.getModule(md)->hasExitCode()) { clog << "[odsupercomponent]: Something went wrong...lost connection to module " << md.toString(); clog << ", module is in shutdownModule list but has not set an ExitCode." << endl; } } } }
void SuperComponent::handleExitCode(const ModuleDescriptor& md, const coredata::dmcp::ModuleExitCodeMessage::ModuleExitCode &me) { string exitcode; switch (me) { case coredata::dmcp::ModuleExitCodeMessage::OKAY: exitcode = "OKAY"; break; case coredata::dmcp::ModuleExitCodeMessage::EXCEPTION_CAUGHT: exitcode = "EXCEPTION_CAUGHT"; break; case coredata::dmcp::ModuleExitCodeMessage::SERIOUS_ERROR: exitcode = "SERIOUS_ERROR"; break; case coredata::dmcp::ModuleExitCodeMessage::CONNECTION_LOST: exitcode = "CONNECTION_LOST"; break; case coredata::dmcp::ModuleExitCodeMessage::NO_SUPERCOMPONENT: exitcode = "NO_SUPERCOMPONENT"; break; case coredata::dmcp::ModuleExitCodeMessage::UNDEFINED_EXITCODE: exitcode = "UNDEFINED_EXITCODE"; break; } CLOG1 << "[odsupercomponent]: Module " << md.toString() << " shutdown with exitcode " << exitcode << endl; if (m_modules.hasModule(md)) { ConnectedModule* module = m_modules.getModule(md); m_modules.removeModule(md); module->setExitCode(); m_shutdownModules.addModule(md, module); } }
void SuperComponent::handleRuntimeStatistics(const ModuleDescriptor& md, const coredata::dmcp::RuntimeStatistic& rs) { Lock l(m_moduleStatisticsMutex); ModuleStatistic entry(md, rs); m_moduleStatistics.putTo_MapOfModuleStatistics(md.getName(), entry); }
void SuperComponent::handleUnkownContainer(const ModuleDescriptor& md, const Container& container) { CLOG1 << "[odsupercomponent]: Received unknown container " << container.toString() << "from " << md.toString() << endl; }
ModuleDescriptor* ModuleDescriptor::getModule(const std::string& filename, map<string, string>& plugInIds) { DynamicModule* pDynMod = Service<PlugInManagerServices>()->getDynamicModule(filename); if (pDynMod == NULL || !pDynMod->isLoaded()) { return NULL; } // try a new style module first OpticksGetModuleDescriptorType pProcAddr = reinterpret_cast<OpticksGetModuleDescriptorType>(pDynMod->getProcedureAddress("opticks_get_module_descriptor")); if (pProcAddr != NULL) { struct OpticksModuleDescriptor* pDescriptor = pProcAddr(ConnectionManager::instance()); if (pDescriptor != NULL) { VERIFY(pDescriptor->version >= MOD_TWO); #if defined(WIN_API) if (pDescriptor->debug == DEBUG_BOOL) { #endif ModuleDescriptor* pModule = new ModuleDescriptor(pDescriptor->pModuleId); FilenameImp fileObj(filename); pModule->mFileName = fileObj.getFullPathAndName(); pModule->setName(pModule->mFileName); pModule->setDisplayText(filename); FileFinderImp find; find.findFile(fileObj.getPath(), fileObj.getFileName()); find.findNextFile(); pModule->mFileSize = find.getLength(); find.getLastModificationTime(pModule->mFileDate); pModule->mDescription = ""; pModule->mpModule = pDynMod; pModule->mModuleVersion = pDescriptor->version; pModule->mInstantiateSymbol = pDescriptor->pInstantiateSymbol; pModule->mCanCache = false; if (pDescriptor->version >= MOD_THREE) { pModule->mCanCache = pDescriptor->cacheable; } pModule->initializePlugInInformation(plugInIds); // pDescriptor is no longer valid at this point return pModule; #if defined(WIN_API) } else { std::string errorMessage("Error loading plug-in from PlugIns folder. The plug-in was "); if (DEBUG_BOOL) { errorMessage += "built in release mode, but this a debug mode version of the application."; } else { errorMessage += "built in debug mode, but this a release mode version of the application."; } MessageResource message("PlugInError", "app", "8B5F1ADB-1210-406f-B961-72C2189CE84D"); message->addProperty("message", errorMessage); message->addProperty("filename", filename); message->finalize(); Service<PlugInManagerServices>()->destroyDynamicModule(pDynMod); return NULL; } #endif } else { std::string errorMessage("Error loading plug-in from PlugIns folder. The plug-in did not " "return the proper struct."); MessageResource message("PlugInError", "app", "B63EB55A-2881-4A2A-AE8B-C8FE7E9C4080"); message->addProperty("message", errorMessage); message->addProperty("filename", filename); message->finalize(); Service<PlugInManagerServices>()->destroyDynamicModule(pDynMod); return NULL; } } // old style modules only supported on Solaris and Windows #if defined(SOLARIS) || defined(WIN_API) // try an old style module // Check the module interface version int version = 0; // no module should ever have this version so it's a good "invalid" value int(*moduleVersionProcedure)() = reinterpret_cast<int(*)()> (pDynMod->getProcedureAddress( "opticks_get_module_interface_version" )); if (moduleVersionProcedure != NULL) { version = moduleVersionProcedure(); } if (version != 1) // This is the currently expected version...it hardly changes so it's hardcoded { Service<PlugInManagerServices>()->destroyDynamicModule(pDynMod); return NULL; } // below are the functions required for a version 1 module bool(*pInitProcedure)(External*) = reinterpret_cast<bool(*)(External*)>(pDynMod->getProcedureAddress("initialize_op")); bool(*pNameProcedure)(char**, char**, char**, unsigned int*, char**, char**) = reinterpret_cast<bool(*)(char**, char**, char**, unsigned int*, char**, char**)>( pDynMod->getProcedureAddress("get_name")); DMPROC pInterfaceProc = pDynMod->getProcedureAddress("instantiate_interface"); DMPROC pDestroyProc = pDynMod->getProcedureAddress("destroy_op"); if (pInitProcedure == NULL || pNameProcedure == NULL || pInterfaceProc == NULL || pDestroyProc == NULL) { Service<PlugInManagerServices>()->destroyDynamicModule(pDynMod); return NULL; } if (!pInitProcedure(ConnectionManager::instance())) { Service<PlugInManagerServices>()->destroyDynamicModule(pDynMod); return NULL; } char* pModuleName = NULL; char* pModuleVersion = NULL; char* pModuleDescription = NULL; unsigned int totalPlugIns = 0; char* pModuleId = NULL; char* pValidationKey = NULL; if (!pNameProcedure(&pModuleName, &pModuleVersion, &pModuleDescription, &totalPlugIns, &pValidationKey, &pModuleId) || pModuleId == NULL) { Service<PlugInManagerServices>()->destroyDynamicModule(pDynMod); return NULL; } ModuleDescriptor* pModule = new ModuleDescriptor(string(pModuleId)); FilenameImp fileObj(filename); pModule->mFileName = fileObj.getFullPathAndName(); pModule->setName(pModule->mFileName); pModule->setDisplayText(filename); FileFinderImp find; find.findFile(fileObj.getPath(), fileObj.getFileName()); find.findNextFile(); pModule->mFileSize = find.getLength(); find.getLastModificationTime(pModule->mFileDate); pModule->mVersion = pModuleVersion; pModule->mDescription = pModuleDescription; pModule->mPlugInTotal = totalPlugIns; pModule->mValidationKey = pValidationKey; pModule->mCanCache = false; pModule->mpModule = pDynMod; pModule->mModuleVersion = version; pModule->initializePlugInInformation(plugInIds); return pModule; #else return NULL; #endif }
bool ModuleDescriptorComparator::operator()(const ModuleDescriptor &m1, const ModuleDescriptor &m2) const { return m1.toString().compare(m2.toString()) < 0; }
void TextureBuilder::fromJson(const QJsonObject &json) { if (!json["colorMap"].isNull() && !json["colorMap"].isUndefined()) _colorMap = json["colorMap"].toString(); if (!json["cloudMap"].isNull() && !json["cloudMap"].isUndefined()) _cloudMap = json["cloudMap"].toString(); if (!json["reflectionMap"].isNull() && !json["reflectionMap"].isUndefined()) _reflectionMap = json["reflectionMap"].toString(); if (!json["bumpMap"].isNull() && !json["bumpMap"].isUndefined()) _bumpMap = json["bumpMap"].toString(); if (!json["builderType"].isNull() && !json["builderType"].isUndefined()) { auto sType = json["builderType"].toString(); if (sType.toLower() != "sphere" && sType.toLower() != "plane" && sType.toLower() != "cylinder") _builderType = "sphere"; else _builderType = sType; } if (!json["size"].isNull() && !json["size"].isUndefined()) { auto a = json["size"].toArray(); _size = std::tuple<int,int>(a[0].toInt(),a[1].toInt()); } if (!json["bounds"].isNull() && !json["bounds"].isUndefined()) { auto a1 = json["bounds"].toArray(); _bounds = std::tuple<double,double,double,double>( a1[0].toDouble(), a1[1].toDouble(), a1[2].toDouble(), a1[3].toDouble() ); } if (!json["randomFactors"].isNull() && !json["randomFactors"].isUndefined()) { auto jsRf = json["randomFactors"]; if (jsRf.isDouble()) { _randomFactors.clear(); _randomFactors.append(jsRf.toDouble()); } if (jsRf.isArray()) { _randomFactors.clear(); QJsonArray arr = jsRf.toArray(); for (auto h = 0; h < arr.size(); ++h) { _randomFactors.append(arr[h].toDouble()); } } } QJsonArray aModules = json["modules"].toArray(); QJsonArray aHeightMaps = json["heightMaps"].toArray(); QJsonArray aHMBuilders = json["heightMapBuilders"].toArray(); QJsonArray aRenderers = json["renderers"].toArray(); QJsonArray aImages = json["images"].toArray(); _modDesc.clear(); _modules.clear(); for (auto h = 0; h < aModules.size(); ++h) { ModuleDescriptor *m = new ModuleDescriptor(); QJsonObject o = aModules[h].toObject(); m->fromJson(o); QString name = m->name(); m->setModules(_modules); QSharedPointer<ModuleDescriptor> p; p.reset(m); _modDesc.insert(name,p); } _rndDesc.clear(); _renderers.clear(); _rndNames.clear(); for (auto h = 0; h < aRenderers.size(); ++h) { RendererDescriptor *m = new RendererDescriptor(); QJsonObject o = aRenderers[h].toObject(); m->fromJson(o); QString name = m->name(); m->setImages(_images); m->setNoiseMaps(_heightMaps); m->setRenderers(_renderers); QSharedPointer<RendererDescriptor> p; p.reset(m); _rndDesc.insert(name,p); _rndNames.append(name); } _nmbDesc.clear(); _noiseMapBuilders.clear(); for (auto h = 0; h < aHMBuilders.size(); ++h) { NoiseMapBuilderDescriptor *m = new NoiseMapBuilderDescriptor(); QJsonObject o = aHMBuilders[h].toObject(); m->fromJson(o); assignSizeInfoToNMBDesc(m); //m->setBuilderType(NoiseMapBuilderType::SPHERE); //m->setSize(std::get<0>(_size), std::get<1>(_size)); //m->setBounds(std::get<0>(_bounds),std::get<1>(_bounds),std::get<2>(_bounds),std::get<3>(_bounds)); m->setModules(_modules); QString name = m->name(); QSharedPointer<NoiseMapBuilderDescriptor> p; p.reset(m); _nmbDesc.insert(name,p); } _hmDesc.clear(); _heightMaps.clear(); for (auto h = 0; h < aHeightMaps.size(); ++h) { HeightMapDescriptor *m = new HeightMapDescriptor(); QString o = aHeightMaps[h].toString(); m->setName(o); QSharedPointer<HeightMapDescriptor> p; p.reset(m); _hmDesc.insert(o,p); } _images.clear(); __imDesc.clear(); for (auto h = 0; h < aImages.size(); ++h) { ImageDescriptor *m = new ImageDescriptor(); QString o = aImages[h].toString(); m->setName(o); if (h == 0 && _colorMap == "") _colorMap = o; if (h == 1 && _bumpMap == "") _bumpMap = o; if (h == 2 && _cloudMap == "") _cloudMap = o; if (h == 3 && _reflectionMap == "") _reflectionMap = o; QSharedPointer<ImageDescriptor> p; p.reset(m); __imDesc.insert(o,p); } /* createAll(); connectAll(); */ }
void ConnectedModules::addModule(const ModuleDescriptor& md, ConnectedModule* module) { Lock l(m_modulesMutex); m_modules[md.getName()] = module; }
void ConnectedModules::removeModule(const ModuleDescriptor& md) { Lock l(m_modulesMutex); m_modules.erase(md.getName()); }
bool ConnectedModules::hasModule(const ModuleDescriptor& md) { Lock l(m_modulesMutex); return (m_modules.count(md.getName()) != 0); }