def test_dlopenflags(self): self.assertTrue(hasattr(sys, "getdlopenflags")) self.assertRaises(TypeError, sys.getdlopenflags, 42) oldflags = sys.getdlopenflags() self.assertRaises(TypeError, sys.setdlopenflags) sys.setdlopenflags(oldflags+1) self.assertEqual(sys.getdlopenflags(), oldflags+1) sys.setdlopenflags(oldflags)
def test_dlopenflags(self): import sys raises(TypeError, sys.getdlopenflags, 42) oldflags = sys.getdlopenflags() raises(TypeError, sys.setdlopenflags) sys.setdlopenflags(oldflags+1) assert sys.getdlopenflags() == oldflags+1 sys.setdlopenflags(oldflags)
def test_dlopenflags(self): if hasattr(sys, "setdlopenflags"): assert hasattr(sys, "getdlopenflags") raises(TypeError, sys.getdlopenflags, 42) oldflags = sys.getdlopenflags() raises(TypeError, sys.setdlopenflags) sys.setdlopenflags(oldflags + 1) assert sys.getdlopenflags() == oldflags + 1 sys.setdlopenflags(oldflags)
def __import_extension__(name, package, locals): """Import a module. The 'package' argument is required when performing a relative import. It specifies the package to use as the anchor point from which to resolve the relative import to an absolute import. """ # This is a fix to the problem of using templates/static/exceptions/dynamic # casts with boost.python. It makes all symbols loaded by python from this # point onwards global default_flags = sys.getdlopenflags() sys.setdlopenflags(default_flags|ctypes.RTLD_GLOBAL) if name.startswith('.'): if not package: raise TypeError("relative imports require the 'package' argument") level = 0 for character in name: if character != '.': break level += 1 name = __resolve_name__(name[level:], package, level) __import__(name, locals=locals) sys.setdlopenflags(default_flags) return sys.modules[name]
def setdlopenflags(): oldflags = sys.getdlopenflags() try: from DLFCN import RTLD_GLOBAL, RTLD_LAZY except ImportError: RTLD_GLOBAL = -1 RTLD_LAZY = -1 import os osname = os.uname()[0] if osname == "Linux" or osname == "SunOS" or osname == "FreeBSD": RTLD_GLOBAL = 0x100 RTLD_LAZY = 0x1 elif osname == "Darwin": RTLD_GLOBAL = 0x8 RTLD_LAZY = 0x1 del os except: RTLD_GLOBAL = -1 RTLD_LAZY = -1 if RTLD_GLOBAL != -1 and RTLD_LAZY != -1: sys.setdlopenflags(RTLD_LAZY | RTLD_GLOBAL) return oldflags
def enableHouModule(): '''Set up the environment so that "import hou" works.''' #import sys, os # Importing hou will load in Houdini's libraries and initialize Houdini. # In turn, Houdini will load any HDK extensions written in C++. These # extensions need to link against Houdini's libraries, so we need to # make sure that the symbols from Houdini's libraries are visible to # other libraries that Houdini loads. So, we adjust Python's dlopen # flags before importing hou. HFS = "/opt/hfs.current" if hasattr(sys, "setdlopenflags"): old_dlopen_flags = sys.getdlopenflags() import DLFCN sys.setdlopenflags(old_dlopen_flags | DLFCN.RTLD_GLOBAL) try: import hou except ImportError: # Add $HFS/houdini/python2.6libs to sys.path so Python can find the # hou module. sys.path.append(HFS + "/houdini/python%d.%dlibs" % sys.version_info[:2]) #sys.path.append(os.environ['HFS'] + "/houdini/python2.6libs") import hou finally: if hasattr(sys, "setdlopenflags"): sys.setdlopenflags(old_dlopen_flags)
def loadGenius(): if sys.platform=='win32': modulePath = '/lib/genius.pyd' else: modulePath = '/lib/genius.so' searchPath = [ os.path.abspath(os.path.dirname(os.path.abspath(__file__)) + '/..'), '.', '..'] if os.environ.has_key('GENIUS_DIR'): searchPath.insert(0, os.environ['GENIUS_DIR']) GeniusDir = None for path in searchPath: if os.path.exists(path+modulePath): GeniusDir = os.path.abspath(path) break if GeniusDir==None: raise GeniusError('Genius library binaries are not found.') sys.path.insert(0, GeniusDir+'/lib') global genius try: flagsave = sys.getdlopenflags() if sys.platform=='linux2': import DLFCN sys.setdlopenflags(DLFCN.RTLD_NOW|DLFCN.RTLD_GLOBAL) import genius sys.setdlopenflags(flagsave) except ImportError: raise GeniusError('Failed loading Genius binaries.') genius.Genius.set_genius_dir(GeniusDir) genius.baseDir = GeniusDir
def setup_dlopen(): """Set the flags for a call to import a shared library such that all symbols are imported. On Linux this sets the flags for dlopen so that all symbols from the library are imported in to the global symbol table. Without this each shared library gets its own copy of any singleton, which is not the correct behaviour Returns the original flags """ if platform.system() != "Linux": return None old_flags = sys.getdlopenflags() try: import DLFCN as dynload except: # Try older module try: import dl as dynload except: # If neither is available then this platform is unsupported print "Both the DLFCN and dl modules are unavailable." print "Cannot run Mantid from stand-alone Python on this platform." sys.exit(1) sys.setdlopenflags(dynload.RTLD_NOW | dynload.RTLD_GLOBAL) return old_flags
def setDLFlags(): # brought over from ITK Wrapping/CSwig/Python # Python "help(sys.setdlopenflags)" states: # # setdlopenflags(...) # setdlopenflags(n) -> None # # Set the flags that will be used for dlopen() calls. Among other # things, this will enable a lazy resolving of symbols when # importing a module, if called as sys.setdlopenflags(0) To share # symbols across extension modules, call as # # sys.setdlopenflags(dl.RTLD_NOW|dl.RTLD_GLOBAL) # # GCC 3.x depends on proper merging of symbols for RTTI: # http://gcc.gnu.org/faq.html#dso # try: import dl newflags = dl.RTLD_NOW|dl.RTLD_GLOBAL except: newflags = 0x102 # No dl module, so guess (see above). try: oldflags = sys.getdlopenflags() sys.setdlopenflags(newflags) except: oldflags = None return oldflags
def modified_dlopenflags(dlopenflags): try: old_dlopenflags = sys.getdlopenflags() sys.setdlopenflags(dlopenflags) yield finally: sys.setdlopenflags(old_dlopenflags)
def _load_libzmq(): """load bundled libzmq if there is one""" import sys, ctypes, platform, os dlopen = hasattr(sys, 'getdlopenflags') # unix-only # RTLD flags are added to os in Python 3 # get values from os because ctypes values are WRONG on pypy PYPY = platform.python_implementation().lower() == 'pypy' if dlopen: dlflags = sys.getdlopenflags() # set RTLD_GLOBAL, unset RTLD_LOCAL flags = ctypes.RTLD_GLOBAL | dlflags # ctypes.RTLD_LOCAL is 0 on pypy, which is *wrong* flags &= ~ getattr(os, 'RTLD_LOCAL', 4) # pypy on darwin needs RTLD_LAZY for some reason if PYPY and sys.platform == 'darwin': flags |= getattr(os, 'RTLD_LAZY', 1) flags &= ~ getattr(os, 'RTLD_NOW', 2) sys.setdlopenflags(flags) try: from . import libzmq except ImportError: pass else: # store libzmq as zmq._libzmq for backward-compat globals()['_libzmq'] = libzmq if PYPY: # some versions of pypy (5.3 < ? < 5.8) needs explicit CDLL load for some reason, # otherwise symbols won't be globally available # do this unconditionally because it should be harmless (?) ctypes.CDLL(libzmq.__file__, ctypes.RTLD_GLOBAL) finally: if dlopen: sys.setdlopenflags(dlflags)
def imp_load_module(name, *args): pathParts = args[1].split(os.path.sep) extension = os.path.splitext(pathParts[-1])[-1] # Find all swigged LSST libs. Load _lsstcppimport.so by # adding it to the EXCEPTIONLIST since it may not have lsst in # the path (it's in $BASE_DIR/python, not # $BASE_DIR/python/lsst). Also, look for paths that look like # python/lsst as that is how to know if you are in an LSST # package. lsstIdx = [i for i, el in enumerate(pathParts) if el == 'python'] if pathParts[-1] in LIB_EXCEPTION_LIST or (extension in SHARED_LIB_EXTENSION_LIST and pathParts[-1].startswith('_') and 'lsst' in [pathParts[i + 1] for i in lsstIdx]): # Get currently set flags originalDLFlags = sys.getdlopenflags() # Set flags sys.setdlopenflags(DLFLAGS) try: module = orig_imp_load_module(name, *args) finally: # Set original flags sys.setdlopenflags(originalDLFlags) else: module = orig_imp_load_module(name, *args) return module
def DlopenGuard(): if _set_global_flags: old_flags = sys.getdlopenflags() sys.setdlopenflags(old_flags | ctypes.RTLD_GLOBAL) yield if _set_global_flags: sys.setdlopenflags(old_flags)
def enableHouModule(): """Set up the environment so that "import hou" works.""" # Handle dlopen flags so dsos can be loaded correctly. if hasattr(sys, "setdlopenflags"): import DLFCN old_dlopen_flags = sys.getdlopenflags() sys.setdlopenflags(old_dlopen_flags | DLFCN.RTLD_GLOBAL) # Try to import hou. try: import hou # If it can't find it, make sure it is in the path. except ImportError: # Python needs to know where the hou module is. path = os.path.join( os.getenv("HH"), "python{}.{}".format(sys.version_info[0], sys.version_info[1]) ) # Append the path. sys.path.append(path) # Try again. import hou finally: # Restore old flags. if hasattr(sys, "setdlopenflags"): sys.setdlopenflags(old_dlopen_flags)
def DlopenGuard(): # In python 2.7 required constants are not defined. # Thus they are listed explicitly flags = sys.getdlopenflags() sys.setdlopenflags(DLFCN.RTLD_GLOBAL | DLFCN.RTLD_NOW) yield sys.setdlopenflags(flags)
def load_prepare(mod_path, depends_on, has_dependent): root_name = mod_path[0] mod_name = os.path.basename(root_name) env_var_name = 'LIMA_%s_VERSION' % mod_name.upper() if env_var_name in os.environ: version = os.environ[env_var_name] else: version = 'LAST' if version.upper() == 'LAST': version_filter = [] elif version_re.match(version): version_filter = version_code(version) else: raise ImportError('Invalid %s: %s' % (env_var_name, version)) def good_dir(v, r=root_name, f=version_filter): return good_version_dir(v, r, f) version_dirs = [x for x in os.listdir(root_name) if good_dir(x)] if not version_dirs: raise ImportError('Invalid %s: %s' % (env_var_name, version)) version_dirs.sort(key=version_code) version = version_dirs[-1] mod_dir = os.path.join(root_name, version) ld_open_flags = sys.getdlopenflags() cleanup_data = mod_path, mod_dir, ld_open_flags, has_dependent if not depends_on: return load_ld_prepare(cleanup_data) cap_dep = depends_on.upper() dep_version_fname = os.path.join(mod_dir, '%s_VERSION' % cap_dep) dep_version_file = open(dep_version_fname, 'rt') dep_version = dep_version_file.readline().strip() link_strict_version = os.environ['LIMA_LINK_STRICT_VERSION'] if link_strict_version == 'MINOR': dep_version = VSEP.join(dep_version.split(VSEP)[:2]) elif link_strict_version != 'FULL': raise ImportError('Invalid LIMA_LINK_STRICT_VERSION var: %s' % link_strict_version) env_var_name = 'LIMA_%s_VERSION' % cap_dep if env_var_name in os.environ: prev_version = os.environ[env_var_name] if prev_version != dep_version: msg = 'Forcing %s to %s, which was previously set to '\ '%s' % (env_var_name, dep_version, prev_version) raise ImportError('%s: %s' % (mod_name, msg)) else: os.environ[env_var_name] = dep_version return cleanup_data
def load_library(self, flags=None): # XXX review all usages of 'self' here! # import it as a new extension module imp.acquire_lock() try: if hasattr(sys, "getdlopenflags"): previous_flags = sys.getdlopenflags() try: if hasattr(sys, "setdlopenflags") and flags is not None: sys.setdlopenflags(flags) module = imp.load_dynamic(self.verifier.get_module_name(), self.verifier.modulefilename) except ImportError as e: error = "importing %r: %s" % (self.verifier.modulefilename, e) raise ffiplatform.VerificationError(error) finally: if hasattr(sys, "setdlopenflags"): sys.setdlopenflags(previous_flags) finally: imp.release_lock() # # call loading_cpy_struct() to get the struct layout inferred by # the C compiler self._load(module, 'loading') # # the C code will need the <ctype> objects. Collect them in # order in a list. revmapping = dict([(value, key) for (key, value) in self._typesdict.items()]) lst = [revmapping[i] for i in range(len(revmapping))] lst = list(map(self.ffi._get_cached_btype, lst)) # # build the FFILibrary class and instance and call _cffi_setup(). # this will set up some fields like '_cffi_types', and only then # it will invoke the chained list of functions that will really # build (notably) the constant objects, as <cdata> if they are # pointers, and store them as attributes on the 'library' object. class FFILibrary(object): _cffi_python_module = module _cffi_ffi = self.ffi _cffi_dir = [] def __dir__(self): return FFILibrary._cffi_dir + list(self.__dict__) library = FFILibrary() if module._cffi_setup(lst, ffiplatform.VerificationError, library): import warnings warnings.warn("reimporting %r might overwrite older definitions" % (self.verifier.get_module_name())) # # finally, call the loaded_cpy_xxx() functions. This will perform # the final adjustments, like copying the Python->C wrapper # functions from the module to the 'library' object, and setting # up the FFILibrary class with properties for the global C variables. self._load(module, 'loaded', library=library) module._cffi_original_ffi = self.ffi module._cffi_types_of_builtin_funcs = self._types_of_builtin_functions return library
def preserve_dlopenflags(flags): """A context manager that temporarily sets the dlopen flags and then returns them to previous values. """ outer_flags = sys.getdlopenflags() try: sys.setdlopenflags(flags) yield finally: sys.setdlopenflags(outer_flags)
def setup(self): self.old_cwd = os.getcwd() os.chdir(itkConfig.swig_lib) self.old_path = sys.path sys.path = [itkConfig.swig_lib, itkConfig.swig_py] + sys.path try: self.old_dlopenflags = sys.getdlopenflags() sys.setdlopenflags(self.dlopenflags) except: self.old_dlopenflags = None
def import_pyfftw(): if os.name == 'nt': import pyfftw else: # Import pyfftw as soon as possible with RTLD_NOW|RTLD_DEEPBIND # to minimize chance of MKL overriding fftw functions import ctypes import sys curFlags = sys.getdlopenflags() sys.setdlopenflags(curFlags | ctypes.RTLD_GLOBAL) import pyfftw sys.setdlopenflags(curFlags) del curFlags fft_impl = 'pyfftw'
def setup(self): self.old_cwd = os.getcwd() try: os.chdir(itkConfig.swig_lib) except OSError: # silently pass to avoid the case where the dir is not there pass self.old_path = sys.path sys.path = [itkConfig.swig_lib, itkConfig.swig_py] + sys.path try: self.old_dlopenflags = sys.getdlopenflags() sys.setdlopenflags(self.dlopenflags) except: self.old_dlopenflags = None
def _try_import_with_global_library_symbols(): try: import DLFCN dlopen_flags = DLFCN.RTLD_NOW | DLFCN.RTLD_GLOBAL except ImportError: import ctypes dlopen_flags = ctypes.RTLD_GLOBAL import sys old_flags = sys.getdlopenflags() try: sys.setdlopenflags(dlopen_flags) import lupa._lupa finally: sys.setdlopenflags(old_flags)
def dl_import(import_expr): """Import module according to import_expr, but with RTLD_GLOBAL enabled.""" # we need to get the locals and globals of the _calling_ function. Thus, we # need to go deeper into the call stack call_frame = sys._getframe(1) local_dict = call_frame.f_locals global_dict = call_frame.f_globals # RTLD_GLOBAL needs to be set in dlopen() if we want typeinfo and friends to # work properly across DSO boundaries. See http://gcc.gnu.org/faq.html#dso orig_dlopen_flags = sys.getdlopenflags() sys.setdlopenflags(RTLD_LAZY | RTLD_GLOBAL) exec import_expr in local_dict, global_dict sys.setdlopenflags(orig_dlopen_flags) # reset it to normal case to avoid
def os_details(): """ Returns a dictionary containing details about the operating system """ # Compute architecture and linkage bits, linkage = platform.architecture() results = { # Machine details 'platform.arch.bits': bits, 'platform.arch.linkage': linkage, 'platform.machine': platform.machine(), 'platform.process': platform.processor(), 'sys.byteorder': sys.byteorder, # OS details 'os.name': os.name, 'host.name': socket.gethostname(), 'sys.platform': sys.platform, 'platform.system': platform.system(), 'platform.release': platform.release(), 'platform.version': platform.version(), 'encoding.filesystem': sys.getfilesystemencoding(), } # Paths and line separators for name in ('sep', 'altsep', 'pathsep', 'linesep'): results['os.{0}'.format(name)] = getattr(os, name, None) try: # Available since Python 3.4 results['os.cpu_count'] = os.cpu_count() except AttributeError: results['os.cpu_count'] = None try: # Only for Unix # pylint: disable=E1101 results['sys.dlopenflags'] = sys.getdlopenflags() except AttributeError: results['sys.dlopenflags'] = None return results
def import_ext(name, optional=False): components = name.split(".") if len(components) > 1: __import__(".".join(components[:-1])) previous_dlopenflags = None if sys.platform.startswith("linux"): previous_dlopenflags = sys.getdlopenflags() sys.setdlopenflags(0x100 | 0x2) try: mod = __import__(name) except ImportError, e: if optional: return None error_msg = str(e) m = symbol_not_found_pat.search(error_msg) if m: error_msg = error_msg[: m.start(1)] + cpp_function_name.demangle(m.group(1)) + error_msg[m.end(1) :] raise ImportError( "\n ".join(['__import__("%s"): %s' % (name, error_msg), "sys.path:"] + [" " + p for p in sys.path]) )
def os_details(): """ Returns a dictionary containing details about the operating system """ # Compute architecture and linkage bits, linkage = platform.architecture() results = { # Machine details "platform.arch.bits": bits, "platform.arch.linkage": linkage, "platform.machine": platform.machine(), "platform.process": platform.processor(), "sys.byteorder": sys.byteorder, # OS details "os.name": os.name, "host.name": socket.gethostname(), "sys.platform": sys.platform, "platform.system": platform.system(), "platform.release": platform.release(), "platform.version": platform.version(), "encoding.filesystem": sys.getfilesystemencoding(), } # Paths and line separators for name in "sep", "altsep", "pathsep", "linesep": results["os.{0}".format(name)] = getattr(os, name, None) try: # Available since Python 3.4 results["os.cpu_count"] = os.cpu_count() except AttributeError: results["os.cpu_count"] = None try: # Only for Unix # pylint: disable=E1101 results["sys.dlopenflags"] = sys.getdlopenflags() except AttributeError: results["sys.dlopenflags"] = None return results
def _load_libzmq(): """load bundled libzmq if there is one""" import sys, ctypes, platform dlopen = hasattr(sys, 'getdlopenflags') # unix-only if dlopen: dlflags = sys.getdlopenflags() sys.setdlopenflags(ctypes.RTLD_GLOBAL | dlflags) try: from . import libzmq except ImportError: pass else: # store libzmq as zmq._libzmq for backward-compat globals()['_libzmq'] = libzmq if platform.python_implementation().lower() == 'pypy': # pypy needs explicit CDLL load for some reason, # otherwise symbols won't be globally available ctypes.CDLL(libzmq.__file__, ctypes.RTLD_GLOBAL) finally: if dlopen: sys.setdlopenflags(dlflags)
def openmpi_workaround(): # find the flag to be set to open all shared libraries at once try: import dl globalFlag = dl.RTLD_GLOBAL except: try: import ctypes globalFlag = ctypes.RTLD_GLOBAL except: print 'ATTENTION: could not find flag RTLD_GLOBAL for dlopen' # take a good value for Linux (but is platform-dependent) globalFlag = 256 # now set this flag so that dlopen will use it import sys flags = sys.getdlopenflags() sys.setdlopenflags(flags | globalFlag)
def _loadGenius(self): if sys.platform == "win32": modulePath = "/lib/genius.pyd" else: modulePath = "/lib/genius.so" searchPath = [os.path.abspath(os.path.dirname(os.path.abspath(__file__)) + "/.."), ".", ".."] if os.environ.has_key("GENIUS_DIR"): searchPath.insert(0, os.environ["GENIUS_DIR"]) GeniusDir = None for path in searchPath: if os.path.exists(path + modulePath): GeniusDir = os.path.abspath(path) break if GeniusDir == None: raise GeniusError("Genius library binaries are not found.") sys.path.insert(0, GeniusDir + "/lib") try: if sys.platform == "win32": import genius else: flagsave = sys.getdlopenflags() if sys.platform == "linux2": import DLFCN if hasattr(DLFCN, "RTLD_DEEPBIND"): sys.setdlopenflags(DLFCN.RTLD_NOW | DLFCN.RTLD_GLOBAL | DLFCN.RTLD_DEEPBIND) else: sys.setdlopenflags(DLFCN.RTLD_NOW | DLFCN.RTLD_GLOBAL | 0x00008) import genius sys.setdlopenflags(flagsave) except ImportError, e: raise GeniusError("Failed loading Genius binaries. %s" % str(e))
def _shared_cextension(): """Our extensions need to shared symbols amongst them due to: - the static boost python type registry - static singleton instances marked as weak symbols by clang gcc uses an extension to mark these attributes as globally unique but clang marks them as weak and without RTLD_GLOBAL each shared library has its own copy of each singleton. See https://docs.python.org/3/library/sys.html#sys.setdlopenflags """ import sys if not sys.platform.startswith('linux'): yield return import six if six.PY2: import DLFCN as dl else: import os as dl flags_orig = sys.getdlopenflags() sys.setdlopenflags(dl.RTLD_NOW | dl.RTLD_GLOBAL) yield sys.setdlopenflags(flags_orig)
# along with this program. If not, see <http://www.gnu.org/licenses/>. # # Init file for osg package. # # Hack to bring in all symbols OpenSG is linked against and loads from plugins # Search for : setdlopenflags and RTLD_GLOBAL on google to see why from ..OSGBase import AttachmentContainer original_dlopen_flags = None try: import dl, sys original_dlopen_flags = sys.getdlopenflags() sys.setdlopenflags(original_dlopen_flags | dl.RTLD_GLOBAL) except: pass # Import everything from the opensg module from OSGWindowGLUTPy import * if original_dlopen_flags: sys.setdlopenflags(original_dlopen_flags) def _fc_cmp(self, other): """ Comparison operator for field containers. """ id_self = None id_other = None
''' Internal functions and classes of the clingo module. ''' from os import _exit from traceback import print_exception import os import sys try: _FLAGS = None # In the pip module the library also exports the clingo symbols, which # should be globally available for other libraries depending on clingo. if hasattr(sys, 'setdlopenflags'): _FLAGS = sys.getdlopenflags() sys.setdlopenflags(os.RTLD_LAZY|os.RTLD_GLOBAL) try: # Note: imported first to correctly handle the embedded case from _clingo import ffi as _ffi, lib as _lib # type: ignore # pylint: disable=no-name-in-module except ImportError: from ._clingo import ffi as _ffi, lib as _lib # type: ignore # pylint: disable=no-name-in-module finally: if _FLAGS is not None: sys.setdlopenflags(_FLAGS) def _str(f_size, f_str, *args, handler=None): p_size = _ffi.new('size_t*') _handle_error(f_size(*args, p_size), handler) p_str = _ffi.new('char[]', p_size[0]) _handle_error(f_str(*args, p_str, p_size[0]), handler) return _ffi.string(p_str).decode()
import ctypes import sys # this file is simply a facade for the (underscored) native module which ensures the module # is loaded in a specific way... # set RTLD_GLOBAL for tracehook import so that afl-instrumented native libs are able to find # our __afl_area_ptr and __afl_prev_loc globals _prev_dlopenflags = sys.getdlopenflags() sys.setdlopenflags(_prev_dlopenflags | ctypes.RTLD_GLOBAL) from cpytraceafl._tracehook import * sys.setdlopenflags(_prev_dlopenflags)
return Fraction(self.num * other.denom, self.denom * other.num) elif isinstance(other, int): return Fraction(self.num, self.denom * other) return TypeError def __rdiv__(self, other): if isinstance(other, int): return Fraction(self.denom * other, self.num) return TypeError def __float__(self): return float(self.num) / float(self.denom) try: dlsave = sys.getdlopenflags() from DLFCN import RTLD_GLOBAL, RTLD_LAZY except AttributeError: # windows doesn't have sys.getdlopenflags() RTLD_GLOBAL = -1 RTLD_LAZY = -1 except ImportError: RTLD_GLOBAL = -1 RTLD_LAZY = -1 import os osname = os.uname()[0] if osname == 'Linux' or osname == 'SunOS' or osname == 'FreeBSD' or osname == 'GNU/kFreeBSD' or osname == 'GNU': machinename = os.uname()[4] if machinename == 'mips' or machinename == 'mips64': RTLD_GLOBAL = 0x4 RTLD_LAZY = 0x1
def setup(): import atexit, os __path__.append(os.path.join(__path__[0], os.environ['CMTCONFIG'])) # make sure that 3rd party libraries can see Hephaestus symbols by letting # python load the memory tracker in "broadcast" mode import DLFCN, sys dlflags = sys.getdlopenflags() sys.setdlopenflags(DLFCN.RTLD_GLOBAL | DLFCN.RTLD_NOW) import MemoryTracker sys.setdlopenflags(dlflags) # switch off profiling; do filter STL internal allocations MemoryTracker.configure(MemoryTracker.LEAK_CHECK | MemoryTracker.QUICK | MemoryTracker.FILTER_STL) # ignore muon common blocks in report MemoryTracker.ignore('__m_mb_') # ignore CINT dictionary builtup in report MemoryTracker.ignore('G__') MemoryTracker.ignore('TCint::') # ignore Reflex dictionary builtup in report MemoryTracker.ignore('Reflex::') # ignore streamers and collections from ROOT I/O in report MemoryTracker.ignore('TStreamerInfo') MemoryTracker.ignore('TGenCollectionProxy') MemoryTracker.ignore('TCollectionProxy') MemoryTracker.ignore('TStorage') # like STL, the following only leaks if the full object is leaked, so it's a dupe MemoryTracker.ignore('TStringRef::GetRep') MemoryTracker.ignore('TString::Init') MemoryTracker.ignore('TString::Replace') MemoryTracker.ignore('TList::NewLink') # this was a known issue, no longer relevant, but leave ignore in MemoryTracker.ignore('StoreGateSvc::setupProxy') # ignore unknowns, as they've never proven useful; they typically arise from file # static functions (that for that reason have no linker symbol associated with # them), which are usually in system libraries rather than in ATLAS code ... MemoryTracker.ignore('<unknown>') MemoryTracker.ignore('THashTable::THashTable') MemoryTracker.ignore('InitCallFunc_') MemoryTracker.ignore('_PyObject_GenericSetAttrWithDict') MemoryTracker.ignore('_PyObject_GC_NewVar') MemoryTracker.ignore('PyType_GenericAlloc') MemoryTracker.ignore('PyDict_MergeFromSeq2') MemoryTracker.ignore('PyEval_EvalFrameEx') MemoryTracker.ignore('Cintex::CINTClassBuilder') MemoryTracker.ignore('Cintex::CintTag') MemoryTracker.ignore('PyROOT::') MemoryTracker.ignore('ROOT::TSchemaRule::ProcessVersion') MemoryTracker.ignore('CLHEP::HepMatrix::invert') MemoryTracker.ignore('IncidentSvc::addListener') MemoryTracker.ignore('TClass::Init') MemoryTracker.ignore('_PyObject_GC_New') MemoryTracker.ignore('_PyObject_GC_Malloc') MemoryTracker.ignore('_PyObject_GC_Resize') MemoryTracker.ignore('TString::Clobber') MemoryTracker.ignore('PyString_FromStringAndSize') MemoryTracker.ignore('clang::') MemoryTracker.ignore('cling::') MemoryTracker.ignore('llvm::') MemoryTracker.ignore('TExMap::Expand') MemoryTracker.ignore('TExMap::TExMap') MemoryTracker.ignore('TCling::') MemoryTracker.ignore('TClingDataMemberInfo::TClingDataMemberInfo') MemoryTracker.ignore('TClingBaseClassInfo::TClingBaseClassInfo') MemoryTracker.ignore('TClingCallFunc::SetFuncProto') MemoryTracker.ignore('TClassTable::AddAlternate') MemoryTracker.ignore('ROOT::TMetaUtils::GetFileName') atexit.register(MemoryTracker.atexit)
#!/usr/bin/python import ctypes import sys saved_flags = sys.getdlopenflags() sys.setdlopenflags(saved_flags | ctypes.RTLD_GLOBAL) # import dpdk with RTLD_GLOBAL, so it would export its symbols to other PMDs from dpdk import * sys.setdlopenflags(saved_flags) import time import binascii import dpkt params = ["pytest", "-c", "6", "-n", "2", "--no-huge"] params += ["--vdev", "eth_pcap0,iface=eth0"] print "eal init:", rte_eal_init(params) #, "--no-pci"]) enabled_cores = [i for i in xrange(RTE_MAX_LCORE) if rte_lcore_is_enabled(i)] print "enabled_lcores:", enabled_cores print "lcore_id", rte_lcore_id() print "core 2 is on socket %d" % rte_lcore_to_socket_id(2) pool = PacketPool("pktpool", 1024, 2048, 128, 0, 0) print "pool count:", pool.count() print "allocated packet:", pool.alloc() print "pool count:", pool.count()
import ctypes import IECore moduleSearchPath = IECore.SearchPath( os.environ["PYTHONPATH"] ) if moduleSearchPath.find( "IECoreUSD" ) : # Import the USD Python module _without_ RTLD_GLOBAL, otherwise # we get errors like the following spewed to the shell when we first # open a USD file : # # ``` # Coding Error: in DefinePythonClass at line 932 of /disk1/john/dev/gafferDependencies/USD/working/USD-18.09/pxr/base/lib/tf/type.cpp # -- TfType 'TfNotice' already has a defined Python type; cannot redefine # ``` # # > Note : RTLD_GLOBAL is turned on in the first place by IECore/__init__.py. # > Ideally we'd stop doing that and wouldn't need this workaround. See # > https://github.com/ImageEngine/cortex/pull/810. try : originalDLOpenFlags = sys.getdlopenflags() sys.setdlopenflags( originalDLOpenFlags & ~ctypes.RTLD_GLOBAL ) from pxr import Usd finally : sys.setdlopenflags( originalDLOpenFlags ) # Import IECoreUSD so that we get the USD SceneInterface registered, # providing USD functionality to both the SceneReader and SceneWriter. import IECoreUSD
def main(): import sys import hou import soho import sohoglue import SOHOcommon import sys import ctypes if hasattr(sys, 'setdlopenflags'): sys.setdlopenflags(sys.getdlopenflags() | ctypes.RTLD_GLOBAL) import _vfh_ipr from soho import SohoParm LogLevel = type('Enum', (), { 'Info': 0, 'Progress': 1, 'Warning': 2, 'Error': 3, 'Debug': 4, }) def logMessage(level, fmt, *args): _vfh_ipr.logMessage(level, fmt % args) def printDebug(fmt, *args): logMessage(LogLevel.Debug, fmt, *args) def dumpObjects(listName): printDebug("Checking \"%s\"" % listName) for obj in soho.objectList(listName): printDebug(" %s", obj.getName()) def exportObjects(listName): for obj in soho.objectList(listName): _vfh_ipr.exportOpNode(opNode=obj.getName()) def deleteObjects(listName): for obj in soho.objectList(listName): _vfh_ipr.deleteOpNode(opNode=obj.getName()) def getViewParams(camera, sohoCam, t): camParms = { 'space:world': SohoParm('space:world', 'real', [], False), 'focal': SohoParm('focal', 'real', [0.050], False), 'aperture': SohoParm('aperture', 'real', [0.0414214], False), 'orthowidth': SohoParm('orthowidth', 'real', [2], False), 'near': SohoParm('near', 'real', [0.001], False), 'far': SohoParm('far', 'real', [1000], False), 'res': SohoParm('res', 'int', [640, 480], False), 'projection': SohoParm('projection', 'string', ["perspective"], False), 'cropl': SohoParm('cropl', 'real', [-1], False), 'cropr': SohoParm('cropr', 'real', [-1], False), 'cropb': SohoParm('cropb', 'real', [-1], False), 'cropt': SohoParm('cropt', 'real', [-1], False), 'camera': SohoParm('camera', 'string', ['/obj/cam1'], False), } camParmsEval = sohoCam.evaluate(camParms, t) if not camParmsEval: return {} viewParams = {} for key in camParmsEval: viewParams[key] = camParmsEval[key].Value[0] viewParams['transform'] = camParmsEval['space:world'].Value viewParams['ortho'] = 1 if camParmsEval['projection'].Value[0] in { 'ortho' } else 0 viewParams['res'] = camParmsEval['res'].Value cropX = viewParams['res'][0] * viewParams['cropl'] cropY = viewParams['res'][1] * (1.0 - viewParams['cropt']) cropW = viewParams['res'][0] * (viewParams['cropr'] - viewParams['cropl']) cropH = viewParams['res'][1] * (viewParams['cropt'] - viewParams['cropb']) printDebug(" Res: %s" % viewParams['res']) printDebug(" Crop: %i-%i %i x %i" % (cropX, cropY, cropW, cropH)) printDebug(" Camera: %s" % camera) return viewParams def exportView(rop, camera, sohoCam, t): printDebug("exportView()") _vfh_ipr.exportView(viewParams=getViewParams(camera, sohoCam, t)) mode = soho.getDefaultedString('state:previewmode', ['default'])[0] # Evaluate an intrinsic parameter (see HDK_SOHO_API::evaluate()) # The 'state:time' parameter evaluates the time from the ROP. now = soho.getDefaultedFloat('state:time', [0.0])[0] # Evaluate the 'camera' parameter as a string. # If the 'camera' parameter doesn't exist, use ['/obj/cam1']. # SOHO always returns lists of values. camera = soho.getDefaultedString('camera', ['/obj/cam1'])[0] # MPlay / Render View port. host = soho.getDefaultedString("vm_image_mplay_sockethost", [0])[0] port = soho.getDefaultedInt("vm_image_mplay_socketport", [0])[0] # ROP node. ropPath = soho.getOutputDriver().getName() ropNode = hou.node(ropPath) printDebug("Initialize SOHO...") # Initialize SOHO with the camera. # XXX: This doesn't work for me, but it should according to the documentation... # soho.initialize(now, camera) if not sohoglue.initialize(now, camera, None): soho.error("Unable to initialize rendering module with given camera") # Now, add objects to our scene soho.addObjects(now, "*", "*", "*", True) # Before we can evaluate the scene from SOHO, we need to lock the object lists. soho.lockObjects(now) for sohoCam in soho.objectList('objlist:camera'): break else: soho.error("Unable to find viewing camera for render") sohoOverride = soho.getDefaultedString('soho_overridefile', ['Unknown'])[0] printDebug("Processing Mode: \"%s\"" % mode) if mode in {"generate"}: # generate: Generation phase of IPR rendering # In generate mode, SOHO will keep the pipe (soho_pipecmd) # command open between invocations of the soho_program. # objlist:all # objlist:camera # objlist:light # objlist:instance # objlist:fog # objlist:space # objlist:mat # printDebug("IPR Host: %s:%s" % (host, port)) printDebug("Driver: %s" % ropPath) printDebug("Camera: %s" % camera) printDebug("Now: %.3f" % now) for obj in soho.objectList('objlist:instance'): # Register SOP as IPR dependency. obj.getDefaultedString('object:soppath', now, ['']) # Register SHOP as IPR dependency. # TODO: Investigave this. Use OP_Node::addOpInterest() for now. # shader = [] # shader_type = [] # shader_handle = [] # obj.evalShaderAndType("shop_materialpath", now, shader, shader_type, shader_handle) _vfh_ipr.init(rop=ropPath, port=port, now=now, viewParams=getViewParams(camera, sohoCam, now)) elif mode in {"update"}: # update: Send updated changes from previous generation # # In this rendering mode, the special object list parameters: # objlist:dirtyinstance # objlist:dirtylight # objlist:dirtyspace # objlist:dirtyfog # will contain the list of all objects modified since the last render # (whether a generate or update). # # As well, the parameters: # objlist:deletedinstance # objlist:deletedlight # objlist:deletedspace # objlist:deletedfog # will list all objects which have been deleted from the scene. # if not _vfh_ipr.isRopValid(): _vfh_ipr.init(rop=ropPath, port=port, now=now, viewParams=getViewParams(camera, sohoCam, now)) else: # Have to handle "time" event manually here. _vfh_ipr.setTime(now) for obj in soho.objectList('objlist:dirtyinstance'): obj.getDefaultedString('object:soppath', now, ['']) exportObjects("objlist:dirtyinstance") exportObjects("objlist:dirtylight") exportView(ropPath, camera, sohoCam, now)
explicit. """ from __future__ import absolute_import from __future__ import division from __future__ import print_function import ctypes import sys # On UNIX-based platforms, pywrap_tensorflow is a SWIG-generated python library # that dynamically loads _pywrap_tensorflow.so. The default mode for loading # keeps all the symbol private and not visible to other libraries that may be # loaded. Setting the mode to RTLD_GLOBAL to make the symbols visible, so that # custom op libraries imported using `tf.load_op_library()` can access symbols # defined in _pywrap_tensorflow.so. _use_rtld_global = (hasattr(sys, 'getdlopenflags') and hasattr(sys, 'setdlopenflags')) if _use_rtld_global: _default_dlopen_flags = sys.getdlopenflags() def set_dlopen_flags(): if _use_rtld_global: sys.setdlopenflags(_default_dlopen_flags | ctypes.RTLD_GLOBAL) def reset_dlopen_flags(): if _use_rtld_global: sys.setdlopenflags(_default_dlopen_flags)
def setup(): import atexit, os __path__.append(os.path.join(__path__[0], os.environ['CMTCONFIG'])) # make sure that 3rd party libraries can see Hephaestus symbols by letting # python load the memory tracker in "broadcast" mode import DLFCN, sys dlflags = sys.getdlopenflags() sys.setdlopenflags(DLFCN.RTLD_GLOBAL | DLFCN.RTLD_NOW) import MemoryTracker sys.setdlopenflags(dlflags) # switch off profiling; do filter STL internal allocations MemoryTracker.configure(MemoryTracker.LEAK_CHECK | MemoryTracker.QUICK | MemoryTracker.FILTER_STL) # ignore muon common blocks in report MemoryTracker.ignore('__m_mb_') # ignore streamers and collections from ROOT I/O in report MemoryTracker.ignore('TStreamerInfo') MemoryTracker.ignore('TGenCollectionProxy') MemoryTracker.ignore('TCollectionProxy') MemoryTracker.ignore('TStorage') # like STL, the following only leaks if the full object is leaked, so it's a dupe MemoryTracker.ignore('TStringRef::GetRep') MemoryTracker.ignore('TString::Init') MemoryTracker.ignore('TString::Replace') MemoryTracker.ignore('TList::NewLink') # this was a known issue, no longer relevant, but leave ignore in MemoryTracker.ignore('StoreGateSvc::setupProxy') # ignore unknowns, as they've never proven useful; they typically arise from file # static functions (that for that reason have no linker symbol associated with # them), which are usually in system libraries rather than in ATLAS code ... MemoryTracker.ignore('<unknown>') MemoryTracker.ignore('THashTable::THashTable') MemoryTracker.ignore('InitCallFunc_') MemoryTracker.ignore('_PyObject_GenericSetAttrWithDict') MemoryTracker.ignore('_PyObject_GC_NewVar') MemoryTracker.ignore('PyType_GenericAlloc') MemoryTracker.ignore('PyDict_MergeFromSeq2') MemoryTracker.ignore('PyEval_EvalFrameEx') MemoryTracker.ignore('PyROOT::') MemoryTracker.ignore('ROOT::TSchemaRule::ProcessVersion') MemoryTracker.ignore('CLHEP::HepMatrix::invert') MemoryTracker.ignore('IncidentSvc::addListener') MemoryTracker.ignore('TClass::Init') MemoryTracker.ignore('_PyObject_GC_New') MemoryTracker.ignore('_PyObject_GC_Malloc') MemoryTracker.ignore('_PyObject_GC_Resize') MemoryTracker.ignore('TString::Clobber') MemoryTracker.ignore('PyString_FromStringAndSize') MemoryTracker.ignore('clang::') MemoryTracker.ignore('cling::') MemoryTracker.ignore('llvm::') MemoryTracker.ignore('TExMap::Expand') MemoryTracker.ignore('TExMap::TExMap') MemoryTracker.ignore('TCling::') MemoryTracker.ignore('TClingDataMemberInfo::TClingDataMemberInfo') MemoryTracker.ignore('TClingBaseClassInfo::TClingBaseClassInfo') MemoryTracker.ignore('TClingCallFunc::SetFuncProto') MemoryTracker.ignore('TClassTable::AddAlternate') MemoryTracker.ignore('ROOT::TMetaUtils::GetFileName') MemoryTracker.ignore('SvcFactory<SegMemSvc>::create') MemoryTracker.ignore('SvcFactory<JobIDSvc>::create') MemoryTracker.ignore('SvcFactory<MuonTGC_CablingSvc>::create') MemoryTracker.ignore('Service::Service') MemoryTracker.ignore('AthService::AthService') MemoryTracker.ignore('emplace_back_aux<Property') MemoryTracker.ignore('PluginService::Factory2') MemoryTracker.ignore('PropertyMgr::declareProperty') MemoryTracker.ignore('SCT_ByteStreamErrorsSvc') MemoryTracker.ignore('TClassTable::SortTable') MemoryTracker.ignore('TWebPalette::TWebPalette') MemoryTracker.ignore('Gaudi::PluginService::Factory') # ??? MemoryTracker.ignoreCall('TClass::GetClass') MemoryTracker.ignoreCall('TClass::TClass') MemoryTracker.ignoreCall('TClass::GetStreamerInfo') MemoryTracker.ignoreCall('uuid_generate') MemoryTracker.ignoreCall('TPluginManager::FindHandler') MemoryTracker.ignoreCall('TROOT::RegisterModule') MemoryTracker.ignoreCall('TStreamerInfo::TStreamerInfo') MemoryTracker.ignoreCall('TStreamerInfo::Build') MemoryTracker.ignoreCall('TClass::Property') MemoryTracker.ignoreCall('register_xAOD_') MemoryTracker.ignoreCall('xAOD::TDVCollectionProxy::TDVCollectionProxy') MemoryTracker.ignoreCall('Property* PropertyMgr::declareProperty') # Come back to MemoryTracker.ignore('ServiceManager::service') MemoryTracker.ignore('TDVCollectionProxy') MemoryTracker.ignore('allocator<IOVRange>') MemoryTracker.ignore('ArenaCachingHandle') MemoryTracker.ignore('ArenaHandle') MemoryTracker.ignore('vector<SG::ArenaBase') MemoryTracker.ignore('TConverterRegistry::AddConverter') MemoryTracker.ignore('TEmulatedCollectionProxy::InitializeEx') MemoryTracker.ignore('FileMgr::open') MemoryTracker.ignore('FileMgr::close') MemoryTracker.ignore('TMVA::DataSetFactory::Build') MemoryTracker.ignore('SimpleProperty') MemoryTracker.ignore('TDVCollectionFuncs::create_env') ### MemoryTracker.ignore('PoolSvc::setObjPtr') MemoryTracker.ignore('LWPool') MemoryTracker.ignore('std::vector<LWPoolArea') atexit.register(MemoryTracker.atexit)
sys.path.pop() class tlpgui(_tulipgui.tlpgui): pass def tulipguiExitFunc(): import tulipgui tulipgui.tlpgui.runQtMainLoop() # fix loading of Tulip plugins when the tulipgui module has been installed # with the pip tool if platform.system() == 'Linux' and os.path.exists(_tulipGuiNativePluginsPath): dlOpenFlagsBackup = sys.getdlopenflags() if sys.version_info < (3, 6): import DLFCN dlOpenFlags = DLFCN.RTLD_NOW | DLFCN.RTLD_GLOBAL else: dlOpenFlags = os.RTLD_NOW | os.RTLD_GLOBAL sys.setdlopenflags(dlOpenFlags) tlp.loadTulipPluginsFromDir(_tulipGuiPluginsPath) if (platform.system() == 'Linux' and os.path.exists(_tulipGuiNativePluginsPath)): sys.setdlopenflags(dlOpenFlagsBackup) # Check if we are in script execution mode # (sys.ps1 is not defined in that case)
import dl except ImportError: # do not give up too early: # are we on AMD64 ? try: import DLFCN as dl except ImportError: dl = None except SystemError: dl = None # set the dlopen flags so that VTK does not run into problems with # shared symbols. try: # only Python >= 2.2 has this functionality orig_dlopen_flags = sys.getdlopenflags() except AttributeError: orig_dlopen_flags = None if dl and (os.name == 'posix'): sys.setdlopenflags(dl.RTLD_NOW|dl.RTLD_GLOBAL) # -------------------------------------- from vtkCommonCore import * from vtkCommonMath import * from vtkCommonMisc import * from vtkCommonSystem import * from vtkCommonTransforms import * from vtkCommonDataModel import * from vtkCommonExecutionModel import * from vtkCommonComputationalGeometry import *
# See the License for the specific language governing permissions and # limitations under the License. # ============================================================================== """Tests for head.py.""" from __future__ import absolute_import from __future__ import division from __future__ import print_function import math import sys # TODO: #6568 Remove this hack that makes dlopen() not crash. if hasattr(sys, "getdlopenflags") and hasattr(sys, "setdlopenflags"): import ctypes sys.setdlopenflags(sys.getdlopenflags() | ctypes.RTLD_GLOBAL) import numpy as np import six from tensorflow.contrib.learn.python.learn.estimators import constants from tensorflow.contrib.learn.python.learn.estimators import head as head_lib from tensorflow.contrib.learn.python.learn.estimators import model_fn from tensorflow.contrib.learn.python.learn.estimators import prediction_key from tensorflow.core.framework import summary_pb2 from tensorflow.python.client import session from tensorflow.python.framework import constant_op from tensorflow.python.framework import dtypes from tensorflow.python.framework import ops from tensorflow.python.framework import sparse_tensor from tensorflow.python.ops import control_flow_ops
def listPythonSystem(): """! Function to list information about the installed Python system. @return: Dictionary of {attributes: values}. """ try: dllhandle = sys.dllhandle except AttributeError: dllhandle = "Not Defined" try: androidapilevel = sys.getandroidapilevel() except AttributeError: androidapilevel = "Not Defined" try: dlopenflags = sys.getdlopenflags() except AttributeError: dlopenflags = "Not Defined" try: windowsversion_major = sys.getwindowsversion().major except AttributeError: windowsversion_major = "Not Defined" try: windowsversion_minor = sys.getwindowsversion().minor except AttributeError: windowsversion_minor = "Not Defined" try: windowsversion_build = sys.getwindowsversion().build except AttributeError: windowsversion_build = "Not Defined" try: windowsversion_platform = sys.getwindowsversion().platform except AttributeError: windowsversion_platform = "Not Defined" try: service_pack = sys.getwindowsversion().service_pack if service_pack == '': service_pack = 'Not Specified' except AttributeError: service_pack = "Not Defined" try: winver = sys.winver except AttributeError: winver = "Not Defined" if sys.thread_info.lock == None: thread_info_lock = "Not Defined" else: thread_info_lock = sys.thread_info.lock if sys.thread_info.version == None: thread_info_version = "Not Defined" else: thread_info_version = sys.thread_info.version results = {"allocatedblocks": str(sys.getallocatedblocks()), "androidapilevel": str(androidapilevel), "api_version": str(sys.api_version), "base_exec_prefix": str(sys.base_exec_prefix), "base_prefix": str(sys.base_prefix), "byteorder": str(sys.byteorder), "builtin_module_names": ' | '.join(sys.builtin_module_names), "defaultencoding": str(sys.getdefaultencoding()), "dllhandle": str(dllhandle), "dlopenflags": str(dlopenflags), "exec_prefix": str(sys.exec_prefix), "executable": str(sys.executable), "filesystemencoding": str(sys.getfilesystemencoding()), "filesystemencodeerrors": str(sys.getfilesystemencodeerrors()), "flag_debug": str(sys.flags.debug), "flag_inspect": str(sys.flags.inspect), "flag_interactive": str(sys.flags.interactive), "flag_optimize": str(sys.flags.optimize), "flag_dont_write_bytecode": str(sys.flags.dont_write_bytecode), "flag_no_user_site": str(sys.flags.no_user_site), "flag_no_site": str(sys.flags.no_site), "flag_ignore_environment": str(sys.flags.ignore_environment), "flag_verbose": str(sys.flags.verbose), "flag_bytes_warning": str(sys.flags.bytes_warning), "flag_quiet": str(sys.flags.quiet), "flag_has_randomization": str(sys.flags.hash_randomization), "flag_isolated": str(sys.flags.isolated), "flag_dev_mode": str(sys.flags.dev_mode), "flag_utf8_mode": str(sys.flags.utf8_mode), "float_info_max": str(sys.float_info.max), "float_info_max_exp": str(sys.float_info.max_exp), "float_info_max_10_exp": str(sys.float_info.max_10_exp), "float_info_min": str(sys.float_info.min), "float_info_min_exp": str(sys.float_info.min_exp), "float_info_min_10_exp": str(sys.float_info.min_10_exp), "float_info_dig": str(sys.float_info.dig), "float_info_mant_dig": str(sys.float_info.mant_dig), "float_info_epsilon": str(sys.float_info.epsilon), "float_info_radix": str(sys.float_info.radix), "float_info_rounds": str(sys.float_info.rounds), "float_repr_style": str(sys.float_repr_style), "hash_info_width": str(sys.hash_info.width), "hash_info_modulus": str(sys.hash_info.modulus), "hash_info_inf": str(sys.hash_info.inf), "hash_info_nan": str(sys.hash_info.nan), "hash_info_imag": str(sys.hash_info.imag), "hash_info_algorithm": str(sys.hash_info.algorithm), "hash_info_hash_bits": str(sys.hash_info.hash_bits), "hash_info_seed_bits": str(sys.hash_info.seed_bits), "hash_info_cutoff": str(sys.hash_info.cutoff), "hexversion": str(sys.hexversion), "implementation_name": str(sys.implementation.name), "implementation_cache_tag": str(sys.implementation.cache_tag), "int_info_bits_per_digit": str(sys.int_info.bits_per_digit), "int_info_sizeof_digit": str(sys.int_info.sizeof_digit), "maxsize": str(sys.maxsize), "maxunicode": str(sys.maxunicode), "platform": str(sys.platform), "prefix": str(sys.prefix), "recursionlimit": str(sys.getrecursionlimit()), "switchinterval": str(sys.getswitchinterval()), "thread_info_name": str(sys.thread_info.name), "thread_info_lock": str(thread_info_lock), "thread_info_version": str(thread_info_version), "version_info_major": str(sys.version_info.major), "version_info_minor:": str(sys.version_info.minor), "version_info_micro": str(sys.version_info.micro), "version_info_releaselevel": str(sys.version_info.releaselevel), "version_info_serial": str(sys.version_info.serial), "windowsversion_major": str(windowsversion_major), "windowsversion_minor": str(windowsversion_minor), "windowsversion_build": str(windowsversion_build), "windowsversion_platform": str(windowsversion_platform), "windowsversion_service_pack": str(service_pack), "winver": str(sys.winver)} return results
the source code). Copies vs. in-place operation ----------------------------- Most of the functions in `numpy` return a copy of the array argument (e.g., `np.sort`). In-place versions of these functions are often available as array methods, i.e. ``x = np.array([1,2,3]); x.sort()``. Exceptions to this rule are documented. """ from __future__ import division, absolute_import, print_function import sys import ctypes _old_rtld = sys.getdlopenflags() sys.setdlopenflags(_old_rtld | ctypes.RTLD_GLOBAL) class ModuleDeprecationWarning(DeprecationWarning): """Module deprecation warning. The nose tester turns ordinary Deprecation warnings into test failures. That makes it hard to deprecate whole modules, because they get imported by default. So this is a special Deprecation warning that the nose tester will let pass without making tests fail. """ pass
__title__, __url__, __version__) import os import sys if sys.platform.startswith("linux"): # When the _pybinding C++ extension is compiled with MKL, it requires specific # dlopen flags on Linux: RTLD_GLOBAL. This will not play nice with some scipy # modules, i.e. it will produce segfaults. As a workaround, specific modules # are imported first with default dlopenflags. # After that, RTLD_GLOBAL must be set for MKL to load properly. It's not possible # to set RTLD_GLOBAL, import _pybinding and then reset to default flags. This is # fundamentally an MKL issue which makes it difficult to resolve. This workaround # is the best solution at the moment. import scipy.sparse.linalg import scipy.spatial sys.setdlopenflags(sys.getdlopenflags() | os.RTLD_GLOBAL) import _pybinding as _cpp from .model import * from .lattice import * from .shape import * from .modifier import * from .results import * from .support.pickle import save, load from .parallel import parallel_for, parallelize from . import (chebyshev, constants, greens, parallel, pltutils, results, solver, system, utils)
#################################### # fBIRN_lib.py # Script for performing fMRI quality control (fBIRN QA tools) # # TO DO: # - ... #__version__ = 20151026 # IMPORT FUNCTIONS #import os import tempfile import sys import ctypes #provides C compatible data types, allows calling functions from DLLs or shared libraries flags = sys.getdlopenflags() #?? (ctypes stuff) sys.setdlopenflags(flags|ctypes.RTLD_GLOBAL) #?? (ctypes stuff) #import argparse #import traceback #import numpy import nibabel #from compute_fd import * from statsmodels.tsa.tsatools import detrend #import statsmodels.api #import matplotlib # by default matplotlib ships configured to work with a graphical user interface which may require an X11 connection (errors running on background!) # +info:: http://matplotlib.org/faq/howto_faq.html#matplotlib-in-a-web-application-server #matplotlib.use('Agg') # should be specified right after matplotlib is imported #import matplotlib.pyplot as plt import sklearn.cross_validation from Plugin_development.MRI.MRI_fBIRN.utils.mk_slice_mosaic import *
# This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. # # # # from sys import getdlopenflags,setdlopenflags from dl import RTLD_NOW,RTLD_GLOBAL flags = getdlopenflags() setdlopenflags(RTLD_NOW | RTLD_GLOBAL) from _mapnik import * from paths import inputpluginspath # The base Boost.Python class BoostPythonMetaclass = coord.__class__ class _injector(object): class __metaclass__(BoostPythonMetaclass): def __init__(self, name, bases, dict): for b in bases: if type(b) not in (self, type): for k,v in dict.items(): setattr(b,k,v)
__author__ = "Oleksandr Pavlyk" __copyright__ = "Copyright (c) 2016, UChicago Argonne, LLC." __docformat__ = 'restructuredtext en' __all__ = ['fft_impl'] try: import mkl_fft fft_impl = 'mkl_fft' logger.debug('FFT implementation is mkl_fft') except ImportError: import os try: if os.name == 'nt': import pyfftw else: # Import pyfftw as soon as possible with RTLD_NOW|RTLD_DEEPBIND # to minimize chance of MKL overriding fftw functions import ctypes, sys curFlags = sys.getdlopenflags() sys.setdlopenflags(curFlags | ctypes.RTLD_GLOBAL) import pyfftw sys.setdlopenflags(curFlags) del curFlags fft_impl = 'pyfftw' logger.debug('FFT implementation is pyfftw') except ImportError: import numpy.fft fft_impl = 'numpy.fft' logger.debug('FFT implementation is numpy.fft')
import collections import ctypes import inspect import math import sys _oldFlags = sys.getdlopenflags() sys.setdlopenflags(_oldFlags | ctypes.RTLD_GLOBAL) from .libpymod import * sys.setdlopenflags(_oldFlags) # from http://mail.python.org/pipermail/tutor/2003-November/026645.html class Unbuffered(object): def __init__(self, stream): self.stream = stream def write(self, data): self.stream.write(data) self.stream.flush() def __getattr__(self, attr): return getattr(self.stream, attr) sys.stdout = Unbuffered(sys.stdout) def _NoNew__setattr__(self, name, value): if hasattr(self, "_frozen") and self._frozen: msg = "Can not modify object '%s' of type '%s'. It has been frozen." % (self, type(self)) raise AttributeError(msg) if hasattr(self, name): object.__setattr__(self, name, value) else: msg = "Can not create new attribute '%s' on object '%s' of type '%s'." % (name, self, type(self))
# # Unless required by applicable law or agreed to in writing, software distributed under # the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF # ANY KIND, either express or implied. See the License for the specific language # governing permissions and limitations under the License. """Module provides ``OmnisciServer`` class.""" import uuid import sys import os import pyarrow as pa import numpy as np if sys.platform == "linux": prev = sys.getdlopenflags() sys.setdlopenflags(1 | 256) # RTLD_LAZY+RTLD_GLOBAL try: from omniscidbe import PyDbEngine except ModuleNotFoundError: # fallback for older omniscidbe4py package naming from dbe import PyDbEngine if sys.platform == "linux": sys.setdlopenflags(prev) from modin.config import OmnisciFragmentSize, OmnisciLaunchParameters class OmnisciServer: """Wrapper class for OmniSci backend."""
# Copyright (C) AB Strakt # See LICENSE for details. """ pyOpenSSL - A simple wrapper around the OpenSSL library """ import sys try: orig = sys.getdlopenflags() except AttributeError: from OpenSSL import crypto else: try: import DLFCN except ImportError: try: import dl except ImportError: try: import ctypes except ImportError: flags = 2 | 256 else: flags = 2 | ctypes.RTLD_GLOBAL del ctypes else: flags = dl.RTLD_NOW | dl.RTLD_GLOBAL del dl else: flags = DLFCN.RTLD_NOW | DLFCN.RTLD_GLOBAL
import os import platform import sys import time if platform.system() == 'Linux': sys.setdlopenflags(sys.getdlopenflags() | 8) # RTLD_GLOBAL = 0x08 import cisstMultiTaskPython as mts name = 'My Tracker' period = 0.01 configuration = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'configNDITracker.xml') manager = mts.mtsManagerLocal.GetInstance() manager.CreateAllAndWait(5.0) manager.StartAllAndWait(5.0) proxy = mts.mtsComponentWithManagement('{}Proxy'.format(name)) manager.AddComponent(proxy) proxy.CreateAndWait(5.0) time.sleep(0.5) services = proxy.GetManagerComponentServices() result = services.Load('sawNDITracker') assert result, 'Failed to load {} using component services'.format( 'sawNDITracker') args = mts.mtsTaskPeriodicConstructorArg(name, period) result = services.ComponentCreate('mtsNDISerial', args) assert result, 'Failed to create {} of type {}'.format(name, 'mtsNDISerial')
dll_paths = [th_dll_path, py_dll_path, get_nvToolsExt_path(), _dl_flags.environ['PATH']] # then add the path to env _dl_flags.environ['PATH'] = ';'.join(dll_paths) else: # first check if the os package has the required flags if not hasattr(_dl_flags, 'RTLD_GLOBAL') or not hasattr(_dl_flags, 'RTLD_LAZY'): try: # next try if DLFCN exists import DLFCN as _dl_flags except ImportError: # as a last attempt, use compile-time constants import torch._dl as _dl_flags old_flags = sys.getdlopenflags() sys.setdlopenflags(_dl_flags.RTLD_GLOBAL | _dl_flags.RTLD_LAZY) del _dl_flags from torch._C import * __all__ += [name for name in dir(_C) if name[0] != '_' and not name.endswith('Base')] if platform.system() != 'Windows': sys.setdlopenflags(old_flags) del old_flags ################################################################################
import multiprocessing, os, sys, types dlflags = sys.getdlopenflags() sys.setdlopenflags(0x100 | 0x2) # RTLD_GLOBAL | RTLD_NOW import _athenamp as amp sys.setdlopenflags(dlflags) __all__ = ['cpu_count'] # cpu_count is pure python (but does call sysconf for Linux) cpu_count = multiprocessing.cpu_count # the following sets are replacements, which are accessed on C++ through the # _athenamp extesion module for now # current_process is used for identification purposes in multiprocessing; it # serves no real purpose in AthenaMP (it's only used for printing a message) # since there is a single relation of a mother process with multiple children def current_process(): ''' Return process object representing the current process ''' return amp.Process(os.getpid()) # active_children does not match exactly, but since AthenaMP only starts # readers/workers/writers from the mother, an aggregate of all groups will # do; note also that b/c of the AthenaMP model, no cleanup is needed (as is # in multiprocessing: Pools could close and re-open there)
def inline(code, arg_names=[], local_dict=None, global_dict=None, force=0, compiler="gcc", verbose=0, auto_downcast=1, support_code="", libraries=[], library_dirs=[], extra_compile_args=[], runtime_library_dirs=[], extra_objects=[], extra_link_args=[], mask_ret=[], debug=False): """Compile (if necessary) and run the C++ action specified by 'code', using weave.""" # each term on the expansion will properly unwrap a tuple pointer value # to a reference with the appropriate name and type exp_term = """typename boost::remove_pointer<typename tr1::tuple_element<%d,Args>::type>::type& %s = *tr1::get<%d>(_args);""" arg_expansion = "\n".join([ exp_term % (i,arg_names[i],i) for i in \ xrange(0, len(arg_names))]) # we need to get the locals and globals of the _calling_ function. Thus, we # need to go deeper into the call stack call_frame = sys._getframe(1) if local_dict is None: local_dict = call_frame.f_locals if global_dict is None: global_dict = call_frame.f_globals # convert variables to boost::python::object, except some known convertible # types arg_def = props arg_conv = "" arg_alias = [] alias_dict = {} for arg in arg_names: if arg not in local_dict.keys() and arg not in global_dict.keys(): raise ValueError("undefined variable: "+ arg) if arg in local_dict.keys(): arg_val = local_dict[arg] else: arg_val = global_dict[arg] if issubclass(type(arg_val), core.Graph): alias = "__gt__" + arg gi = "__gt__" + arg + "__gi" graph_type = get_graph_type(arg_val) gi_val = arg_val._Graph__graph arg_def += "typedef GraphWrap<%s > %s_graph_t;\n" % (graph_type, arg); arg_def += "GraphInterface& %s = python::extract<GraphInterface&>(%s);\n" %\ (gi, alias) arg_def += "%s_graph_t %s = graph_wrap(*boost::any_cast<%s*>(%s.GetGraphView()), %s);\n" % \ (arg, arg, graph_type, gi, gi) arg_alias.append(alias) alias_dict[alias] = gi_val elif type(arg_val) == core.PropertyMap: alias = "__gt__" + arg if arg_val == arg_val.get_graph().vertex_index: prop_name = "GraphInterface::vertex_index_map_t" elif arg_val == arg_val.get_graph().edge_index: prop_name = "GraphInterface::edge_index_map_t" else: prop_name = "%sprop_%s_t" % \ (arg_val.key_type(), clean_prop_type(arg_val.value_type())) arg_def += "%s %s;\n" % (prop_name, arg) arg_conv += "%s = get_prop<%s>(%s);\n" % \ (arg, prop_name, alias) arg_alias.append(alias) alias_dict[alias] = arg_val elif type(arg_val) not in [int, bool, float, string, numpy.ndarray]: alias = "__gt__" + arg obj_type = "python::object" if type(arg_val) == list: obj_type = "python::list" elif type(arg_val) == dict: obj_type = "python::dict" elif type(arg_val) == tuple: obj_type = "python::tuple" arg_def += "%s %s;\n" % (obj_type, arg) arg_conv += "%s = %s(python::object(python::handle<>" % (arg, obj_type) + \ "(python::borrowed((PyObject*)(%s)))));\n" % alias arg_alias.append(alias) alias_dict[alias] = arg_val elif type(arg_val) == bool: #weave is dumb with bools alias = "__gt__" + arg arg_def += "bool %s;\n" % arg; arg_conv += "%s = python::extract<bool>(python::object(python::handle<>" % arg + \ "(python::borrowed((PyObject*)(%s)))));\n" % alias arg_alias.append(alias) alias_dict[alias] = arg_val else: arg_alias.append(arg) if arg in local_dict.keys(): alias_dict[arg] = local_dict[arg] else: alias_dict[arg] = global_dict[arg] # handle returned values return_vals = "" for arg in arg_names: if arg in local_dict.keys(): arg_val = local_dict[arg] else: arg_val = global_dict[arg] if arg not in mask_ret and \ type(arg_val) not in [numpy.ndarray, core.PropertyMap] and \ not issubclass(type(arg_val), core.Graph): return_vals += 'return_vals["%s"] = %s;\n' % (arg, arg) support_code += globals()["support_template"] # set debug flag and disable optimization in debug mode compile_args = [cxxflags] + extra_compile_args if debug: compile_args = [re.sub("-O[^ ]*", "", x) for x in compile_args] + ["-g"] # insert a hash value into the code below, to force recompilation when # support_code (and module version) changes support_hash = hashlib.md5(support_code + code + \ " ".join(libraries + library_dirs + [cxxflags] + \ extra_compile_args +\ extra_objects + \ extra_link_args) + \ headers_hash + core.__version__).hexdigest() code += "\n// support code hash: " + support_hash inline_code = string.Template(globals()["code_template"]).\ substitute(var_defs=arg_def, var_extract=arg_conv, code=code, return_vals=return_vals) # RTLD_GLOBAL needs to be set in dlopen() if we want typeinfo and # friends to work properly across DSO boundaries. See # http://gcc.gnu.org/faq.html#dso orig_dlopen_flags = sys.getdlopenflags() sys.setdlopenflags(core.RTLD_NOW|core.RTLD_GLOBAL) # call weave and pass all the updated kw arguments ret_vals = \ scipy.weave.inline(inline_code, arg_alias, force=force, local_dict=alias_dict, global_dict=global_dict, compiler=compiler, verbose=verbose, auto_downcast=auto_downcast, support_code=support_code, libraries=libraries, library_dirs=sys.path + library_dirs, extra_compile_args=compile_args, runtime_library_dirs=runtime_library_dirs, extra_objects=extra_objects, extra_link_args=["-Wl,-E "] + extra_link_args) # check if exception was thrown if ret_vals["__exception_thrown"]: libgraph_tool_core.raise_error(ret_vals["__exception_error"]) else: del ret_vals["__exception_thrown"] del ret_vals["__exception_error"] sys.setdlopenflags(orig_dlopen_flags) # reset dlopen to normal case to # avoid unnecessary symbol collision # set return vals for arg in arg_names: if ret_vals.has_key(arg): if local_dict.has_key(arg): local_dict[arg] = ret_vals[arg] else: global_dict[arg] = ret_vals[arg] return ret_vals
import mfem if mfem.mfem_mode is None: mfem.mfem_mode = 'parallel' if mfem.mfem_mode == 'serial': raise ImportError("MFEM serial mode is already loaded") from mpi4py import MPI ## libmfem.a is linked only with _array.so ## this make sure that symbols are resovled import sys, ctypes rtld_now = sys.getdlopenflags() sys.setdlopenflags(ctypes.RTLD_GLOBAL | sys.getdlopenflags()) from array import * from socketstream import * from operators import * from blockoperator import * from blockvector import * from blockmatrix import * from coefficient import * from lininteg import * from handle import * from mesh import * from fe_coll import * from vector import * from fespace import * from linearform import * from bilininteg import * from gridfunc import *
# System imports import sys # Import NumPy so it will not be screwed by imports after RTLD_GLOBAL is set # Work around for lp:1085986 import numpy # Work around lp:956939 and lp:961946 import io # Store dl open flags to restore them after import stored_dlopen_flags = None if "linux" in sys.platform: stored_dlopen_flags = sys.getdlopenflags() # A try to get rid of problems with dynamic_cast of types defined in different # SWIG modules. The problem rises from the dynamic loader not making all types # available for all shared modules. The key is the RTLD_GLOBAL. RTLD_NOW is set # by default. This seems to be similar to the dynamicloadmpi problem above. # See: for references: http://gcc.gnu.org/faq.html#dso if "linux" in sys.platform: # FIXME: What with other platforms? try: from ctypes import RTLD_NOW, RTLD_GLOBAL except ImportError: RTLD_NOW = 2 RTLD_GLOBAL = 256 sys.setdlopenflags(RTLD_NOW | RTLD_GLOBAL)
def import_scope(flags): prev = sys.getdlopenflags() sys.setdlopenflags(flags) yield sys.setdlopenflags(prev)
Underworld is an open-source project. """ # first import h5py. this is due to the dlopen changes which follow. # by importing h5py, we ensure it uses the libHDF5 it was built against # as opposed to version PETSc is possibly built against. import h5py as _h5py # ok, now need to change default python dlopen flags to global # this is because when python imports the module, the shared libraries are loaded as RTLD_LOCAL # and then when MPI_Init is called, OpenMPI tries to dlopen its plugin, they are unable to # link to the openmpi libraries as they are private import sys as _sys import ctypes as _ctypes _oldflags = _sys.getdlopenflags() _sys.setdlopenflags(_oldflags | _ctypes.RTLD_GLOBAL) __version__ = "2.8.1b" # squelch h5py/numpy future warnings import warnings as _warnings _warnings.simplefilter(action='ignore', category=FutureWarning) # also these warnings as they are very noisey and not necessary # https://stackoverflow.com/questions/40845304/runtimewarning-numpy-dtype-size-changed-may-indicate-binary-incompatibility _warnings.filterwarnings("ignore", message="numpy.dtype size changed") _warnings.filterwarnings("ignore", message="numpy.ufunc size changed") # DEPRECATE # let's check PYTHONPATH includes path to lib directory, as this will probably