def __init__(self,databuf_id=1): self.buf = shm.SharedMemoryHandle(GUPPI_DATABUF_KEY+databuf_id-1) self.data_type = self.buf.read(NumberOfBytes=64, offset=0) if NEW_GBT: packed = self.buf.read(NumberOfBytes=8+4*8+3*4, offset=64) self.buf_type = n.fromstring(packed[0:8], dtype=n.int64) self.struct_size, self.block_size, self.header_size, self.index_size = \ n.fromstring(packed[8:40], dtype=n.int64) self.shmid, self.semid, self.n_block= \ n.fromstring(packed[40:52], dtype=n.int32) else: packed = self.buf.read(NumberOfBytes=3*8+3*4, offset=64) self.struct_size, self.block_size, self.header_size = \ n.fromstring(packed[0:24], dtype=n.int64) self.shmid, self.semid, self.n_block= \ n.fromstring(packed[24:36], dtype=n.int32) self.header_offset = self.struct_size if NEW_GBT: self.data_offset = self.struct_size + \ self.n_block*(self.header_size + self.index_size) else: self.data_offset = self.struct_size + self.n_block*self.header_size self.dtype = n.int8 self.read_size = self.block_size self.read_all_hdr()
def __init__(self, instance_id=None, status_semid=None, status_key=None): # Init and IPC key information if instance_id is not None: instance_id = 0 else: instance_id = instance_id if status_key is not None: self.status_key = status_key else: self.status_key = hashpipe_key.hashpipe_status_key(instance_id) if status_semid is not None: self.status_semid = status_semid else: self.status_semid = hashpipe_key.hashpipe_status_semname( instance_id) print "BFBE: FlagPole:: status key=%x" % self.status_key print "BFBE: FlagPole:: status semid: %s" % self.status_semid # Create a handle to shared memory self.status_buffer = shm.SharedMemoryHandle(self.status_key) self.sem = _possem.sem_open(self.status_semid, _possem.O_CREAT, 00644, 1) print "BFBE: FlagPole:: FlagPolse.sem", self.sem # Create a header to hold the data read from shared memory self.hdr = None self.read()
def __init__(self, instance_id=0, databuf_id=1): self.buf = shm.SharedMemoryHandle( vegas_databuf.ipckey(instance_id) + databuf_id - 1) self.data_type = self.buf.read(NumberOfBytes=64, offset=0) if NEW_GBT: packed = self.buf.read(NumberOfBytes=8 + 5 * 8 + 3 * 4, offset=64) self.buf_type = n.fromstring(packed[0:8], dtype=n.int64) self.databuf_size, self.struct_size, self.block_size, self.header_size, \ self.index_size = n.fromstring(packed[8:48], dtype=n.int64) self.shmid, self.semid, self.n_block= \ n.fromstring(packed[48:60], dtype=n.int32) else: packed = self.buf.read(NumberOfBytes=3 * 8 + 3 * 4, offset=64) self.struct_size, self.block_size, self.header_size = \ n.fromstring(packed[0:24], dtype=n.int64) self.shmid, self.semid, self.n_block= \ n.fromstring(packed[24:36], dtype=n.int32) self.header_offset = self.struct_size if NEW_GBT: self.data_offset = self.struct_size + \ self.n_block*(self.header_size + self.index_size) else: self.data_offset = self.struct_size + self.n_block * self.header_size self.dtype = n.int8 self.read_size = self.block_size self.read_all_hdr()
def __init__(self, databuf_id=1, vegas_format=True): """ Create an access object to an HPC data buffer. Two formats are supported. The 'new' vegas format and the standard guppi format. """ self.vegas_format = vegas_format self.buf = shm.SharedMemoryHandle(VEGAS_DATABUF_KEY + databuf_id - 1) self.data_type = self.buf.read(NumberOfBytes=64, offset=0) if self.vegas_format: packed = self.buf.read(NumberOfBytes=8 + 5 * 8 + 3 * 4, offset=64) self.buf_type = n.fromstring(packed[0:8], dtype=n.int64) self.databuf_size, self.struct_size, self.block_size, self.header_size, \ self.index_size = n.fromstring(packed[8:48], dtype=n.int64) self.shmid, self.semid, self.n_block= \ n.fromstring(packed[48:60], dtype=n.int32) else: packed = self.buf.read(NumberOfBytes=3 * 8 + 3 * 4, offset=64) self.struct_size, self.block_size, self.header_size = \ n.fromstring(packed[0:24], dtype=n.int64) self.shmid, self.semid, self.n_block= \ n.fromstring(packed[24:36], dtype=n.int32) self.header_offset = self.struct_size if self.vegas_format: self.data_offset = self.struct_size + \ self.n_block*(self.header_size + self.index_size) else: self.data_offset = self.struct_size + self.n_block * self.header_size self.dtype = n.int8 self.read_size = self.block_size self.read_all_hdr()
def __init__(self): self.stat_buf = shm.SharedMemoryHandle(VEGAS_STATUS_KEY) self.sem = possem.sem_open(VEGAS_STATUS_SEMID, possem.O_CREAT, 00644, 1) self.hdr = None self.gbtstat = None self.read()
def __init__(self,param_dict,keys=None,store_dtype=None): if store_dtype is None: store_dtype = param_dict.values()[0].dtype self.total_size = sum([v.size*store_dtype.itemsize for v in param_dict.values()]) self.store_dtype = store_dtype self.specs = OrderedDict() for k,v in param_dict.items(): self.specs[k] = get_var_spec(v) self.partitioning = partition_sizes(np.array([np.prod(spec.shape) for spec in self.specs.values()])) if keys is None: init = True else: init = False self.keys = keys if init: shm_nbytes = [int(sum([self.specs.values()[i].size for i in p.tolist()])*self.store_dtype.itemsize) for p in self.partitioning] MemoryHandles = [shm_wrapper.create_memory(nbytes) for nbytes in shm_nbytes] SemaphoreHandles = [shm_wrapper.create_semaphore() for l in range(len(self.partitioning))] self.mmappings = [mem_objs(MH,SH) for MH,SH in zip(MemoryHandles, SemaphoreHandles)] self.keys = [mem_keys(MH.key,SH.key) for MH,SH in zip(MemoryHandles, SemaphoreHandles)] self.write_arrays(param_dict) else: MemoryHandles = [shm_wrapper.SharedMemoryHandle(k.memory_key) for k in self.keys] SemaphoreHandles = [shm_wrapper.SemaphoreHandle(k.semaphore_key) for k in self.keys] self.mmappings = [mem_objs(MH,SH) for MH,SH in zip(MemoryHandles,SemaphoreHandles)]
def __init__(self, logger=None, side='client', memory_key=None, read_semaphore_key=None, write_semaphore_key=None, provider=None): """Setup pipes for communication """ assert ((side == 'client') or ((memory_key != None) and (read_semaphore_key != None) and (write_semaphore_key != None))) if side == 'client': self.memory_handle = shm_wrapper.create_memory(16384) self.read_semaphore = shm_wrapper.create_semaphore(InitialValue=0) self.write_semaphore = shm_wrapper.create_semaphore(InitialValue=0) if side == 'server': self.memory_handle = shm_wrapper.SharedMemoryHandle(memory_key) self.read_semaphore = shm_wrapper.SemaphoreHandle( read_semaphore_key) self.write_semaphore = shm_wrapper.SemaphoreHandle( write_semaphore_key) self.side = side Connection.__init__(self, logger=logger, side=side, provider=provider)
def __init__(self, instance_id=0): self.stat_buf = shm.SharedMemoryHandle( vegas_status.ipckey(instance_id)) self.sem = possem.sem_open(vegas_status.semname(instance_id), possem.O_CREAT, 00644, 1) self.hdr = None self.gbtstat = None self.read()
def __init__(self): self.stat_buf = shm.SharedMemoryHandle(VEGAS_STATUS_KEY) self.sem = possem.sem_open(VEGAS_STATUS_SEMID, possem.O_CREAT, 00644, 1) self.hdr = None self.gbtstat = None self.read() self.new_databuf_format = True if 'BACKEND' in self.keys(): if 'GUPPI' == self['BACKEND']: self.new_databuf_format = False # GUPPI mode
def __init__(self, log, shm_id=1): # Connect or create shm try: self.stat_buf = shmw.SharedMemoryHandle(STATUS_KEY + shm_id - 1) log.info("Connected to status shm key: 0x%08x" % (STATUS_KEY + shm_id - 1)) print("Try Connected to status shm key: 0x%08x" % (STATUS_KEY + shm_id - 1)) except KeyError: self.a = shm.create_memory(STATUS_KEY + shm_id - 1, STATUS_SIZE, 0666) log.info("Created new status shm key: 0x%08x" % (STATUS_KEY + shm_id - 1)) print("Created new status shm key: 0x%08x" % (STATUS_KEY + shm_id - 1)) # Init self.chk_init() self.stat_buf = shmw.SharedMemoryHandle(STATUS_KEY + shm_id - 1) log.info("Connected to status shm key: 0x%08x" % (STATUS_KEY + shm_id - 1)) print("Connected to status shm key: 0x%08x" % (STATUS_KEY + shm_id - 1)) # Semaphore for status shm try: self.semid = shm.getsemid(STATUS_SEM_KEY + shm_id - 1) self.sem = shm.semaphore(self.semid) except KeyError: self.sem = shm.create_semaphore(STATUS_SEM_KEY + shm_id - 1) self.semid = shm.getsemid(STATUS_SEM_KEY + shm_id - 1) self.hdr = None if (self.sem.val == 3): log.info("WARNING sem 0x%08x is lock" % (STATUS_SEM_KEY + shm_id - 1)) print("WARNING sem 0x%08x is lock" % (STATUS_SEM_KEY + shm_id - 1)) self.read()
def __init__(self, databuf_id=1): self.buf = shmw.SharedMemoryHandle(DATABUF_KEY + databuf_id - 1) self.data_type = self.buf.read(NumberOfBytes=64, offset=0) packed = self.buf.read(NumberOfBytes=3 * 8 + 3 * 4, offset=64) self.struct_size, self.block_size, self.header_size = \ n.fromstring(packed[0:24], dtype=n.int64) self.shmid, self.semid, self.n_block= \ n.fromstring(packed[24:36], dtype=n.int32) self.header_offset = self.struct_size self.data_offset = self.struct_size + self.n_block * self.header_size self.dtype = n.int8 self.read_size = self.block_size self.read_all_hdr() # Try to grab semid self.semid = shm.getsemid(DATABUF_KEY + databuf_id - 1)
def __init__(self, status_key=None, status_semid=None): # Get user dependend IPC key. TBF: multiple instances instance_id = 0 self.status_key = status_key if status_key is not None \ else hashpipe_key.hashpipe_status_key(instance_id) self.status_semid = status_semid if status_semid is not None \ else hashpipe_key.hashpipe_status_semname(instance_id) print "status key: %x " % self.status_key print "status semid: %s" % self.status_semid self.stat_buf = shm.SharedMemoryHandle(self.status_key) self.sem = possem.sem_open(self.status_semid, possem.O_CREAT, 00644, 1) print "vegas_status.sem", self.sem self.hdr = None self.gbtstat = None self.read()
def ReadFromMemory(MemoryHandle): s = MemoryHandle.read(MemoryHandle.size).strip() say("read %s" % s) return s def say(s): print "conclusion@%1.6f: %s" % (time.time(), s) if len(sys.argv) != 3: print "Please supply Mrs. Premise's keys on the command line." sys.exit(-1) MemoryHandle = shm_wrapper.SharedMemoryHandle(int(sys.argv[1])) SemaphoreHandle = shm_wrapper.SemaphoreHandle(int(sys.argv[2])) WhatIWrote = "" s = "" for i in xrange(0, DemoConstants.ITERATIONS): say("i = %d" % i) if DemoConstants.USE_SEMAPHORE: # Wait for Mrs. Premise to free up the semaphore. say("waiting for semaphore") SemaphoreHandle.P() s = ReadFromMemory(MemoryHandle) while s == WhatIWrote: