def _execute_benchmark_test(queue):
try:
log = logging.getLogger("bm-runner")
request = queue.get()
arch_type = GuardedArchitecture.get_type_by_id(request.guard_type)
bosy = BoundedSynthesis(request.spec_filepath, arch_type)
templates_count = bosy.spec.templates_count
bosy.min_bound = tuple(request.min_bound * templates_count
if len(request.min_bound) == 1
else request.min_bound)
bosy.max_increments = request.max_increment
# set number of instances
instance_count = request.instance_count
if len(instance_count) > 1 and len(instance_count) != templates_count:
raise BenchmarkRunException(
"Invalid number of instances: Please provide a "
"number of instances for each template")
if sum(instance_count) < 2:
raise BenchmarkRunException(
"Invalid number of instances: Please provide an "
"overall instance number of at least 2.")
bosy.instance_count = tuple(instance_count * templates_count
if len(instance_count) == 1
else instance_count)
# set other parameters
bosy.encoder_type = \
[SMTEncoder.STATE_GUARD_ENCODER,
SMTEncoder.LABEL_GUARD_ENCODER][request.use_label_guards]
bosy.test_mode = request.use_test_mode
bosy.encoder_optimization = \
[EncodingOptimization.NONE,
EncodingOptimization.LAMBDA_SCC][request.use_scc]
t = time.clock()
model = bosy.solve()
t = time.clock() - t
try:
if model is not None and request.save_dot:
dotvisualization.model_to_dot(
model, request.dot_filepath,
name=request.dot_name)
log.debug("Wrote dot file to '%s'" % request.dot_filepath)
except Exception as ex:
log.critical("Could not write model graph: %s", ex)
result = BenchmarkTestResult()
result.request = request
result.runtime = t
result.current_bound = bosy.spec.bound
result.is_satisfiable = (model is not None)
queue.put(result)
except Exception as ex:
queue.put(ex)
sys.exit(1)
def main(argv=None):
"""Command line options."""
if argv is None:
argv = sys.argv
else:
sys.argv.extend(argv)
program_name = os.path.basename(sys.argv[0])
program_version = "v%s" % __version__
program_build_date = str(__updated__)
program_version_message = "%%(prog)s %s (%s)" % (program_version, program_build_date)
program_shortdesc = __import__("__main__").__doc__.split("\n")[1]
program_license = """%s
Created by simon, ayrat, swen on %s.
Copyright 2014. All rights reserved.
Free for any use with references to the original authors.
Distributed on an "AS IS" basis without warranties
or conditions of any kind, either express or implied.
USAGE
""" % (
program_shortdesc,
str(__date__),
)
try:
# Setup argument parser
parser = ArgumentParser(description=program_license, formatter_class=RawDescriptionHelpFormatter)
parser.add_argument("ltl_filepath", type=str, help="path of ltl specification file")
parser.add_argument(
"-v", "--verbose", dest="verbose", action="count", help="set verbosity level [default: %(default)s]"
)
parser.add_argument(
"--dot-path",
dest="dot_path",
type=str,
default=config.DEFAULT_TARGET_FOLDER,
help="Default dot file path, relative to spec " "file or absolute [default: %(default)s]",
)
parser.add_argument(
"-t",
"--system-type",
dest="system_type",
help=("System type (conjunctive, disjunctive) " "[default: %(default)s]"),
default="conjunctive",
)
parser.add_argument(
"--min-bound",
dest="min_bound",
help=("Minimal template size for each template " "[default: %(default)s]"),
type=int,
default=2,
nargs="+",
)
parser.add_argument(
"--max-increments",
dest="max_increments",
help=("Maximal number of increments of template " "bounds [default: %(default)s]"),
type=int,
default=1024,
)
parser.add_argument(
"--instances",
dest="instance_count",
help="Number of instances for each template",
type=int,
nargs="+",
required=True,
)
parser.add_argument("-V", "--version", action="version", version=program_version_message)
# parser.add_argument('--smt2', action='store_true',
# help="Use SMT2 encoder [default: %(default)s]",
# default=False)
parser.add_argument(
"--test",
action="store_true",
help=("Use test mode (ignore cut-offs) " "[default: %(default)s]"),
default=False,
)
parser.add_argument(
"--optimization",
action="store_true",
help=("Use encoding optimizations " "[default: %(default)s]"),
default=False,
)
parser.add_argument(
"--label-guards",
dest="label_guards",
action="store_true",
help=("Synthesize label guards " "instead of state guards"),
)
args = parser.parse_args()
logging.basicConfig(level=helpers.logging_helper.verbosity_to_log_level(args.verbose))
print("Log level: %s" % logging.getLevelName(logging.getLogger().getEffectiveLevel()))
# setup bounded synthesis instance
ltl_filepath = args.ltl_filepath
arch_type = guarded_system.GuardedArchitecture.get_type_by_id(GuardedArchitectureType[args.system_type])
if arch_type is None:
sys.exit("Invalid system type")
bosy = BoundedSynthesis(ltl_filepath, arch_type)
# set minimal bound
min_bound = args.min_bound
templates_count = bosy.spec.templates_count
if len(min_bound) > 1 and len(min_bound) != templates_count:
sys.exit("Invalid number of minimal templates bound")
bosy.min_bound = tuple(min_bound * templates_count if len(min_bound) == 1 else min_bound)
max_increments = args.max_increments
bosy.max_increments = max_increments
# set number of instances
instance_count = args.instance_count
if len(instance_count) > 1 and len(instance_count) != templates_count:
sys.exit("Invalid number of instances: Please provide a " "number of instances for each template")
if sum(instance_count) < 2:
sys.exit("Invalid number of instances: Please provide an " "overall instance number of at least 2.")
bosy.instance_count = tuple(instance_count * templates_count if len(instance_count) == 1 else instance_count)
# set other parameters
bosy.encoder_type = [SMTEncoder.STATE_GUARD_ENCODER, SMTEncoder.LABEL_GUARD_ENCODER][args.label_guards]
bosy.test_mode = args.test
bosy.encoder_optimization = [EncodingOptimization.NONE, EncodingOptimization.LAMBDA_SCC][args.optimization]
print("Start finding a solution for problem '%s'" % bosy.spec_filename)
print("Number of templates: %s" % str(bosy.spec.templates_count))
print("Minimal bound: %s" % str(bosy.min_bound))
print("Maximal increments: %s" % str(bosy.max_increments))
print("Number of instances: %s" % str(bosy.instance_count))
print("System type: %s" % str(args.system_type))
t = time.clock()
model = bosy.solve()
elapsed_time = time.clock() - t
print("==============================================================")
print("Initial bound was %s; " "current bound is %s" % (str(bosy.min_bound), str(bosy.spec.bound)))
print("Status: " + ["model found", "no model found"][model is None])
if model is not None:
print("\n".join([str(template_model) for template_model in model.values()]))
print("Elapsed time: %ss" % elapsed_time)
print("==============================================================")
dot_path = args.dot_path
if model is not None and dot_path is not None:
# extend by directory of specification if relative
if not os.path.isabs(dot_path):
dot_path = os.path.join(os.path.dirname(args.ltl_filepath), dot_path)
# if directory, we need to specify the filename
if not os.path.basename(dot_path):
spec_name = os.path.splitext(os.path.basename(args.ltl_filepath))[0]
filename = config.DEFAULT_DOT_FILENAME.format(spec_name=spec_name)
dot_path = os.path.join(dot_path, filename)
model_to_dot(model, dot_path)
return 0
except Exception as ex:
if DEBUG:
raise (ex)
indent = len(program_name) * " "
sys.stderr.write(program_name + ": " + repr(ex) + "\n")
sys.stderr.write(indent + " for help use --help")
return 2