def close(self):
import _ctypes
fn = self.lib.lt_close_env
fn.argtypes = [POINTER(SN_env)]
fn(self.env)
_ctypes.dlclose(self.lib._handle)
def close(self):
if self.system == 'windows':
_ctypes.FreeLibrary(self.kunpeng._handle)
else:
handle = self.kunpeng._handle
del self.kunpeng
_ctypes.dlclose(handle)
def close(self):
# unload the models on the C++ side
_unload_models = self.libptr.unload_models
_unload_models.restype = None
_unload_models.argtypes = [c.c_void_p]
self.libptr.unload_models(self._zpar_session_obj)
# clean up the data structures on the python side
if self.tagger:
self.tagger.cleanup()
if self.parser:
self.parser.cleanup()
if self.depparser:
self.depparser.cleanup()
# set all the fields to none to enable clean reuse
self.tagger = None
self.parser = None
self.depparser = None
self.modelpath = None
# clean up the CDLL object too so that upon reuse, we get a new one
_ctypes.dlclose(self.libptr._handle)
# pretty sure once the old object libptr was pointed to should
# get garbage collected at some point after this
self.libptr = None
self._zpar_session_obj = None
def __del__(self):
if self._lib and self._fd:
self._lib.uinput_destroy(self._fd)
self._fd = None
_ctypes.dlclose(self._lib._handle)
self._lib = None
def g2ToFile_nostreams(folder_name, file_out_name, max_time, bin_width,
pulse_spacing, max_pulse_distance):
file_list = os.listdir(folder_name)
int_bin_width = round(bin_width / tagger_resolution) * tagger_resolution
int_max_time = round(max_time / int_bin_width) * int_bin_width
int_pulse_spacing = round(pulse_spacing / int_bin_width) * int_bin_width
max_bin = int(round(int_max_time / int_bin_width))
num_files = len(file_list)
numer_list = [int(0)] * (2 * max_bin + 1)
denom_ctypes = ctypes.c_int(0)
ctypes_file_list = file_list_to_ctypes(file_list, folder_name)
lib = ctypes.CDLL(working_directory + '/' + lib_name)
lib.getG2Correlations_nostreams.argtypes = [
ctypes.c_char_p * num_files, ctypes.c_int, ctypes.c_double,
ctypes.c_double, ctypes.c_double, ctypes.c_int, ctypes.py_object,
ctypes.POINTER(ctypes.c_int)
]
start_time = time.time()
#with wurlitzer.sys_pipes():
lib.getG2Correlations_nostreams(ctypes_file_list, num_files, int_max_time,
int_bin_width, int_pulse_spacing,
max_pulse_distance, numer_list,
ctypes.byref(denom_ctypes))
print("Finished in " + str(time.time() - start_time) + "s")
if os.name == 'nt':
_ctypes.FreeLibrary(lib._handle)
else:
_ctypes.dlclose(lib._handle)
tau = np.arange(-max_bin, max_bin + 1) * int_bin_width
scipy.io.savemat(file_out_name, {
'numer': np.array(numer_list),
'denom': denom_ctypes.value,
'tau': tau
})
def __del__(self):
if self._lib and self._fd:
self._lib.uinput_destroy(self._fd)
self._fd = None
_ctypes.dlclose(self._lib._handle)
self._lib = None
def close(self):
import _ctypes
fn = self.lib.lt_close_env
fn.argtypes = [POINTER(SN_env)]
fn(self.env)
_ctypes.dlclose(self.lib._handle)
def closeLibrary():
import _ctypes
if "FreeLibrary" in dir(_ctypes):
_ctypes.FreeLibrary(ssl._lib._handle)
else:
_ctypes.dlclose(ssl._lib._handle)
def close(self):
# unload the models on the C++ side
self.libptr.unload_models()
# clean up the data structures on the python side
if self.tagger:
self.tagger.cleanup()
if self.parser:
self.parser.cleanup()
if self.depparser:
self.depparser.cleanup()
# set all the fields to none to enable clean reuse
self.tagger = None
self.parser = None
self.depparser = None
self.modelpath = None
# clean up the CDLL object too so that upon reuse, we get a new one
_ctypes.dlclose(self.libptr._handle)
# pretty sure once the old object libptr was pointed to should
# get garbage collected at some point after this
self.libptr = None
def cleanup_lib(self):
""" unload the previously loaded shared library """
if not self.using_openmp:
#this if statement is necessary because shared libraries that use
#OpenMP will core dump when unloaded, this is a well-known issue with OpenMP
logging.debug('unloading shared library')
_ctypes.dlclose(self.lib._handle)
def reload_library(lib):
handle = lib._handle
name = lib._name
del lib
while is_loaded(name):
_ctypes.dlclose(handle)
return ctypes.cdll.LoadLibrary(name)
def close(self):
if self.compiled is not None:
self.compiled = None
gc.collect()
dlclose(self.handle)
self.handle = None
gc.collect()
def cleanup_lib(self):
""" unload the previously loaded shared library """
if not self.using_openmp:
#this if statement is necessary because shared libraries that use
#OpenMP will core dump when unloaded, this is a well-known issue with OpenMP
logging.debug('unloading shared library')
_ctypes.dlclose(self.lib._handle)
def check_instruction(test_name, exec_name):
if args.instruction_check and test_name in variables.test_to_enable_symbol_dict:
symbol_name = variables.test_to_enable_symbol_dict[test_name]
if symbol_name:
lib = ctypes.cdll.LoadLibrary(exec_name)
# Raise AttributeError if symbol undefined
symbol = getattr(lib, symbol_name)
_ctypes.dlclose(lib._handle)
def dlclose(obj):
"""
Close/unload a PIE binary or a shared library.
:param obj: object returned by ctypes.CDLL when the resource was loaded
"""
if platform == "win32":
_ctypes.FreeLibrary(obj._handle) # pylint:disable=protected-access,no-member
else:
_ctypes.dlclose(obj._handle) # pylint:disable=protected-access,no-member
def unload_library(name):
if os.name != 'nt':
"""
Don't unload the library on windows, as it may result in a crash when
this gets really unloaded.
"""
if name in _library_cache:
dlclose(_library_cache[name]._handle)
del _library_cache[name]
def unload_library(name):
if os.name != 'nt':
"""
Don't unload the library on windows, as it may result in a crash when
this gets really unloaded.
"""
if name in _library_cache:
dlclose(_library_cache[name]._handle)
del _library_cache[name]
def __del__(self):
if self._DlibraryHandle is not None:
if self.port is not None:
try:
self.Close()
except:
raise YaPySerialError("Could'n t close serial port!")
dlclose(self._DlibraryHandle)
self._DlibraryHandle = None
self.DlibraryHandle = None
def close_dll(dll):
"""Closes dewesoft dll"""
result = dll.DWDeInit()
if result != DWStatus.DWSTAT_OK.value:
raise RuntimeError("DWDeInit() failed: {}".format(result))
if platform.system() == 'Windows':
_ctypes.FreeLibrary(dll._handle)
else:
_ctypes.dlclose(dll._handle)
def freeLibrary(self):
""" Call FMU destructor before being destructed. Just cleaning up. """
if hasattr(self, "_library"):
self.freeModelInstance()
if platform.system() == "Linux":
_ctypes.dlclose(self._libraryHandle)
elif platform.system() == "Windows":
_ctypes.FreeLibrary(self._libraryHandle) # only for windows
else:
raise FMUError.FMUError("Unknown platform: %s\n" % platform.system())
def unload(self, plugin):
filepath = plugin.file
cdll = plugin.cdll
self.unregister(plugin)
if cdll:
if platform.system() == 'Windows':
_ctypes.FreeLibrary(cdll._handle)
else:
_ctypes.dlclose(cdll._handle)
return filepath
def __del__(self):
if self._DlibraryHandle is not None:
if self.port is not None:
try:
self.Close()
except:
raise YaPySerialError("Could'n t close serial port!")
dlclose(self._DlibraryHandle)
self._DlibraryHandle = None
self.DlibraryHandle = None
def closeLibrary():
handle = ssl._lib._handle
if "FreeLibrary" in dir(_ctypes):
_ctypes.FreeLibrary(handle)
_ctypes.FreeLibrary(handle)
print "OpenSSL closed, handle:", handle
else:
_ctypes.dlclose(handle)
_ctypes.dlclose(handle)
print "OpenSSL dlclosed, handle:", handle
def __del__(self):
import sys
from _ctypes import dlclose
# XXX fish fish fish
mod = self.__dict__['mod']
dlclose(mod._lib._handle)
try:
del sys.modules[mod.__name__]
except KeyError:
pass
def closeLibrary():
handle = ssl._lib._handle
if "FreeLibrary" in dir(_ctypes):
_ctypes.FreeLibrary(handle)
_ctypes.FreeLibrary(handle)
print "OpenSSL closed, handle:", handle
else:
_ctypes.dlclose(handle)
_ctypes.dlclose(handle)
print "OpenSSL dlclosed, handle:", handle
def set_function_pointers(acados, model_name, user_fun_name, acados_ext_fun):
# print(user_fun_name)
# generate function pointers getter
generate_getter(user_fun_name)
# compile and load shared library
model_getter_name = user_fun_name + '_getter.so'
# model_getter_name = 'fun_getter.so' # XXX it needs an unique name !!!
system('gcc -fPIC -shared casadi_fun_ptr_getter.c -o ' +
model_getter_name + ' -L. ' + model_name)
# print(model_name)
# system('nm ' + model_name)
model_getter = CDLL(model_getter_name)
# set up function pointers
model_getter.get_fun_fun.restype = c_void_p
tmp_ptr = model_getter.get_fun_fun()
# print(tmp_ptr)
acados.external_function_casadi_set_fun.argtypes = [c_void_p, c_void_p]
acados.external_function_casadi_set_fun(acados_ext_fun, tmp_ptr)
model_getter.get_fun_work.restype = c_void_p
tmp_ptr = model_getter.get_fun_work()
acados.external_function_casadi_set_work.argtypes = [c_void_p, c_void_p]
acados.external_function_casadi_set_work(acados_ext_fun, tmp_ptr)
model_getter.get_fun_sparsity_in.restype = c_void_p
tmp_ptr = model_getter.get_fun_sparsity_in()
acados.external_function_casadi_set_sparsity_in.argtypes = [
c_void_p, c_void_p
]
acados.external_function_casadi_set_sparsity_in(acados_ext_fun, tmp_ptr)
model_getter.get_fun_sparsity_out.restype = c_void_p
tmp_ptr = model_getter.get_fun_sparsity_out()
acados.external_function_casadi_set_sparsity_out.argtypes = [
c_void_p, c_void_p
]
acados.external_function_casadi_set_sparsity_out(acados_ext_fun, tmp_ptr)
model_getter.get_fun_n_in.restype = c_void_p
tmp_ptr = model_getter.get_fun_n_in()
acados.external_function_casadi_set_n_in.argtypes = [c_void_p, c_void_p]
acados.external_function_casadi_set_n_in(acados_ext_fun, tmp_ptr)
model_getter.get_fun_n_out.restype = c_void_p
tmp_ptr = model_getter.get_fun_n_out()
acados.external_function_casadi_set_n_out.argtypes = [c_void_p, c_void_p]
acados.external_function_casadi_set_n_out(acados_ext_fun, tmp_ptr)
_ctypes.dlclose(model_getter._handle)
system('rm casadi_fun_ptr_getter.c')
system('rm ' + model_getter_name)
def error_handling(self):
time.sleep(0.001)
handle = self._shared._handle
# dlclose(handle)
while True:
try:
dlclose(handle)
except:
break
self.__attach()
def freeLibrary(self):
''' Call FMU destructor before being destructed. Just cleaning up. '''
if hasattr(self, '_library'):
self.freeModelInstance()
if platform.system() == 'Linux':
_ctypes.dlclose(self._libraryHandle)
elif platform.system() == 'Windows':
_ctypes.FreeLibrary(self._libraryHandle) #only for windows
else:
raise FMUError.FMUError('Unknown platform: %s\n' %
platform.system())
def g2ToFile_pulse(folder_name, file_out_name, min_tau_1, max_tau_1, min_tau_2,
max_tau_2, bin_width):
file_list = os.listdir(folder_name)
int_bin_width = round(bin_width / tagger_resolution) * tagger_resolution
int_min_tau_1 = round(min_tau_1 / int_bin_width) * int_bin_width
min_tau_1_bin = int(round(int_min_tau_1 / int_bin_width))
int_min_tau_2 = round(min_tau_2 / int_bin_width) * int_bin_width
min_tau_2_bin = int(round(int_min_tau_2 / int_bin_width))
int_max_tau_1 = round(max_tau_1 / int_bin_width) * int_bin_width
max_tau_1_bin = int(round(int_max_tau_1 / int_bin_width))
int_max_tau_2 = round(max_tau_2 / int_bin_width) * int_bin_width
max_tau_2_bin = int(round(int_max_tau_2 / int_bin_width))
num_files = len(file_list)
numer_list = [int(0)] * (max_tau_1_bin - min_tau_1_bin +
1) * (max_tau_2_bin - min_tau_2_bin + 1)
denom_ctypes = ctypes.c_int(0)
ctypes_file_list = file_list_to_ctypes(file_list, folder_name)
lib = ctypes.CDLL(working_directory + '/' + lib_name)
lib.getG2Correlations_pulse.argtypes = [
ctypes.c_char_p * num_files, ctypes.c_int, ctypes.c_double,
ctypes.c_double, ctypes.c_double, ctypes.c_double, ctypes.c_double,
ctypes.py_object,
ctypes.POINTER(ctypes.c_int), ctypes.c_int
]
start_time = time.time()
#with wurlitzer.sys_pipes():
lib.getG2Correlations_pulse(ctypes_file_list, num_files, int_min_tau_1,
int_max_tau_1, int_min_tau_2, int_max_tau_2,
int_bin_width, numer_list,
ctypes.byref(denom_ctypes), 4)
print("Finished in " + str(time.time() - start_time) + "s")
time.sleep(1)
if os.name == 'nt':
_ctypes.FreeLibrary(lib._handle)
else:
_ctypes.dlclose(lib._handle)
tau_1 = np.arange(min_tau_1_bin, max_tau_1_bin + 1) * int_bin_width
tau_2 = np.arange(min_tau_2_bin, max_tau_2_bin + 1) * int_bin_width
scipy.io.savemat(
file_out_name, {
'numer':
np.array(numer_list).reshape(max_tau_2_bin - min_tau_2_bin + 1,
max_tau_1_bin - min_tau_1_bin + 1),
'tau_1':
tau_1,
'tau_2':
tau_2
})
def __del__(self):
"""Handle removal of the DLL when the simulator is deleted."""
if self._dll is not None:
handle = self._dll._handle
if platform.system() == 'Windows':
_ctypes.FreeLibrary(handle) # pylint: disable=no-member
else:
_ctypes.dlclose(handle) # pylint: disable=no-member
self._dll = None
if self._dir is not None:
shutil.rmtree(self._dir)
self._dir = None
def release(self):
# type: () -> None
"""
Release any resources associated with the model.
"""
dll_handle = self._dll._handle
if os.name == 'nt':
ct.windll.kernel32.FreeLibrary(dll_handle)
else:
_ct.dlclose(dll_handle)
del self._dll
self._dll = None
def __detach(self):
try:
self.command('quit')
except:
pass
time.sleep(0.001)
handle = self._shared._handle
while True:
try:
dlclose(handle)
except:
break
def unload(dss):
library = dss.dss_lib
if os.name == "nt":
from ctypes import windll
windll.kernel32.FreeLibrary(library._handle)
else:
while _isLoaded():
import _ctypes
_ctypes.dlclose(library._handle)
_dss_delete(dss)
def _unload_lib_obj(olib):
if utils.is_windows():
import _ctypes
_ctypes.FreeLibrary(olib._handle)
del olib
elif utils.is_linux():
import _ctypes
_ctypes.dlclose(olib._handle)
del olib
elif utils.is_mac():
import _ctypes
_ctypes.dlclose(olib._handle)
del olib
def __del__(self):
import sys
if sys.platform == "win32":
from _ctypes import FreeLibrary as dlclose
else:
from _ctypes import dlclose
# XXX fish fish fish
mod = self.__dict__['mod']
dlclose(mod._lib._handle)
try:
del sys.modules[mod.__name__]
except KeyError:
pass
def __del__(self):
import sys
if sys.platform == "win32":
from _ctypes import FreeLibrary as dlclose
else:
from _ctypes import dlclose
# XXX fish fish fish
mod = self.__dict__['mod']
dlclose(mod._lib._handle)
try:
del sys.modules[mod.__name__]
except KeyError:
pass
def set_function_pointers(acados, model_name, user_fun_name, acados_ext_fun):
# print(user_fun_name)
# generate function pointers getter
generate_getter(user_fun_name)
# compile and load shared library
model_getter_name = user_fun_name + '_getter.so'
# model_getter_name = 'fun_getter.so' # XXX it needs an unique name !!!
system('gcc -fPIC -shared casadi_fun_ptr_getter.c -o ' + model_getter_name + ' -L. ' + model_name)
# print(model_name)
# system('nm ' + model_name)
model_getter = CDLL(model_getter_name)
# set up function pointers
model_getter.get_fun_fun.restype = c_void_p
tmp_ptr = model_getter.get_fun_fun()
# print(tmp_ptr)
acados.external_function_casadi_set_fun.argtypes = [c_void_p, c_void_p]
acados.external_function_casadi_set_fun(acados_ext_fun, tmp_ptr)
model_getter.get_fun_work.restype = c_void_p
tmp_ptr = model_getter.get_fun_work()
acados.external_function_casadi_set_work.argtypes = [c_void_p, c_void_p]
acados.external_function_casadi_set_work(acados_ext_fun, tmp_ptr)
model_getter.get_fun_sparsity_in.restype = c_void_p
tmp_ptr = model_getter.get_fun_sparsity_in()
acados.external_function_casadi_set_sparsity_in.argtypes = [c_void_p, c_void_p]
acados.external_function_casadi_set_sparsity_in(acados_ext_fun, tmp_ptr)
model_getter.get_fun_sparsity_out.restype = c_void_p
tmp_ptr = model_getter.get_fun_sparsity_out()
acados.external_function_casadi_set_sparsity_out.argtypes = [c_void_p, c_void_p]
acados.external_function_casadi_set_sparsity_out(acados_ext_fun, tmp_ptr)
model_getter.get_fun_n_in.restype = c_void_p
tmp_ptr = model_getter.get_fun_n_in()
acados.external_function_casadi_set_n_in.argtypes = [c_void_p, c_void_p]
acados.external_function_casadi_set_n_in(acados_ext_fun, tmp_ptr)
model_getter.get_fun_n_out.restype = c_void_p
tmp_ptr = model_getter.get_fun_n_out()
acados.external_function_casadi_set_n_out.argtypes = [c_void_p, c_void_p]
acados.external_function_casadi_set_n_out(acados_ext_fun, tmp_ptr)
_ctypes.dlclose(model_getter._handle)
system('rm casadi_fun_ptr_getter.c')
system('rm ' + model_getter_name)
def load_shared_lib(shared_lib_path: str) -> ctypes.CDLL:
"""
Load a shared library using ctypes freeing the resource at end.
"""
plugin_dll = ctypes.cdll.LoadLibrary(shared_lib_path)
try:
yield plugin_dll
finally:
if sys.platform == 'win32':
from _ctypes import FreeLibrary
FreeLibrary(plugin_dll._handle)
else:
from _ctypes import dlclose
dlclose(plugin_dll._handle)
def ctypes_integrate(ccode, ranges, tmpfolder='libs/', **kwargs):
tmpfile = '{}{}'.format(tmpfolder, str(uuid.uuid4()))
with open(tmpfile+'.c', 'w') as file:
file.writelines(ccode)
call(['gcc', '-shared', '-o', tmpfile+'.dylib', '-fPIC', tmpfile+'.c'])
lib = ctypes.CDLL(tmpfile+'.dylib')
lib.f.restype = ctypes.c_double
lib.f.argtypes = (ctypes.c_int, ctypes.c_double)
result = np.sum([nquad(lib.f, rng)[0] for rng in ranges])
dlclose(lib._handle) # this is to release the lib, so we can import the new version
try:
os.remove(tmpfile+'.c') # clean up
os.remove(tmpfile+'.dylib') # clean up
except FileNotFoundError: pass
return result
def close(self):
if self._lib is None:
return
try:
import _ctypes
if hasattr(_ctypes, 'dlclose'):
_ctypes.dlclose(self._lib._handle)
else:
logger.warning(
'Cannot close shared library; Python implementation does not provide "_ctypes.dlclose"'
)
except Exception as e:
logger.exception(e)
finally:
self._lib = None
def unloadchifhandle(lib):
"""Release a handle on the chif iLOrest library
:param lib: The library handle provided by loading the chif library.
:type lib: library handle.
"""
try:
libhandle = lib._handle
if os.name == 'nt':
windll.kernel32.FreeLibrary(None, handle=libhandle)
else:
dlclose(libhandle)
except Exception:
pass
def unload(self):
global yaya
if yaya:
yaya.unload()
# force Python to unload the library
# else the next load would not function properly
try:
_ctypes.FreeLibrary(yaya._handle)
except:
pass
try:
_ctypes.dlclose(yaya._handle)
except:
pass
yaya = cdll.LoadLibrary("libaya5.so")
def remove_lib(self):
# Unload the currently loaded dynamic linked library to be secure
if self._lib is not None:
_ctypes.FreeLibrary(self._lib._handle) if platform == 'win32' else _ctypes.dlclose(self._lib._handle)
del self._lib
self._lib = None
# deactivate the cleanup finalizers for the current set of files
if self._cleanup_files is not None:
self._cleanup_files.detach()
if self._cleanup_lib is not None:
self._cleanup_lib.detach()
# If file already exists, pull new names. This is necessary on a Windows machine, because
# Python's ctype does not deal in any sort of manner well with dynamic linked libraries on this OS.
if path.isfile(self.lib_file):
[remove(s) for s in [self.src_file, self.lib_file, self.log_file]]
if MPI:
mpi_comm = MPI.COMM_WORLD
mpi_rank = mpi_comm.Get_rank()
basename = path.join(get_cache_dir(), self._cache_key) if mpi_rank == 0 else None
basename = mpi_comm.bcast(basename, root=0)
basename = basename + "_%d" % mpi_rank
else:
basename = path.join(get_cache_dir(), "%s_0" % self._cache_key)
self.src_file = "%s.c" % basename
self.lib_file = "%s.%s" % (basename, 'dll' if platform == 'win32' else 'so')
self.log_file = "%s.log" % basename
def unloadChifHandle(self, lib):
"""Release a handle on the chif hprest library
:param lib: The library handle provided by loading the chif library.
:type lib: library handle.
"""
try:
libhandle = lib._handle
if os.name == 'nt':
windll.kernel32.FreeLibrary(None, handle=libhandle)
else:
dlclose(libhandle)
except Exception:
pass
def _load(self, name):
loader = self._get_loader()
#Unload on Windows first
if os.name == 'nt':
handle = _get_handle_by_name(name)
if handle != 0:
dlclose(handle)
#Let ctypes find it
try:
return getattr(loader, name)
#Bad luck, let's search on sys.path
except OSError:
return self._load_from_sys_path(loader, name)
def close_devices(self):
if self.devices_open:
import _ctypes
import gc
self.pyaudio.Pa_Terminate()
self.pypm.Pm_Terminate()
for x in (self.pyaudio._handle, self.pypm._handle):
if pydaw_util.IS_WINDOWS:
_ctypes.FreeLibrary(x)
else:
_ctypes.dlclose(x)
del self.pyaudio
del self.pypm
gc.collect()
self.devices_open = False
time.sleep(0.5) # Give the kernel audio API time to close
else:
pass
def so_test():
# load dynamic-link library.
sotest = cdll.LoadLibrary("./so/sointerface.so")
# execute the function in linked library
print (sotest.sum(1,2))
# before reload, need to delete the dynamic-link library.
dlclose(sotest._handle)
# in win32: _ctypes.FreeLibrary(sotest._handle)
del sotest
# update the library
os.system('make test2')
# time.sleep(1)
# reload the updated library.
sotest = cdll.LoadLibrary("./so/sointerface.so")
# execute the function in updated library
print (sotest.sum(1,2))
def __del__(self):
# print('\nin descruction\n')
if self.scheme=='erk':
if self.sens_forw=='false':
self.__acados.external_function_casadi_free(self.expl_ode_fun)
else:
self.__acados.external_function_casadi_free(self.expl_vde_for)
if self.scheme=='irk':
if self.sens_forw=='false':
self.__acados.external_function_casadi_free(self.impl_ode_fun)
self.__acados.external_function_casadi_free(self.impl_ode_fun_jac_x_xdot_z)
self.__acados.sim_config_destroy(self.config)
self.__acados.sim_dims_destroy(self.dims)
self.__acados.sim_opts_destroy(self.opts)
self.__acados.sim_out_destroy(self.sim_in)
self.__acados.sim_in_destroy(self.sim_out)
self.__acados.sim_solver_destroy(self.solver)
# print(self.__model)
# print(self.__model._handle)
# on POSIX systems; on windows call FreeLibrary instead
# print(self.__model._handle)
_ctypes.dlclose(self.__model._handle)
def compute_nustar(dom, potential, eta, Loss, M, nu_prev, eta_prev, t,
pid='0', tmpfolder='libs/', KL=None):
""" Determines the normalizing nustar for the dual-averaging update """
tmpfile = '{}{}'.format(tmpfolder, str(uuid.uuid4()))
with open(tmpfile+'.c', 'w') as file:
file.writelines(generate_ccode(dom, potential, eta, Loss))
call(['gcc', '-shared', '-o', tmpfile+'.dylib', '-fPIC', tmpfile+'.c'])
lib = ctypes.CDLL(tmpfile+'.dylib')
lib.f.restype = ctypes.c_double
lib.f.argtypes = (ctypes.c_int, ctypes.c_double)
# compute the bounds for the root finding method for mu*
if potential.isconvex():
a = eta_prev/eta*nu_prev - M # this is a bound based on convexity of the potential
b = eta_prev/eta*nu_prev + (eta_prev/eta-1)*t*M
else:
a = - Loss.max() - np.max(potential.phi_inv(1/dom.volume)/eta, 0) # this is (coarse) lower bound on nustar
b = nu_prev + 50 # this is NOT CORRECT - a hack. Need to find conservative bound for nonconvex potentials
try:
if isinstance(dom, nBox) or isinstance(dom, UnionOfDisjointnBoxes):
if isinstance(dom, nBox):
ranges = [dom.bounds]
elif isinstance(dom, UnionOfDisjointnBoxes):
ranges = [nbox.bounds for nbox in dom.nboxes]
if isinstance(potential, ExponentialPotential):
# in this case we don't have to search for nustar, we can find it (semi-)explicitly
integral = np.sum([nquad(lib.f, rng, [0])[0] for rng in ranges])
nustar = np.log(integral)/eta
else:
f = lambda nu: np.sum([nquad(lib.f, rng, args=[nu],
opts=[{'epsabs':1.49e-4, 'epsrel':1.49e-3}]*dom.n)[0]
for rng in ranges]) - 1
success = False
while not success:
try:
nustar = brentq(f, a, b)
success = True
except ValueError:
print('WARINING: PROCESS {} HAS ENCOUNTERED f(a)!=f(b)!'.format(pid))
a, b = a - 20, b + 20
elif isinstance(dom, DifferenceOfnBoxes):
if isinstance(potential, ExponentialPotential):
# in this case we don't have to search for nustar, we can find it (semi-)explicitly
integral = (nquad(lib.f, dom.outer.bounds, [0])[0]
- np.sum([nquad(lib.f, nbox.bounds, args=[0],
opts=[{'epsabs':1.49e-4, 'epsrel':1.49e-3}]*dom.n)[0] for nbox in dom.inner]))
nustar = np.log(integral)/eta
else:
f = lambda nu: (nquad(lib.f, dom.outer.bounds, [nu], opts=[{'epsabs':1.49e-4, 'epsrel':1.49e-3}])[0]
- np.sum([nquad(lib.f, nbox.bounds, [nu])[0] for nbox in dom.inner]) - 1)
success = False
while not success:
try:
nustar = brentq(f, a, b)
success = True
except ValueError:
a, b = a - 20, b + 20
print('WARINING: PROCESS {} HAS ENCOUNTERED f(a)!=f(b)!'.format(pid))
else:
raise Exception('For now, domain must be an nBox or a UnionOfDisjointnBoxes!')
if KL is not None: # Compute KL(x*,lambda)
tmpfile_KL = '{}{}'.format(tmpfolder, str(uuid.uuid4()))
with open(tmpfile_KL+'.c', 'w') as file:
file.writelines(generate_ccode(dom, potential, eta, Loss, KL=True))
try:
call(['gcc', '-shared', '-o', tmpfile_KL+'.dylib', '-fPIC', tmpfile_KL+'.c'])
lib_KL = ctypes.CDLL(tmpfile_KL+'.dylib')
lib_KL.f.restype = ctypes.c_double
lib_KL.f.argtypes = (ctypes.c_int, ctypes.c_double)
KLval = np.sum([nquad(lib_KL.f, rng, args=[nustar],
opts=[{'epsabs':1.49e-6, 'epsrel':1.49e-6}]*dom.n)[0]
for rng in ranges])
KL.append(KLval)
finally:
dlclose(lib_KL._handle)
del lib_KL
try:
os.remove(tmpfile_KL+'.c') # clean up
os.remove(tmpfile_KL+'.dylib') # clean up
except FileNotFoundError: pass
return nustar
finally:
dlclose(lib._handle) # this is to release the lib, so we can import the new version
del lib # can this fix our memory leak?
try:
os.remove(tmpfile+'.c') # clean up
os.remove(tmpfile+'.dylib') # clean up
except FileNotFoundError: pass
def unload_plugin():
dlclose(lib._handle)
def deleteCB(self, offset):
"""Free the state associated to @offset and delete it
@offset: gcc state offset
"""
_ctypes.dlclose(self.states[offset]._handle)
del self.states[offset]
def unload_library(self, tdll):
dlclose(tdll._handle)
