umaudemc 0.15.0__py3-none-any.whl → 0.16.0__py3-none-any.whl

umaudemc/__init__.py

@@ -1 +1 @@
-__version__ = '0.15.0'
+__version__ = '0.16.0'

umaudemc/__main__.py

@@ -316,6 +316,11 @@ def build_parser():
 		'--distribute',
 		help='Distribute the computation over some machines'
 	)
+	parser_scheck.add_argument(
+		'-D',
+		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 +332,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

@@ -22,7 +22,10 @@ def show_results(program, nsims, qdata):
 	for k, (fname, line, column, params) in enumerate(program.query_locations):
 		# 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} ({fname}:{line}:{column}){sim_detail}')
 
 		# For parametric queries, we show the result for every value
 		var = params[0] if params else None
@@ -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)
 
 
@@ -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

@@ -5,6 +5,7 @@
 import json
 import multiprocessing as mp
 import os
+import random
 import socket
 import sys
 import tarfile
@@ -60,6 +61,7 @@ class Worker:
 		self.block = args.block
 
 		maude.setRandomSeed(args.seed)
+		random.seed(args.seed)
 
 		# Do the same as the scheck command without checks
 		args.file = os.path.join(tmp_dir, args.file)
@@ -69,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
@@ -90,12 +93,15 @@ class Worker:
 		block = self.block
 
 		# Query data
-		qdata = [QueryData(k, idict)
+		# (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.query_locations)
 		         for idict in make_parameter_dicts(qinfo[3])]
 
 		sums = array('d', [0.0] * len(qdata))
 		sum_sq = array('d', [0.0] * len(qdata))
+		counts = array('i', [0] * len(qdata))
 
 		while True:
 
@@ -103,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)
@@ -123,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
@@ -126,6 +127,10 @@ def flatten_maude_file(filename, fobj):
 def process_dspec(dspec, fname):
 	"""Normalize a distributed SMC specification"""
 
+	if not isinstance(dspec, dict):
+		usermsgs.print_error_file('the distribution specification must be a dictionary.', fname)
+		return False
+
 	# Normalize workers to a dictionary
 	workers = dspec.get('workers')
 
@@ -170,19 +175,21 @@ 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']
 
 	# Generate a random seed for each worker
+	random.seed(args.seed)
+
 	seeds = [random.getrandbits(20) for _ in range(len(workers))]
 
 	# Data to be passed to the external machine
 	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()
@@ -194,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']
 
@@ -223,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()
 
@@ -242,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
@@ -254,22 +261,23 @@ 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()
 
 		for sock, data in zip(sockets, dspec['workers']):
-			selector.register(sock, selectors.EVENT_READ, data=data)
+			selector.register(sock, selectors.EVENT_READ, data={'block': args.block} | data)
 			sock.send(b'c')
 
 		buffer = array('d')
+		ibuffer = array('i')
 
 		# Query data
-		qdata = [QueryData(k, idict)
+		qdata = [QueryData(k, args.delta, idict)
 		         for k, qinfo in enumerate(program.query_locations)
 		         for idict in make_parameter_dicts(qinfo[3])]
 		nqueries = len(qdata)
@@ -287,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:
@@ -305,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:

umaudemc/quatex.py

@@ -144,6 +144,11 @@ class QuaTExLexer:
 		self.sline = self.line
 		self.scolumn = self.column
 
+	@staticmethod
+	def _is_name(c):
+		"""Whether the character is allowed in a name"""
+		return c.isalnum() or c == '$'
+
 	def get_token(self):
 		"""Get the next token from the stream"""
 
@@ -166,9 +171,9 @@ class QuaTExLexer:
 			self.ltype = self.LT_STRING
 			self._capture_string()
 
-		elif c.isalpha():
+		elif c.isalpha() or c == '$':
 			self.ltype = self.LT_NAME
-			self._capture(str.isalnum)
+			self._capture(self._is_name)
 
 		elif c.isdecimal():
 			self.ltype = self.LT_NUMBER
@@ -223,7 +228,7 @@ class QuaTExParser:
 	UNARY_OPS = ('!', )
 	UNARY_AST = (ast.Not, )
 
-	def __init__(self, source, filename='<stdin>', legacy=False):
+	def __init__(self, source, filename='<stdin>', legacy=False, constants=None):
 		# Filename is only used for diagnostics
 		self.lexer = QuaTExLexer(source, filename)
 		# PMaude legacy syntax
@@ -238,6 +243,8 @@ class QuaTExParser:
 		# Whether the variables that may occur
 		# in an expression are known
 		self.known_vars = True
+		# Constants defined outside
+		self.constants = {} if constants is None else constants
 
 		# State stack for parsing expressions
 		self.stack = []
@@ -448,6 +455,13 @@ class QuaTExParser:
 				inside_next = True
 				call_name, call_line, call_column = token, line, column
 
+			elif token == 'discard' and not (inside_cond or call_name):
+				if current:
+					self._eprint('misplaced discard keyword.')
+					return None
+
+				current = ast.Constant(None)
+
 			elif token == ',':
 				if current and self._in_state(self.PS_CALLARGS):
 					arg_stack[-1].append(current)
@@ -542,14 +556,20 @@ class QuaTExParser:
 
 				# Simply a variable
 				else:
+					current = ast.Name(token, ast.Load())
+
 					if not self.known_vars:
 						self.fvars.append((token, line, column))
 
 					elif token not in self.fvars:
-						self._eprint(f'unknown variable "{token}".', line=line, column=column)
-						self.ok = False
+						# The variable is an externally-defined constant
+						if token.startswith('$') and (value := self.constants.get(token[1:])) is not None:
+							current = ast.Constant(value)
+
+						else:
+							self._eprint(f'unknown variable "{token}".', line=line, column=column)
+							self.ok = False
 
-					current = ast.Name(token, ast.Load())
 
 					# We continue with the peeked token
 					token = next_token
@@ -846,10 +866,10 @@ class QuaTExParser:
 		                     tuple((fname, line, column, params) for fname, line, column, _, params in self.queries))
 
 
-def parse_quatex(input_file, filename='<string>', legacy=False):
+def parse_quatex(input_file, filename='<string>', legacy=False, constants=None):
 	"""Parse a QuaTEx formula"""
 
 	# Load, parse, and compile the QuaTEx file
-	parser = QuaTExParser(input_file, filename=filename, legacy=legacy)
+	parser = QuaTExParser(input_file, filename=filename, legacy=legacy, constants=constants)
 
 	return parser.parse(), parser.seen_files

umaudemc/simulators.py

@@ -27,7 +27,11 @@ def parse_hole_term(module, term_str):
 
 	# Collect all variables in the term
 	varset = set()
-	collect_vars(term, varset)
+
+	if term.isVariable():
+		varset.add(term)
+	else:
+		collect_vars(term, varset)
 
 	if len(varset) > 1:
 		usermsgs.print_warning('The observation "{message}" '

umaudemc/statistical.py

@@ -2,6 +2,7 @@
 # Statistical model-checking engine
 #
 
+import contextlib
 import math
 import os
 import random
@@ -40,7 +41,7 @@ def run(program, qdata, simulator):
 	# List where to store the results of each query
 	results = [None] * len(qdata)
 	# Remaining queries for being processed
-	remaining = list(range(len(qdata)))
+	remaining = [k for k, q in enumerate(qdata) if not q.converged]
 
 	# Variables when evaluating expressions
 	cvars = [{'rval': simulator.rval, **q.params} for q in qdata]
@@ -62,8 +63,16 @@ def run(program, qdata, simulator):
 				# Execute the compiled slot
 				value = eval(program.slots[pc[k]], cvars[k])
 
+				# The expression finishes with a call
+				if isinstance(value, tuple):
+					has_next, jump, *args = value
+
+					pc[k] = jump
+					cvars[k] = dict(zip(program.varnames[pc[k]], args),
+					                rval=simulator.rval)
+
 				# The evaluation of the k-th query has finished
-				if isinstance(value, float):
+				else:
 					remaining.pop(index)
 					results[k] = value
 
@@ -73,13 +82,6 @@ def run(program, qdata, simulator):
 
 					break
 
-				# The expression finishes with a call
-				else:
-					has_next, jump, *args = value
-
-					pc[k] = jump
-					cvars[k] = dict(zip(program.varnames[pc[k]], args),
-					                rval=simulator.rval)
 
 			if has_next:
 				index += 1
@@ -91,11 +93,13 @@ def run(program, qdata, simulator):
 class QueryData:
 	"""Data associated to a query under evaluation"""
 
-	def __init__(self, query, params):
+	def __init__(self, query, delta, params):
 		# Query expression index
 		self.query = query
 		# Initial dictionary of variable values
 		self.params = params
+		# Radius of the confidence interval
+		self.delta = delta
 
 		# Sum of the query outcomes
 		self.sum = 0.0
@@ -107,6 +111,13 @@ class QueryData:
 		self.s = 0.0
 		# Radius of the confidence interval
 		self.h = 0.0
+		# Number of runs
+		self.n = 0
+		# Whether the query has converged
+		self.converged = False
+
+		# Number of discarded runs
+		self.discarded = 0
 
 
 def make_parameter_dicts(qinfo):
@@ -123,34 +134,47 @@ def make_parameter_dicts(qinfo):
 			x += step
 
 
-def check_interval(qdata, num_sims, alpha, delta, quantile, verbose):
+def check_interval(qdata, num_sims, min_sim, alpha, quantile, verbose):
 	"""Check the confidence interval"""
 
-	# The radius of encloses the confidence level in the reference
-	# distribution for calculating confidence intervals
-	tinv = quantile(num_sims - 1, 1 - alpha / 2) / math.sqrt(num_sims)
-
 	# Whether the size of the confidence interval for all queries have converged
 	converged = True
 
 	for query in qdata:
-		query.mu = query.sum / num_sims
-		query.s = math.sqrt(max(query.sum_sq - query.sum * query.mu, 0.0) / (num_sims - 1))
+		# This query has already converged
+		if query.converged:
+			continue
+		# All executions of this query have been discarded
+		elif query.n == 0:
+			converged = False
+			continue
+
+		# The radius encloses the confidence level in the reference
+		# distribution for calculating confidence intervals
+		tinv = quantile(query.n - 1, 1 - alpha / 2) / math.sqrt(query.n)
+
+		query.mu = query.sum / query.n
+		query.s = math.sqrt(max(query.sum_sq - query.sum * query.mu, 0.0) / (query.n - 1))
 		query.h = query.s * tinv
 
-		if query.h > delta:
+		if query.h <= query.delta and query.n >= min_sim:
+			query.converged = True
+			query.discarded = num_sims - query.n
+		else:
 			converged = False
 
 	# Print intermediate results if in verbose mode
 	if verbose:
-		usermsgs.print_info(f'  step={num_sims} μ={" ".join(str(q.mu) for q in qdata)}'
+		usermsgs.print_info(f'  step={num_sims} n={" ".join(str(q.n) for q in qdata)}'
+		                    f' μ={" ".join(str(q.mu) for q in qdata)}'
 		                    f' σ={" ".join(str(q.s) for q in qdata)}'
 		                    f' r={" ".join(str(q.h) for q in qdata)}')
 
 	return converged
 
 
-def run_single(program, qdata, num_sims, max_sim, simulator, alpha, delta, block_size, verbose=False):
+def run_single(program, qdata, num_sims, min_sim, max_sim, simulator, alpha, block_size,
+               verbose=False, dump=None):
 	"""Run simulation in a single thread"""
 
 	# Size of the first block of execution (it coincides with num_sims
@@ -166,11 +190,17 @@ def run_single(program, qdata, num_sims, max_sim, simulator, alpha, delta, block
 			# Run the simulation and compute all queries at once
 			values = run(program, qdata, simulator)
 
-			for k, query in enumerate(qdata):
-				query.sum += values[k]
-				query.sum_sq += values[k] * values[k]
+			# Dump evaluations if required
+			if dump:
+				print(*values, file=dump)
 
-		converged = check_interval(qdata, num_sims, alpha, delta, quantile, verbose)
+			for value, query in zip(values, qdata):
+				if value is not None:
+					query.sum += value
+					query.sum_sq += value * value
+					query.n += 1
+
+		converged = check_interval(qdata, num_sims, min_sim, alpha, quantile, verbose)
 
 		if converged or max_sim and num_sims >= max_sim:
 			break
@@ -181,7 +211,7 @@ def run_single(program, qdata, num_sims, max_sim, simulator, alpha, delta, block
 	return num_sims, qdata
 
 
-def thread_main(program, qdata, simulator, num_sims, block_size, seed, queue, barrier, more):
+def thread_main(program, qdata, simulator, num_sims, block_size, seed, queue, barrier, more, dump=None):
 	"""Entry point of a calculating thread"""
 
 	maude.setRandomSeed(seed)
@@ -189,8 +219,12 @@ def thread_main(program, qdata, simulator, num_sims, block_size, seed, queue, ba
 
 	block = num_sims
 
+	# Open dump file for the raw data
+	dump_file = open(dump, 'w') if dump else None
+
 	sums = [0.0] * len(qdata)
 	sum_sq = [0.0] * len(qdata)
+	counts = [0] * len(qdata)
 
 	# Repeat until the main process says we are done
 	while True:
@@ -199,17 +233,23 @@ def thread_main(program, qdata, simulator, num_sims, block_size, seed, queue, ba
 			# Run the simulation and compute all queries at once
 			values = run(program, qdata, simulator)
 
+			if dump is not None:
+				print(*values, file=dump_file)
+
 			for k in range(len(qdata)):
-				sums[k] += values[k]
-				sum_sq[k] += values[k] * values[k]
+				if values[k] is not None:
+					sums[k] += values[k]
+					sum_sq[k] += values[k] * values[k]
+					counts[k] += 1
 
 		# Send the results to the main process and wait for it
-		queue.put((sums, sum_sq))
+		queue.put((sums, sum_sq, counts))
 		barrier.wait()
 
 		for k in range(len(qdata)):
 			sums[k] = 0.0
 			sum_sq[k] = 0.0
+			counts[k] = 0
 
 		if not more.value:
 			break
@@ -218,7 +258,7 @@ def thread_main(program, qdata, simulator, num_sims, block_size, seed, queue, ba
 		block = block_size
 
 
-def run_parallel(program, qdata, num_sims, max_sim, simulator, alpha, delta, block_size, jobs, verbose=False):
+def run_parallel(program, qdata, num_sims, min_sim, max_sim, simulator, alpha, block_size, jobs, verbose=False, dump=None):
 	"""Run the simulation in multiple threads"""
 	import multiprocessing as mp
 	mp.set_start_method('fork', force=True)
@@ -234,6 +274,8 @@ def run_parallel(program, qdata, num_sims, max_sim, simulator, alpha, delta, blo
 
 	# Random number seeds
 	seeds = [random.getrandbits(20) for _ in range(jobs)]
+	# Dump file names
+	dumps = [f'{dump}.{os.getpid()}-{k}' for k in range(jobs)] if dump else ([None] * jobs)
 	# Queue for transferring the query evaluations
 	queue = mp.Queue()
 	barrier = mp.Barrier(jobs + 1)
@@ -243,7 +285,7 @@ def run_parallel(program, qdata, num_sims, max_sim, simulator, alpha, delta, blo
 	processes = [mp.Process(target=thread_main,
 	                        args=(program, qdata, simulator, num_sims // jobs + (k < rest),
 	                              block_size // jobs + (k < rest_block),
-	                              seeds[k], queue, barrier, more)) for k in range(jobs)]
+	                              seeds[k], queue, barrier, more, dumps[k])) for k in range(jobs)]
 
 	# Start all processes
 	for p in processes:
@@ -252,13 +294,14 @@ def run_parallel(program, qdata, num_sims, max_sim, simulator, alpha, delta, blo
 	# Exactly as in run_single but with several threads
 	while True:
 		for _ in range(jobs):
-			sums, sum_sq = queue.get()
+			sums, sum_sq, counts = queue.get()
 
 			for k, query in enumerate(qdata):
 				query.sum += sums[k]
 				query.sum_sq += sum_sq[k]
+				query.n += counts[k]
 
-		converged = check_interval(qdata, num_sims, alpha, delta, quantile, verbose)
+		converged = check_interval(qdata, num_sims, min_sim, alpha, quantile, verbose)
 
 		if converged or max_sim and num_sims >= max_sim:
 			break
@@ -288,27 +331,30 @@ def qdata_to_dict(num_sims, qdata, program):
 	for k, (fname, line, column, params) in enumerate(program.query_locations):
 		# For parametric queries, we return an array of values
 		if params:
-			mean, std, radius = [], [], []
+			mean, std, radius, count, discarded = [], [], [], [], []
 
 			while q and q.query == k:
 				mean.append(q.mu)
 				std.append(q.s)
 				radius.append(q.h)
+				count.append(q.n)
+				discarded.append(q.discarded)
 				q = next(qdata_it, None)
 
 			# We also write information about the parameter
 			param_info = {'params': [dict(name=params[0], start=params[1], step=params[2], stop=params[3])]}
 
 		else:
-			mean, std, radius = q.mu, q.s, q.h
+			mean, std, radius, count, discarded = q.mu, q.s, q.h, q.n, q.discarded
 			param_info = {}
 
-		queries.append(dict(mean=mean, std=std, radius=radius, file=fname, line=line, column=column, **param_info))
+		queries.append(dict(mean=mean, std=std, radius=radius, file=fname, line=line, column=column,
+		                    nsims=count, discarded=discarded, **param_info))
 
 	return dict(nsims=num_sims, queries=queries)
 
 
-def check(program, simulator, seed, alpha, delta, block, min_sim, max_sim, jobs, verbose=False):
+def check(program, simulator, seed, alpha, delta, block, min_sim, max_sim, jobs, verbose=False, dump=None):
 	"""Run the statistical model checker"""
 
 	# The number of simulations for the first block
@@ -324,14 +370,15 @@ def check(program, simulator, seed, alpha, delta, block, min_sim, max_sim, jobs,
 
 	# Each query maintains some data like the sum of the outcomes
 	# and the sum of their squares
-	qdata = [QueryData(k, idict)
+	qdata = [QueryData(k, delta, idict)
 	         for k, qinfo in enumerate(program.query_locations)
 	         for idict in make_parameter_dicts(qinfo[3])]
 
 	# Run the simulations
 	if jobs == 1 and num_sims != 1:
-		return run_single(program, qdata, num_sims, max_sim, simulator, alpha,
-		                  delta, block, verbose=verbose)
+		with (open(dump, 'w') if dump else contextlib.nullcontext()) as dump_file:
+			return run_single(program, qdata, num_sims, min_sim, max_sim, simulator, alpha,
+					  block, verbose=verbose, dump=dump_file)
 	else:
-		return run_parallel(program, qdata, num_sims, max_sim, simulator, alpha,
-		                    delta, block, jobs, verbose=verbose)
+		return run_parallel(program, qdata, num_sims, min_sim, max_sim, simulator, alpha,
+				    block, jobs, verbose=verbose, dump=dump)

{umaudemc-0.15.0.dist-info → umaudemc-0.16.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: umaudemc
-Version: 0.15.0
+Version: 0.16.0
 Summary: Unified Maude model-checking utility
 Author-email: ningit <ningit@users.noreply.github.com>
 License-Expression: GPL-3.0-or-later

{umaudemc-0.15.0.dist-info → umaudemc-0.16.0.dist-info}/RECORD

@@ -1,10 +1,10 @@
-umaudemc/__init__.py,sha256=iCWCR3zceWVR3HY2_dnmoKBKY7eAZrsQ5pfmt6srIVw,23
-umaudemc/__main__.py,sha256=x7HLEryX--lIKW1JYjF66XLZQ9lUnAQmd2ADGRipEfo,14823
-umaudemc/api.py,sha256=I-o5foy8NUlO4JT4pX9L7kkuHQG_8_GMkWlOKt708E8,19733
+umaudemc/__init__.py,sha256=ZkVXSbnNkhhpmMRr5ur6FqBcUYuqHyK0KUV5Je_XFn8,23
+umaudemc/__main__.py,sha256=zmgS0amNTdNZ4i2fhg860uLechFnBthvPNFBbFgUSJc,15039
+umaudemc/api.py,sha256=naZ5edEbvx-S-NU29yAAJtqglfYnSAYVS2RJNyxJMQQ,19893
 umaudemc/backends.py,sha256=mzJkALYwcKPInT0lBiRsCxJSewKvx5j_akQsqWN1Ezo,4590
 umaudemc/common.py,sha256=UcIf7hTpP2qjcT9u_9-UcYR0nNeosx1xRZW7wsuT2bE,7305
 umaudemc/counterprint.py,sha256=vVqM_UjGRk_xeftFxBGI5m6cQXV7mf8KvbQ_fvAvSQk,9226
-umaudemc/distributed.py,sha256=6iR02PYQBZOWZ3bIm7AP-sCSFdTazXHb25FqldUxIg8,8653
+umaudemc/distributed.py,sha256=CljCg0VzLG7pDsDb_q1Lc95OVVjrU02cadkHRz9O8qY,9112
 umaudemc/formatter.py,sha256=nbQlIsR5Xv18OEcpJdnTDGqO9xGL_amvBGFMU2OmheU,6026
 umaudemc/formulae.py,sha256=jZPPDhjgsb7cs5rWvitiQoO0fd8JIlK98at2SN-LzVE,12156
 umaudemc/grapher.py,sha256=K1chKNNlEzQvfOsiFmRPJmd9OpxRIrg6OyiMW6gqOCU,4348
@@ -14,11 +14,11 @@ umaudemc/kleene.py,sha256=sW5SGdXpbLrjGtihPn8qgnhSH5WgltFaLVRx6GLwQU4,4697
 umaudemc/mproc.py,sha256=9X5pTb3Z3XHcdOo8ynH7I5RZQpjzm9xr4IBbEtaglUE,11766
 umaudemc/opsem.py,sha256=Xfdi9QGy-vcpmQ9ni8lBDAlKNw-fCRzYr6wnPbv6m1s,9448
 umaudemc/probabilistic.py,sha256=MNvFeEd84-OYedSnyksZB87UckPfwizVNJepCItgRy8,29306
-umaudemc/pyslang.py,sha256=zOfVGtfnOWDGghtaYLfQHq61KvbzVFmAM_0-upNhrTk,87753
-umaudemc/quatex.py,sha256=SQAbVz1csGXGqcfzFcjP89BdIpN8K2aiwP_PMLGPr1o,23239
+umaudemc/pyslang.py,sha256=ABSXYUQO2TmDq8EZ3EpVZV8NecZ0p0gERlSvLUIVAm8,87970
+umaudemc/quatex.py,sha256=Je5g16Tzb1t9NtHPSww0W6wUTIrHPdQCOJN-bTliOnQ,23888
 umaudemc/resources.py,sha256=qKqvgLYTJVtsQHQMXFObyCLTo6-fssQeu_mG7tvVyD0,932
-umaudemc/simulators.py,sha256=Lk50Ql7hWUasWkQSWxboeR5LYfJtpwrANjUDuxYjuZ4,13232
-umaudemc/statistical.py,sha256=buthWv4ovvxsvDs0eWgJw7lX2_9BsnLsW_PxW17RHCI,9087
+umaudemc/simulators.py,sha256=ZGDpQjFj2Sv4GLq-NGVBMH78cFiG45KFPKfAfH1ds9w,13283
+umaudemc/statistical.py,sha256=FY3yXvv9NRiwYOQdwLDRf4WTXG1QupGJU8KwdHQhJyo,10534
 umaudemc/terminal.py,sha256=B4GWLyW4Sdymgoavj418y4TI4MnWqNu3JS4BBoSYeTc,1037
 umaudemc/usermsgs.py,sha256=h4VPxljyKidEI8vpPcToKJA6mcLu9PtMkIh6vH3rDuA,719
 umaudemc/webui.py,sha256=XlDV87tOOdcclHp2_oerrvHwRmCZdqAR4PppqeZm47A,11072
@@ -40,8 +40,8 @@ umaudemc/command/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,
 umaudemc/command/check.py,sha256=PyaPDMw5OnPxSIZ10U4we0b5tTrjnYKAtAeQkJh2uLE,12031
 umaudemc/command/graph.py,sha256=JqGzESC2sn-LBh2sqctrij03ItzwDO808s2qkNKUle0,6112
 umaudemc/command/pcheck.py,sha256=eV4e4GcOHanP4hcIhMKd5Js22_ONac6kYj70FXun3mY,7274
-umaudemc/command/scheck.py,sha256=jiVNsLfbNDUleWl9HuNW7GTQdszd5cefZJn0_Epm9UU,4967
-umaudemc/command/sworker.py,sha256=hZv7hpZg3Z-BnTtYqNwG7y2Njyr3NMV7-EIANrj8POM,4344
+umaudemc/command/scheck.py,sha256=wByVmANax4-Jw3S6MHbXevYDiVP81HIhMk1M7yZwuMs,6205
+umaudemc/command/sworker.py,sha256=rTfGbIRvXV7cVEmlTwkKrP9tfZN0ESNJKtVLnIVCOMs,4654
 umaudemc/command/test.py,sha256=Ru21JXNF61F5N5jayjwxp8okIjOAvuZuAlV_5ltQ-GU,37088
 umaudemc/data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 umaudemc/data/opsem.maude,sha256=geDP3_RMgtS1rRmYOybJDCXn_-dyHHxg0JxfYg1ftv0,27929
@@ -52,9 +52,9 @@ umaudemc/data/smcgraph.js,sha256=iCNQNmsuGdL_GLnqVhGDisediFtedxw3C24rxSiQwx8,667
 umaudemc/data/smcview.css,sha256=ExFqrMkSeaf8VxFrJXflyCsRW3FTwbv78q0Hoo2UVrM,3833
 umaudemc/data/smcview.js,sha256=_fHum1DRU1mhco-9-c6KqTLgiC5u_cCUf61jIK7wcIQ,14509
 umaudemc/data/templog.maude,sha256=TZ-66hVWoG6gp7gJpS6FsQn7dpBTLrr76bKo-UfHGcA,9161
-umaudemc-0.15.0.dist-info/licenses/LICENSE,sha256=MrEGL32oSWfnAZ0Bq4BZNcqnq3Mhp87Q4w6-deXfFnA,17992
-umaudemc-0.15.0.dist-info/METADATA,sha256=MQLEOo16TB5BJRq90duHk0UTEMVF8i8MeENz7jt1OdE,1654
-umaudemc-0.15.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-umaudemc-0.15.0.dist-info/entry_points.txt,sha256=8rYRlLkn4orZtAoujDSeol1t_UFBrK0bfjmLTNv9B44,52
-umaudemc-0.15.0.dist-info/top_level.txt,sha256=Yo_CF78HLGBSblk3890qLcx6XZ17zHCbGcT9iG8sfMw,9
-umaudemc-0.15.0.dist-info/RECORD,,
+umaudemc-0.16.0.dist-info/licenses/LICENSE,sha256=MrEGL32oSWfnAZ0Bq4BZNcqnq3Mhp87Q4w6-deXfFnA,17992
+umaudemc-0.16.0.dist-info/METADATA,sha256=53-pCZwFfBsUPOyA_ocXL1TauD09WrY6NL574Sf1LbQ,1654
+umaudemc-0.16.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+umaudemc-0.16.0.dist-info/entry_points.txt,sha256=8rYRlLkn4orZtAoujDSeol1t_UFBrK0bfjmLTNv9B44,52
+umaudemc-0.16.0.dist-info/top_level.txt,sha256=Yo_CF78HLGBSblk3890qLcx6XZ17zHCbGcT9iG8sfMw,9
+umaudemc-0.16.0.dist-info/RECORD,,