def main(): global semaphore print('Python: ', __file__, ' PID: ', os.getpid()) signal.signal(signal.SIGINT, signal_handler) signal.signal(signal.SIGUSR1, signal_handler) semaphore = posix_ipc.Semaphore(SEM_KEY, posix_ipc.O_CREX, initial_value=1) while True: semaphore.acquire() print() print('Lock ', __file__, '...') sec_sleep = random.randint(1, 5) print('Sleep: ', sec_sleep) time.sleep(sec_sleep) semaphore.release() print('Unock ', __file__, '...') print() time.sleep(1)
def get_shared_memory_object(name): """ Get a SharedMemory object that correlates to the name given. Args: name: The name of a shared memory. Returns: A SharedMemory object. """ try: memory = posix_ipc.SharedMemory(name) semaphore = posix_ipc.Semaphore(name) except posix_ipc.ExistentialError: return None except Exception: return None mapfile = mmap.mmap(memory.fd, memory.size) memory.close_fd() semaphore.release() return SharedMemory(memory, semaphore, mapfile)
def func_soma(valor_matriz1, valor_matriz2, modoDeEscrita=None): global result global index #Regiao critica if modoDeEscrita == None: #Usando threads mutex.acquire() result.append(valor_matriz1 + valor_matriz2) mutex.release() else: #usando fork + memoria compartilhada valor = valor_matriz1 + valor_matriz2 mamoria_map = None memoria = posix_ipc.SharedMemory("shm") mamoria_map = mmap.mmap(memoria.fd, memoria.size) memoria.close_fd() semaforo = posix_ipc.Semaphore("semafa") #Regiao critica semaforo.acquire() mamoria_map.seek(index * 4) mamoria_map.write(valor.to_bytes(4, byteorder='big')) semaforo.release()
def main(): """docstring for main""" sem = posix_ipc.Semaphore( "/sem", flags=posix_ipc.O_CREAT, mode=0600, initial_value=1) sem.acquire() # beginning of critical session with open("/tmp/count", "r+") as f: count = f.readline() if (count): count = int(count) + 1 else: count = 1 f.seek(0) f.truncate() f.write(str(count)) # end of critical session sem.release() sem.close()
def __init__(self, prefix, name, size=0, part_spec=None, open_only=False, read_only=False): self.prefix = prefix self.name = name self.open_only = open_only self.read_only = read_only self.shm_obj = None self.sem_obj = None self.part_sem_obj_list = [] # list of (upper_bound, sem_obj) self.mm = None flags = 0 prot = mmap.PROT_READ if not open_only: flags = ipc.O_CREAT | ipc.O_EXCL if size <= 0: raise RuntimeError('size should be greater than 0 while open_only=False') if not read_only: prot = prot | mmap.PROT_WRITE self.shm_obj = ipc.SharedMemory('%s.%s' % (prefix, name), flags=flags, size=size, read_only=read_only) self.sem_obj = ipc.Semaphore('%s.%s' % (prefix, name), flags=flags, initial_value=1) if part_spec: self._init_part_sems(part_spec, flags) self.mm = mmap.mmap(self.shm_obj.fd, 0, prot=prot)
def func_multiplicacao(valores, modoDeEscrita=None): global result soma = 0 for i in range(0, len(valores), 2): soma += valores[i] * valores[i + 1] #Regiao critica if modoDeEscrita == None: #usando thread mutex.acquire() result.append(soma) mutex.release() else: #usando fork + memoria compartilhada mamoria_map = None memoria = posix_ipc.SharedMemory("shm") mamoria_map = mmap.mmap(memoria.fd, memoria.size) memoria.close_fd() semaforo = posix_ipc.Semaphore("semafa") #Regiao critica semaforo.acquire() mamoria_map.seek(index * 4) mamoria_map.write(soma.to_bytes(4, byteorder='big')) semaforo.release()
def path_lock(path): path = str(path) log.debug("Waiting for lock on path: {}".format(path)) sem = posix_ipc.Semaphore( name="/{}".format(hashlib.md5(path.encode("utf-8")).hexdigest()), flags=posix_ipc.O_CREAT, initial_value=1, ) # posix_ipc.Semaphore() can be used as a context manager, and ``with`` uses implicit # ``try/finally`` blocks. However, as a context manager, posix_ipc.Semaphore() does # not ``close()`` and ``unlink()``. try: sem.acquire() log.debug("Acquired lock on path: {}".format(path)) yield finally: sem.release() log.debug("Released lock on path: {}".format(path)) try: sem.unlink() sem.close() except posix_ipc.ExistentialError: pass
def __init__(self, control_port, data_port=None, socket_timeout=300000, data_hwm=10, port=None): if port is not None: raise RuntimeError( "The port parameter of Worker was renamed to data_port" " (as in the Controller)") self.context = zmq.Context() self._socket_timeout = socket_timeout self._worker_id = os.getpid() if data_port: self.init_mb_sock(data_port, data_hwm) self._init_control_socket(control_port) self._job_uid = self.send_req("platoon-get_job_uid") print("JOB UID received from the controler {}".format(self._job_uid)) self._lock = posix_ipc.Semaphore("{}_lock".format(self._job_uid)) signal.signal(signal.SIGINT, self._handle_force_close) try: self._register_to_platoon() except Exception as exc: print(PlatoonWarning( "As pygpu is not is not imported, `all_reduce` will not be functional." ), file=sys.stderr) self._local_comm = None self._shmem_names = dict() self._shmrefs = dict() self.shared_arrays = dict()
def shm_setup(direction, shape=None): mode = 'r+b' base_address = get_address(direction) semaphore_address = base_address + '-semaphore' buffer_address = base_address + '-buffer{}' if shape: flags = posix_ipc.O_CREX else: flags = 0 sem = posix_ipc.Semaphore(semaphore_address, flags=flags) buffers = [] for i in range(3): addr = buffer_address.format(i) if shape: size = shape[0] * shape[1] * shape[2] + md_struct.size else: json_buf = posix_ipc.SharedMemory(addr, flags=flags, size=md_struct.size + 100) json_mem = mmap.mmap(json_buf.fd, json_buf.size) json_mem.seek(0) _, height, width, depth = md_struct.unpack_from(json_mem) size = height * width * depth + md_struct.size buf = posix_ipc.SharedMemory(addr, flags=flags, size=size) fd = mmap.mmap(buf.fd, buf.size) buffers.append(fd) if shape: fd.seek(0) md_struct.pack_into(fd, 0, 0, *shape) return sem, buffers
def __init__(self, rank, world_size, port_pub_sub, port_push_pull, job_id): self.rank = rank self.world_size = world_size self.port_pub_sub = port_pub_sub self.port_push_pull = port_push_pull self.job_id = job_id self._lock = posix_ipc.Semaphore("{}_lock".format(self.job_id)) self.gpu_ctx = gpuarray.get_context(None) self.local_id = collectives.GpuCommCliqueId(context=self.gpu_ctx) self.lock() comm_id_file = 'comm_id.pkl' if not os.path.isfile(comm_id_file): comm_id = self.local_id.comm_id utils.dump_pkl(comm_id, comm_id_file) else: comm_id = utils.load_pkl(comm_id_file) self.local_id.comm_id = comm_id self.unlock() print 'local_id ', self.local_id.comm_id # the following call is blocked till all workers finish calling it #print self.local_id.comm_id, self.job_id self.local_comm = collectives.GpuComm(self.local_id, self.world_size, self.rank) self.init_socket() print 'finish init worker with rank %d'%rank
def open_sem(self, name): return ipc.Semaphore(name, 0)
criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_COUNT, 30, 0.1) # prepare object points, like (0,0,0), (1,0,0), (2,0,0) ....,(6,5,0) objp = np.zeros((args.checkerboard_width * args.checkerboard_height, 3), np.float32) objp[:, :2] = np.mgrid[0:8, 0:6].T.reshape(-1, 2) # Arrays to store object points and image points from all the images. objpoints = [] # 3d point in real world space imgpoints = [] # 2d points in image plane. if not args.file: shm_fd = posixshmutils.shm_setup('{}_shm_block'.format(camera_name), args.width * args.height * 3) read_semaphore = posix_ipc.Semaphore( '/{}_shm_block_0_read'.format(camera_name), flags=posix_ipc.O_CREAT, initial_value=100) write_semaphore = posix_ipc.Semaphore( '/{}_shm_block_0_write'.format(camera_name), flags=posix_ipc.O_CREAT, initial_value=1) cam_daemon = subprocess.Popen( ['auv-{}-daemon'.format(camera_name), '-o'], stdout=open('/tmp/stdout', 'w'), stderr=open('/tmp/stderr', 'w')) print('acquiring semaphores') while write_semaphore.value == 0: pass read_semaphore.acquire() print('getting image')
def __init__(self, control_port=5567, data_port=None, data_hwm=10, devices=None, experiment_name='', log_directory='', worker_args='', multi=False): self._workers = set() self._need_init = True self._devices = list() if devices is not None: self._devices = Controller.get_workers_devices(devices) self._local_size = len(self._devices) self._global_size = self._local_size self._get_platoon_info_count = [0] self._init_new_shmem_count = [0] self._am_i_first_count = [0] signal.signal(signal.SIGTERM, self._handle_force_close) signal.signal(signal.SIGINT, self._handle_force_close) # If we are starting a multi-node training self._multinode = multi if self._multinode: print("## Running in multi-node mode.") try: self._init_region_comm() except Exception as exc: print("WARNING! {} while being in multi-node mode".format(exc), file=sys.stderr) self._region_comm = None if data_port: self.init_data(data_port, data_hwm) self._init_control_socket(control_port) # Cleanup and init local lock and job_uid name self._job_uid = "platoon_{0}_{1}".format( os.path.basename(os.path.expanduser('~')), control_port) self._lock_name = "{}_lock".format(self._job_uid) # The ExistentialError is apparently the only way to verify if # the semaphore/shared_memory exists. try: posix_ipc.unlink_semaphore(self._lock_name) except posix_ipc.ExistentialError: pass # Initializing lock self._lock = posix_ipc.Semaphore(self._lock_name, posix_ipc.O_CREAT, initial_value=1) # Init dictionaries for shared buffers with workers self._shmrefs = dict() self.shared_buffers = dict() # Initialize workers if experiment_name: try: os.makedirs(log_directory) except OSError: pass if worker_args is None: worker_args = '' worker_args += " --control-port=%d" % control_port worker_args += " --data-hwm=%d" % data_hwm if data_port: worker_args += " --data-port=%d" % data_port try: for device in self._devices: p = launch_process(log_directory, experiment_name, shlex.split(worker_args), device, "worker") self._workers.add(p.pid) except OSError as exc: print("ERROR! OS error in Popen: {}".format(exc), file=sys.stderr) sys.exit(3) except Exception as exc: print("ERROR! Other while launching process: {}".format(exc), file=sys.stderr) sys.exit(4)
def test_default_initial_value(self): """tests that the initial value is 0 by default""" if posix_ipc.SEMAPHORE_VALUE_SUPPORTED: sem = posix_ipc.Semaphore(None, posix_ipc.O_CREX) self.assertEqual(sem.value, 0) sem.unlink()
def test_zero_initial_value(self): """tests that the initial value is 0 when assigned""" if posix_ipc.SEMAPHORE_VALUE_SUPPORTED: sem = posix_ipc.Semaphore(None, posix_ipc.O_CREX, initial_value=0) self.assertEqual(sem.value, 0) sem.unlink()
# 3rd party modules import posix_ipc # Utils for this demo import utils PY_MAJOR_VERSION = sys.version_info[0] utils.say("Oooo 'ello, I'm Mrs. Conclusion!") params = utils.read_params() # Mrs. Premise has already created the semaphore and shared memory. # I just need to get handles to them. memory = posix_ipc.SharedMemory(params["SHARED_MEMORY_NAME"]) semaphore = posix_ipc.Semaphore(params["SEMAPHORE_NAME"]) # MMap the shared memory mapfile = mmap.mmap(memory.fd, memory.size) # Once I've mmapped the file descriptor, I can close it without # interfering with the mmap. This also demonstrates that os.close() is a # perfectly legitimate alternative to the SharedMemory's close_fd() method. os.close(memory.fd) what_i_wrote = "" for i in range(0, params["ITERATIONS"]): utils.say("iteration %d" % i) if not params["LIVE_DANGEROUSLY"]: # Wait for Mrs. Premise to free up the semaphore.
import os import signal import sys import thread import posix_ipc as pos import time #On récupère les paramètres et varables utiles nomFichier = sys.argv[2] #récupère le 1er paramètre, le nom du fichier nbsecondes = sys.argv[4] #récupère le 2eme paramètre, le nombre de secondes pidServeur = os.getpid() #On récupère l'id du processus serveur, peut être inutile ! #On va creer les sémaphore qui serviront ensuite, a l'interieur d'une fonction cela ne fonctionne pas. try: Ssupp = pos.Semaphore("/Semaphore_supp" + nomFichier ,pos.O_CREAT,initial_value=1) except pos.ExistentialError: Ssupp = pos.Semaphore("/Semaphore_supp" + nomFichier,pos.O_CREAT) try: Slaps = pos.Semaphore("/Semaphore_laps" + nomFichier ,pos.O_CREAT,initial_value=1) except pos.ExistentialError: Slaps = pos.Semaphore("/Semaphore_laps" + nomFichier,pos.O_CREAT) try: Svisu = pos.Semaphore("/Semaphore_visu" + nomFichier ,pos.O_CREAT,initial_value=1) except pos.ExistentialError: Svisu = pos.Semaphore("/Semaphore_visu" + nomFichier,pos.O_CREAT) try: Sadd = pos.Semaphore("/Semaphore_add" + nomFichier ,pos.O_CREAT,initial_value=1) except pos.ExistentialError: Sadd = pos.Semaphore("/Semaphore_add" + nomFichier,pos.O_CREAT) try:
def __init__(self, name): flags = posix_ipc.O_RDWR + posix_ipc.O_CREAT self._sem = posix_ipc.Semaphore(name, flags=flags, mode=0o600) self._name = name
def setUp(self): self.sem = posix_ipc.Semaphore(None, posix_ipc.O_CREX, initial_value=1)
import sys, socket sys.path.append("/home/dryden2/lib64/python2.6/site-packages") import posix_ipc hostname = socket.gethostname() try: gdb_semaphore = posix_ipc.Semaphore("/PGDBSemaphore" + hostname) gdb_semaphore.unlink() gdb_semaphore.close() print "Closed semaphore." except posix_ipc.ExistentialError: pass try: gdb_shmem = posix_ipc.SharedMemory("/PGDBMem" + hostname) gdb_shmem.unlink() print "Closed shared memory." except posix_ipc.ExistentialError: pass
try: filmess = pos.MessageQueue("/queue", pos.O_CREAT) # ouvre la file except pos.ExistentialError: pos.unlink_message_queue("/queue") # détruit la file filmess = pos.MessageQueue( "/queue", pos.O_CREAT) # puis redemande la création (message, priorite) = filmess.receive() # retire le message en tête de file print "gobatch : Le message reçu est : {}, de priorité {}".format( message, priorite) # Type d'action en fonction de la priorité (type) du message if priorite == 1: # Action : lecture du fichier fbatch lectureFichier() elif priorite == 2: # Action : suppression de la commande spécifiée supprimerThread(message) elif priorite == 3: # Action : écriture dans le fichier fbatch creationThread() if __name__ == "__main__": #Initialisation du sémaphore try: S = pos.Semaphore("/S1", pos.O_CREAT | pos.O_EXCL, initial_value=0) except pos.ExistentialError: S = pos.Semaphore("/S1", pos.O_CREAT) run()
def test_nonzero_initial_value(self): """tests that the initial value is non-zero when assigned""" sem = posix_ipc.Semaphore(None, posix_ipc.O_CREX, initial_value=42) self.assertEqual(sem.value, 42) sem.unlink()
def test_default_initial_value(self): """tests that the initial value is 0 by default""" sem = posix_ipc.Semaphore(None, posix_ipc.O_CREX) self.assertEqual(sem.value, 0) sem.unlink()
def unroll(args, func, method, results): global index if method == "thred": #Modo thread threads = [] valores = [] if args[2] == 0: #soma for i in range(len(args[0])): for j in range(len(args[0][0])): threads.append( threading.Thread(target=func, args=(args[0][i][j], args[1][i][j]))) else: #multiplicao for i in range(len(args[0])): for colunas_matriz2 in range(len(args[1][0])): for j in range(len(args[1])): valores.append(args[0][i][j]) valores.append(args[1][j][colunas_matriz2]) threads.append( threading.Thread(target=func, args=([valores.copy()]))) valores.clear() for i in range(len(threads)): threads[i].start() else: #Modo multiporcessos i = 0 j = 0 tamanho_da_memoria = len(args[0][0]) * len(args[1]) * 4 memoria_mapeada = None #Memoria compartilhada memoria_compartilhada = posix_ipc.SharedMemory("shm", flags=posix_ipc.O_CREAT, mode=0o777, size=tamanho_da_memoria) memoria_mapeada = mmap.mmap(memoria_compartilhada.fd, memoria_compartilhada.size) memoria_compartilhada.close_fd() #memoria_mapeada.seek(0) #Semaforos semaforo = posix_ipc.Semaphore("semafa", flags=posix_ipc.O_CREAT, mode=0o777, initial_value=1) pid_processo_pai = os.getpid() processoPaiPrecisaMaisUmFilho = True while processoPaiPrecisaMaisUmFilho: if i != (len(args[0])): pid = os.fork() if pid == 0: if args[2] == 0: func(args[0][i][j], args[1][i][j], "fork") else: valores = [] for x in range(len(args[0][0])): valores.append(args[0][i][x]) valores.append(args[1][x][j]) func(valores, "fork") os.kill(os.getpid(), signal.SIGKILL) else: if j < (len(args[0][0]) - 1): j += 1 else: i += 1 j = 0 index += 1 else: time.sleep(0.5) processoPaiPrecisaMaisUmFilho = False break if pid_processo_pai == os.getpid(): #Imprimir os valores que estão na memoria compartilhada if args[2] == 0: print("Resultado da soma:") else: print("Resultado da multiplicação:") memoria_mapeada.seek(0) for i in range((len(args[0]) * len(args[0][0]))): valorFinal = memoria_mapeada.read(4) valor = int.from_bytes(valorFinal, byteorder='big') print(str(valor), " ", end='') if (i + 1) % len(args[0][0]) == 0: print() #====================================================== memoria_mapeada.close() posix_ipc.unlink_shared_memory("shm") semaforo.close() index = 0
elif user_answer == "fork": #Usando o mode fork + memoria compartilhada tamanho_da_memoria = len(matriz1) * len(matriz2[1]) * 4 memoria_mapeada = None #Memoria compartilhada memoria_compartilhada = posix_ipc.SharedMemory("shm", flags=posix_ipc.O_CREAT, mode=0o777, size=tamanho_da_memoria) memoria_mapeada = mmap.mmap(memoria_compartilhada.fd, memoria_compartilhada.size) memoria_compartilhada.close_fd() #memoria_mapeada.seek(0) #Semaforos semaforo = posix_ipc.Semaphore("semafa", flags=posix_ipc.O_CREAT, mode=0o777, initial_value=1) #Usando o fork para fazer a soma unroll([matriz1, matriz2, 0], func_soma, "fork", result) #Imprimir os valores que estão na memoria compartilhada print("Resultado da soma:") printSHM() #Usando o fork para fazer a multiplicação unroll([matriz1, matriz2, 1], func_multiplicacao, "fork", result) #Imprimir os valores que estão na memoria compartilhada print("Resultado da multiplicação:") printSHM() #Fechando as coisas memoria_mapeada.close() posix_ipc.unlink_shared_memory("shm") semaforo.close()
def test_no_flags(self): """tests that opening a semaphore with no flags opens the existing semaphore and doesn't create a new semaphore""" sem_copy = posix_ipc.Semaphore(self.sem.name) self.assertEqual(self.sem.name, sem_copy.name)
# Assert manual control over the garbage collector gc.disable() the_range = range(TEST_COUNT) if SKIP_SEMAPHORE_TESTS: say("Skipping semaphore tests") else: say("Running semaphore create/destroy test...") print_mem_before() for i in the_range: name = "/" + ''.join(random.sample(NAME_CHARACTERS, NAME_LENGTH)) sem = posix_ipc.Semaphore(name, posix_ipc.O_CREX) sem.unlink() sem.close() print_mem_after() say("Running semaphore create/destroy test 2...") print_mem_before() for i in the_range: name = "/" + ''.join(random.sample(NAME_CHARACTERS, NAME_LENGTH)) sem = posix_ipc.Semaphore(name, posix_ipc.O_CREX) sem.close() posix_ipc.unlink_semaphore(name) print_mem_after()
def test_o_creat_existing(self): """tests posix_ipc.O_CREAT to open an existing semaphore without O_EXCL""" sem_copy = posix_ipc.Semaphore(self.sem.name, posix_ipc.O_CREAT) self.assertEqual(self.sem.name, sem_copy.name)
import posix_ipc import sys import threading SMEM_NAME = "smlu" # Cria a mémoria compartilhada memory = posix_ipc.SharedMemory(SMEM_NAME, flags=posix_ipc.O_CREAT, mode=0o777, size=50) mm_results = mmap.mmap(memory.fd, memory.size) memory.close_fd() #Cria o semáforo sem = posix_ipc.Semaphore("test_sem", flags=posix_ipc.O_CREAT, mode=0o777, initial_value=1) #Funcao que efetua a operacao em cada elemento da matriz em uma thread. def proc_func(args, pos): result = sum(args) # inicio da área protegida sem.acquire() mm_results[pos:pos + 4] = result.to_bytes(4, byteorder='big') sem.release() # fim da área protegida #Funcao que efetua a operacao em cada elemento da matriz em um processo def thread_func(results, args, pos):
#! /usr/bin/python3 # -*- coding: utf8 -*- import posix_ipc as pos pos.Semaphore('/Info_Logger', pos.O_CREAT).unlink() pos.Semaphore('/Error_Logger', pos.O_CREAT).unlink() pos.Semaphore('/FBatch_Semaphore', pos.O_CREAT).unlink() pos.Semaphore('/FBatch_Updated', pos.O_CREAT).unlink() pos.MessageQueue('/queue', pos.O_CREAT).unlink() exit()