def set_log_file_async(self, filename):
self.log.info("Starting async load of log %s" % filename)
try:
self.logparser = LogParser(filename)
except IOError:
self.log.error("Unable to load log file %s" % filename)
self.logparser = None
return
except LogParseException:
self.log.error("Invalid log file %s" % filename)
self.logparser = None
return
#Build frame-to-snapshot mapping
self.snapshot_frames = []
for i in range(0, self.logparser.get_snapshot_count()):
self.logparser.seek_snapshot_index(i)
(dt, var_changes) = self.logparser.parse_one_slice()
for (q, var_name, r, val) in var_changes:
if var_name == self.camvar: #TODO: fix; make work with downward camera
self.snapshot_frames.append(val)
if self.kill.is_set():
return
if self.kill.is_set():
return
self.logparser.seek_snapshot_index(0) #Seek to start of the log again
self.last_index = 0
self.log.info("Switched to log file %s" % filename)
def log_to_array(logname, targets):
parse = LogParser(logname)
times = []
values = []
current_state = [0 for v in targets]
index = dict([(v, i) for i, v in enumerate(targets)])
while not parse.finished_parsing():
time, changes = parse.parse_one_slice()
changed = False
for var, name, type, value in changes:
if name in index:
current_state[index[name]] = float(value)
changed = True
if changed:
times.append(time)
values.append(current_state[:])
start = times[0]
times = np.array([(t - start).microseconds / 1e6 + (t - start).seconds
for t in times])
values = np.array(values).T
return times, values
def log_to_array(logname, targets):
parse = LogParser(logname)
times = []
values = []
current_state = [0 for v in targets]
index = dict( [(v,i) for i,v in enumerate(targets)] )
while not parse.finished_parsing():
time, changes = parse.parse_one_slice()
changed = False
for var, name, type, value in changes:
if name in index:
current_state[index[name]] = float(value)
changed = True
if changed:
times.append(time)
values.append(current_state[:])
start = times[0]
times = np.array([(t-start).microseconds/1e6+(t-start).seconds for t in times])
values = np.array(values).T
return times, values
def set_log_file_async(self, filename):
self.log.info("Starting async load of log %s" % filename)
try:
self.logparser = LogParser(filename)
except IOError:
self.log.error("Unable to load log file %s" % filename)
self.logparser = None
return
except LogParseException:
self.log.error("Invalid log file %s" % filename)
self.logparser = None
return
#Build frame-to-snapshot mapping
self.snapshot_frames = []
for i in range(0, self.logparser.get_snapshot_count()):
self.logparser.seek_snapshot_index(i)
(dt, var_changes) = self.logparser.parse_one_slice()
for (q, var_name, r, val) in var_changes:
if var_name == self.camvar: #TODO: fix; make work with downward camera
self.snapshot_frames.append(val)
if self.kill.is_set():
return
if self.kill.is_set():
return
self.logparser.seek_snapshot_index(0) #Seek to start of the log again
self.last_index = 0
self.log.info("Switched to log file %s" % filename)
class LogPlayer(Thread):
"""
Thread in charge of playing logs
"""
def __init__(self, filter=''):
Thread.__init__(self)
self.c = Condition()
self.frame = None
self.log_to_load = None
self.last_frame = -1
self.logparser = None
self.kill = Event()
self.enabled = False
# Shared variable filter
self.filter = filter
self.filtervars = []
if filter != '':
gps = libshm.parse.parse(filter)
for g in gps:
self.filtervars += map(lambda x: g['groupname'] + "." + x,
g['vars'].keys())
self.log.info("Filter applied")
self.start()
def set_frame(self, frame):
if not self.enabled:
return
if self.logparser is None:
self.log.error("No log file loaded; unable to seek")
return
with self.c:
self.frame = frame
self.c.notify()
def set_enabled(self, enabled):
if self.logparser is None:
self.log.error("No log file loaded; unable to play log")
return
self.enabled = enabled
if enabled:
self.log.info("Log playback now synchronized with CAVE")
else:
self.log.info("No longer playing log")
def set_camera(self, linked_camera):
self.camvar = camera_map[linked_camera]
#Get the snapshot index of a given frame given the snapshot mapping table
def index_of_frame(self, frame):
i = bisect.bisect_right(self.snapshot_frames, frame)
return max(0, i - 1)
#Switch log files
def set_log_file(self, filename):
with self.c:
self.log_to_load = filename
self.c.notify()
#Actually set the log file
#This can be slow so it is done asynchronously
def set_log_file_async(self, filename):
self.log.info("Starting async load of log %s" % filename)
try:
self.logparser = LogParser(filename)
except IOError:
self.log.error("Unable to load log file %s" % filename)
self.logparser = None
return
except LogParseException:
self.log.error("Invalid log file %s" % filename)
self.logparser = None
return
#Build frame-to-snapshot mapping
self.snapshot_frames = []
for i in range(0, self.logparser.get_snapshot_count()):
self.logparser.seek_snapshot_index(i)
(dt, var_changes) = self.logparser.parse_one_slice()
for (q, var_name, r, val) in var_changes:
if var_name == self.camvar: #TODO: fix; make work with downward camera
self.snapshot_frames.append(val)
if self.kill.is_set():
return
if self.kill.is_set():
return
self.logparser.seek_snapshot_index(0) #Seek to start of the log again
self.last_index = 0
self.log.info("Switched to log file %s" % filename)
def destroy(self):
with self.c:
self.kill.set()
self.c.notify()
def run(self):
while not self.kill.is_set():
with self.c:
while self.frame is None and self.log_to_load is None:
self.c.wait()
if self.kill.is_set():
return
seek_frame = None
log_to_load = None
if self.frame is not None:
seek_frame = self.frame
self.frame = None
if self.log_to_load is not None:
log_to_load = self.log_to_load
self.log_to_load = None
if log_to_load is not None:
self.set_log_file_async(log_to_load)
if seek_frame is not None:
t1 = time()
if (seek_frame <= self.last_frame
or seek_frame > self.last_frame + MAX_FRAME_DIFF):
index = self.index_of_frame(seek_frame)
self.logparser.seek_snapshot_index(index)
while True:
v = self.logparser.parse_one_slice()
if v is None:
self.log.warning("Frame %d out of range of log" %
seek_frame)
break
changetime, changelist = v
exit = False
for (svar, varstr, vtype, val) in changelist:
if svar is not None:
if self.filtervars and varstr not in self.filtervars:
continue
svar.set(val)
if varstr == self.camvar:
if val >= seek_frame:
exit = True
if exit:
#Reached desired frame
break
self.last_frame = seek_frame
dt = time() - t1
self.kill.wait(1.0 / FPS - dt)
ap = argparse.ArgumentParser(description='Benchmark a log file playback.')
ap.add_argument('log file', type=str, help='filename of the log file')
args = vars(ap.parse_args())
filename = args['log file']
try:
login = open(filename, 'r')
except IOError:
print "Input filename " + filename + " not found."
sys.exit(0)
st = time()
try:
parse = LogParser(filename, parse_file_end=False)
except:
print "There was a problem with the log header."
sys.exit(0)
et = time() - st
print "Log header parse took %.2f ms" % (et * 1e3)
#Starting log benchmark
st = time()
total_time = 0
all_type_times = {}
slices = 0
des = args['variables']
wrt_mode = (len(args['WRT_VARIABLE']) > 0)
wrt_prev = None
ddict = dict(map(lambda x: (x, 0), des)) #output variable dictionary
if wrt_mode:
ddict[args['WRT_VARIABLE']] = 0
des += [args['WRT_VARIABLE']]
ivaldict = dict(map(lambda x: (x, False), des)) #initial value set?
outputfilename = args['OUTPUT_FILENAME']
filename = args['INPUT_FILENAME']
parse = LogParser(filename)
log_start_time = parse.get_starttime()
log_end_time = parse.get_endtime()
cur_time = log_start_time
interrupted = False
def timediff(t1, t2):
z = (t2 - t1)
return z.seconds + z.microseconds / 1e6
print "Generating pickle file %s from %s..." % (args['OUTPUT_FILENAME'],
args['INPUT_FILENAME'])
ap = argparse.ArgumentParser(description='Benchmark a log file playback.')
ap.add_argument('log file', type=str, help='filename of the log file')
args = vars(ap.parse_args())
filename = args['log file']
try:
login = open(filename, 'r')
except IOError:
print "Input filename " + filename + " not found."
sys.exit(0)
st = time()
try:
parse = LogParser(filename, parse_file_end=False)
except:
print "There was a problem with the log header."
sys.exit(0)
et = time() - st
print "Log header parse took %.2f ms" % (et * 1e3)
#Starting log benchmark
st = time()
total_time = 0
all_type_times = {}
slices = 0
class LogPlayer(Thread):
"""
Thread in charge of playing logs
"""
def __init__(self, filter=''):
Thread.__init__(self)
self.c = Condition()
self.frame = None
self.log_to_load = None
self.last_frame = -1
self.logparser = None
self.kill = Event()
self.enabled = False
# Shared variable filter
self.filter = filter
self.filtervars = []
if filter != '':
gps = libshm.parse.parse(filter)
for g in gps:
self.filtervars += map(lambda x : g['groupname'] + "." + x, g['vars'].keys())
self.log.info("Filter applied")
self.start()
def set_frame(self, frame):
if not self.enabled:
return
if self.logparser is None:
self.log.error("No log file loaded; unable to seek")
return
with self.c:
self.frame = frame
self.c.notify()
def set_enabled(self, enabled):
if self.logparser is None:
self.log.error("No log file loaded; unable to play log")
return
self.enabled = enabled
if enabled:
self.log.info("Log playback now synchronized with CAVE")
else:
self.log.info("No longer playing log")
def set_camera(self, linked_camera):
self.camvar = camera_map[linked_camera]
#Get the snapshot index of a given frame given the snapshot mapping table
def index_of_frame(self, frame):
i = bisect.bisect_right(self.snapshot_frames, frame)
return max(0, i-1)
#Switch log files
def set_log_file(self, filename):
with self.c:
self.log_to_load = filename
self.c.notify()
#Actually set the log file
#This can be slow so it is done asynchronously
def set_log_file_async(self, filename):
self.log.info("Starting async load of log %s" % filename)
try:
self.logparser = LogParser(filename)
except IOError:
self.log.error("Unable to load log file %s" % filename)
self.logparser = None
return
except LogParseException:
self.log.error("Invalid log file %s" % filename)
self.logparser = None
return
#Build frame-to-snapshot mapping
self.snapshot_frames = []
for i in range(0, self.logparser.get_snapshot_count()):
self.logparser.seek_snapshot_index(i)
(dt, var_changes) = self.logparser.parse_one_slice()
for (q, var_name, r, val) in var_changes:
if var_name == self.camvar: #TODO: fix; make work with downward camera
self.snapshot_frames.append(val)
if self.kill.is_set():
return
if self.kill.is_set():
return
self.logparser.seek_snapshot_index(0) #Seek to start of the log again
self.last_index = 0
self.log.info("Switched to log file %s" % filename)
def destroy(self):
with self.c:
self.kill.set()
self.c.notify()
def run(self):
while not self.kill.is_set():
with self.c:
while self.frame is None and self.log_to_load is None:
self.c.wait()
if self.kill.is_set():
return
seek_frame = None
log_to_load = None
if self.frame is not None:
seek_frame = self.frame
self.frame = None
if self.log_to_load is not None:
log_to_load = self.log_to_load
self.log_to_load = None
if log_to_load is not None:
self.set_log_file_async(log_to_load)
if seek_frame is not None:
t1 = time()
if (seek_frame <= self.last_frame or seek_frame > self.last_frame + MAX_FRAME_DIFF):
index = self.index_of_frame(seek_frame)
self.logparser.seek_snapshot_index(index)
while True:
v = self.logparser.parse_one_slice()
if v is None:
self.log.warning("Frame %d out of range of log" % seek_frame)
break
changetime, changelist = v
exit = False
for (svar, varstr, vtype, val) in changelist:
if svar is not None:
if self.filtervars and varstr not in self.filtervars:
continue
svar.set(val)
if varstr == self.camvar:
if val >= seek_frame:
exit = True
if exit:
#Reached desired frame
break
self.last_frame = seek_frame
dt = time() - t1
self.kill.wait(1.0 / FPS - dt)
Program to display information about a shared variable log file in a human-readable format.
See logview.py --help for details
Jeff Heidel 2012
'''
ap = argparse.ArgumentParser(description='')
ap.add_argument('filename', type=str, help='filename of the shm log to display')
ap.add_argument('-t', action="store_true", help='include variable table in printout')
ap.add_argument('-v', action="store_true", help='include all variable changes in printout')
ap.add_argument('-s', action="store_true", help='include snapshot table in printout')
args = vars(ap.parse_args())
filename = args['filename']
parse = LogParser(filename)
### General Log Information
print "Info: ", parse.info.strip()
log_start_time = parse.get_starttime()
print "Log starts:", str(log_start_time)
log_end_time = parse.get_endtime()
print "Log ends: ", str(log_end_time)
print "Duration: ", str(log_end_time - log_start_time)
print "Contains: %s variables" % str(len(parse.svars))
size = os.path.getsize(filename)
print "Log size: %d (%s MB)" % (size, str(round(size / (1024.0**2), 2)))
### Display any log warnings
if len(parse.get_warnings()) > 0:
type=str,
help='filename of the shm log to display')
ap.add_argument('-t',
action="store_true",
help='include variable table in printout')
ap.add_argument('-v',
action="store_true",
help='include all variable changes in printout')
ap.add_argument('-s',
action="store_true",
help='include snapshot table in printout')
args = vars(ap.parse_args())
filename = args['filename']
parse = LogParser(filename)
### General Log Information
print "Info: ", parse.info.strip()
log_start_time = parse.get_starttime()
print "Log starts:", str(log_start_time)
log_end_time = parse.get_endtime()
print "Log ends: ", str(log_end_time)
print "Duration: ", str(log_end_time - log_start_time)
print "Contains: %s variables" % str(len(parse.svars))
size = os.path.getsize(filename)
print "Log size: %d (%s MB)" % (size, str(round(size / (1024.0**2), 2)))
### Display any log warnings
if len(parse.get_warnings()) > 0:
print "\n---- Log Warnings ----"
args = vars(ap.parse_args())
filename = args['incomplete']
try:
login = open(filename, 'r')
except IOError:
print "Input filename " + filename + " not found."
sys.exit(0)
if args['incomplete'] == args['new']:
print "Your output file cannot be the same as your input file."
sys.exit(0)
try:
parse = LogParser(filename, parse_file_end=False)
except:
print "There was a problem with the log header. This file cannot be rebuilt."
sys.exit(0)
log_start_time = parse.get_starttime()
print "Log starts at: " + str(log_start_time)
logout = open(args['new'], 'w')
def copy_to(x):
#copies login to logout up to position x
while login.tell() != x:
logout.write(login.read(1))
args = vars(ap.parse_args())
filename = args['incomplete']
try:
login = open(filename, 'r')
except IOError:
print "Input filename " + filename + " not found."
sys.exit(0)
if args['incomplete'] == args['new']:
print "Your output file cannot be the same as your input file."
sys.exit(0)
try:
parse = LogParser(filename, parse_file_end=False)
except:
print "There was a problem with the log header. This file cannot be rebuilt."
sys.exit(0)
log_start_time = parse.get_starttime()
print "Log starts at: " + str(log_start_time)
logout = open(args['new'], 'w')
def copy_to(x):
#copies login to logout up to position x
while login.tell() != x:
logout.write(login.read(1))
copy_to(parse.f.tell()) #copy start of the file including header information