def profile_cartographer(theory='skj', extra_size=0, tool='time', infer=True):
'''
Profile cartographer load-infer-dump on region of world.
Available tools: time, valgrind, cachegrind, callgrind, helgrind
'''
size = pomagma.util.MIN_SIZES[theory] + extra_size
with atlas.chdir(theory):
opts = {'log_file': 'profile.log', 'log_level': 2}
region = DB('region.normal.{:d}'.format(size))
temp = pomagma.util.temp_name(DB('profile'))
world = DB('world')
world_size = atlas.get_item_count(world)
if size >= world_size:
print 'Using world of size {}'.format(world_size)
region = world
elif not os.path.exists(region):
print 'Creating {} for profile'.format(region)
assert os.path.exists(world), 'First initialize world map'
with cartographer.load(theory, world, **opts) as db:
db.trim([{'size': size, 'filename': region}])
opts.setdefault('runner', PROFILERS.get(tool, tool))
with cartographer.load(theory, region, **opts) as db:
if infer:
for priority in [0, 1]:
count = db.infer(priority)
print 'Proved {} theorems'.format(count)
db.dump(temp)
print 'Hash:', atlas.get_hash(temp)
os.remove(temp)
def test(theory=THEORY, extra_size=0, **options):
"""Test theory by building a world map.
Options: log_level, log_file
"""
buildtype = 'debug' if pomagma.util.debug else 'release'
path = os.path.join(pomagma.util.DATA, 'test', buildtype, 'atlas', theory)
if os.path.exists(path):
os.system('rm -f {}/*'.format(path))
else:
os.makedirs(path)
with pomagma.util.chdir(path), pomagma.util.mutex(block=False):
options.setdefault('log_file', 'test.log')
world = DB('test.world')
diverge_conjectures = 'diverge_conjectures.facts'
diverge_theorems = 'diverge_theorems.facts'
equal_conjectures = 'equal_conjectures.facts'
equal_theorems = 'equal_theorems.facts'
size = pomagma.util.MIN_SIZES[theory] + extra_size
surveyor.init(theory, world, size, **options)
with cartographer.load(theory, world, **options) as db:
db.validate()
for priority in [0, 1]:
while db.infer(priority):
db.validate()
db.conjecture(diverge_conjectures, equal_conjectures)
theorist.try_prove_diverge(
diverge_conjectures,
diverge_conjectures,
diverge_theorems,
**options)
db.assume(diverge_theorems)
db.validate()
db.dump(world)
theorist.try_prove_nless(
theory,
world,
equal_conjectures,
equal_conjectures,
equal_theorems,
**options)
with cartographer.load(theory, world, **options) as db:
db.assume(equal_theorems)
db.validate()
for priority in [0, 1]:
while db.infer(priority):
db.validate()
db.dump(world)
with analyst.load(theory, world, **options) as db:
fail_count = db.test_inference()
assert fail_count == 0, 'analyst.test_inference failed'
print 'Theory {} appears valid.'.format(theory)
def trim(theory=THEORY, parallel=True, **options):
'''
Trim a set of normal regions for running analyst on small machines.
Options: log_level, log_file
'''
with atlas.chdir(theory):
options.setdefault('log_file', 'trim.log')
with cartographer.load(theory, 'world.normal.h5', **options) as db:
min_size = pomagma.util.MIN_SIZES[theory]
max_size = db.info()['item_count']
sizes = sparse_range(min_size, max_size)
tasks = []
for size in sizes:
tasks.append({
'size': size,
'temperature': 0,
'filename': 'region.normal.{:d}.h5'.format(size)
})
if parallel:
print 'Trimming {} regions of sizes {}-{}'.format(
len(sizes),
sizes[0],
sizes[-1])
db.trim(tasks)
else:
for task in tasks:
print 'Trimming region of size {}'.format(task['size'])
db.trim([task])
def profile_surveyor(theory='skj', grow_by=64, extra_size=0, tool='time'):
"""Profile surveyor on random region of world.
Available tools: time, valgrind, cachegrind, callgrind, helgrind
"""
size = pomagma.util.MIN_SIZES[theory] + extra_size
with atlas.chdir(theory):
opts = {'log_file': 'profile.log', 'log_level': 2}
region = DB('region.normal.{:d}'.format(size))
temp = pomagma.util.temp_name(DB('profile'))
world = DB('world')
if not os.path.exists(region):
print 'Creating {} for profile'.format(region)
assert os.path.exists(world), 'First initialize world map'
with cartographer.load(theory, world, **opts) as db:
db.trim([{'size': size, 'filename': region}])
opts.setdefault('runner', PROFILERS.get(tool, tool))
surveyor.survey(theory, region, temp, size + grow_by, **opts)
os.remove(temp)
def profile_surveyor(theory, size_blocks=3, dsize_blocks=0):
'''
Profile surveyor through callgrind on random region of world.
Inputs: theory, region size in blocks (1 block = 512 obs)
'''
size = size_blocks * 512 - 1
dsize = dsize_blocks * 512
min_size = pomagma.util.MIN_SIZES[theory]
assert size >= min_size
with atlas.chdir(theory):
opts = {'log_file': 'profile.log', 'log_level': 2}
region = 'region.{:d}.h5'.format(size)
temp = pomagma.util.temp_name('profile.h5')
world = 'world.h5'
if not os.path.exists(region):
assert os.path.exists(world), 'First initialize world map'
with cartographer.load(theory, world, **opts) as db:
db.trim({'size': size, 'filename': region})
opts.setdefault('runner', 'valgrind --tool=callgrind')
surveyor.survey(theory, region, temp, size + dsize, **opts)
os.remove(temp)
def _test_atlas(theory):
'''
Test basic operations in one theory:
init, validate, copy, survey, aggregate,
conjecture_diverge, conjecture_equal
'''
buildtype = 'debug' if pomagma.util.debug else 'release'
path = os.path.join(pomagma.util.DATA, 'test', buildtype, 'atlas', theory)
if os.path.exists(path):
os.system('rm -f {}/*'.format(path))
else:
os.makedirs(path)
with ExitStack() as stack:
with_ = stack.enter_context
with_(pomagma.util.chdir(path))
with_(mock.patch('pomagma.util.BLOB_DIR', new=path))
with_(pomagma.util.mutex(block=False))
min_size = pomagma.util.MIN_SIZES[theory]
dsize = min(64, 1 + min_size)
sizes = [min_size + i * dsize for i in range(10)]
opts = {'log_file': 'test.log', 'log_level': 2}
diverge_conjectures = 'diverge_conjectures.facts'
diverge_theorems = 'diverge_theorems.facts'
equal_conjectures = 'equal_conjectures.facts'
equal_theorems = 'equal_theorems.facts'
surveyor.init(theory, DB(0), sizes[0], **opts)
changed = atlas.update_theory(theory, DB(0), DB(1), **opts)
assert not changed
with cartographer.load(theory, DB(0), **opts) as db:
db.validate()
db.dump(DB(1))
expected_size = atlas.get_item_count(DB(1))
actual_size = db.info()['item_count']
assert actual_size == expected_size
surveyor.survey(theory, DB(1), DB(2), sizes[1], **opts)
with cartographer.load(theory, DB(2), **opts) as db:
db.trim([{'size': sizes[0], 'filename': DB(3)}])
surveyor.survey(theory, DB(3), DB(4), sizes[1], **opts)
with cartographer.load(theory, DB(2), **opts) as db:
db.aggregate(DB(4))
db.dump(DB(5))
with cartographer.load(theory, DB(5), **opts) as db:
db.aggregate(DB(0))
db.dump(DB(6))
digest5 = atlas.get_hash(DB(5))
digest6 = atlas.get_hash(DB(6))
assert digest5 == digest6
counts = db.conjecture(diverge_conjectures, equal_conjectures)
assert counts['diverge_count'] > 0, counts['diverge_count']
assert counts['equal_count'] > 0, counts['equal_count']
if theory != 'h4':
theorem_count = theorist.try_prove_diverge(
diverge_conjectures,
diverge_conjectures,
diverge_theorems,
**opts)
assert theorem_count > 0, theorem_count
counts = db.assume(diverge_theorems)
assert counts['pos'] + counts['neg'] > 0, counts
assert counts['ignored'] == 0, counts
db.validate()
db.dump(DB(6))
theorem_count = theorist.try_prove_nless(
theory,
DB(6),
equal_conjectures,
equal_conjectures,
equal_theorems,
**opts)
# assert theorem_count > 0, theorem_count
if theory != 'h4':
with cartographer.load(theory, DB(6), **opts) as db:
db.assume(equal_theorems)
if theorem_count > 0:
assert counts['merge'] > 0, counts
db.validate()
for priority in [0, 1]:
while db.infer(priority):
db.validate()
for priority in [0, 1]:
assert not db.infer(priority)
db.dump(DB(7))
with analyst.load(theory, DB(7), **opts) as db:
fail_count = db.test_inference()
assert fail_count == 0, 'analyst.test_inference failed'
blobstore.validate_blobs()
def _test_atlas(theory):
'''
Test basic operations in one theory:
init, validate, copy, survey, aggregate,
conjecture_diverge, conjecture_equal
'''
buildtype = 'debug' if pomagma.util.debug else 'release'
path = os.path.join(pomagma.util.DATA, 'test', buildtype, 'atlas', theory)
if os.path.exists(path):
os.system('rm -f {}/*'.format(path))
else:
os.makedirs(path)
with pomagma.util.chdir(path), pomagma.util.mutex(block=False):
min_size = pomagma.util.MIN_SIZES[theory]
dsize = min(64, 1 + min_size)
sizes = [min_size + i * dsize for i in range(10)]
opts = {'log_file': 'test.log', 'log_level': 2}
diverge_conjectures = 'diverge_conjectures.facts'
diverge_theorems = 'diverge_theorems.facts'
equal_conjectures = 'equal_conjectures.facts'
equal_theorems = 'equal_theorems.facts'
surveyor.init(theory, '0.h5', sizes[0], **opts)
with cartographer.load(theory, '0.h5', **opts) as db:
db.validate()
db.dump('1.h5')
expected_size = pomagma.util.get_item_count('1.h5')
actual_size = db.info()['item_count']
assert actual_size == expected_size
surveyor.survey(theory, '1.h5', '2.h5', sizes[1], **opts)
with cartographer.load(theory, '2.h5', **opts) as db:
db.trim([{'size': sizes[0], 'filename': '3.h5'}])
surveyor.survey(theory, '3.h5', '4.h5', sizes[1], **opts)
with cartographer.load(theory, '2.h5', **opts) as db:
db.aggregate('4.h5')
db.dump('5.h5')
with cartographer.load(theory, '5.h5', **opts) as db:
db.aggregate('0.h5')
db.dump('6.h5')
digest5 = pomagma.util.get_hash('5.h5')
digest6 = pomagma.util.get_hash('6.h5')
assert digest5 == digest6
counts = db.conjecture(diverge_conjectures, equal_conjectures)
assert counts['diverge_count'] > 0, counts['diverge_count']
assert counts['equal_count'] > 0, counts['equal_count']
if theory != 'h4':
theorem_count = theorist.try_prove_diverge(
diverge_conjectures,
diverge_conjectures,
diverge_theorems,
**opts)
assert theorem_count > 0, theorem_count
counts = db.assume(diverge_theorems)
assert counts['pos'] + counts['neg'] > 0, counts
db.validate()
db.dump('6.h5')
theorem_count = theorist.try_prove_nless(
theory,
'6.h5',
equal_conjectures,
equal_conjectures,
equal_theorems,
**opts)
# assert theorem_count > 0, theorem_count
if theory != 'h4':
with cartographer.load(theory, '6.h5', **opts) as db:
db.assume(equal_theorems)
if theorem_count > 0:
assert counts['merge'] > 0, counts
db.validate()
for priority in [0, 1]:
while db.infer(priority):
db.validate()
for priority in [0, 1]:
assert not db.infer(priority)
db.dump('7.h5')
with analyst.load(theory, '7.h5', **opts) as db:
fail_count = db.test_inference()
assert fail_count == 0, 'analyst.test_inference failed'