From 4775b3e3dfe049244f269819bad2e085b41e6338 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jon=C3=A1=C5=A1=20Fiala?= Date: Mon, 27 Jan 2025 01:37:02 +0100 Subject: [PATCH] Update smt-logs and add time --- eval/Analyse.ipynb | 915 ++++++++++++++++-- eval/eval.sh | 6 +- eval/smt-logs | 2 +- .../graph/analysis/matching_loop/mod.rs | 2 +- smt-log-parser/src/bin/smt-scope/cmd/eval.rs | 7 + 5 files changed, 851 insertions(+), 81 deletions(-) diff --git a/eval/Analyse.ipynb b/eval/Analyse.ipynb index 6a635448..899d5c42 100644 --- a/eval/Analyse.ipynb +++ b/eval/Analyse.ipynb @@ -2,10 +2,50 @@ "cells": [ { "cell_type": "code", - "execution_count": 28, + "execution_count": 2, "id": "df06b9b5-4ed1-4f54-9dac-534a3035ec29", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Finding *.data files in ./data_other/github/v6/silicon\n", + "silicon files: 2724\n", + "Finding *.data files in ./data_other/github/v6/verus\n", + "verus files: 2581\n", + "Finding *.data files in ./data_other/github/v6/carbon\n", + "Missing axiom-profiler in delete_edge1-unjoin_dags.data:\n", + "[LOGFILE] delete_edge1-unjoin_dags-fHash-40a6f8fa3b681f555edab097ccd61bfd783282da236e93acf6d54ef674f0d44e.log 709943165b\n", + "[tool] dummy\n", + "[Parse] 377792us\n", + "[tool] smt-scope\n", + "Z3 4.8.7\n", + "\n", + "Missing axiom-profiler in graph_mark-mark.data:\n", + "[LOGFILE] graph_mark-mark-fHash-40a6f8fa3b681f555edab097ccd61bfd783282da236e93acf6d54ef674f0d44e.log 155919841b\n", + "[tool] dummy\n", + "[Parse] 130603us\n", + "[tool] smt-scope\n", + "Z3 4.8.7\n", + "\n", + "carbon files: 4772\n", + "Finding *.data files in ./data_other/github/v6/fstar\n", + "fstar files: 755\n", + "Finding *.data files in ./data_other/github/v6/dafny\n", + "Missing axiom-profiler in Bitvectors-Impl___module.__default.Unary.data:\n", + "[LOGFILE] Bitvectors-Impl___module.__default.Unary-fHash-40a6f8fa3b681f555edab097ccd61bfd783282da236e93acf6d54ef674f0d44e.log 18221963b\n", + "[tool] dummy\n", + "[Parse] 8046us\n", + "[tool] smt-scope\n", + "Z3 4.8.7\n", + "\n", + "dafny files: 13152\n", + "Finding *.data files in ./data_other/github/v6/smt-comp\n", + "smt-comp files: 5465\n" + ] + } + ], "source": [ "import os\n", "\n", @@ -18,12 +58,16 @@ " print(f\"Unknown time format {time_str}\")\n", " assert False\n", "\n", + "benchmarks = [\"silicon\", \"verus\", \"carbon\", \"fstar\", \"dafny\", \"smt-comp\"]\n", + "tools = [\"dummy\", \"smt-scope\", \"axiom-profiler\"]\n", + "# tools = [\"smt-scope\", \"axiom-profiler\"]\n", + "\n", "all_data = {}\n", - "benchmarks = [\"carbon\", \"silicon\", \"fstar\", \"verus\", \"dafny\", \"smt-comp\"]\n", + "version = \"github/v6\"\n", "for dir in benchmarks:\n", " dir_data = {}\n", - " print(f\"Finding *.data files in ./data_v1/{dir}\")\n", - " for root, dirs, files in os.walk(f\"./data_v1/{dir}_eval\"):\n", + " print(f\"Finding *.data files in ./data_other/{version}/{dir}\")\n", + " for root, dirs, files in os.walk(f\"./data_other/{version}/{dir}\"):\n", " for file in files:\n", " if file.endswith(\".data\"):\n", " data_str = open(os.path.join(root, file), \"r\").read()\n", @@ -35,21 +79,18 @@ " continue # log file was not generated\n", " assert len(first_line) == 3 and first_line[0] == \"[LOGFILE]\" and first_line[2][-1] == \"b\"\n", " log_size = int(first_line[2][:-1])\n", - " data = { \"log_size\": log_size, \"axiom_profiler\": {}, \"smt_scope\": {} }\n", - "\n", - " assert data_lines[1] == \"[tool] smt-scope\"\n", - " assert data_lines[2] == \"Z3 4.8.7\"\n", - "\n", - " i = 3\n", - " current = data[\"smt_scope\"]\n", + " data = { \"log_size\": log_size }\n", + " i = 1\n", + " in_exception = None\n", + " exception_kind = \"\"\n", " while i < len(data_lines):\n", " line = data_lines[i].split(\" \")\n", - " # ['[Parse] 1789us', '[Graph] 752us', '[Analysis] 202us', '[Loops] 0 true, 0 false', '[Branching] 0']\n", - " # ['[Parse] 148ms', '[Graph] 1ms', '[Analysis] 16ms', '[Loops] 0 true, 0 false', '']\n", " match line[0]:\n", " case \"[tool]\":\n", - " assert len(line) == 2 and line[1] == \"axiom-profiler\"\n", - " current = data[\"axiom_profiler\"]\n", + " assert len(line) == 2 and line[1] in tools\n", + " curr_tool = line[1]\n", + " current = {}\n", + " data[curr_tool] = current\n", " case \"[Parse]\":\n", " parse = {}\n", " time = line[1]\n", @@ -75,28 +116,89 @@ " current[\"analysis\"] = analysis\n", " case \"[Loops]\":\n", " assert len(line) == 5 and line[2] == \"true,\" and line[4] == \"false\"\n", - " current[\"loops\"] = (int(line[1]), int(line[3]))\n", + " current[\"loops\"] = { \"true-count\": int(line[1]), \"false-count\": int(line[3]), \"true\": [], \"false\": [] }\n", + " case \"[OneLoop]\":\n", + " assert len(line) >= 5 and len(line) % 2 == 1 and line[2] == \"repetitions,\" and line[3] in [\"true-loop,\", \"false-loop,\"]\n", + " repetitions = int(line[1])\n", + " true_loop = line[3] == \"true-loop,\"\n", + " quants = [line[4]]\n", + " for j in range(5, len(line), 2):\n", + " assert line[j] == \"->\"\n", + " quants.append(line[j+1])\n", + " if true_loop:\n", + " current[\"loops\"][\"true\"].append((repetitions, quants))\n", + " assert len(current[\"loops\"][\"true\"]) <= current[\"loops\"][\"true-count\"]\n", + " else:\n", + " current[\"loops\"][\"false\"].append((repetitions, quants))\n", + " assert len(current[\"loops\"][\"true\"]) == current[\"loops\"][\"true-count\"]\n", + " assert len(current[\"loops\"][\"false\"]) <= current[\"loops\"][\"false-count\"]\n", " case \"[Branching]\":\n", - " assert len(line) == 2\n", - " current[\"branching\"] = int(line[1])\n", - " case \"\":\n", - " break\n", + " branching = int(line[1])\n", + " if branching == 0:\n", + " assert len(line) == 3 and line[2] == \"\"\n", + " current[\"branching\"] = []\n", + " else:\n", + " quants = []\n", + " assert len(line) == branching * 2 + 2\n", + " for j in range(2, branching+2, 2):\n", + " assert line[j+1][-1] == \"x\"\n", + " multiplicity = float(line[j+1][:-1])\n", + " quants.append((line[j], multiplicity))\n", + " current[\"branching\"] = quants\n", + "\n", + " case \"Unhandled\" if data_lines[i] == \"Unhandled Exception:\" and curr_tool == \"axiom-profiler\":\n", + " in_exception = True\n", + " exception_kind = \"\"\n", + " case \"Error:\" if data_lines[i].startswith(\"Error: Garbage collector could not allocate\") and curr_tool == \"axiom-profiler\":\n", + " in_exception = True\n", + " exception_kind = \"OutOfMemory\"\n", + "\n", + " case \"System.NullReferenceException:\" if in_exception != None:\n", + " exception_kind = \"NullReference\"\n", + " case \"System.OutOfMemoryException:\" if in_exception != None:\n", + " exception_kind = \"OutOfMemory\"\n", + "\n", + " case \"[ERROR]\" if in_exception == True and len(line) >= 4:\n", + " assert line[1] == \"FATAL\" and line[2] == \"UNHANDLED\" and line[3] == \"EXCEPTION:\"\n", + " in_exception = False\n", + " if exception_kind == \"\":\n", + " print(f\"ERR: {data_lines[i]}\\n{data_str}\")\n", + " assert False\n", + " case \"\" if in_exception != None and len(line) >= 4 and line[1] == \"\" and line[2] == \"at\":\n", + " if exception_kind == \"\":\n", + " print(f\"ERR: {data_lines[i]}\\n{data_str}\")\n", + " assert False\n", + "\n", + " case \"Z3\" if curr_tool == \"smt-scope\":\n", + " assert len(line) == 2 and line[1] == \"4.8.7\"\n", " case _ if data_lines[i].startswith(\"This log file contains multiple checks; they will be merged and displayed as one, but the data could be invalid, confusing, or both.\"):\n", " current[\"warn_multiple_checks\"] = True\n", - " case _:\n", - " print(f\"Unknown line {data_lines[i]}\")\n", - " assert False\n", + " case other:\n", + " if len(line) != 1 or other != \"\":\n", + " print(data_lines)\n", + " print(f\"Unknown line \\\"{data_lines[i]}\\\" {curr_tool}, {in_exception}, {line}\")\n", + " assert False\n", + " elif in_exception != None:\n", + " assert not \"exception\" in current\n", + " current[\"exception\"] = exception_kind\n", + " in_exception = None\n", " i += 1\n", - "\n", " # print(data)\n", - " dir_data[os.path.join(root, file)] = data\n", + " skip = False\n", + " for tool in tools:\n", + " if not tool in data:\n", + " print(f\"Missing {tool} in {file}:\\n{data_str}\")\n", + " skip = True\n", + " break\n", + " if not skip:\n", + " dir_data[os.path.join(root, file)] = data\n", " all_data[dir] = dir_data\n", " print(f\"{dir} files: {len(dir_data)}\")\n" ] }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 3, "id": "8d222928", "metadata": {}, "outputs": [], @@ -107,45 +209,101 @@ }, { "cell_type": "code", - "execution_count": 103, + "execution_count": 156, "id": "78c67b18-5a97-4c39-aeaf-fa26feadd482", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing silicon\n", + "Processing verus\n", + "Processing carbon\n", + "Processing fstar\n", + "Processing dafny\n", + "Processing smt-comp\n", + "Processing silicon\n", + "Processing verus\n", + "Processing carbon\n", + "Processing fstar\n", + "Processing dafny\n", + "Processing smt-comp\n", + "Processing silicon\n", + "Processing verus\n", + "Processing carbon\n", + "Processing fstar\n", + "Processing dafny\n", + "Processing smt-comp\n", + "Plotting dummy 29449 points\n", + "Plotting smt-scope 29449 points\n", + "Plotting axiom-profiler 26194 points\n", + "Interest point: 200mb, ap: 39.82368588404005s, ss: 1.0715001913438762s, du: 0.2292832831356656s\n", + "Max smt-scope: 8.068007999999999s\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "ap = { \"xs\": [], \"ys\": [], \"exs\": [], \"eys\": [] }\n", - "ss = { \"xs\": [], \"ys\": [] }\n", - "for dir in benchmarks:\n", - " dir_data = all_data[dir]\n", - " print(f\"Processing {dir}\")\n", - " # ap = { \"xs\": [], \"ys\": [], \"exs\": [], \"eys\": [] }\n", - " # ss = { \"xs\": [], \"ys\": [] }\n", - " for file, data in dir_data.items():\n", - " size = data[\"log_size\"]\n", - " for tool in [\"axiom_profiler\", \"smt_scope\"]:\n", + "ap_errs = { \"exs\": [], \"eys\": [] }\n", + "plots = {}\n", + "fit_lines = {}\n", + "\n", + "sizescale = 1024 * 1024\n", + "timescale = 1000 * 1000\n", + "\n", + "for tool in tools:\n", + " plots[tool] = { \"xs\": [], \"ys\": [] }\n", + " plots_tool = plots[tool]\n", + " for dir in benchmarks:\n", + " dir_data = all_data[dir]\n", + " print(f\"Processing {dir}\")\n", + " # ap = { \"xs\": [], \"ys\": [], \"exs\": [], \"eys\": [] }\n", + " # ss = { \"xs\": [], \"ys\": [] }\n", + " for file, data in dir_data.items():\n", + " size = data[\"log_size\"]\n", " for step in [\"parse\", \"graph\", \"analysis\"]:\n", + " if not tool in data:\n", + " print(f\"Missing {tool} in {file}:\\n{data}\")\n", + " assert False\n", " if not step in data[tool]:\n", " continue\n", " tool_data = data[tool][step]\n", " this_size = size\n", - "\n", - " if tool == \"axiom_profiler\":\n", - " # key \"err\" exists and is a float\n", - " if \"err\" in data[tool][\"parse\"]:\n", - " this_size *= data[tool][\"parse\"][\"err\"]\n", - " xs = ap[\"exs\"]\n", - " ys = ap[\"eys\"]\n", - " else:\n", - " xs = ap[\"xs\"]\n", - " ys = ap[\"ys\"]\n", + " if \"err\" in data[tool][\"parse\"]:\n", + " assert tool == \"axiom-profiler\"\n", + " this_size *= data[tool][\"parse\"][\"err\"]\n", + " xs = ap_errs[\"exs\"]\n", + " ys = ap_errs[\"eys\"]\n", " else:\n", - " assert not \"err\" in tool_data\n", - " xs = ss[\"xs\"]\n", - " ys = ss[\"ys\"]\n", + " xs = plots_tool[\"xs\"]\n", + " ys = plots_tool[\"ys\"]\n", " if step == \"parse\":\n", - " xs.append(this_size / 1024)\n", - " ys.append(tool_data[\"time\"] / 1000)\n", + " xs.append(this_size / sizescale)\n", + " ys.append(tool_data[\"time\"] / timescale)\n", " else:\n", - " ys[-1] += tool_data[\"time\"] / 1000\n", + " ys[-1] += tool_data[\"time\"] / timescale\n", + " # if tool == \"smt-scope\":\n", + " # min_time = np.exp(fit_lines[\"dummy\"](np.log(size / sizescale)))\n", + " # if min_time / 2 > plots_tool[\"ys\"][-1]:\n", + " # print(f\"Warning: {file} {min_time} {plots_tool['ys'][-1]}\")\n", + " \n", + " # Fit a best fit line to the ap[\"xs\"]/ap[\"ys\"] dots using `polyfit`\n", + " # and plot the line using `plot`\n", + " plots_tool[\"log\"] = { \"xs\": np.log(plots_tool[\"xs\"]), \"ys\": np.log(plots_tool[\"ys\"]) }\n", + " fit_poly = 2# if tool == \"axiom-profiler\" else 1\n", + " points_line = np.poly1d(np.polyfit(plots_tool[\"log\"][\"xs\"], plots_tool[\"log\"][\"ys\"], fit_poly))\n", + " fit_lines[tool] = points_line\n", + "\n", "# Plot the time taken to parse each file as a scatter plot\n", "# x-axis: size of the log file, y-axis: time taken to parse the log file\n", "# there should be two types of points (one for axiom-profiler and one for smt-scope)\n", @@ -153,38 +311,629 @@ "marker_size = 10\n", "marker_shape = \".\"\n", "marker_edgecolors = \"none\"\n", - "ax.scatter(ap[\"xs\"], ap[\"ys\"], color=\"red\", label=\"axiom-profiler\", s=marker_size, marker=marker_shape, edgecolors=marker_edgecolors)\n", - "if len(ap[\"exs\"]) > 0:\n", - " ax.scatter(ap[\"exs\"], ap[\"eys\"], color=\"orange\", label=\"axiom-profiler (err)\", s=marker_size, marker=marker_shape, edgecolors=marker_edgecolors)\n", - "ax.scatter(ss[\"xs\"], ss[\"ys\"], color=\"blue\", label=\"smt-scope\", s=marker_size, marker=marker_shape, edgecolors=marker_edgecolors)\n", - "# Fit a best fit line to the ap[\"xs\"]/ap[\"ys\"] dots using `polyfit`\n", - "# and plot the line using `plot`\n", - "ap_log = { \"xs\": np.log(ap[\"xs\"]), \"ys\": np.log(ap[\"ys\"]) }\n", - "ap_line = np.poly1d(np.polyfit(ap_log[\"xs\"], ap_log[\"ys\"], 2))\n", - "ax.plot(np.unique(ap[\"xs\"]), np.exp(ap_line(np.unique(ap_log[\"xs\"]))), color=\"black\")\n", - "ss_log = { \"xs\": np.log(ss[\"xs\"]), \"ys\": np.log(ss[\"ys\"]) }\n", - "ss_line = np.poly1d(np.polyfit(ss_log[\"xs\"], ss_log[\"ys\"], 1))\n", - "ax.plot(np.unique(ss[\"xs\"]), np.exp(ss_line(np.unique(ss_log[\"xs\"]))), color=\"black\")\n", - "\n", - "interest = 200 * 1024\n", - "ap_interest = np.exp(ap_line(np.log(interest)))\n", - "ss_interest = np.exp(ss_line(np.log(interest)))\n", - "print(f\"Interest point: {interest / 1024}mb, ap: {ap_interest / 1000}s, ss: {ss_interest / 1000}s\")\n", + "\n", + "for tool in tools:\n", + " points = plots[tool]\n", + " match tool:\n", + " case \"dummy\":\n", + " color = \"black\"\n", + " label = \"System limit\"\n", + " case \"smt-scope\":\n", + " color = \"blue\"\n", + " label = \"SMT Scope\"\n", + " case \"axiom-profiler\":\n", + " color = \"red\"\n", + " label = \"Axiom Profiler\"\n", + " print(f\"Plotting {tool} {len(points['xs'])} points\")\n", + " ax.scatter(points[\"xs\"], points[\"ys\"], color=color, label=label, s=marker_size, marker=marker_shape, edgecolors=marker_edgecolors)\n", + " points_line = fit_lines[tool]\n", + " ax.plot(np.unique(points[\"xs\"]), np.exp(points_line(np.unique(points[\"log\"][\"xs\"]))), color=\"black\")\n", + "if len(ap_errs[\"exs\"]) > 0:\n", + " ax.scatter(ap_errs[\"exs\"], ap_errs[\"eys\"], color=\"orange\", label=\"Axiom Profiler partial\", s=marker_size, marker=marker_shape, edgecolors=marker_edgecolors)\n", + "\n", + "interest = 200\n", + "ap_interest = np.exp(fit_lines[\"axiom-profiler\"](np.log(interest)))\n", + "ss_interest = np.exp(fit_lines[\"smt-scope\"](np.log(interest)))\n", + "du_interest = np.exp(fit_lines[\"dummy\"](np.log(interest)))\n", + "print(f\"Interest point: {interest}mb, ap: {ap_interest}s, ss: {ss_interest}s, du: {du_interest}s\")\n", + "max_smt_scope = max(plots[\"smt-scope\"][\"ys\"])\n", + "print(f\"Max smt-scope: {max_smt_scope}s\")\n", "plt.axvline(interest, color=\"black\", linestyle=\"dashed\", alpha=0.4)\n", "plt.axhline(ap_interest, color=\"black\", linestyle=\"dashed\", alpha=0.4)\n", "plt.axhline(ss_interest, color=\"black\", linestyle=\"dashed\", alpha=0.4)\n", "plt.plot([interest, interest], [ss_interest, ap_interest], color=\"black\")\n", "\n", "\n", - "ax.set_xlabel(\"Log file size (kb)\")\n", - "ax.set_ylabel(f\"Time taken (ms)\")\n", - "ax.set_title(f\"Time\")\n", + "ax.set_xlabel(\"Trace file size (mb)\")\n", + "ax.set_ylabel(f\"Parse and analysis time (s)\")\n", + "# ax.set_title(f\"Time\")\n", "# Set x-axis to log base 2 scale\n", "ax.set_xscale('log')#, base=2)\n", "ax.set_yscale('log')\n", "lgnd = ax.legend(markerscale=5)\n", - "plt.savefig(f\"./data_v1/all.pdf\")\n", - "plt.show()\n" + "plt.savefig(f\"./data_other/{version}/all.pdf\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "98a88c67", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing silicon\n", + "['quant-u-26649{0}'] 95 ./data_other/github/v6/silicon/silver/src/test/resources/termination/functions/basic/postsCheck-00.data\n", + "['prog.numberOfElem{1}'] 97 ./data_other/github/v6/silicon/silver/src/test/resources/termination/functions/basic/adt-00.data\n", + "['k!859{0}', 'k!850{0}'] 47 ./data_other/github/v6/silicon/silver/src/test/resources/all/maps/example3-01.data\n", + "['k!682{0}', 'k!673{0}'] 47 ./data_other/github/v6/silicon/silver/src/test/resources/all/maps/example2-01.data\n", + "['k!1438{0}', 'k!1429{0}'] 47 ./data_other/github/v6/silicon/silver/src/test/resources/all/maps/example1-01.data\n", + "['prog./home/runner/work/smt-logs/smt-logs/viper/viperserver/silicon/silver/src/test/resources/all/predicates/lseg.vpr@55@14@55@119{0}', 'quant-u-21938{0}'] 48 ./data_other/github/v6/silicon/silver/src/test/resources/all/predicates/lseg-01.data\n", + "['prog.single_def{0}'] 21 ./data_other/github/v6/silicon/silver/src/test/resources/all/third_party/stefan_recent/testHistoryLemmasPVL-01.data\n", + "['prog.seq_assoc{0}', 'prog.single_def{0}'] 20 ./data_other/github/v6/silicon/silver/src/test/resources/all/third_party/stefan_recent/testHistoryLemmasPVL-01.data\n", + "['prog.insertCons{6}'] 6 ./data_other/github/v6/silicon/silver/src/test/resources/all/issues/silicon/0045-01.data\n", + "['quant-u-24445{0}', 'quant-u-24444{0}', 'prog./home/runner/work/smt-logs/smt-logs/viper/viperserver/silicon/silver/src/test/resources/all/issues/silicon/0336b.vpr@11@4@12@44{0}'] 6 ./data_other/github/v6/silicon/silver/src/test/resources/all/issues/silicon/0336b-01.data\n", + "['quant-u-24195{0}'] 96 ./data_other/github/v6/silicon/silver/src/test/resources/all/issues/silicon/0365-01.data\n", + "['prog./home/runner/work/smt-logs/smt-logs/viper/viperserver/silicon/silver/src/test/resources/quantifiedpermissions/sequences/linked-list-qp-append.vpr@19@7@21@4{0}', 'qp.fvfValDef0{0}', 'quant-u-10612{0}'] 17 ./data_other/github/v6/silicon/silver/src/test/resources/quantifiedpermissions/sequences/linked-list-qp-append-01.data\n", + "['prog./home/runner/work/smt-logs/smt-logs/viper/viperserver/silicon/silver/src/test/resources/quantifiedpermissions/sets/unionfind.vpr@116@6@116@66{0}'] 97 ./data_other/github/v6/silicon/silver/src/test/resources/quantifiedpermissions/sets/unionfind-00.data\n", + "['quant-u-19109{0}', 'prog./home/runner/work/smt-logs/smt-logs/viper/viperserver/silicon/silver/src/test/resources/examples/graph-marking/graph-marking.vpr@23@28@23@38{1}', 'qp.fvfValDef0{0}', 'quant-u-19108{0}', 'qp.fvfResTrgDef1{0}'] 17 ./data_other/github/v6/silicon/silver/src/test/resources/examples/graph-marking/graph-marking-01.data\n", + "['quant-u-19108{0}', 'prog./home/runner/work/smt-logs/smt-logs/viper/viperserver/silicon/silver/src/test/resources/examples/graph-marking/graph-marking.vpr@23@28@23@38{1}', 'qp.fvfValDef0{0}', 'quant-u-19109{0}'] 16 ./data_other/github/v6/silicon/silver/src/test/resources/examples/graph-marking/graph-marking-01.data\n", + "['quant-u-19130{0}', 'qp.fvfValDef0{0}', 'prog./home/runner/work/smt-logs/smt-logs/viper/viperserver/silicon/silver/src/test/resources/examples/graph-marking/graph-marking.vpr@23@28@23@38{1}', 'left-invOfFct{0}', 'qp.fvfValDef2{0}'] 8 ./data_other/github/v6/silicon/silver/src/test/resources/examples/graph-marking/graph-marking-01.data\n", + "['quant-u-19210{0}', 'prog./home/runner/work/smt-logs/smt-logs/viper/viperserver/silicon/silver/src/test/resources/examples/graph-marking/graph-marking.vpr@23@28@23@38{1}', 'left-invOfFct{0}', 'qp.fvfValDef0{0}', 'qp.fvfValDef2{0}'] 8 ./data_other/github/v6/silicon/silver/src/test/resources/examples/graph-marking/graph-marking-01.data\n", + "['left-invOfFct{0}', 'prog./home/runner/work/smt-logs/smt-logs/viper/viperserver/silicon/silver/src/test/resources/examples/graph-marking/graph-marking.vpr@23@28@23@38{1}', 'qp.fvfValDef0{0}', 'quant-u-19210{0}'] 8 ./data_other/github/v6/silicon/silver/src/test/resources/examples/graph-marking/graph-marking-01.data\n", + "['quant-u-19112{0}', 'qp.fvfValDef2{0}', 'prog./home/runner/work/smt-logs/smt-logs/viper/viperserver/silicon/silver/src/test/resources/examples/graph-marking/graph-marking.vpr@23@28@23@38{1}', 'quant-u-19111{0}', 'qp.fvfValDef0{0}'] 7 ./data_other/github/v6/silicon/silver/src/test/resources/examples/graph-marking/graph-marking-01.data\n", + "['left-invOfFct{0}', 'quant-u-19130{0}', 'qp.fvfValDef0{0}', 'prog./home/runner/work/smt-logs/smt-logs/viper/viperserver/silicon/silver/src/test/resources/examples/graph-marking/graph-marking.vpr@23@28@23@38{1}'] 7 ./data_other/github/v6/silicon/silver/src/test/resources/examples/graph-marking/graph-marking-01.data\n", + "['quant-u-19111{0}', 'qp.fvfValDef2{0}', 'quant-u-19112{0}', 'prog./home/runner/work/smt-logs/smt-logs/viper/viperserver/silicon/silver/src/test/resources/examples/graph-marking/graph-marking.vpr@23@28@23@38{1}'] 6 ./data_other/github/v6/silicon/silver/src/test/resources/examples/graph-marking/graph-marking-01.data\n", + "['prog./home/runner/work/smt-logs/smt-logs/viper/viperserver/silicon/silver/src/test/resources/quantifiedpredicates/issues/block_array.vpr@50@9@50@157-aux{0}'] 94 ./data_other/github/v6/silicon/silver/src/test/resources/quantifiedpredicates/issues/block_array-01.data\n", + "['prog./home/runner/work/smt-logs/smt-logs/viper/viperserver/silicon/silver/src/test/resources/quantifiedpredicates/issues/block_array.vpr@51@9@51@161-aux{0}'] 33 ./data_other/github/v6/silicon/silver/src/test/resources/quantifiedpredicates/issues/block_array-01.data\n", + "['quant-u-14893{0}', 'prog./home/runner/work/smt-logs/smt-logs/viper/viperserver/silicon/silver/src/test/resources/graphs/static/examples/graph_mark.vpr@195@13@195@21{1}', 'car-invOfFct{0}'] 31 ./data_other/github/v6/silicon/silver/src/test/resources/graphs/static/examples/graph_mark-01.data\n", + "['quant-u-14896{0}', 'cdr-invOfFct{0}', 'prog./home/runner/work/smt-logs/smt-logs/viper/viperserver/silicon/silver/src/test/resources/graphs/static/examples/graph_mark.vpr@195@13@195@21{1}'] 7 ./data_other/github/v6/silicon/silver/src/test/resources/graphs/static/examples/graph_mark-01.data\n", + "['quant-u-13640{0}', 'next-invOfFct{0}', 'qp.fvfValDef165{0}', 'prog./home/runner/work/smt-logs/smt-logs/viper/viperserver/silicon/silver/src/test/resources/graphs/static/unsound/list-swap.vpr@324@19@324@27{1}'] 31 ./data_other/github/v6/silicon/silver/src/test/resources/graphs/static/unsound/list-swap-01.data\n", + "['quant-u-13640{0}', 'qp.fvfValDef165{0}', 'prog./home/runner/work/smt-logs/smt-logs/viper/viperserver/silicon/silver/src/test/resources/graphs/static/unsound/list-swap.vpr@324@19@324@27{1}', 'next-invOfFct{0}', 'qp.fvfValDef107{0}'] 30 ./data_other/github/v6/silicon/silver/src/test/resources/graphs/static/unsound/list-swap-01.data\n", + "['quant-u-13599{0}', 'prog./home/runner/work/smt-logs/smt-logs/viper/viperserver/silicon/silver/src/test/resources/graphs/static/unsound/list-swap.vpr@301@14@301@22{1}', 'qp.fvfValDef107{0}', 'next-invOfFct{0}'] 6 ./data_other/github/v6/silicon/silver/src/test/resources/graphs/static/unsound/list-swap-01.data\n", + "['quant-u-488{1}', 'quant-u-472{0}'] 34 ./data_other/github/v6/silicon/src/test/resources/frontends/prusti/with-spec-list.rs-01.data\n", + "['prog./home/runner/work/smt-logs/smt-logs/viper/viperserver/silicon/src/test/resources/frontends/prusti/knapsack.rs.vpr@3440@2446@3440@3044{0}', 'quant-u-103{0}'] 29 ./data_other/github/v6/silicon/src/test/resources/frontends/prusti/knapsack.rs-01.data\n", + "Silicon & 2724 & 30 & 7 & 281 \\\\\n", + "Processing verus\n", + "['user_crate__vstd__arithmetic__mul__lemma_mul_is_distributive_sub_14{0}'] 96 ./data_other/github/v6/verus/source/rust_verify_test/tests/basic/test_is_core/vstd__arithmetic__internals__mod_internals.data\n", + "['user_crate__vstd__arithmetic__mul__lemma_mul_is_distributive_sub_14{0}', 'user_crate__vstd__arithmetic__mul__lemma_mul_is_distributive_add_9{0}'] 95 ./data_other/github/v6/verus/source/rust_verify_test/tests/basic/test_is_core/vstd__arithmetic__internals__mod_internals.data\n", + "Verus & 2581 & 2 & 2 & 12 \\\\\n", + "Processing carbon\n", + "['stdinbpl.223:15{1}'] 96 ./data_other/github/v6/carbon/silver/src/test/resources/termination/functions/basic/adt-f_definedness.data\n", + "['stdinbpl.422:20{0}', 'stdinbpl.416:20{0}'] 47 ./data_other/github/v6/carbon/silver/src/test/resources/all/maps/example1-test4.data\n", + "['stdinbpl.260:15{0}'] 96 ./data_other/github/v6/carbon/silver/src/test/resources/all/issues/silicon/0365-try_lock_shared.data\n", + "['stdinbpl.671:15{6}'] 6 ./data_other/github/v6/carbon/silver/src/test/resources/all/issues/silicon/0045-property01.data\n", + "['stdinbpl.778:20{0}'] 37 ./data_other/github/v6/carbon/silver/src/test/resources/quantifiedpermissions/sequences/bsearch-bfind_orig.data\n", + "['stdinbpl.4944:24{1}', 'stdinbpl.790:15{0}'] 16 ./data_other/github/v6/carbon/silver/src/test/resources/graphs/static/outlines/list_append-append.data\n", + "Carbon & 4772 & 6 & 4 & 635 \\\\\n", + "Processing fstar\n", + "['projection_inverse_BoxInt_proj_0{0}', '@query.10{0}'] 45 ./data_other/github/v6/fstar/tests/vale/queries-X64.Vale.StrongPost_i.data\n", + "['Prims_interpretation_Tm_arrow_35447810753695c4fe25c93af1251992.1{0}', 'refinement_interpretation_Tm_refine_51a1a11c85affab19a1e24b7b60f7bf9.1{0}'] 7 ./data_other/github/v6/fstar/examples/tactics/queries-Arith-4.data\n", + "['equation_Imp.triple.1{0}'] 6 ./data_other/github/v6/fstar/doc/book/code/queries-Imp.data\n", + "['equation_Alex.unbounded.1{0}'] 6 ./data_other/github/v6/fstar/doc/book/code/queries-Alex.data\n", + "Fstar & 755 & 4 & 1 & 42 \\\\\n", + "Processing dafny\n", + "['k!71{0}'] 7 ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/lambdas/LitInt-Impl___module.__default.CheckFib.data\n", + "['k!130{0}'] 97 ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/triggers/splitting-triggers-recovers-expressivity-Impl___module.__de-n6.data\n", + "['k!326{0}', 'k!225{0}'] 47 ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny1/Rippling.legacy-Impl___module.__default.P67.data\n", + "['k!154{0}', 'k!176{0}', 'k!145{0}', 'k!326{0}', 'k!225{0}', 'k!317{1}'] 44 ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny1/Rippling.legacy-Impl___module.__default.P67.data\n", + "['k!158{0}', 'k!176{0}', 'k!145{0}', 'k!167{0}', 'k!217{0}', 'k!225{0}', 'k!317{1}', 'k!326{0}'] 43 ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny1/Rippling.legacy-Impl___module.__default.P67.data\n", + "['k!299{0}'] 41 ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny1/FindZero-Impl___module.__default.FindZero__Assert.data\n", + "['k!473{0}'] 39 ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny1/ExtensibleArrayAuto-Impl___module.__default.Main.data\n", + "['k!180{0}', 'k!258{0}'] 47 ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny1/Rippling.legacy-Impl___module.__default.P54.data\n", + "['k!128{0}', 'k!258{0}', 'k!247{1}', 'k!180{0}', 'k!151{0}', 'k!172{0}', 'k!115{0}'] 44 ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny1/Rippling.legacy-Impl___module.__default.P54.data\n", + "['k!124{0}', 'k!258{0}', 'k!151{0}', 'k!247{1}', 'k!180{0}', 'k!115{0}'] 44 ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny1/Rippling.legacy-Impl___module.__default.P54.data\n", + "['k!128{0}', 'k!258{0}', 'k!151{0}', 'k!172{0}', 'k!247{1}', 'k!180{0}', 'k!115{0}', 'k!137{0}'] 42 ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny1/Rippling.legacy-Impl___module.__default.P54.data\n", + "['k!158{0}', 'k!176{0}', 'k!145{0}', 'k!217{0}'] 43 ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny1/Rippling.legacy-Impl___module.__default.P65.data\n", + "['k!417{0}'] 70 ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny1/Substitution-Impl___module.__default.TheoremSeq.data\n", + "['k!345{0}'] 97 ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny0/Maps-Impl___module.__default.GeneralMaps4.data\n", + "['k!165{0}'] 30 ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny0/LetExpr-Impl___module.__default.M3.data\n", + "['k!114{0}', 'k!110{0}'] 14 ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny0/ComputationsLoop2-Impl___module.__default.Test.data\n", + "['k!96{0}'] 10 ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny0/LetExpr-Impl__LitLet.__default.M1.data\n", + "['k!86{0}'] 30 ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny0/ComputationsNeg-Impl___module.__default.go__bad.data\n", + "['k!223{0}'] 97 ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny0/DeterministicPick-Impl__Attempt__Smallest.__default.ASmallest-n2.data\n", + "['k!102{0}'] 30 ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny0/ComputationsLoop-Impl___module.__default.Test.data\n", + "['k!398{0}'] 96 ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny0/TypeAdjustments-Impl__Comprehensions.__default.Maps1.data\n", + "['k!114{0}'] 6 ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny0/AllLiteralsAxiom-Impl__NeedsAllLiteralsAxiom.__default.calc__-n3.data\n", + "['k!217{0}'] 53 ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny0/IMaps-Impl___module.__default.m8.data\n", + "['k!99{0}'] 6 ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny0/LetExpr-Impl__LitLet.__default.M3.data\n", + "['k!630{1}'] 97 ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/comp/rust/loops-Impl___module.__default.Main_split0.data\n", + "['k!655{1}'] 97 ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/comp/rust/loops-Impl___module.__default.Main_split1.data\n", + "['k!990{1}'] 97 ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/comp/rust/loops-Impl___module.__default.Main_split2.data\n", + "['k!227{0}'] 96 ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/VerifyThis2015/Problem1-Impl___module.__default.Same1__Aux.data\n", + "['k!1263{0}'] 91 ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/git-issues/git-issue-3855-Impl___module.Memory.dynCopy.data\n", + "['k!170{0}'] 7 ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/git-issues/git-issue-1250-Impl___module.__default.Eleven.data\n", + "['k!1219{0}'] 38 ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/git-issues/git-issue-3855-Impl___module.__default.Main1.data\n", + "['k!647{0}'] 93 ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny2/SnapshotableTrees-Impl__SnapTree.Tree.Insert.data\n", + "['k!557{0}', 'k!168{0}', 'k!391{0}', 'k!565{0}', 'k!565{2}'] 31 ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny2/COST-verif-comp-2011-4-FloydCycleDetect-Impl___module.Node.An-n6.data\n", + "['k!565{0}', 'k!391{0}', 'k!557{0}', 'k!168{0}'] 31 ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny2/COST-verif-comp-2011-4-FloydCycleDetect-Impl___module.Node.An-n6.data\n", + "['k!414{1}', 'k!248{0}', 'k!518{0}'] 31 ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny4/UnionFind-Impl__M3.UnionFind.ReachUnaffectedByChangeFromRoot_-n4.data\n", + "['k!233{0}'] 95 ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny4/Primes-Impl___module.__default.LargestElementExists.data\n", + "['k!276{0}'] 95 ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny4/git-issue135-Impl___module.__default.lemma__MapTest.data\n", + "Dafny & 13152 & 37 & 17 & 706 \\\\\n", + "Processing smt-comp\n", + "['k!20{0}'] 17 ./data_other/github/v6/smt-comp/non-incremental/UFNIRA/20240414-funcprobs/prove/problem_U9.data\n", + "['k!28{0}'] 17 ./data_other/github/v6/smt-comp/non-incremental/UFNIRA/20240414-funcprobs/prove/problem_U30.data\n", + "['k!21{0}'] 11 ./data_other/github/v6/smt-comp/non-incremental/UFNIRA/20240414-funcprobs/prove/problem_U12.data\n", + "['k!27{0}'] 8 ./data_other/github/v6/smt-comp/non-incremental/UFNIRA/20240414-funcprobs/prove/problem_U38.data\n", + "['k!22{0}'] 7 ./data_other/github/v6/smt-comp/non-incremental/UFNIRA/20240414-funcprobs/find/problem_U61.data\n", + "Smt-comp & 5465 & 5 & 4 & 32 \\\\\n", + "Total & 29449 & 84 & 35 & 1708 \\\\\n" + ] + } + ], + "source": [ + "def check_contained(quant_seq, loops):\n", + " return set(quant_seq) in loops\n", + "\n", + "total = 0\n", + "true_matching_loops = 0\n", + "false_matching_loops = 0\n", + "branching_count = 0\n", + "for dir in benchmarks:\n", + " dir_data = all_data[dir]\n", + " print(f\"Processing {dir}\")\n", + " unique_true_loops = []\n", + " true_loops_files = []\n", + " unique_false_loops = []\n", + " unique_branching = []\n", + " for file, data in dir_data.items():\n", + " for quant, mult in data[\"smt-scope\"][\"branching\"]:\n", + " quant = quant.split(\"[\")\n", + " assert len(quant) == 2\n", + " quant = quant[0]\n", + " if not quant in unique_branching:\n", + " unique_branching.append(quant)\n", + " branching_count += 1\n", + " # else:\n", + " # print(f\"Duplicate branching {quant}\")\n", + " if \"loops\" in data[\"smt-scope\"]:\n", + " loops = data[\"smt-scope\"][\"loops\"]\n", + " for reps,loop in loops[\"true\"]:\n", + " loop = [x.split(\"[\") for x in loop]\n", + " assert all([len(x) == 2 for x in loop])\n", + " loop = [x[0] for x in loop]\n", + " # if any([l.startswith(\"qp.\") for l in loop]):\n", + " # continue\n", + " if not check_contained(loop, unique_true_loops):\n", + " print(f\"{loop} {reps} {file}\")\n", + " unique_true_loops.append(set(loop))\n", + " true_loops_files.append(file)\n", + " true_matching_loops += 1\n", + " # else:\n", + " # print(f\"Duplicate true loop {loop}\")\n", + " for reps,loop in loops[\"false\"]:\n", + " loop = [x.split(\"[\") for x in loop]\n", + " assert all([len(x) == 2 for x in loop])\n", + " loop = [x[0] for x in loop]\n", + " if not check_contained(loop, unique_false_loops):\n", + " # print(f\"FALSE {loop} {reps} {file}\")\n", + " unique_false_loops.append(set(loop))\n", + " false_matching_loops += 1\n", + " # else:\n", + " # print(f\"Duplicate false loop {loop}\")\n", + " # print(f\"{dir} items: {len(dir_data.items())}, true loops: {len(unique_true_loops)}, false loops: {len(unique_false_loops)}, branching: {len(unique_branching)}\")\n", + " total += len(dir_data)\n", + " print(f\"{dir.capitalize()} & {len(dir_data)} & {len(unique_true_loops)} & {len(unique_false_loops)} & {len(unique_branching)} \\\\\\\\\")\n", + " # for file, loop in zip(true_loops_files, unique_true_loops):\n", + " # print(f\"{file} {loop}\")\n", + "print(f\"Total & {total} & {true_matching_loops} & {false_matching_loops} & {branching_count} \\\\\\\\\")" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "986f631f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing silicon\n", + "['prog.seq_assoc'] 21 ./data_other/github/v6/silicon/silver/src/test/resources/all/third_party/stefan_recent/testHistoryLemmasPVL-01.data\n", + "['prog./home/runner/work/smt-logs/smt-logs/viper/viperserver/silicon/silver/src/test/resources/quantifiedpermissions/issues/unofficial_0002.vpr@19@28@19@38'] 3 ./data_other/github/v6/silicon/silver/src/test/resources/quantifiedpermissions/issues/unofficial_0002-01.data\n", + "['prog./home/runner/work/smt-logs/smt-logs/viper/viperserver/silicon/silver/src/test/resources/quantifiedpermissions/issues/issue_0121.vpr@17@12@17@65'] 3 ./data_other/github/v6/silicon/silver/src/test/resources/quantifiedpermissions/issues/issue_0121-01.data\n", + "['prog.$get_set_1_ax'] 3 ./data_other/github/v6/silicon/src/test/resources/frontends/vyper/testsresourcesexamplesEtherStore.vy-01.data\n", + "Silicon & 2724 & 4 & 0 & 775 \\\\\n", + "Processing verus\n", + "['prelude_u_clip'] 3 ./data_other/github/v6/verus/source/rust_verify_test/tests/summer_school/e21_pass.data\n", + "Verus & 2581 & 1 & 0 & 408 \\\\\n", + "Processing carbon\n", + "['stdinbpl.112:22'] 3 ./data_other/github/v6/carbon/silver/src/test/resources/termination/functions/expressions/forall-test_pres_termination_proof.data\n", + "['stdinbpl.31:15'] 3 ./data_other/github/v6/carbon/silver/src/test/resources/all/heap-dependent_triggers/triggerWand-m3.data\n", + "['stdinbpl.169:22'] 3 ./data_other/github/v6/carbon/silver/src/test/resources/all/invariants/while3-test02a.data\n", + "Carbon & 4772 & 3 & 1 & 1266 \\\\\n", + "Processing fstar\n", + "Fstar & 755 & 0 & 0 & 680 \\\\\n", + "Processing dafny\n", + "['k!193'] 8 ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/c++/datatypes-Impl___module.__default.Main.data\n", + "['k!147'] 5 ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/c++/arrays-Impl___module.__default.returnANonNullArray.data\n", + "['k!241'] 5 ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/patterns/PatternMatching-Impl___module.__default.Main.data\n", + "['k!151'] 4 ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/traits/Traits-Fields-Impl___module.__default.Main.data\n", + "['k!212'] 3 ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/VSI-Benchmarks/b7-Impl___module.Stream.Create.data\n", + "['k!124'] 4 ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny0/Basics-Impl___module.__default.TestCalls.data\n", + "['k!97'] 3 ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny0/DiamondImports-Impl__ImportOpened_mD.__default.Client.data\n", + "['k!89'] 3 ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny0/Fuel.legacy-Impl__TestModule4.__default.test3.data\n", + "['k!143'] 3 ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny0/NameclashesCompile-Impl___module.__default.Main.data\n", + "['k!272'] 4 ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/comp/Calls-Impl__FunctionValues.__default.Test.data\n", + "['k!174'] 3 ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/comp/DefaultParameters-Compile-Impl___module.__default.Main.data\n", + "['k!120'] 3 ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/exceptions/Exceptions1-Impl___module.__default.TestControlFlowCase__-n1.data\n", + "['k!119'] 3 ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/exports/LIFO-Impl__MainImpl.__default.Main.data\n", + "['k!135'] 3 ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/exports/ExportVerify-Impl__Client__Revealing.__default.M.data\n", + "['k!132'] 3 ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/exports/ExportVerify-Impl__Client__Revealing.__default.M.data\n", + "['k!614'] 3 ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/concurrency/11-MutexGuard2.legacy-Impl___module.__default.SetData_sp-n38.data\n", + "['k!176'] 3 ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/git-issues/git-issue-2013-Impl___module.__default.TestTraits.data\n", + "['k!180'] 3 ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny2/COST-verif-comp-2011-2-MaxTree-datatype-Impl___module.__defau-n2.data\n", + "['k!136'] 3 ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny4/SoftwareFoundations-Basics-Impl___module.__default.test__mult-n8.data\n", + "['k!144'] 3 ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny4/CoqArt-InsertionSort-Impl___module.__default.example__sort__2-n1.data\n", + "Dafny & 13152 & 20 & 14 & 3694 \\\\\n", + "Processing smt-comp\n", + "['k!24'] 3 ./data_other/github/v6/smt-comp/non-incremental/UFNIRA/20240414-funcprobs/prove/problem_U67.data\n", + "['k!21'] 3 ./data_other/github/v6/smt-comp/non-incremental/UFNIRA/20240414-funcprobs/prove/problem_U31.data\n", + "['k!31'] 3 ./data_other/github/v6/smt-comp/non-incremental/UFNIRA/20240414-funcprobs/check/problem_U29_sol1.data\n", + "Smt-comp & 5465 & 3 & 0 & 511 \\\\\n", + "Total & 29449 & 31 & 15 & 7334 \\\\\n", + "24.904071445549935\n" + ] + } + ], + "source": [ + "def check_contained(quant_seq, loops):\n", + " return set(quant_seq) in loops\n", + "\n", + "total = 0\n", + "true_matching_loops = 0\n", + "false_matching_loops = 0\n", + "branching_count = 0\n", + "for dir in benchmarks:\n", + " dir_data = all_data[dir]\n", + " print(f\"Processing {dir}\")\n", + " unique_true_loops = []\n", + " true_loops_files = []\n", + " unique_false_loops = []\n", + " unique_branching = []\n", + " for file, data in dir_data.items():\n", + " if \"exception\" in data[\"axiom-profiler\"]:\n", + " unique_branching.append(data[\"axiom-profiler\"][\"exception\"])\n", + " assert not \"parse\" in data[\"axiom-profiler\"]\n", + " # print(f\"File size: {data['log_size'] / 1024 / 1024}mb\")\n", + " elif not \"parse\" in data[\"axiom-profiler\"]:\n", + " assert False\n", + " unique_branching.append(\"Err\")\n", + " elif \"err\" in data[\"axiom-profiler\"][\"parse\"]:\n", + " unique_branching.append(data[\"axiom-profiler\"][\"parse\"][\"err\"])\n", + " elif \"err\" in data[\"axiom-profiler\"][\"analysis\"]:\n", + " unique_branching.append(data[\"axiom-profiler\"][\"analysis\"][\"err\"])\n", + " elif \"err\" in data[\"axiom-profiler\"][\"graph\"]:\n", + " unique_branching.append(data[\"axiom-profiler\"][\"graph\"][\"err\"])\n", + "\n", + " if \"loops\" in data[\"axiom-profiler\"]:\n", + " loops = data[\"axiom-profiler\"][\"loops\"]\n", + " for reps,loop in loops[\"true\"]:\n", + " loop = [x.split(\"[\") for x in loop]\n", + " assert all([len(x) == 2 for x in loop])\n", + " loop = [x[0] for x in loop]\n", + " if not check_contained(loop, unique_true_loops):\n", + " print(f\"{loop} {reps} {file}\")\n", + " unique_true_loops.append(set(loop))\n", + " true_loops_files.append(file)\n", + " true_matching_loops += 1\n", + " # else:\n", + " # print(f\"Duplicate true loop {loop}\")\n", + " for reps,loop in loops[\"false\"]:\n", + " loop = [x.split(\"[\") for x in loop]\n", + " assert all([len(x) == 2 for x in loop])\n", + " loop = [x[0] for x in loop]\n", + " if not check_contained(loop, unique_false_loops):\n", + " unique_false_loops.append(set(loop))\n", + " false_matching_loops += 1\n", + " # else:\n", + " # print(f\"Duplicate false loop {loop}\")\n", + " # print(f\"{dir} items: {len(dir_data.items())}, true loops: {len(unique_true_loops)}, false loops: {len(unique_false_loops)}, branching: {len(unique_branching)}\")\n", + " total += len(dir_data)\n", + " branching_count += len(unique_branching)\n", + " print(f\"{dir.capitalize()} & {len(dir_data)} & {len(unique_true_loops)} & {len(unique_false_loops)} & {len(unique_branching)} \\\\\\\\\")\n", + " # for file, loop in zip(true_loops_files, unique_true_loops):\n", + " # print(f\"{file} {loop}\")\n", + "print(f\"Total & {total} & {true_matching_loops} & {false_matching_loops} & {branching_count} \\\\\\\\\")\n", + "print(100*branching_count/total)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "0f1a4ad1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing silicon\n", + "AP true loop not in SMT-Scope: ['prog./home/runner/work/smt-logs/smt-logs/viper/viperserver/silicon/silver/src/test/resources/quantifiedpermissions/issues/unofficial_0002.vpr@19@28@19@38'] (3)\n", + "True loops: []\n", + "False loops: []\n", + "File ./data_other/github/v6/silicon/silver/src/test/resources/quantifiedpermissions/issues/unofficial_0002-01.data\n", + "AP true loop not in SMT-Scope: ['prog./home/runner/work/smt-logs/smt-logs/viper/viperserver/silicon/silver/src/test/resources/quantifiedpermissions/issues/issue_0121.vpr@17@12@17@65'] (3)\n", + "True loops: []\n", + "False loops: []\n", + "File ./data_other/github/v6/silicon/silver/src/test/resources/quantifiedpermissions/issues/issue_0121-01.data\n", + "AP true loop not in SMT-Scope: ['prog.$get_set_1_ax'] (3)\n", + "True loops: []\n", + "False loops: []\n", + "File ./data_other/github/v6/silicon/src/test/resources/frontends/vyper/testsresourcesexamplesEtherStore.vy-01.data\n", + "Processing verus\n", + "AP true loop not in SMT-Scope: ['prelude_u_clip'] (3)\n", + "True loops: []\n", + "False loops: []\n", + "File ./data_other/github/v6/verus/source/rust_verify_test/tests/summer_school/e21_pass.data\n", + "Processing carbon\n", + "AP false loop not in SMT-Scope: ['stdinbpl.93:15'] (3)\n", + "True loops: []\n", + "False loops: []\n", + "File ./data_other/github/v6/carbon/silver/src/test/resources/adt/adt_as_fields_1-adt_as_fields_1.data\n", + "AP true loop not in SMT-Scope: ['stdinbpl.112:22'] (3)\n", + "True loops: []\n", + "False loops: []\n", + "File ./data_other/github/v6/carbon/silver/src/test/resources/termination/functions/expressions/forall-test_pres_termination_proof.data\n", + "AP true loop not in SMT-Scope: ['stdinbpl.31:15'] (3)\n", + "True loops: []\n", + "False loops: []\n", + "File ./data_other/github/v6/carbon/silver/src/test/resources/all/heap-dependent_triggers/triggerWand-m3.data\n", + "AP true loop not in SMT-Scope: ['stdinbpl.169:22'] (3)\n", + "True loops: []\n", + "False loops: []\n", + "File ./data_other/github/v6/carbon/silver/src/test/resources/all/invariants/while3-test02a.data\n", + "Processing fstar\n", + "Processing dafny\n", + "AP true loop not in SMT-Scope: ['k!193'] (8)\n", + "True loops: []\n", + "False loops: []\n", + "File ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/c++/datatypes-Impl___module.__default.Main.data\n", + "AP false loop not in SMT-Scope: ['k!144'] (3)\n", + "True loops: []\n", + "False loops: []\n", + "File ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/c++/seqs-Impl___module.__default.Contains.data\n", + "AP false loop not in SMT-Scope: ['k!95'] (3)\n", + "True loops: []\n", + "False loops: []\n", + "File ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/c++/seqs-Impl___module.__default.Contains.data\n", + "AP true loop not in SMT-Scope: ['k!147'] (5)\n", + "True loops: []\n", + "False loops: []\n", + "File ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/c++/arrays-Impl___module.__default.returnANonNullArray.data\n", + "AP false loop not in SMT-Scope: ['k!147'] (4)\n", + "True loops: []\n", + "False loops: []\n", + "File ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/c++/arrays-Impl___module.__default.returnANonNullArray.data\n", + "AP true loop not in SMT-Scope: ['k!241'] (5)\n", + "True loops: []\n", + "False loops: []\n", + "File ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/patterns/PatternMatching-Impl___module.__default.Main.data\n", + "AP false loop not in SMT-Scope: ['k!402'] (3)\n", + "True loops: []\n", + "False loops: []\n", + "File ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/patterns/PatternMatching-Impl___module.__default.Main.data\n", + "AP true loop not in SMT-Scope: ['k!151'] (4)\n", + "True loops: []\n", + "False loops: []\n", + "File ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/traits/Traits-Fields-Impl___module.__default.Main.data\n", + "AP false loop not in SMT-Scope: ['k!151'] (3)\n", + "True loops: []\n", + "False loops: []\n", + "File ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/traits/Traits-Fields-Impl___module.__default.Main.data\n", + "AP true loop not in SMT-Scope: ['k!212'] (3)\n", + "True loops: []\n", + "False loops: []\n", + "File ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/VSI-Benchmarks/b7-Impl___module.Stream.Create.data\n", + "AP false loop not in SMT-Scope: ['k!102'] (4)\n", + "True loops: []\n", + "False loops: []\n", + "File ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny0/Fuel.legacy-Impl__TestModule4.__default.test4.data\n", + "AP true loop not in SMT-Scope: ['k!124'] (4)\n", + "True loops: []\n", + "False loops: []\n", + "File ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny0/Basics-Impl___module.__default.TestCalls.data\n", + "AP false loop not in SMT-Scope: ['k!171'] (3)\n", + "True loops: []\n", + "False loops: []\n", + "File ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny0/QuantificationNewSyntax-Impl__NewSyntax.__default.M.data\n", + "AP true loop not in SMT-Scope: ['k!97'] (3)\n", + "True loops: []\n", + "False loops: []\n", + "File ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny0/DiamondImports-Impl__ImportOpened_mD.__default.Client.data\n", + "AP false loop not in SMT-Scope: ['k!439'] (3)\n", + "True loops: []\n", + "False loops: []\n", + "File ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny0/SharedDestructorsCompile-Impl___module.__default.Main.data\n", + "AP true loop not in SMT-Scope: ['k!89'] (3)\n", + "True loops: []\n", + "False loops: []\n", + "File ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny0/Fuel.legacy-Impl__TestModule4.__default.test3.data\n", + "AP true loop not in SMT-Scope: ['k!143'] (3)\n", + "True loops: []\n", + "False loops: []\n", + "File ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny0/NameclashesCompile-Impl___module.__default.Main.data\n", + "AP false loop not in SMT-Scope: ['k!86'] (3)\n", + "True loops: []\n", + "False loops: []\n", + "File ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny0/Newtypes-CheckWellFormed__Constraints.Tb.data\n", + "AP false loop not in SMT-Scope: ['k!230'] (4)\n", + "True loops: []\n", + "False loops: []\n", + "File ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny0/TypeParameters-Impl__ParseGenerics.__default.TestA.data\n", + "AP true loop not in SMT-Scope: ['k!272'] (4)\n", + "True loops: []\n", + "False loops: []\n", + "File ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/comp/Calls-Impl__FunctionValues.__default.Test.data\n", + "AP true loop not in SMT-Scope: ['k!174'] (3)\n", + "True loops: []\n", + "False loops: []\n", + "File ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/comp/DefaultParameters-Compile-Impl___module.__default.Main.data\n", + "AP true loop not in SMT-Scope: ['k!120'] (3)\n", + "True loops: []\n", + "False loops: []\n", + "File ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/exceptions/Exceptions1-Impl___module.__default.TestControlFlowCase__-n1.data\n", + "AP true loop not in SMT-Scope: ['k!119'] (3)\n", + "True loops: []\n", + "False loops: []\n", + "File ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/exports/LIFO-Impl__MainImpl.__default.Main.data\n", + "AP false loop not in SMT-Scope: ['k!119'] (3)\n", + "True loops: []\n", + "False loops: []\n", + "File ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/exports/LIFO-Impl__MainImpl.__default.Main.data\n", + "AP true loop not in SMT-Scope: ['k!135'] (3)\n", + "True loops: []\n", + "False loops: []\n", + "File ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/exports/ExportVerify-Impl__Client__Revealing.__default.M.data\n", + "AP true loop not in SMT-Scope: ['k!132'] (3)\n", + "True loops: []\n", + "False loops: []\n", + "File ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/exports/ExportVerify-Impl__Client__Revealing.__default.M.data\n", + "AP true loop not in SMT-Scope: ['k!614'] (3)\n", + "True loops: []\n", + "False loops: []\n", + "File ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/concurrency/11-MutexGuard2.legacy-Impl___module.__default.SetData_sp-n38.data\n", + "AP true loop not in SMT-Scope: ['k!176'] (3)\n", + "True loops: []\n", + "False loops: []\n", + "File ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/git-issues/git-issue-2013-Impl___module.__default.TestTraits.data\n", + "AP false loop not in SMT-Scope: ['k!101'] (3)\n", + "True loops: []\n", + "False loops: []\n", + "File ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/git-issues/git-issue-1029-CheckWellformed__ValueType.__default.Gimmi-n0.data\n", + "AP true loop not in SMT-Scope: ['k!180'] (3)\n", + "True loops: []\n", + "False loops: []\n", + "File ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny2/COST-verif-comp-2011-2-MaxTree-datatype-Impl___module.__defau-n2.data\n", + "AP false loop not in SMT-Scope: ['k!114'] (99)\n", + "True loops: []\n", + "False loops: []\n", + "File ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/wishlist/sequences-literals-Impl___module.__default.LargeList2.data\n", + "AP true loop not in SMT-Scope: ['k!136'] (3)\n", + "True loops: []\n", + "False loops: []\n", + "File ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny4/SoftwareFoundations-Basics-Impl___module.__default.test__mult-n8.data\n", + "AP true loop not in SMT-Scope: ['k!144'] (3)\n", + "True loops: []\n", + "False loops: []\n", + "File ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny4/CoqArt-InsertionSort-Impl___module.__default.example__sort__2-n1.data\n", + "AP false loop not in SMT-Scope: ['k!135'] (3)\n", + "True loops: []\n", + "False loops: []\n", + "File ./data_other/github/v6/dafny/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny3/Zip-Impl___module.__default.Bswitch2Lemma_h.data\n", + "Processing smt-comp\n", + "AP true loop not in SMT-Scope: ['k!24'] (3)\n", + "True loops: []\n", + "False loops: [['k!24']]\n", + "File ./data_other/github/v6/smt-comp/non-incremental/UFNIRA/20240414-funcprobs/prove/problem_U67.data\n", + "AP true loop not in SMT-Scope: ['k!21'] (3)\n", + "True loops: []\n", + "False loops: []\n", + "File ./data_other/github/v6/smt-comp/non-incremental/UFNIRA/20240414-funcprobs/prove/problem_U31.data\n", + "AP true loop not in SMT-Scope: ['k!31'] (3)\n", + "True loops: []\n", + "False loops: []\n", + "File ./data_other/github/v6/smt-comp/non-incremental/UFNIRA/20240414-funcprobs/check/problem_U29_sol1.data\n", + "Total & 29449 & 1/19/11 & 0/11/4 & 0 \\\\\n" + ] + } + ], + "source": [ + "def check_contained(quant_seq, loops):\n", + " return set(quant_seq) in loops\n", + "\n", + "total = 0\n", + "\n", + "true_matching_loops = 0\n", + "missing_true_matching_loops = 0\n", + "bad_true_matching_loops = 0\n", + "\n", + "false_matching_loops = 0\n", + "missing_false_matching_loops = 0\n", + "bad_false_matching_loops = 0\n", + "branching_count = 0\n", + "for dir in benchmarks:\n", + " dir_data = all_data[dir]\n", + " print(f\"Processing {dir}\")\n", + " unique_true_loops = []\n", + " unique_false_loops = []\n", + " unique_true_loops_ap = []\n", + " unique_false_loops_ap = []\n", + " for file, data in dir_data.items():\n", + " true_loops = []\n", + " false_loops = []\n", + " if \"loops\" in data[\"smt-scope\"]:\n", + " loops = data[\"smt-scope\"][\"loops\"]\n", + " for reps,loop_data in loops[\"true\"]:\n", + " loop = [x.split(\"[\") for x in loop_data]\n", + " assert all([len(x) == 2 for x in loop])\n", + " loop = [x[0] for x in loop]\n", + " if not check_contained(loop, unique_true_loops):\n", + " unique_true_loops.append(set(loop))\n", + " true_loops.append([x.split(\"{\")[0] for x in loop])\n", + " for reps,loop_data in loops[\"false\"]:\n", + " loop = [x.split(\"[\") for x in loop_data]\n", + " assert all([len(x) == 2 for x in loop])\n", + " loop = [x[0] for x in loop]\n", + " if not check_contained(loop, unique_false_loops):\n", + " unique_false_loops.append(set(loop))\n", + " false_loops.append([x.split(\"{\")[0] for x in loop])\n", + "\n", + " if \"loops\" in data[\"axiom-profiler\"]:\n", + " loops = data[\"axiom-profiler\"][\"loops\"]\n", + " for reps,loop in loops[\"true\"]:\n", + " loop = [x.split(\"[\") for x in loop]\n", + " assert all([len(x) == 2 for x in loop])\n", + " loop = [x[0] for x in loop]\n", + " if not check_contained(loop, unique_true_loops_ap):\n", + " assert len(loop) == 1\n", + " if not any([loop[0] in x for x in true_loops]):\n", + " print(f\"AP true loop not in SMT-Scope: {loop} ({reps})\")\n", + " print(f\"True loops: {true_loops}\")\n", + " print(f\"False loops: {false_loops}\")\n", + " print(f\"File {file}\")\n", + " # The `verus` and `carbon` loops are wrong\n", + " if reps <= 3 and not \"verus/\" in file and not \"carbon/\" in file and not \"/testsresourcesexamplesEtherStore.vy-01.data\" in file:\n", + " missing_true_matching_loops += 1\n", + " else:\n", + " bad_true_matching_loops += 1\n", + " assert reps <= 3 or \"dafny/\" in file\n", + " else:\n", + " true_matching_loops += 1\n", + " unique_true_loops_ap.append(set(loop))\n", + " for reps,loop in loops[\"false\"]:\n", + " loop = [x.split(\"[\") for x in loop]\n", + " assert all([len(x) == 2 for x in loop])\n", + " loop = [x[0] for x in loop]\n", + " if not check_contained(loop, unique_false_loops_ap):\n", + " assert len(loop) == 1\n", + " if not any([loop[0] in x for x in false_loops]):\n", + " print(f\"AP false loop not in SMT-Scope: {loop} ({reps})\")\n", + " print(f\"True loops: {true_loops}\")\n", + " print(f\"False loops: {false_loops}\")\n", + " print(f\"File {file}\")\n", + " if reps <= 3:\n", + " missing_false_matching_loops += 1\n", + " else:\n", + " bad_false_matching_loops += 1\n", + " assert reps <= 3 or \"dafny\" in file\n", + " else:\n", + " false_matching_loops += 1\n", + " unique_false_loops_ap.append(set(loop))\n", + "\n", + " # print(f\"{dir} items: {len(dir_data.items())}, true loops: {len(unique_true_loops)}, false loops: {len(unique_false_loops)}, branching: {len(unique_branching)}\")\n", + " total += len(dir_data)\n", + " # branching_count += len(unique_branching)\n", + " # print(f\"{dir.capitalize()} & {len(dir_data)} & {len(unique_true_loops)} & {len(unique_false_loops)} & {len(unique_branching)} \\\\\\\\\")\n", + " # for file, loop in zip(true_loops_files, unique_true_loops):\n", + " # print(f\"{file} {loop}\")\n", + "print(f\"Total & {total} & {true_matching_loops}/{missing_true_matching_loops}/{bad_true_matching_loops} & {false_matching_loops}/{missing_false_matching_loops}/{bad_false_matching_loops} & {branching_count} \\\\\\\\\")\n", + "# print(100*branching_count/total)" ] } ], @@ -193,6 +942,18 @@ "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.1" } }, "nbformat": 4, diff --git a/eval/eval.sh b/eval/eval.sh index 22edbb3f..3e279aa2 100755 --- a/eval/eval.sh +++ b/eval/eval.sh @@ -24,7 +24,9 @@ while read -r file; do # [ "$FILE" == "silicon/silver/src/test/resources/quantifiedpermissions/misc/functions-01.smt2" ] || continue cd "$DIRNAME/data" - "$SMT2_DIR/z3.sh" "$file" + exec 3>&1 4>&2 + Z3_TIME=$(TIMEFORMAT="%R"; { time "$SMT2_DIR/z3.sh" "$file" 1>&3 2>&4; } 2>&1) + exec 3>&- 4>&- OUTPUT_DIR="$(dirname "$OUTPUT")" LOGFILE="$(find "$OUTPUT_DIR" -name "$(basename "$OUTPUT")-fHash-*.log" -maxdepth 1 -type f)" @@ -32,7 +34,7 @@ while read -r file; do [ ! -s "$LOGFILE" ] && echo "!!! Log file is empty for \"$FILE\"" && continue || true cd "$OUTPUT_DIR" - echo "[LOGFILE] $(basename "$LOGFILE") $(ls -l "$LOGFILE" | awk '{print $5}')b" > "$OUTPUT.data" + echo "[LOGFILE] $(basename "$LOGFILE") $(ls -l "$LOGFILE" | awk '{print $5}')b ${Z3_TIME}s" > "$OUTPUT.data" "$DIRNAME/run.sh" "$LOGFILE" >> "$OUTPUT.data" rm -f "$LOGFILE" diff --git a/eval/smt-logs b/eval/smt-logs index 012583b8..0631fb6b 160000 --- a/eval/smt-logs +++ b/eval/smt-logs @@ -1 +1 @@ -Subproject commit 012583b82d06d4004ccbf86f98e35aafaf68968e +Subproject commit 0631fb6bb97bf101bc2f4ba1976bef18c38699a2 diff --git a/smt-log-parser/src/analysis/graph/analysis/matching_loop/mod.rs b/smt-log-parser/src/analysis/graph/analysis/matching_loop/mod.rs index e674ab34..0f80f574 100644 --- a/smt-log-parser/src/analysis/graph/analysis/matching_loop/mod.rs +++ b/smt-log-parser/src/analysis/graph/analysis/matching_loop/mod.rs @@ -13,7 +13,7 @@ use mem_dbg::{MemDbg, MemSize}; use crate::{idx, items::InstIdx, BoxSlice, FxHashMap, Graph, TiVec}; -pub const MIN_MATCHING_LOOP_LENGTH: u32 = 6; +pub const MIN_MATCHING_LOOP_LENGTH: u32 = 5; idx!(MlSigIdx, "∞{}"); diff --git a/smt-log-parser/src/bin/smt-scope/cmd/eval.rs b/smt-log-parser/src/bin/smt-scope/cmd/eval.rs index 842b142c..b1950d5f 100644 --- a/smt-log-parser/src/bin/smt-scope/cmd/eval.rs +++ b/smt-log-parser/src/bin/smt-scope/cmd/eval.rs @@ -73,6 +73,13 @@ pub fn run(logfile: PathBuf, dummy: bool) -> Result<(), String> { } } println!("{}", to_print.join(" -> ")); + if ml.leaves.0.len() > 1 { + print!("[ExtraLoop]"); + for (repetitions, _) in ml.leaves.0.iter().skip(1) { + print!(" {repetitions}"); + } + println!(); + } } let rpq = redundancy.per_quant.iter_enumerated(); let pos_im = rpq.filter(|(_, d)| d.input_multiplicativity() > 1.0);