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()
