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