umaudemc 0.15.1__py3-none-any.whl → 0.17.0__py3-none-any.whl

umaudemc/__init__.py

@@ -1 +1 @@
-__version__ = '0.15.1'
+__version__ = '0.17.0'

umaudemc/__main__.py

@@ -316,6 +316,12 @@ def build_parser():
 		'--distribute',
 		help='Distribute the computation over some machines'
 	)
+	parser_scheck.add_argument(
+		'-D',
+		metavar='name=value',
+		action='append',
+		help='Define a constant to be used in QuaTEx expressions'
+	)
 	parser_scheck.add_argument(
 		'--format', '-f',
 		help='Output format for the simulation results',
@@ -327,6 +333,10 @@ def build_parser():
 		help='Plot the results of parametric queries (using Matplotlib)',
 		action='store_true'
 	)
+	parser_scheck.add_argument(
+		'--dump',
+		help='Dump query evaluations into the given file',
+	)
 
 	parser_scheck.set_defaults(mode='scheck')
 

umaudemc/api.py

@@ -420,7 +420,7 @@ class MaudeModel:
 		return result, stats
 
 	def scheck(self, quatex, assign='uniform', alpha=0.05, delta=0.5, block=30, nsims=(30, None),
-	           seed=None, jobs=1, usermsgs=_usermsgs, verbose=False):
+	           seed=None, jobs=1, usermsgs=_usermsgs, verbose=False, constants=None):
 		"""
 		Statistical model checking of a given QuaTEx expression
 
@@ -444,15 +444,17 @@ class MaudeModel:
 		:type usermsgs: An object with print_error, print_warning and print_info methods
 		:param verbose: Enable verbose messages about the simulation state between blocks
 		:type verbose: bool
+		:param constants: Constants to be used in the QuaTEx expression
+		:type constants: dict[str, float]
 		:returns: the probabilistic model-checking result and a dictionary with statistics
 		"""
 
 		# Parse the QuaTEx query
 		if isinstance(quatex, str) and os.path.exists(quatex):
 			with open(quatex) as quatex_file:
-				program = _quatex.parse_quatex(quatex_file, filename=quatex)
+				program = _quatex.parse_quatex(quatex_file, filename=quatex, constants=constants)
 		else:
-			program = _quatex.parse_quatex(quatex)
+			program = _quatex.parse_quatex(quatex, constants=constants)
 
 		if not program:
 			return None

umaudemc/command/scheck.py

@@ -19,13 +19,16 @@ def show_results(program, nsims, qdata):
 	qdata_it = iter(qdata)
 	q = next(qdata_it, None)
 
-	for k, (fname, line, column, params) in enumerate(program.query_locations):
+	for k, query in enumerate(program.queries):
 		# Print the query name and location only if there are many
 		if program.nqueries > 1:
-			print(f'Query {k + 1} ({fname}:{line}:{column})')
+			# If the number of simulation is lower for this query
+			sim_detail = f' ({q.n} simulations)' if q.n != nsims else ''
+
+			print(f'Query {k + 1} ({query.filename}:{query.line}:{query.column}){sim_detail}')
 
 		# For parametric queries, we show the result for every value
-		var = params[0] if params else None
+		var = query.parameters[0] if query.parameters else None
 
 		while q and q.query == k:
 			if var:
@@ -33,6 +36,11 @@ def show_results(program, nsims, qdata):
 			else:
 				print(f'  μ = {q.mu:<25} σ = {q.s:<25} r = {q.h}')
 
+			# If executions have been discarded
+			if q.discarded:
+				total = q.discarded + q.n
+				print(f'  where {q.discarded} executions out of {total} ({round(q.discarded / total * 100, 2)}%) have been discarded')
+
 			q = next(qdata_it, None)
 
 
@@ -85,10 +93,10 @@ def plot_results(program, qdata):
 		return
 
 	for k, xs, ys, rs in results:
-		line, column, _ = program.query_locations[k]
+		query = program.queries[k]
 
 		# Plot the mean
-		p = plt.plot(xs, ys, label=f'{line}:{column}')
+		p = plt.plot(xs, ys, label=f'{query.line}:{query.column}')
 		# Plot the confidence interval
 		plt.fill_between(xs, [y - r for y, r in zip(ys, rs)],
 		                 [y + r for y, r in zip(ys, rs)],
@@ -121,6 +129,31 @@ def parse_range(rtext):
 	return lims
 
 
+def parse_defines(defines):
+	"""Parse constant definitions with -D in the command line"""
+
+	constants = {}
+
+	if not defines:
+		return constants
+
+	for df in defines:
+		if df.count('=') != 1:
+			usermsgs.print_error(f'The argument of -D must be key=value, not {df}. This definition will be ignored.')
+			continue
+
+		key, value = df.strip().split('=')
+
+		try:
+			constants[key] = float(value)
+
+		except ValueError:
+			usermsgs.print_error(f'The value of a -D assignment must be a number, not {value}. This definition will be ignored.')
+			continue
+
+	return constants
+
+
 def scheck(args):
 	"""Statistical check subcommand"""
 
@@ -135,8 +168,13 @@ def scheck(args):
 		usermsgs.print_error(f'The query file "{args.query}" does not exist.')
 		return 1
 
+	# Parse the constants definitions in the command line
+	constants = parse_defines(args.D)
+
 	with open(args.query) as quatex_file:
-		program, seen_files = parse_quatex(quatex_file, filename=args.query, legacy=args.assign == 'pmaude')
+		program, seen_files = parse_quatex(quatex_file, filename=args.query,
+		                                   legacy=args.assign == 'pmaude',
+						   constants=constants)
 
 	if not program:
 		return 1
@@ -167,7 +205,7 @@ def scheck(args):
 	if args.distribute:
 		from ..distributed import distributed_check
 
-		num_sims, qdata = distributed_check(args, data, min_sim, max_sim, program, seen_files)
+		num_sims, qdata = distributed_check(args, data, min_sim, max_sim, program, constants, seen_files)
 
 		if num_sims is None:
 			return 1
@@ -182,7 +220,12 @@ def scheck(args):
 		# Call the statistical model checker
 		num_sims, qdata = check(program, simulator,
 		                        args.seed, args.alpha, args.delta, args.block,
-		                        min_sim, max_sim, args.jobs, args.verbose)
+		                        min_sim, max_sim, args.jobs, args.verbose, args.dump)
+
+	# Check the discarded count when there is no convergence
+	for query in qdata:
+		if not query.converged:
+			query.discarded = num_sims - query.n
 
 	# Print the results on the terminal
 	(show_json if args.format == 'json' else show_results)(program, num_sims, qdata)

umaudemc/command/sworker.py

@@ -71,7 +71,8 @@ class Worker:
 
 		with open(os.path.join(tmp_dir, args.query)) as quatex_file:
 			self.program, _ = parse_quatex(quatex_file, filename=args.query,
-			                               legacy=args.assign == 'pmaude')
+			                               legacy=args.assign == 'pmaude',
+						       constants=args.constants)
 
 		if not self.program:
 			return False
@@ -92,12 +93,15 @@ class Worker:
 		block = self.block
 
 		# Query data
-		qdata = [QueryData(k, idict)
-		         for k, qinfo in enumerate(program.query_locations)
-		         for idict in make_parameter_dicts(qinfo[3])]
+		# (delta, its second argument, does not matter because
+		# convergence is not evaluated by the worker)
+		qdata = [QueryData(k, 1.0, idict)
+		         for k, qinfo in enumerate(program.queries)
+		         for idict, _ in make_parameter_dicts(qinfo, 1.0)]
 
 		sums = array('d', [0.0] * len(qdata))
 		sum_sq = array('d', [0.0] * len(qdata))
+		counts = array('i', [0] * len(qdata))
 
 		while True:
 
@@ -105,11 +109,13 @@ class Worker:
 				# Run the simulation and compute all queries at once
 				values = run(program, qdata, simulator)
 
-				for k in range(len(qdata)):
-					sums[k] += values[k]
-					sum_sq[k] += values[k] * values[k]
+				for k, value in enumerate(values):
+					if value is not None:
+						sums[k] += value
+						sum_sq[k] += value * value
+						counts[k] += 1
 
-			conn.send(b'b' + sums.tobytes() + sum_sq.tobytes())
+			conn.send(b'b' + sums.tobytes() + sum_sq.tobytes() + counts.tobytes())
 
 			# Check whether to continue
 			answer = conn.recv(1)
@@ -125,6 +131,7 @@ class Worker:
 			for k in range(len(qdata)):
 				sums[k] = 0
 				sum_sq[k] = 0
+				counts[k] = 0
 
 
 def handle_request(message, conn, addr, keep_file):

umaudemc/distributed.py

@@ -9,6 +9,7 @@ import random
 import re
 import selectors
 import socket
+import sys
 import tarfile
 from array import array
 from contextlib import ExitStack
@@ -174,7 +175,7 @@ def process_dspec(dspec, fname):
 	return True
 
 
-def setup_workers(args, initial_data, dspec, seen_files, stack):
+def setup_workers(args, initial_data, dspec, constants, seen_files, stack):
 	"""Setup workers and send problem data"""
 
 	workers = dspec['workers']
@@ -188,7 +189,7 @@ def setup_workers(args, initial_data, dspec, seen_files, stack):
 	COPY = ('initial', 'strategy', 'module', 'metamodule', 'opaque', 'full_matchrew',
 	        'purge_fails', 'merge_states', 'assign', 'block', 'query', 'assign', 'advise', 'verbose')
 
-	data = {key: args.__dict__[key] for key in COPY} | {'file': 'source.maude'}
+	data = {key: args.__dict__[key] for key in COPY} | {'file': 'source.maude', 'constants': constants}
 
 	# Make a flattened version of the Maude file
 	flat_source = io.BytesIO()
@@ -200,6 +201,10 @@ def setup_workers(args, initial_data, dspec, seen_files, stack):
 	# Save the sockets for each worker
 	sockets = []
 
+	# Root of the QuaTEx sources
+	quatex_root = os.path.commonpath([os.path.dirname(fn) for fn in seen_files])
+	data['query'] = os.path.relpath(data['query'], start=quatex_root)
+
 	for worker, seed in zip(workers, seeds):
 		address, port = worker['address'], worker['port']
 
@@ -229,12 +234,8 @@ def setup_workers(args, initial_data, dspec, seen_files, stack):
 				tarf.addfile(flat_info, flat_source)
 
 				for file in seen_files:
-					relpath = os.path.relpath(file)
-
-					if relpath.startswith('..'):
-						usermsgs.print_error('QuaTEx file outside the working tree, it will not be included and the execution will fail.')
-					else:
-						tarf.add(relpath)
+					relpath = os.path.relpath(file, start=quatex_root)
+					tarf.add(file, arcname=relpath)
 
 			fobj.flush()
 
@@ -248,7 +249,7 @@ def setup_workers(args, initial_data, dspec, seen_files, stack):
 	return sockets
 
 
-def distributed_check(args, initial_data, min_sim, max_sim, program, seen_files):
+def distributed_check(args, initial_data, min_sim, max_sim, program, constants, seen_files):
 	"""Distributed statistical model checking"""
 
 	# Load the distribution specification
@@ -260,10 +261,10 @@ def distributed_check(args, initial_data, min_sim, max_sim, program, seen_files)
 	with ExitStack() as stack:
 
 		# Socket to connect with the workers
-		if not (sockets := setup_workers(args, initial_data, dspec, seen_files, stack)):
+		if not (sockets := setup_workers(args, initial_data, dspec, constants, seen_files, stack)):
 			return None, None
 
-		print('All workers are ready. Starting...')
+		print('All workers are ready. Starting...', file=sys.stderr)
 
 		# Use a selector to wait for updates from any worker
 		selector = selectors.DefaultSelector()
@@ -273,11 +274,12 @@ def distributed_check(args, initial_data, min_sim, max_sim, program, seen_files)
 			sock.send(b'c')
 
 		buffer = array('d')
+		ibuffer = array('i')
 
 		# Query data
-		qdata = [QueryData(k, idict)
-		         for k, qinfo in enumerate(program.query_locations)
-		         for idict in make_parameter_dicts(qinfo[3])]
+		qdata = [QueryData(k, delta, idict)
+		         for k, qinfo in enumerate(program.queries)
+		         for idict, delta in make_parameter_dicts(qinfo, args.delta)]
 		nqueries = len(qdata)
 		num_sims = 0
 
@@ -293,16 +295,19 @@ def distributed_check(args, initial_data, min_sim, max_sim, program, seen_files)
 				answer = sock.recv(1)
 
 				if answer == b'b':
-					data = sock.recv(16 * nqueries)
-					buffer.frombytes(data)
+					data = sock.recv(24 * nqueries)
+					buffer.frombytes(data[:16 * nqueries])
+					ibuffer.frombytes(data[16 * nqueries:])
 
 					for k in range(nqueries):
 						qdata[k].sum += buffer[k]
 						qdata[k].sum_sq += buffer[nqueries + k]
+						qdata[k].n += ibuffer[k]
 
 					num_sims += key.data['block']
 
 					del buffer[:]
+					del ibuffer[:]
 					finished.append(key.fileobj)
 
 				else:
@@ -311,7 +316,7 @@ def distributed_check(args, initial_data, min_sim, max_sim, program, seen_files)
 					sockets.remove(key.fileobj)
 
 			# Check whether the simulation has converged
-			converged = check_interval(qdata, num_sims, args.alpha, args.delta, quantile, args.verbose)
+			converged = check_interval(qdata, num_sims, min_sim, args.alpha, quantile, args.verbose)
 
 			if converged or max_sim and num_sims >= max_sim:
 				break

umaudemc/pyslang.py

@@ -47,6 +47,11 @@ class Instruction:
 	def __repr__(self):
 		return f'Instruction({self.NAMES[self.type]}, {self.extra})'
 
+	@property
+	def does_rewrite(self):
+		"""Whether the instruction rewrites the subject term"""
+		return self.type in (self.RLAPP, self.RWCNEXT) and self.extra[0]
+
 
 class StratProgram:
 	"""Compiled strategy program"""
@@ -506,7 +511,7 @@ class StratCompiler:
 
 		self.generate(next(s.arguments()), p, False)
 
-		initial_jump.extra = (p.pc + 1, initial_pc)
+		initial_jump.extra = (p.pc + (2 if self.use_kleene else 1), initial_pc)
 		p.append(Instruction.JUMP, (p.pc + 1, initial_pc))
 
 		if self.use_kleene:
@@ -658,12 +663,20 @@ class StratCompiler:
 	def norm(self, s, p, tail):
 		# A variation of the conditional and the iteration
 		initial_pc = p.pc
+
+		if self.use_kleene:
+			p.append(Instruction.KLEENE, (initial_pc, True))
+
 		subsearch = p.append(Instruction.SUBSEARCH)
 		self.generate(next(s.arguments()), p, False)
 		p.append(Instruction.NOFAIL)
 		p.append(Instruction.JUMP, (initial_pc, ))
+
 		subsearch.extra = p.pc
 
+		if self.use_kleene:
+			p.append(Instruction.KLEENE, (initial_pc, True))
+
 	def call(self, s, p, tail):
 		# Strategy calls are executed by CALL instructions, but the body of
 		# their definitions should be generated too. This is done afterwards
@@ -869,9 +882,6 @@ class StratCompiler:
 			def __repr__(self):
 				return f'BasicBlock({self.start}, {self.length}, {self.has_rewrite}, {self.next}, {self.reachable})'
 
-		def does_rewrite(inst):
-			return inst.type == Instruction.RLAPP or inst.type == Instruction.RWCNEXT and inst.extra[0]
-
 		# (1) Abstract the code as a graph of blocks linked by jumps
 
 		# Blocks are aggregated by definition (the first entry is the initial expression)
@@ -891,7 +901,7 @@ class StratCompiler:
 				inst = p[k]
 
 				# This block contains a rewrite
-				if does_rewrite(inst):
+				if inst.does_rewrite:
 					current.has_rewrite = True
 
 				# JUMP, CHOICE, SUBSEARCH, and CALL instructions close a block
@@ -1099,7 +1109,7 @@ class StratCompiler:
 						# notify_pending is not possible within a rewriting condition
 
 						# There is a RLAPP, so we need to issue a NOTIFY for the previous one
-						if does_rewrite(inst):
+						if inst.does_rewrite:
 							notify_points.append(k)
 
 						# Failures discard the notification
@@ -1116,7 +1126,7 @@ class StratCompiler:
 							notify_points.append(k)
 							notify_pending = False
 
-					elif rwc_level == 0 and does_rewrite(inst):
+					elif rwc_level == 0 and inst.does_rewrite:
 						notify_pending = True
 
 				for sc in block.next: