void setScoped ( dictionary& dict, const word& keyword, const bool overwrite, entry* d ) { if (keyword[0] == ':') { // Go up to top level and recurse to find entries setScoped ( const_cast<dictionary&>(dict.topDict()), keyword.substr(1, keyword.size()-1), overwrite, d ); return; } else { string::size_type dotPos = keyword.find('.'); if (dotPos == string::npos) { // Non-scoped lookup if (overwrite) { dict.set(d); } else { dict.add(d, false); } return; } else { if (dotPos == 0) { // Starting with a '.'. Go up for every 2nd '.' found const dictionary* dictPtr = &dict; string::size_type begVar = dotPos + 1; string::const_iterator iter = keyword.begin() + begVar; string::size_type endVar = begVar; while ( iter != keyword.end() && *iter == '.' ) { ++iter; ++endVar; // Go to parent if (&dictPtr->parent() == &dictionary::null) { FatalIOErrorInFunction(dict) << "No parent of current dictionary" << " when searching for " << keyword.substr ( begVar, keyword.size() - begVar ) << exit(FatalIOError); } dictPtr = &dictPtr->parent(); } setScoped ( const_cast<dictionary&>(*dictPtr), keyword.substr(endVar), overwrite, d ); return; } else { // Extract the first word word firstWord = keyword.substr(0, dotPos); const entry* entPtr = dict.lookupScopedEntryPtr ( firstWord, false, // Recursive false ); if (!entPtr || !entPtr->isDict()) { FatalIOErrorInFunction(dict) << "keyword " << firstWord << " is undefined in dictionary " << dict.name() << " or is not a dictionary" << endl << "Valid keywords are " << dict.keys() << exit(FatalIOError); } const dictionary& firstDict = entPtr->dict(); setScoped ( const_cast<dictionary&>(firstDict), keyword.substr(dotPos, keyword.size()-dotPos), overwrite, d ); return; } } } }
Foam::functionEntries::codeStream::streamingFunctionType Foam::functionEntries::codeStream::getFunction ( const dictionary& parentDict, const dictionary& codeDict ) { // get code, codeInclude, codeOptions dynamicCodeContext context(codeDict); // codeName: codeStream + _<sha1> // codeDir : _<sha1> std::string sha1Str(context.sha1().str(true)); dynamicCode dynCode("codeStream" + sha1Str, sha1Str); // Load library if not already loaded // Version information is encoded in the libPath (encoded with the SHA1) const fileName libPath = dynCode.libPath(); // see if library is loaded void* lib = NULL; if (isA<IOdictionary>(parentDict.topDict())) { lib = libs(parentDict).findLibrary(libPath); } if (!lib) { Info<< "Using #codeStream with " << libPath << endl; } // nothing loaded // avoid compilation if possible by loading an existing library if (!lib) { if (isA<IOdictionary>(parentDict.topDict())) { // Cached access to dl libs. Guarantees clean up upon destruction // of Time. dlLibraryTable& dlLibs = libs(parentDict); if (dlLibs.open(libPath, false)) { lib = dlLibs.findLibrary(libPath); } } else { // Uncached opening of libPath. Do not complain if cannot be loaded lib = dlOpen(libPath, false); } } // create library if required if (!lib) { bool create = Pstream::master() || (regIOobject::fileModificationSkew <= 0); // not NFS if (create) { if (!dynCode.upToDate(context)) { // filter with this context dynCode.reset(context); // compile filtered C template dynCode.addCompileFile(codeTemplateC); // define Make/options dynCode.setMakeOptions ( "EXE_INC = -g \\\n" + context.options() + "\n\nLIB_LIBS = \\\n" + " -lOpenFOAM \\\n" + context.libs() ); if (!dynCode.copyOrCreateFiles(true)) { FatalIOErrorIn ( "functionEntries::codeStream::execute(..)", parentDict ) << "Failed writing files for" << nl << dynCode.libRelPath() << nl << exit(FatalIOError); } } if (!dynCode.wmakeLibso()) { FatalIOErrorIn ( "functionEntries::codeStream::execute(..)", parentDict ) << "Failed wmake " << dynCode.libRelPath() << nl << exit(FatalIOError); } } //- Only block if we're not doing master-only reading. (flag set by // regIOobject::read, IOdictionary constructor) if ( !regIOobject::masterOnlyReading && regIOobject::fileModificationSkew > 0 ) { //- Since the library has only been compiled on the master the // other nodes need to pick this library up through NFS // We do this by just polling a few times using the // fileModificationSkew. off_t mySize = Foam::fileSize(libPath); off_t masterSize = mySize; Pstream::scatter(masterSize); if (debug) { Pout<< endl<< "on processor " << Pstream::myProcNo() << " have masterSize:" << masterSize << " and localSize:" << mySize << endl; } if (mySize < masterSize) { if (debug) { Pout<< "Local file " << libPath << " not of same size (" << mySize << ") as master (" << masterSize << "). Waiting for " << regIOobject::fileModificationSkew << " seconds." << endl; } Foam::sleep(regIOobject::fileModificationSkew); // Recheck local size mySize = Foam::fileSize(libPath); if (mySize < masterSize) { FatalIOErrorIn ( "functionEntries::codeStream::execute(..)", parentDict ) << "Cannot read (NFS mounted) library " << nl << libPath << nl << "on processor " << Pstream::myProcNo() << " detected size " << mySize << " whereas master size is " << masterSize << " bytes." << nl << "If your case is not NFS mounted" << " (so distributed) set fileModificationSkew" << " to 0" << exit(FatalIOError); } } if (debug) { Pout<< endl<< "on processor " << Pstream::myProcNo() << " after waiting: have masterSize:" << masterSize << " and localSize:" << mySize << endl; } } if (isA<IOdictionary>(parentDict.topDict())) { // Cached access to dl libs. Guarantees clean up upon destruction // of Time. dlLibraryTable& dlLibs = libs(parentDict); if (debug) { Pout<< "Opening cached dictionary:" << libPath << endl; } if (!dlLibs.open(libPath, false)) { FatalIOErrorIn ( "functionEntries::codeStream::execute(..)", parentDict ) << "Failed loading library " << libPath << nl << "Did you add all libraries to the 'libs' entry" << " in system/controlDict?" << exit(FatalIOError); } lib = dlLibs.findLibrary(libPath); } else { // Uncached opening of libPath if (debug) { Pout<< "Opening uncached dictionary:" << libPath << endl; } lib = dlOpen(libPath, true); } } bool haveLib = lib; reduce(haveLib, andOp<bool>()); if (!haveLib) { FatalIOErrorIn ( "functionEntries::codeStream::execute(..)", parentDict ) << "Failed loading library " << libPath << " on some processors." << exit(FatalIOError); } // Find the function handle in the library streamingFunctionType function = reinterpret_cast<streamingFunctionType> ( dlSym(lib, dynCode.codeName()) ); if (!function) { FatalIOErrorIn ( "functionEntries::codeStream::execute(..)", parentDict ) << "Failed looking up symbol " << dynCode.codeName() << " in library " << lib << exit(FatalIOError); } return function; }