def __init__(self,
host,
port,
xprt,
max_recv_len=MAX_RECV_LEN,
auth=None,
auth_opt=None):
try:
from ovis_ldms import ldms
except:
raise ImportError(
"Failed to import ovis_ldms.ldms. "
"Please make sure that ldms is built with --enable-swig")
else:
self.ldms_module = ldms
if xprt is None:
raise ArgumentError("xprt is required to create an LDMS transport")
self.socket = None
self.host = host
self.port = port
self.xprt = xprt
self.state = "INIT"
self.ldms = None
self.ldms = ldms.Xprt(name=self.xprt, auth=auth, auth_opts=auth_opt)
if not self.ldms:
raise ValueError("Failed to create LDMS transport")
self.state = "NEW"
self.max_recv_len = self.ldms.msg_max
self.ldms.connect(host=self.host, port=self.port)
self.type = "inband"
self.state = "CONNECTED"
def __init__(self, xprt, host, port, auth=None, auth_opt=None):
"""Create a communicator interface with an LDMS Daemon (LDMSD)
Parameters:
- The transport name: 'sock', 'rdma', 'ugni', or 'fabric'
- The host name
- The port number
Keyword Parameters:
auth - The authentication plugin name
auth_opt - Options (if any) to pass to the authentication plugin
"""
self.INIT = Communicator.INIT
self.CONNECTED = Communicator.CONNECTED
self.CLOSED = Communicator.CLOSED
self.host = host
self.port = port
self.xprt = xprt
self.state = self.INIT
self.auth = auth
self.auth_opt = auth_opt
self.ldms = ldms.Xprt(name=self.xprt, auth=auth, auth_opts=auth_opt)
if not self.ldms:
raise ValueError(f"Failed to create LDMS transport "
f"{xprt}, {host}, {port}, {auth}, {auth_opt}")
self.max_recv_len = self.ldms.msg_max
def __init__(self, name, level):
_host, _port = name.rsplit("-", 1)
self.name = name
self.host = _host
self.port = int(_port)
self.level = level
self.xprt = ldms.Xprt(name = XPRT)
def do_agg(samp_port, agg_port, *args, **kwargs):
# agg-1 routine
D.x = x = ldms.Xprt()
x.connect(host="localhost", port = samp_port)
agg_change_base_value(x, 1) # initial
time.sleep(1)
D.dlist = dlist = x.dir()
# lookup
sets = do_lookup(x)
grps = [ s for s in sets if type(s) == ldms.Grp ]
ASSERT(len(grps) == 1, "expect 1 group")
D.grp = grp = grps[0]
INFO("==== 1st grp update ====")
do_update(grp, [ grp ]) # The first update will update only grp.
# This is because grp is inconsistent.
INFO("==== 2nd grp update ====")
do_update(grp, D.sets) # This update will update all members.
verify_sets(sets)
# Change the BASE_VALUE and update
INFO("==== change base value, then grp update ====")
agg_change_base_value(x, 10)
time.sleep(2)
do_update(grp, D.sets)
verify_sets(sets)
do_agg_grp(x)
do_remote_member_change()
def reconnect(self):
if self.ldms:
self.close()
self.ldms = ldms.Xprt(name=self.xprt, auth=self.auth, auth_opts=self.auth_opt)
if self.ldms is None:
return False
self.max_recv_len = self.ldms.msg_max
return self.connect()
from ovis_ldms import ldms
from record_common import *
LOG_FMT = "%(asctime)s.%(msecs)03d %(levelname)s %(module)s %(message)s"
logging.basicConfig(datefmt="%F-%T", format=LOG_FMT, level=logging.INFO)
log = logging.getLogger()
ldms.init(16*1024*1024)
set1 = add_set("node-1/set1")
set3_p = add_set("node-1/set3_p", array_card=SET_BUFFER)
set3_c = add_set("node-1/set3_c", array_card=SET_BUFFER)
set3_c.data_copy_set(1) # turn on data copy
update_set(set1, 1)
update_set(set3_p, 2)
update_set(set3_c, 3)
verify_set(set1)
verify_set(set3_p)
verify_set(set3_c)
x = ldms.Xprt(name="sock")
def listen_cb(ep, ev, arg):
log.debug("{}: {}".format(ev.type.name, ep))
G.ep = ep
G.ev = ev
rc = x.listen(host="0.0.0.0", port=412, cb=listen_cb)
import set_test
ldms.init(16*1024*1024)
def on_SIGTERM(*args):
os._exit(0)
signal.signal(signal.SIGTERM, on_SIGTERM)
# Request SIGHUP our process when parent exited
libc = ctypes.CDLL(None)
# prctl(PR_SET_PDEATHSIG, SIGHUP)
libc.prctl(1, 1)
# create the transport
lx = ldms.Xprt()
# listen
lx.listen(port=10001)
# create and publish set
set_name = "sync/" + set_test.SET_NAME
lset = ldms.Set(name=set_name, schema=set_test.SCHEMA)
lset.producer_name = "sync"
lset.publish()
# populate set data
set_test.populate_data(lset)
while True:
x = lx.accept()
psr.add_argument("-x", "--xprt", default="sock",
help="Transport type (default: sock)")
psr.add_argument("-p", "--port", default="20001",
help="Port to listen or to connect (default: 20001)")
psr.add_argument("-h", "--host", default=socket.gethostname(),
help="Port to listen or to connect (default: ${HOSTNAME})")
psr.add_argument("-m", "--mem", type=int, default=16*1024*1024,
help="Memory allocation (default: 16000000)")
psr.add_argument("-i", "--interval", default=1.0, type=float,
help="Interval (1.0 sec)")
psr.add_argument("-?", "--help", action="help",
help="Show help message")
g = psr.parse_args()
ldms.init(g.mem)
g.x = ldms.Xprt(name=g.xprt)
g.sets = dict()
g.cond = thread.Condition()
g.num_lookups = 0
g.num_updates = 0
g.num_sets = 0
g.done_dir = False
def interval_block(interval, offset):
t0 = time.time()
t1 = (t0 + interval)//interval*interval + offset
dt = t1 - t0
time.sleep(dt)
def client_lookup_cb(x, status, more, lset, arg):
g.sets[lset.name] = lset
#!/usr/bin/python3 -i
import os
import sys
from ovis_ldms import ldms
from record_common import *
ldms.init(16 * 1024 * 1024)
x0 = ldms.Xprt(name="sock")
x0.connect(host="localhost", port=411)
x1 = ldms.Xprt(name="sock")
x1.connect(host="localhost", port=412)
d0 = x0.dir()
d1 = x1.dir()
record_sampler = x0.lookup(d0[0].name)
set1 = x1.lookup("node-1/set1")
set3_p = x1.lookup("node-1/set3_p")
set3_c = x1.lookup("node-1/set3_c")
record_sampler.update()
set1.update()
set3_p.update()
set3_c.update()
verify_set(record_sampler)
verify_set(set1)
import time
import logging
import json
import threading
from set_array_common import G, set_dict, print_set, jprint, PORT, dict_list
from ovis_ldms import ldms
LOG_FMT = "%(asctime)s.%(msecs)03d %(levelname)s %(module)s %(message)s"
logging.basicConfig(datefmt="%F-%T", format=LOG_FMT, level=logging.INFO)
log = logging.getLogger()
ldms.init(16 * 1024 * 1024)
x = ldms.Xprt("sock")
x.connect(host="localhost", port=PORT)
dirs = x.dir()
names = [d.name for d in dirs]
assert (set(names) == set(["set1", "set3"]))
s1 = x.lookup("set1")
s3 = x.lookup("set3")
update_rec = list()
sem = threading.Semaphore(1)
def update_cb(s, fl, a):
#print("flag:", fl)
_set = set_dict(s)
def connect(self):
if self._conn:
self._conn.close()
self._conn = ldms.Xprt(self.xprt)
self._conn.connect(host=self.host, port=self.port)
if D.ev.type == ldms.EVENT_CONNECTED:
check(" xprt_cb({}) CONNECTED arg check".format(xprt), arg == 10)
D.connected = 1
xprt.dir(cb=dir_cb, cb_arg=arg + 10)
elif D.ev.type == ldms.EVENT_DISCONNECTED:
check(" xprt_cb({}) DISCONNECTED arg check".format(xprt), arg == 10)
D.connected = 0
async_cond.acquire()
async_cond.notify()
async_cond.release()
elif D.ev.type == ldms.EVENT_RECV:
global recv_queue
recv_queue.put(ev.data)
x = ldms.Xprt()
x.connect(host="localhost", port=10002, cb=xprt_cb, cb_arg=10)
t0 = time.time()
DT = 3.0
while D.updated < 2 and (time.time() - t0 < DT):
async_cond.acquire()
async_cond.wait(timeout=1.0)
check(" async update completed", D.updated == 2)
check(" dir result check", set(async_dlist) == \
set(["async/"+SET_NAME, "sync/"+SET_NAME]))
check(" schema name check", set(s.schema_name for s in async_slist) == \
set([ 'simple' ]))
for s in async_slist:
check(" {} data check".format(s.name), s.as_dict() == EXPECTED_DATA)
check(" {} units check".format(s.name),
[s.units(i) for i in range(0, len(s))] == UNITS)
def do_listen(port):
lx = ldms.Xprt()
lx.listen(port=port, cb=passive_xprt_cb, cb_arg=lx)
