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:
