def initialize(self): super(Radosbench, self).initialize() logger.info('Pausing for 60s for idle monitoring.') with monitoring.monitor("%s/idle_monitoring" % self.run_dir): time.sleep(60) common.sync_files('%s/*' % self.run_dir, self.out_dir)
def mkpools(self): with monitoring.monitor("%s/pool_monitoring" % self.run_dir): if self.pool_per_proc: # allow use of a separate storage pool per process for i in range(self.concurrent_procs): for node in settings.getnodes('clients').split(','): node = node.rpartition("@")[2] self.cluster.rmpool('rados-bench-%s-%s' % (node, i), self.pool_profile) self.cluster.mkpool('rados-bench-%s-%s' % (node, i), self.pool_profile, 'radosbench') else: # the default behavior is to use a single Ceph storage pool for all rados bench processes self.cluster.rmpool('rados-bench-cbt', self.pool_profile) self.cluster.mkpool('rados-bench-cbt', self.pool_profile, 'radosbench')
def _run(self, mode, run_dir, out_dir, max_objects, runtime): # We'll always drop caches for rados bench self.dropcaches() if self.concurrent_ops: concurrent_ops_str = '--concurrent-ios %s' % self.concurrent_ops rados_version = self.get_rados_version() # Max Objects max_objects_str = '' if max_objects: if rados_version < 10: raise ValueError('max_objects not supported by rados_version < 10') max_objects_str = '--max-objects %s' % max_objects # Operation type op_type = mode if mode == 'prefill': op_type = 'write' if op_type == 'write': op_size_str = '-b %s' % self.op_size else: op_size_str = '' # Write to OMAP write_omap_str = '' if self.write_omap: if rados_version < 10: raise ValueError('write_omap not supported by rados_version < 10') write_omap_str = '--write-omap' run_dir = os.path.join(self.run_dir, run_dir) common.make_remote_dir(run_dir) # dump the cluster config self.cluster.dump_config(run_dir) # Run the backfill testing thread if requested (but not for prefill) if mode != 'prefill' and 'recovery_test' in self.cluster.config: recovery_callback = self.recovery_callback self.cluster.create_recovery_test(run_dir, recovery_callback) # Run rados bench with monitoring.monitor(run_dir) as monitor: logger.info('Running radosbench %s test.' % mode) ps = [] for i in range(self.concurrent_procs): out_file = '%s/output.%s' % (run_dir, i) objecter_log = '%s/objecter.%s.log' % (run_dir, i) if self.pool_per_proc: # support previous behavior of 1 storage pool per rados process pool_name_cmd = 'rados-bench-`{fqdn_cmd}`-{i}' pool_name = pool_name_cmd.format(fqdn_cmd=common.get_fqdn_cmd(), i=i) run_name = '' else: # default behavior is to use a single storage pool pool_name = self.pool run_name_fmt = '--run-name {object_set_id} `{fqdn_cmd}`-{i}' run_name = run_name_fmt.format( object_set_id=self.object_set_id, fqdn_cmd=common.get_fqdn_cmd(), i=i) rados_bench_cmd_fmt = \ '{cmd} -c {conf} -p {pool} bench {op_size_arg} {duration} ' \ '{op_type} {concurrent_ops_arg} {max_objects_arg} ' \ '{write_omap_arg} {run_name} --no-cleanup ' \ '2> {stderr} > {stdout}' rados_bench_cmd = rados_bench_cmd_fmt.format( cmd=self.cmd_path_full, conf=self.tmp_conf, pool=pool_name, op_size_arg=op_size_str, duration=runtime, op_type=op_type, concurrent_ops_arg=concurrent_ops_str, max_objects_arg=max_objects_str, write_omap_arg=write_omap_str, run_name=run_name, stderr=objecter_log, stdout=out_file) p = common.pdsh(settings.getnodes('clients'), rados_bench_cmd) ps.append(p) for p in ps: p.wait() # If we were doing recovery, wait until it's done (but not for prefill). if mode != 'prefill' and 'recovery_test' in self.cluster.config: self.cluster.wait_recovery_done() # Finally, get the historic ops self.cluster.dump_historic_ops(run_dir) out_dir = os.path.join(self.out_dir, out_dir) common.sync_files('%s/*' % run_dir, out_dir) self.analyze(out_dir)
import main import monitoring import onosCore from uuid import uuid4 #database name app = Flask(__name__) app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:///MIRAI4.db" db = SQLAlchemy(app) #multiprocessing call, checking module call, monitoring module call t = producer.producer() checking = simpleChecking.check() truechecking = main.mainclass() monitor = monitoring.monitor() clear = onosCore.test() token = 1 from sqlalchemy import Column, Integer, String #database class class Mirai4(db.Model): #table name & components (creation) __tablename__ = 'mirai4' id = db.Column(Integer, primary_key=True) containerName = db.Column(String(120)) result = db.Column(String(50) ) code = db.Column(String(120)) newcontainerName = db.Column(String(120)) token = db.Column(String(120))
Benchmark("evadeV-5-3", "examples/evade-monitoring.nm", "N=5,RADIUS=3", "Pmax=? [F<=12 \"crash\"]"), Benchmark("evadeV-6-3", "examples/evade-monitoring.nm", "N=6,RADIUS=3", "Pmax=? [F<=12 \"crash\"]"), Benchmark("refuelA-12-50", "examples/refuel.nm", "N=12,ENERGY=50", "Pmax=? [F<=12 \"empty\"]"), Benchmark("refuelB-12-50","examples/refuelB.nm", "N=12,ENERGY=50", "Pmax=? [F<=12 \"empty\"]") ] if __name__ == "__main__": # Wait for termination, never crash. sp.set_settings(["--signal-timeout", "100000"]) parser = argparse.ArgumentParser(description="Run experiments with premise.") parser.add_argument("--number-traces", default=50, type=int, help="How many traces to run") parser.add_argument("--trace-length", default=500, type=int, help="How long should the traces be?") parser.add_argument("--promptness-deadline", default=1000, type=int, help="How long may one iteration take at most?") parser.add_argument("--verbose", action='store_true', help="Enable extra output") args = parser.parse_args() nr_traces = args.number_traces trace_length = args.trace_length promtness_deadline = args.promptness_deadline # in ms configurations = [monitoring.UnfoldingOptions(exact_arithmetic=True), monitoring.UnfoldingOptions(exact_arithmetic=False), monitoring.ForwardFilteringOptions(exact_arithmetic=True, convex_hull_reduction=False), monitoring.ForwardFilteringOptions(exact_arithmetic=True, convex_hull_reduction=True)] for benchmark in benchmarks: for config in configurations: print(f"Running {benchmark.name} with {str(config)}") try: monitoring.monitor(benchmark.modelpath, benchmark.risk_def, benchmark.constants, trace_length, config, verbose=args.verbose, promptness_deadline=promtness_deadline, simulator_seed=range(nr_traces), model_id=benchmark.name) except RuntimeWarning: print("Skipped (likely, the folder exists)") pass
def main(): parser = argparse.ArgumentParser( description="Run premise simulating from model.") methodgroup = parser.add_mutually_exclusive_group(required=True) methodgroup.add_argument('--filtering', action='store_true') methodgroup.add_argument('--unfolding', action='store_true') numericsgroup = parser.add_mutually_exclusive_group(required=True) numericsgroup.add_argument('--exact', action='store_true') numericsgroup.add_argument('--float', action='store_false', dest="exact") parser.add_argument("--name", default="default_name", help="Name for stat output") parser.add_argument("--model", required=True, help="Path to models") parser.add_argument("--constants", default="", type=str, help="Constant definition string") parser.add_argument("--risk", required=True, help="Property defining the state risk") parser.add_argument("--number-traces", default=50, type=int, help="How many traces to run") parser.add_argument("--trace-length", default=500, type=int, help="How long should the traces be?") parser.add_argument("--promptness-deadline", default=1000, type=int, help="How long may one iteration take at most?") parser.add_argument("--verbose", action='store_true', help="Enable extra output") parser.add_argument("--seed", help="Set a random seed for reproducible experiments") parser.add_argument("--no-convexhull-reduction", help="Disable Convexhull Reduction", dest="convexhull", action='store_false') args = parser.parse_args() trace_length = args.trace_length promptness_deadline = args.promptness_deadline # in ms if args.seed is None: seed = [random.getrandbits(64) for _ in range(args.number_traces)] else: random.seed(args.seed) seed = [random.getrandbits(64) for _ in range(args.number_traces)] if args.filtering: options = monitoring.ForwardFilteringOptions( exact_arithmetic=args.exact, convex_hull_reduction=args.convexhull) elif args.unfolding: options = monitoring.UnfoldingOptions(exact_arithmetic=args.exact) else: RuntimeError("Unknown method!") monitoring.monitor(args.model, args.risk, args.constants, trace_length, options, args.verbose, seed, promptness_deadline, args.name)