def test_log_verbose(self):
target_cmd = [ './ci_test_basic' ]
env = { 'CALI_LOG_VERBOSITY' : '3',
'CALI_LOG_LOGFILE' : 'stdout'
}
report_out = cat.run_test(target_cmd, env)
lines = report_out.decode().splitlines()
log_targets = [
'CALI_LOG_VERBOSITY=3',
'== CALIPER: Releasing process scope',
'== CALIPER: Releasing thread scope',
'Blackboard buffer',
'Metadata tree',
'Metadata memory pool'
]
for target in log_targets:
for line in lines:
if target in line:
break
else:
self.fail('%s not found in log' % target)
def test_hatchetcontroller(self):
""" Test hatchet-region-profile controller """
target_cmd = [
'./ci_test_macros', '0',
'hatchet-region-profile,use.mpi=false,output=stdout'
]
caliper_config = {'CALI_LOG_VERBOSITY': '0'}
obj = json.loads(cat.run_test(target_cmd, caliper_config)[0])
self.assertTrue({'data', 'columns', 'column_metadata',
'nodes'}.issubset(set(obj.keys())))
columns = obj['columns']
self.assertEqual({'path', 'time'}, set(columns))
data = obj['data']
self.assertEqual(len(data), 8)
self.assertEqual(len(data[0]), 2)
meta = obj['column_metadata']
self.assertEqual(len(meta), 2)
time_idx = columns.index('time')
path_idx = columns.index('path')
self.assertTrue(meta[time_idx]['is_value'])
self.assertEqual(meta[time_idx]['attribute.unit'], 'sec')
self.assertFalse(meta[path_idx]['is_value'])
def test_report_nested_key(self):
target_cmd = ['./ci_test_macros']
caliper_config = {
'CALI_SERVICES_ENABLE': 'event,trace,report',
'CALI_REPORT_CONFIG':
'select *,count() group by prop:nested,iteration#mainloop format expand',
'CALI_LOG_VERBOSITY': '0'
}
query_output, _ = cat.run_test(target_cmd, caliper_config)
snapshots = cat.get_snapshots_from_text(query_output)
self.assertTrue(
cat.has_snapshot_with_attributes(
snapshots, {
'function': 'main/foo',
'loop': 'mainloop',
'annotation': 'pre-loop',
'statement': 'foo.init',
'iteration#mainloop': '2',
'count': '1'
}))
self.assertTrue(
cat.has_snapshot_with_attributes(
snapshots, {
'function': 'main/foo',
'loop': 'mainloop/fooloop',
'iteration#mainloop': '3',
'count': '9'
}))
def test_report_tree_formatter(self):
target_cmd = ['./ci_test_macros']
caliper_config = {
'CALI_SERVICES_ENABLE': 'event,trace,report',
'CALI_REPORT_CONFIG':
'select *,count() as Count group by prop:nested where cali.event.end format tree',
'CALI_LOG_VERBOSITY': '0'
}
report_targets = [
'Path Count', 'main 1',
' mainloop 5', ' foo 4',
' fooloop 20', ' pre-loop 4',
' foo.init 4', ' before_loop 1'
]
report_output, _ = cat.run_test(target_cmd, caliper_config)
lines = report_output.decode().splitlines()
for target in report_targets:
for line in lines:
if target in line:
break
else:
self.fail('%s not found in report' % target)
def test_loopmonitor_target_loop(self):
target_cmd = ['./ci_test_macros', '0', 'none', '10']
caliper_config = {
'CALI_SERVICES_ENABLE': 'loop_monitor,trace,report',
'CALI_LOOP_MONITOR_ITERATION_INTERVAL': '5',
'CALI_LOOP_MONITOR_TARGET_LOOPS': 'fooloop',
'CALI_REPORT_CONFIG':
'select * where iteration#fooloop format expand',
'CALI_REPORT_FILENAME': 'stdout',
'CALI_LOG_VERBOSITY': '0'
}
query_output = cat.run_test(target_cmd, caliper_config)
snapshots = cat.get_snapshots_from_text(query_output[0])
self.assertEqual(len(snapshots), 20)
self.assertTrue(
cat.has_snapshot_with_attributes(
snapshots, {
'iteration#mainloop': '3',
'iteration#fooloop': '4',
'loop.iterations': '5',
'loop': 'mainloop/fooloop'
}))
self.assertTrue(
cat.has_snapshot_with_attributes(
snapshots, {
'iteration#mainloop': '7',
'iteration#fooloop': '9',
'loop.iterations': '5',
'loop': 'mainloop/fooloop'
}))
def test_loopreport_timeseries(self):
target_cmd = [
'./ci_test_macros', '0',
'loop-report,timeseries=true,summary=false,iteration_interval=15,output=stdout',
'75'
]
caliper_config = {
'CALI_LOG_VERBOSITY': '0',
}
log_targets = [
'Iteration summary (mainloop):', 'Block Iterations Time (s)',
' 0 15', ' 30 15', ' 60 15'
]
report_out, _ = cat.run_test(target_cmd, caliper_config)
lines = report_out.decode().splitlines()
for target in log_targets:
for line in lines:
if target in line:
break
else:
self.fail('%s not found in log' % target)
def test_regionmonitor_time_interval(self):
target_cmd = ['./ci_test_macros', '5000', 'none', '5']
caliper_config = {
'CALI_SERVICES_ENABLE': 'region_monitor,trace,report',
'CALI_REGION_MONITOR_TIME_INTERVAL': '0.01',
'CALI_REPORT_CONFIG': 'select * format expand',
'CALI_REPORT_FILENAME': 'stdout',
'CALI_LOG_VERBOSITY': '0'
}
query_output = cat.run_test(target_cmd, caliper_config)
snapshots = cat.get_snapshots_from_text(query_output[0])
self.assertTrue(len(snapshots) == 4)
self.assertTrue(
cat.has_snapshot_with_attributes(snapshots, {
'loop': 'mainloop/fooloop',
'function': 'main/foo'
}))
self.assertFalse(
cat.has_snapshot_with_attributes(snapshots,
{'annotation': 'pre-loop'}))
self.assertFalse(
cat.has_snapshot_with_attributes(snapshots,
{'annotation': 'before_loop'}))
def test_report_aggregate(self):
""" Test reader lib's CSV export via report service """
target_cmd = ['./ci_test_macros']
caliper_config = {
'CALI_SERVICES_ENABLE': 'event,aggregate,report',
'CALI_REPORT_CONFIG':
'select function,count(),inclusive_sum(count) group by function format expand',
'CALI_LOG_VERBOSITY': '0'
}
query_output, _ = cat.run_test(target_cmd, caliper_config)
snapshots = cat.get_snapshots_from_text(query_output)
self.assertTrue(
cat.has_snapshot_with_attributes(snapshots, {
'function': 'main',
'count': '17',
'inclusive#count': '77'
}))
self.assertTrue(
cat.has_snapshot_with_attributes(snapshots, {
'function': 'main/foo',
'count': '60',
'inclusive#count': '60'
}))
def test_loopreport_target_loop_selection(self):
target_cmd = [ './ci_test_macros', '0', 'loop-report,target_loops=fooloop,timeseries=true,summary=true,iteration_interval=5,output=stdout,timeseries.maxrows=0', '20' ]
caliper_config = {
'CALI_LOG_VERBOSITY' : '0',
}
log_targets = [
'Iteration summary (fooloop):',
'mainloop/fooloop 400',
'Block Iterations Time (s)',
' 0 100',
' 5 100',
' 10 100'
]
report_out,_ = cat.run_test(target_cmd, caliper_config)
lines = report_out.decode().splitlines()
for target in log_targets:
for line in lines:
if target in line:
break
else:
self.fail('%s not found in log' % target)
def test_textlog_with_iteration_event(self):
target_cmd = ['./ci_test_macros']
caliper_config = {
'CALI_SERVICES_ENABLE': 'loop_monitor,textlog',
'CALI_LOOP_MONITOR_ITERATION_INTERVAL': '1',
'CALI_TEXTLOG_TRIGGER': 'loop.start_iteration',
'CALI_TEXTLOG_FORMATSTRING':
'%function% iteration: %[2]loop.start_iteration%',
'CALI_LOG_VERBOSITY': '0',
}
log_targets = [
'main iteration: 0', 'main iteration: 1', 'main iteration: 2',
'main iteration: 3'
]
report_out, _ = cat.run_test(target_cmd, caliper_config)
lines = report_out.decode().splitlines()
for target in log_targets:
for line in lines:
if target in line:
break
else:
self.fail('%s not found in log' % target)
def test_textlog_with_end_event(self):
target_cmd = ['./ci_test_macros']
caliper_config = {
'CALI_SERVICES_ENABLE': 'event,textlog',
'CALI_TEXTLOG_TRIGGER': 'iteration#main\ loop',
'CALI_TEXTLOG_FORMATSTRING':
'%function% iteration: %[2]iteration#main loop%',
'CALI_LOG_VERBOSITY': '0',
}
log_targets = [
'main iteration: 0', 'main iteration: 1', 'main iteration: 2',
'main iteration: 3'
]
report_out, _ = cat.run_test(target_cmd, caliper_config)
lines = report_out.decode().splitlines()
for target in log_targets:
for line in lines:
if target in line:
break
else:
self.fail('%s not found in log' % target)
def test_log_silent(self):
target_cmd = ['./ci_test_basic']
env = {'CALI_LOG_VERBOSITY': '0', 'CALI_LOG_LOGFILE': 'stdout'}
report_out, _ = cat.run_test(target_cmd, env)
lines = report_out.decode().splitlines()
self.assertTrue(len(lines) == 0)
def test_hatchet_sample_profile_lookup(self):
target_cmd = [ './ci_test_macros', '5000', 'hatchet-sample-profile(use.mpi=false,output=stdout,sample.callpath=false,lookup.sourceloc=true,lookup.module=true)' ]
caliper_config = {
'CALI_LOG_VERBOSITY' : '0'
}
obj = json.loads( cat.run_test(target_cmd, caliper_config)[0] )
self.assertEqual(set(obj['columns']), { 'count', 'sourceloc#cali.sampler.pc', 'module#cali.sampler.pc', 'path' } )
def test_mem_highwatermark_option(self):
target_cmd = [ './ci_test_macros', '10', 'hatchet-region-profile,use.mpi=false,output=stdout,output.format=json,mem.highwatermark' ]
caliper_config = {
'CALI_LOG_VERBOSITY' : '0'
}
obj = json.loads( cat.run_test(target_cmd, caliper_config)[0] )
self.assertEqual(obj[1]['path'], 'main')
self.assertTrue(float(obj[1]['Allocated MB']) > 0.0)
def test_report(self):
target_cmd = [ './ci_test_report' ]
# create some distraction: read-from-env should be disabled
env = { 'CALI_SERVICES_ENABLE' : 'debug' }
report_out = cat.run_test(target_cmd, env)
lines = report_out.decode().splitlines()
self.assertEqual(lines[0].rstrip(), 'function annotation count')
self.assertEqual(lines[1].rstrip(), 'main my phase 2')
def test_report(self):
target_cmd = [ './ci_test_report' ]
# create some distraction: read-from-env should be disabled
env = { 'CALI_SERVICES_ENABLE' : 'debug' }
report_out = cat.run_test(target_cmd, env)
lines = report_out.decode().splitlines()
self.assertEqual(lines[0].rstrip(), 'function annotation count')
self.assertEqual(lines[1].rstrip(), 'main my phase 2')
def test_hatchet_profile_ioservice(self):
# Test the I/O bytes metric in the
target_cmd = [ './ci_test_io', 'hatchet-region-profile,output=stdout,output.format=json,io.bytes.read=true' ]
caliper_config = {
'CALI_LOG_VERBOSITY' : '0'
}
obj = json.loads( cat.run_test(target_cmd, caliper_config)[0] )
self.assertEqual(obj[1]['path'], 'main')
self.assertEqual(int(obj[1]['Bytes read']), 16)
def test_tau(self):
target_cmd = ['./ci_test_mpi_before_cali']
caliper_config = {
'CALI_SERVICES_ENABLE': 'tau',
'CALI_LOG_VERBOSITY': '0',
'TAU_PROFILE': '0',
'TAU_TRACE': '0'
}
#query_output = cat.run_test_with_query(target_cmd, query_cmd, caliper_config)
query_output = cat.run_test(target_cmd, caliper_config)
def test_loopreport_display_all_rows(self):
target_cmd = [ './ci_test_macros', '0', 'loop-report,timeseries.maxrows=0,timeseries=true,summary=false,iteration_interval=2,output=stdout', '80' ]
caliper_config = {
'CALI_LOG_VERBOSITY' : '0',
}
report_out,_ = cat.run_test(target_cmd, caliper_config)
lines = report_out.decode().splitlines()
self.assertGreater(len(lines), 40)
self.assertLess(len(lines), 48)
def test_createdir(self):
target_cmd = [ './ci_test_macros', '0', 'hatchet-region-profile,output.format=json,output=foo/bar/test.json' ]
caliper_config = {
'CALI_LOG_VERBOSITY' : '0'
}
if os.path.exists('foo/bar/test.json'):
os.remove('foo/bar/test.json')
if os.path.exists('foo/bar'):
os.removedirs('foo/bar')
self.assertFalse(os.path.exists('foo/bar'))
cat.run_test(target_cmd, caliper_config)
self.assertTrue(os.path.isdir('foo/bar'))
self.assertTrue(os.path.isfile('foo/bar/test.json'))
if os.path.exists('foo/bar/test.json'):
os.remove('foo/bar/test.json')
if os.path.exists('foo/bar'):
os.removedirs('foo/bar')
def test_tau(self):
target_cmd = ['./ci_test_tau_service']
query_cmd = [
'../../src/tools/cali-query/cali-query', '-q',
'SELECT count(),iteration#fooloop WHERE loop=fooloop GROUP BY iteration#fooloop FORMAT expand'
]
caliper_config = {
'CALI_SERVICES_ENABLE': 'event,trace,report,tau',
'CALI_REPORT_CONFIG': 'format cali',
'CALI_LOG_VERBOSITY': '0'
}
#query_output = cat.run_test_with_query(target_cmd, query_cmd, caliper_config)
query_output = cat.run_test(target_cmd, caliper_config)
def test_report_attribute_aliases(self):
target_cmd = ['./ci_test_macros']
caliper_config = {
'CALI_SERVICES_ENABLE': 'event,trace,report',
'CALI_REPORT_CONFIG':
'select function as my\\ function\\ alias,count() group by function format expand',
'CALI_LOG_VERBOSITY': '0'
}
query_output, _ = cat.run_test(target_cmd, caliper_config)
snapshots = cat.get_snapshots_from_text(query_output)
self.assertTrue(
cat.has_snapshot_with_keys(snapshots,
{'my function alias', 'count'}))
def test_openmpreport_regions(self):
target_cmd = ['./ci_test_openmp', 'openmp-report,output=stdout']
caliper_config = {'CALI_LOG_VERBOSITY': '0'}
report_targets = [
'Path #Threads Time (thread) Time (total) Work % Barrier % Time (work) Time (barrier)'
]
report_output, _ = cat.run_test(target_cmd, caliper_config)
lines = report_output.decode().splitlines()
for target in report_targets:
for line in lines:
if target in line:
break
def test_ioservice(self):
target_cmd = [
'./ci_test_openmp',
'hatchet-region-profile,openmp.times,output=stdout'
]
caliper_config = {'CALI_LOG_VERBOSITY': '0'}
obj = json.loads(cat.run_test(target_cmd, caliper_config)[0])
self.assertTrue({'data', 'columns', 'column_metadata',
'nodes'}.issubset(set(obj.keys())))
expected = {'path', 'time', 'Time (barrier)', 'Time (work)'}
self.assertTrue(expected.issubset(set(obj['columns'])))
def test_caliquery_list_services(self):
target_cmd = [ '../../src/tools/cali-query/cali-query', '--help=services' ]
env = {
'CALI_LOG_VERBOSITY' : '0',
}
service_targets = [
'aggregate', 'event', 'recorder', 'report', 'timestamp', 'trace'
]
report_out,_ = cat.run_test(target_cmd, env)
res = report_out.decode().split(',')
for target in service_targets:
if not target in res:
self.fail('%s not found in log' % target)
def test_report_aggregate(self):
""" Test reader lib's CSV export via report service """
target_cmd = [ './ci_test_macros' ]
caliper_config = {
'CALI_SERVICES_ENABLE' : 'event,aggregate,report',
'CALI_REPORT_CONFIG' : 'select function,count(),inclusive_sum(count) group by function format expand',
'CALI_LOG_VERBOSITY' : '0'
}
query_output = cat.run_test(target_cmd, caliper_config)
snapshots = cat.get_snapshots_from_text(query_output)
self.assertTrue(cat.has_snapshot_with_attributes(
snapshots, { 'function': 'main', 'count': '12', 'inclusive#count': '27' }))
self.assertTrue(cat.has_snapshot_with_attributes(
snapshots, { 'function': 'main/foo', 'count': '15', 'inclusive#count': '15' }))
def test_collective_output_channel(self):
target_cmd = ['./ci_test_collective_output_channel', 'mpi-report']
caliper_config = {
'PATH': '/usr/bin', # for ssh/rsh
'CALI_LOG_VERBOSITY': '0',
}
log_targets = ['Function', 'MPI_Barrier']
report_out, _ = cat.run_test(target_cmd, caliper_config)
lines = report_out.decode().splitlines()
for target in log_targets:
for line in lines:
if target in line:
break
else:
self.fail('%s not found in log' % target)
def test_textlog_autostring(self):
target_cmd = ['./ci_test_macros']
caliper_config = {
'CALI_SERVICES_ENABLE': 'event,textlog,timestamp',
'CALI_TEXTLOG_TRIGGER': 'loop',
'CALI_LOG_VERBOSITY': '0',
}
log_targets = ['loop=main loop/fooloop']
report_out, _ = cat.run_test(target_cmd, caliper_config)
lines = report_out.decode().splitlines()
for target in log_targets:
for line in lines:
if target in line:
break
else:
self.fail('%s not found in log' % target)
def test_validator_pass_macros(self):
target_cmd = ['./ci_test_macros', '0']
env = {
'CALI_LOG_VERBOSITY': '1',
'CALI_LOG_LOGFILE': 'stdout',
'CALI_SERVICES_ENABLE': 'validator'
}
log_targets = ['validator: No annotation nesting errors found']
report_out, _ = cat.run_test(target_cmd, env)
lines = report_out.decode().splitlines()
for target in log_targets:
for line in lines:
if target in line:
break
else:
self.fail('%s not found in log' % target)
def test_sample_report_nompi(self):
target_cmd = [
'./ci_test_macros', '5000', 'callpath-sample-report,output=stdout'
]
caliper_config = {
'CALI_LOG_VERBOSITY': '0',
}
log_targets = ['Path', 'main', ' foo']
report_out, _ = cat.run_test(target_cmd, caliper_config)
lines = report_out.decode().splitlines()
for target in log_targets:
for line in lines:
if target in line:
break
else:
self.fail('%s not found in log' % target)
def test_report_table_formatter(self):
target_cmd = ['./ci_test_macros']
caliper_config = {
'CALI_SERVICES_ENABLE': 'event,trace,report',
'CALI_REPORT_CONFIG':
'select *,count() group by loop where event.end#loop format table order by count desc',
'CALI_LOG_VERBOSITY': '0'
}
report_targets = [
'loop count', 'mainloop/fooloop 4',
'mainloop 1'
]
report_output, _ = cat.run_test(target_cmd, caliper_config)
output_lines = report_output.decode().splitlines()
for lineno in [0, 1, 2]:
self.assertEqual(report_targets[lineno],
output_lines[lineno].rstrip())
def test_loopmonitor_time_interval(self):
target_cmd = ['./ci_test_macros', '2000', 'none', '10']
caliper_config = {
'CALI_SERVICES_ENABLE': 'loop_monitor,trace,report',
'CALI_LOOP_MONITOR_TIME_INTERVAL': '0.05',
'CALI_REPORT_CONFIG':
'select count(),sum(loop.iterations) where loop format json',
'CALI_REPORT_FILENAME': 'stdout',
'CALI_LOG_VERBOSITY': '0'
}
query_output = cat.run_test(target_cmd, caliper_config)
obj = json.loads(query_output[0])
self.assertTrue(len(obj) == 1)
count = int(obj[0]['count'])
sum = int(obj[0]['sum#loop.iterations'])
self.assertTrue(count > 2 and count < 8)
self.assertEqual(sum, 10)
