def Setup(self):
utils.say("Oooo 'ello, I'm Mrs. Premise!")
self.Params = utils.read_params()
try:
self.Semaphore = sysv_ipc.Semaphore(self.Params["KEY"],
sysv_ipc.IPC_CREX)
except sysv_ipc.ExistentialError as err:
self.Logger.debug(err)
# One of my peers created the semaphore already
self.Semaphore = sysv_ipc.Semaphore(self.Params["KEY"])
# Waiting for that peer to do the first acquire or release
while not self.Semaphore.o_time:
time.sleep(.1)
else:
# Initializing sem.o_time to nonzero value
self.Semaphore.release()
# Now the semaphore is safe to use.
try:
self.Memory = sysv_ipc.SharedMemory(self.Params["KEY"],
sysv_ipc.IPC_CREX)
except sysv_ipc.ExistentialError as err:
self.Logger.debug(err)
self.Memory = sysv_ipc.SharedMemory(self.Params["KEY"])
else:
self.Memory.release()
self.Logger.debug("Setup done")
return True
def _init_shm(self, retro_run_id):
if self.system != 'Snes':
self.shm = None
return
##### Set up the shared memory segment ##################################################
# currently only supports Snes
# Set the identifier that the SNES C code may use to create a shared memory segment
if retro_run_id is None:
self.retro_run_id = random.randint(1, 1 << 30)
else:
self.retro_run_id = retro_run_id
os.environ['RETRO_RUN_ID'] = f"{self.retro_run_id}"
self.shm_key = self.retro_run_id
shm_size = VISITED_BUFFER_SIZE * WORD_SIZE # enough to hold 2^15 16-bit words
try:
self.shm = ipc.SharedMemory(self.shm_key,
flags=ipc.IPC_CREX,
mode=0o666,
size=shm_size)
except Exception as e: # FIXME tighten this except up
shm = ipc.SharedMemory(self.shm_key, 0, 0)
ipc.remove_shared_memory(shm.id)
self.shm = ipc.SharedMemory(self.shm_key,
flags=ipc.IPC_CREX,
mode=0o666,
size=shm_size)
return
def main():
# Let's use Amazon S3
myS3 = MyS3(boto3.resource('s3'), boto3.client('s3',use_ssl=False))
# Create shared memory object
memory_key = sysv_ipc.SharedMemory(123456)
memory_return = sysv_ipc.SharedMemory(123458)
# Read value from shared memory
key = memory_key.read()
if sys.argv[1] == 'delete':
ret = myS3.delete(key)
elif sys.argv[1] == 'put':
memory_value = sysv_ipc.SharedMemory(123457)
value = memory_value.read()
ret = myS3.put(key, value)
elif sys.argv[1] == 'get':
memory_value = sysv_ipc.SharedMemory(123457)
memory_len = sysv_ipc.SharedMemory(123459)
ret = myS3.get(key, memory_value, memory_len)
else:
print('else')
memory_return.write(ret)
def test_IPC_CREAT_new(self):
"""tests sysv_ipc.IPC_CREAT to create a new SharedMemory without IPC_EXCL"""
# I can't pass None for the name unless I also pass IPC_EXCL.
key = tests_base.make_key()
# Note: this method of finding an unused key is vulnerable to a race
# condition. It's good enough for test, but don't copy it for use in
# production code!
key_is_available = False
while not key_is_available:
try:
mem = sysv_ipc.SharedMemory(key)
mem.detach()
mem.remove()
except sysv_ipc.ExistentialError:
key_is_available = True
else:
key = tests_base.make_key()
mem = sysv_ipc.SharedMemory(key,
sysv_ipc.IPC_CREAT,
size=sysv_ipc.PAGE_SIZE)
self.assertIsNotNone(mem)
mem.detach()
mem.remove()
def __init__(self, id=123456, create=None):
if create:
self.shm = sysv_ipc.SharedMemory(id, sysv_ipc.IPC_CREAT, mode=0666)
else:
self.shm = sysv_ipc.SharedMemory(id, 0, mode=0666)
self.shm_offset = {'top': 0}
def test_remove_shared_memory(self):
"""Exercise remove_shared_memory()"""
mem = sysv_ipc.SharedMemory(None, sysv_ipc.IPC_CREX)
sysv_ipc.remove_shared_memory(mem.id)
with self.assertRaises(sysv_ipc.ExistentialError):
sysv_ipc.SharedMemory(mem.key)
def __init__(self, serialPort, ID=0):
"""Initializes the status and data memory"""
self.dataMemory = sysv_ipc.SharedMemory(65)
self.statusMemory = sysv_ipc.SharedMemory(88)
instruction = NanotecSharedMemoryClient.argumentsToString(
["NanotecMotor", serialPort, ID])
self.serialPort = self.sendInstruction(instruction)
return
def activateIPC(self):
try:
self.memory = sysv_ipc.SharedMemory(123456, sysv_ipc.IPC_CREX)
except:
# if memory exists just open shared memory
self.memory = sysv_ipc.SharedMemory(123456)
self.ipcThread = Thread(target=self.loopIPC)
self.ipcThread.start()
def get_sysv_memory():
global GLOBAL_SHARE_MEMORY
if GLOBAL_SHARE_MEMORY:
return GLOBAL_SHARE_MEMORY
try:
memory = sysv_ipc.SharedMemory(SHARED_MEMORY_KEY,
sysv_ipc.IPC_CREX,
mode=0666)
except sysv_ipc.ExistentialError:
memory = sysv_ipc.SharedMemory(SHARED_MEMORY_KEY)
GLOBAL_SHARE_MEMORY = memory
return GLOBAL_SHARE_MEMORY
def initMemory(id: int):
'''
initialization of shared memory that will hold the look up table
'''
global sharedMemory
try:
sharedMemory = ss.SharedMemory(
id,
ss.IPC_CREAT) #this will look for already created shered memory
except:
sharedMemory = ss.SharedMemory(
id, ss.IPC_CREX) #this will create a new one
return
def readmem(key):
mem = sysv_ipc.SharedMemory(key)
dlen = 32
offset = 0
#read n, shape, stride
n = int(extract_double(mem.read(dlen, offset)))
offset += dlen
shape = []
stride = []
for i in range(n):
shape += [int(extract_double(mem.read(dlen, offset)))]
offset += dlen
for i in range(n):
stride += [int(extract_double(mem.read(dlen, offset)))]
offset += dlen
data = []
#read data
reading = 0
while offset < mem.size:
data += [float(extract_double(mem.read(dlen, offset)))]
offset += dlen
return data, n, shape, stride
def main():
HEADER_SHM = 'IhhI'
HEADER_PROCESS_STATUS = 'iiii%ds%dsi%ds%ds' % (
MAX_PROCESS_NAME_LEN, MAX_PROCESS_NAME_LEN,
(MAX_NUM_OF_ARGVS * MAX_ARGV_LEN + MAX_NUM_OF_ARGVS * 4),
4 * MAX_ALARM_COUNT)
key = sysv_ipc.ftok(SHM_PATH, ord(FTOK_ID), True)
Shm = sysv_ipc.SharedMemory(key)
UnpackShmStrSize = struct.calcsize(HEADER_SHM)
UnpackProcStrSize = struct.calcsize(HEADER_PROCESS_STATUS)
TotalUnpackSize = UnpackShmStrSize + UnpackProcStrSize * MAX_PROCESSES
ShmValue = ReadBytes(Shm, TotalUnpackSize)
ProcessStatusTpl = namedtuple('ProcessStatusTpl', ATTR_PROCESS_STATUS)
print '====== Process List ===================================================='
print ' idx | vld | pid | ppid | name | alias |'
print '------------------------------------------------------------------------'
offset = 0
for i in range(MAX_PROCESSES):
offset = UnpackShmStrSize + UnpackProcStrSize * i
ProcessStatus = ProcessStatusTpl._make(
struct.unpack_from(HEADER_PROCESS_STATUS, ShmValue, offset))
ShmProcStatusDisplayFmt = ' %3s | %3s | %6s | %6s | %-16s | %-20s |' % (
i, ProcessStatus.valid, ProcessStatus.pid, ProcessStatus.ppid,
RemoveNul(ProcessStatus.szName), RemoveNul(ProcessStatus.szAlias))
print ShmProcStatusDisplayFmt
print '------------------------------------------------------------------------'
def __init__(self):
try:
self.sem = sysv_ipc.Semaphore(key_smartphone_ip_sem, sysv_ipc.IPC_CREX)
except sysv_ipc.ExistentialError:
# One of my peers created the semaphore already
self.sem = sysv_ipc.Semaphore(key_smartphone_ip_sem)
# Waiting for that peer to do the first acquire or release
while not self.sem.o_time:
time.sleep(.1)
else:
# Initializing sem.o_time to nonzero value
self.sem.release()
try:
self.memory = sysv_ipc.SharedMemory(key_smartphone_ip_sm, sysv_ipc.IPC_CREX)
except sysv_ipc.ExistentialError:
self.memory = sysv_ipc.SharedMemory(key_smartphone_ip_sm)
def main():
"""Main Function Entry."""
signal.signal(signal.SIGTERM, do_exit)
process = []
xml = PboxXML()
xmllist = xml.get_config()
key = 5000 # random.randint(1000, 9999)
for root, dirs, files in os.walk('./'): # pylint: disable=W0612
for match in glob(os.path.join(root, '_main.py')):
for config in xmllist:
if config['devicedriver'] in match:
msg = bytes(json.dumps(config), encoding="utf8")
key = key + 1
memory = sysv_ipc.SharedMemory(key,
flags=sysv_ipc.IPC_CREAT,
size=len(msg))
memory.write(msg)
# print(os.system('python ' + match + ' &'))
proc = subprocess.Popen(['python', match, str(key)])
process.append(proc)
print('process id = %d' % proc.pid)
while True:
#os.system('ps -ef|grep python3|grep -v grep')
try:
time.sleep(10)
print('I am master!!!')
except KeyboardInterrupt:
led.clear()
for proc in process:
proc.kill()
sys.exit()
def main():
configure_logging()
logger = logging.getLogger('main')
logger.info("Start main process")
pid = os.getpid()
shmlock = multiprocessing.Lock()
shm = sysv_ipc.SharedMemory(SHM_KEY,
flags=sysv_ipc.IPC_CREX,
mode=0o600,
size=SHM_SIZE)
try:
shmlock.acquire()
for unused in range(4):
worker_process = multiprocessing.Process(target=worker,
args=(pid, shm.key,
shmlock),
daemon=True)
worker_process.start()
indexer_process = multiprocessing.Process(target=indexer,
args=(pid, shm.key, shmlock),
daemon=True)
indexer_process.start()
finally:
shm.detach()
try:
signal.pause()
except KeyboardInterrupt:
pass
logger.info("Stopping main process")
def test_nondefault_init_character(self):
"""tests that the init_character can be something other than the default"""
init_character = b'@'
mem = sysv_ipc.SharedMemory(None, sysv_ipc.IPC_CREX, init_character=init_character)
self.assertEqual(mem.read(mem.size), init_character * mem.size)
mem.detach()
mem.remove()
def __init__(self, shm_key, lock_key, msg_size, queue_len):
self.msg_size = msg_size
self.queue_len = queue_len
self.mem_size = HEAD_LEN + msg_size * queue_len
self.mem = sysv_ipc.SharedMemory(shm_key,
flags=sysv_ipc.IPC_CREAT,
mode=0600,
size=self.mem_size)
assert self.mem_size == self.mem.size
self.lock = sysv_ipc.Semaphore(lock_key,
flags=sysv_ipc.IPC_CREAT,
mode=0600,
initial_value=1)
self.lock.acquire()
head_buff = self.mem.read(HEAD_LEN, offset=0)
_mb, msg_bgn, msg_end, msg_cnt, _me = struct.unpack('!5I', head_buff)
if (_mb, msg_bgn, msg_end, msg_cnt, _me) == (0, 0, 0, 0, 0):
_mb = MAGIC_BGN
_me = MAGIC_END
head_buff = struct.pack('!5I', _mb, msg_bgn, msg_end, msg_cnt, _me)
self.mem.write(head_buff, offset=0)
print 'IPC_MsgQ: init bytes=%s' % self.mem_size
self.lock.release()
assert _mb == MAGIC_BGN
assert _me == MAGIC_END
def test_kwargs(self):
"""ensure init accepts keyword args as advertised"""
# mode 0x180 = 0600. Octal is difficult to express in Python 2/3 compatible code.
mem = sysv_ipc.SharedMemory(None, flags=sysv_ipc.IPC_CREX, mode=0x180,
size=sysv_ipc.PAGE_SIZE, init_character=b'x')
mem.detach()
mem.remove()
def main():
# Create shared memory file
dir = os.getcwd()
file = "shm"
shmfile = os.path.join(dir, file)
f = open(shmfile, "w+")
f.close()
# Attach shared memory to process
key = sysv_ipc.ftok(shmfile, 255)
shm = sysv_ipc.SharedMemory(key, sysv_ipc.IPC_CREAT, size=256)
# Interval Timer
interval = Interval(0.001, CoordinateToShm, args=[shm]) #run every ms
print("shmfile: {}".format(shmfile))
print("Starting Interval, press CTRL+C to stop.")
interval.start()
while True:
try:
time.sleep(0.1)
except KeyboardInterrupt:
print("Shutting down")
interval.stop()
shm.detach()
shm.remove()
break
def doReadShm(self, key):
memory = sysv_ipc.SharedMemory(key)
memory_value = memory.read()
#print ( memory_value )
return memory_value
def getFrameCount(self):
frameCount = "-1"
if self.running == True:
if self.memory == None:
# Open shared memory object
self.memory = sysv_ipc.SharedMemory(20130821)
if self.semaphore == None:
# Open semaphore
self.semaphore = sysv_ipc.Semaphore(20130822)
# Acquire the semaphore
self.semaphore.acquire(2)
# Read frame count from shared memory
frameCount = self.memory.read()
# Release the semaphore
self.semaphore.release()
# Find the 'end' of the string and strip
i = frameCount.find('\0')
if i != -1:
frameCount = frameCount[:i]
return frameCount
def _run(self):
# Obtain the keys for the shared memory and semaphores.
keySharedMemory = sysv_ipc.ftok(self.name, 1, True)
keySemMutex = sysv_ipc.ftok(self.name, 2, True)
keySemCondition = sysv_ipc.ftok(self.name, 3, True)
# Instantiate the SharedMemory and Semaphore objects.
shm = sysv_ipc.SharedMemory(keySharedMemory)
mutex = sysv_ipc.Semaphore(keySemCondition)
cond = sysv_ipc.Semaphore(keySemCondition)
while self.running:
start = time.time()
try:
cond.Z(timeout=1)
except:
continue
# with statement???
mutex.acquire()
shm.attach()
buf = shm.read()
shm.detach()
mutex.release()
img = numpy.frombuffer(buf, numpy.uint8).reshape(480, 640, 4)
self.on_data(img)
elapsed_time = time.time() - start
logger.info('%2.2f Hz', 1.0 / elapsed_time)
def _start(self):
self._group_list = sysv_ipc.SharedMemory(ftok(self._GROUP_LIST_KEY,
self._GROUP_PROJECT),
sysv_ipc.IPC_CREAT,
size=self._SEGMENT_SIZE)
self._lock = self.get_lock(self._INTERNAL_LOCK_NAME)
self._executor.start()
def main():
HEADER_SHM = 'i'
HEADER_PROCESS_STATUS = '32s32siiii32s128s'
key = sysv_ipc.ftok(SHM_PATH, ord(FTOK_ID), True)
Shm = sysv_ipc.SharedMemory(key)
UnpackShmStrSize = struct.calcsize(HEADER_SHM)
UnpackProcStrSize = struct.calcsize(HEADER_PROCESS_STATUS)
TotalUnpackSize = UnpackShmStrSize + UnpackProcStrSize * MAX_EXT_SERVER
ShmValue = ReadBytes(Shm, TotalUnpackSize)
ProcessStatusTpl = namedtuple('ProcessStatusTpl', ATTR_EXT_STATUS)
print '====== Process List ===================================================='
print ' idx | vld | pid | ppid | name | alias |'
print '------------------------------------------------------------------------'
offset = 0
for i in range(MAX_EXT_SERVER):
offset = UnpackShmStrSize + UnpackProcStrSize * i
ProcessStatus = ProcessStatusTpl._make(
struct.unpack_from(HEADER_PROCESS_STATUS, ShmValue, offset))
ShmProcStatusDisplayFmt = ' %s | %s' % (RemoveNul(
ProcessStatus.szName), RemoveNul(ProcessStatus.szProcName))
print ShmProcStatusDisplayFmt
# print ProcessStatus
print '------------------------------------------------------------------------'
def __init__(self,shm_key, win_size,buf_depth,log_file,min_target,max_target):
self.win_size = win_size
self.buf_depth = buf_depth
self.log_file = log_file.encode('utf-8')
self.min_target = min_target
self.max_target = max_target
self.shm_key = shm_key
self.heartbeat_python_lib = cdll.LoadLibrary('./heartbeat_python_lib.so')
self.cnt = -1
# conversion is from hearbeat code
log_shm_key = self.shm_key*2
state_shm_eky = self.shm_key*2+1
# remove exsisting shm
shm_ids = [shm_key ,log_shm_key, state_shm_eky]
for tmp_shm_key in shm_ids:
try:
memory = sysv_ipc.SharedMemory(tmp_shm_key)
except sysv_ipc.ExistentialError:
print('''The shared memory with tmp_shm_key "{}" doesn't exist.'''.format(tmp_shm_key))
else:
memory.remove()
print('Removed the shared memory with tmp_shm_key "{}".'.format(tmp_shm_key))
self.heartbeat_python_lib.anchors_heartbeat_init.argtypes = [ctypes.c_int,ctypes.c_int64,ctypes.c_int64,ctypes.c_char_p,ctypes.c_double,ctypes.c_double ]
suc = self.heartbeat_python_lib.anchors_heartbeat_init(self.shm_key,self.win_size,self.buf_depth,self.log_file,self.min_target,self.max_target)
if suc:
print("hb_init!")
def worker(parentpid, shmkey, shmlock):
configure_logging()
logger = logging.getLogger('worker')
logger.info("Worker has been started with pid %d", os.getpid())
shm = sysv_ipc.SharedMemory(shmkey, flags=0, mode=0o600, size=0)
try:
signal.signal(signal.SIGINT, signal.SIG_IGN)
while 1:
try:
if shmlock.acquire(block=True, timeout=1):
try:
data = Int2Int.from_ptr(shm.address)
logger.info("Processing %d keys: %s", len(data),
list(data))
finally:
shmlock.release()
else:
raise logger.warning("SHM is not available")
except Exception:
logger.exception("Processing data error")
for unused in range(random.randint(0, 10)):
if os.getppid() != parentpid:
raise StopProcess
time.sleep(0.5)
except StopProcess:
logger.info("Stopping worker process")
finally:
shm.detach()
sys.exit(0)
def __init__(self, key, size=7):
try:
self.mem = sysv_ipc.SharedMemory(key)
except sysv_ipc.ExistentialError:
self.mem = sysv_ipc.SharedMemory(key, sysv_ipc.IPC_CREAT, 0666,
size)
self.mem.write("."[0] * size, 0)
def init(aliasfile="robot/alias_list.txt"):
"""
Initialise the shared memory. This assumes that a robot process is already running
so that a block of shared memory is allocated for us to connect to.
"""
# For now, we read aliases from alias_list.txt. However, they are quite erratic and weird because
# they were added in the time when the robot was controlled using Tcl (and nobody knows why they
# didn't stick to logical variable naming).
add_aliases(aliasfile)
global locs
global memobjects
memobjects = {}
for ob in objects:
# Try to attach to the robot memory
try:
memobj = sysv_ipc.SharedMemory(
objects[ob]
) #, [flags = 0, [mode = 0600, [size = 0 or PAGE_SIZE, [init_character = ' ']]]])
memobjects[ob] = memobj
except:
print(
"Cannot access shared memory key OB_KEY. Robot process not running?"
)
def __init__(self, nb_foyers=4):
"""Constructeur de notre classe"""
#print("FIRST THING IN METEO")
self.nb_foyers = nb_foyers
self.date = 0 # int between 0 and 365 -> to get from Market
self.conditions = [
self.weather_conditions() for _ in range(self.nb_foyers)
] # contient les facteurs pour le calcul de la tempé
self.temperatures = []
try:
self.sm = sysv_ipc.SharedMemory(
10) # on se connecte à la shared memory
except sysv_ipc.ExistentialError:
print("Méteo Cannot connect to shared Memory", 10,
", terminating NOW.")
sys.exit(1)
try:
self.smSema = sysv_ipc.Semaphore(10)
except sysv_ipc.ExistentialError:
print("Méteo Cannot connect to semaphore", 10,
", terminating NOW.")
sys.exit(1)
self.current_temperature(
) # donne les températures actuelles pour les foyers
self.setup()
def get_screen(self):
self.proc_pipe.write(bytes([11]))
self.proc_pipe.write(bytes([(self._unique + 5) * 2]))
self.proc_pipe.flush()
startTime = time.time()
while True:
try:
memory = sysv_ipc.SharedMemory((self._unique + 5) * 2)
except sysv_ipc.ExistentialError:
if time.time() - startTime < Console.shared_memory_timeout:
continue
else:
self.log("Shared memory timeout!")
return self.get_screen()
except Exception as ex:
self.log("Shared memory error ", type(ex))
return
break
screen_data = np.empty((480, 640, 3), dtype=np.uint8)
for i in range(640 * 480):
rgb = memory.read(3, i * 3)
if len(rgb) == 3:
screen_data[479 - int(i / 640), i % 640, 0] = rgb[0]
screen_data[479 - int(i / 640), i % 640, 1] = rgb[1]
screen_data[479 - int(i / 640), i % 640, 2] = rgb[2]
return screen_data
