Efficient RL-based Cache Vulnerability Exploration by Penalizing Useless Agent Actions

Kanato Nakanishi; Soramichi Akiyama

REVIEW 4 major objections 4 minor 20 references

Efficient RL-based Cache Vulnerability Exploration by Penalizing Useless Agent Actions

T0 review · 4 major / 4 minor · reviewed 2026-08-07 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read Penalizing RL actions that leave the cache state unchanged accelerates automated cache-timing attack exploration, cutting training time by up to 28%.

desk verdict A simple reward-shaping trick for RL cache-attack exploration that shows a modest average speedup on some configs, but the abstract misreports the main number and the method's own failure case exposes a definitional flaw. read the letter →

arxiv 2506.07200 v1 pith:JS37FG4D submitted 2025-06-08 cs.CR

Kanato Nakanishi , Soramichi Akiyama This is my paper · ORCID

classification cs.CR

keywords reinforcementlearningcache-timingattackside-channelvulnerabilityexplorationcachestatehashingrewardshapingtrainingefficiencysimulatoruselessactions

verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

Automated discovery of cache-timing attack sequences with reinforcement learning is slow because agents waste many actions that do not change the cache. The paper's claim is that such 'useless' actions can be detected during training by hashing the cache state before and after each action, and that giving the agent a small negative reward whenever the hash is unchanged steers it toward more informative exploration. Across 17 simulated cache configurations this penalty reduced training time by up to 28% and by 4.84% in geometric mean across the 16 runs that converged. The result matters because mapping a cache design's vulnerabilities requires many training runs, and a single baseline run reportedly takes over two hours.

What carries the argument

The load-bearing mechanism is the cache-state hash comparison. Before each action the environment hashes the simulated cache's in-memory state; after the action it hashes again, and if the two hashes are identical the action is labeled useless and the agent receives a small negative reward. Actions that run the victim or issue the final guess are exempt. This binary state-preservation test is what turns the qualitative idea of 'no contribution to exploration' into a cheap, automatic reward signal, at the price of relying on a simulator whose cache state can be read without perturbing it.

What would settle it

Run the state-hash penalty on a family of cache configurations in which every attack requires the agent to flush or confirm already-empty lines before the victim runs; if training time does not degrade there, the paper's own explanation for configuration No.10 (non-convergent, 57% slower) would not generalize. The direct repeat of No.10 with the penalty disabled versus enabled is the simplest concrete check.

Watch

Extended reading notes

Core claim

The central discovery is that a substantial fraction of RL exploration actions in cache-timing vulnerability hunting are waste from the environment's perspective: in the baseline, up to 43.08% of actions left the cache state unchanged. The paper proposes to identify these actions on the fly by comparing the hash of the simulated cache's in-memory representation before and after each action, and to assign a small negative reward (e.g., -0.01) whenever the hash matches. This reward-shaping signal causes the learned policy to avoid state-preserving actions, and the authors report that the useless-action ratio fell by up to 10.39 percentage points and training time fell in 11 of 17 configurations. The authors are explicit that the benefit is configuration-dependent: in configuration No.10, actions that preserve the cache state are actually needed to preemptively flush or confirm empty lines, and there the penalty made training 57% slower and non-convergent.

Load-bearing premise

The load-bearing premise is that an action is useless exactly when it leaves the cache state unchanged; if preserving the cache state can still be necessary for a successful attack, the penalty punishes useful behavior and can slow or break training.

Editorial extensions

If this is right

Training time drops in 11 of 17 tested cache structures, with a best-case 28% speedup and a geometric-mean reduction of 4.84% over the 16 configurations that converged.
The useless-action share of baseline RL exploration is large (up to 43.08%), so even a partial reduction can meaningfully shorten repeated attack-survey runs.
Because the penalty value is stored in a config file, the mechanism can be tuned or disabled per cache configuration without altering the RL algorithm.
The state-hash approach is limited to simulated caches for now; transferring it to real hardware requires a way to observe cache state that does not itself disturb that state.
Multiple training runs are needed because the agent discovers one attack sequence per run, so faster per-run training makes broader vulnerability coverage practical.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

The equality 'leaves cache state unchanged' equals 'useless' is a proxy that can fail when the agent must set preconditions, such as confirming that victim-mapped lines are already empty; a more faithful criterion might reward information gain about the secret address rather than state change.
The fixed -0.01 penalty could be replaced by a penalty scaled with the degree of state change or annealed over training, which might rescue configurations where the trick backfired by increasing the useless-action ratio.
The same hash-and-penalize pattern transfers to any simulator-based RL exploration where the environment state is fully readable, not only cache-timing attacks.

Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Desk Editor's Note

read the letter

Quick take: this is a small, honest reward-shaping paper that would be fine as a workshop paper, but it needs a careful revision and a corrected abstract before you'd trust the numbers. The interesting bit is that penalizing cache-state-preserving actions in RL-based cache attack exploration only helps on some configurations and can actively break training on others, and the paper's own data shows why.

What's new is the state-hash penalty; AutoCAT and MACTA only use length penalties. The method is cheap, generic, and simple to implement on top of AutoCAT. The evaluation spans 17 cache configurations with 10 runs each, and the authors report both useless-action ratio and wall-clock training time. They are unusually candid about the failure case (No.10) and about configurations where the useless-action ratio goes up. That transparency earns credit.

The soft spots are real. The abstract says the method reduces useless actions by up to 43.08%, which is wrong: 43.08% is the baseline ratio in config No.15; the actual maximum reduction is 10.39 percentage points. That needs to be fixed. More substantially, the definition of 'useless' as 'does not change cache state' is not equivalent to 'does not contribute to exploration.' The No.10 discussion makes this explicit: flushing an already-empty line is state-preserving but can be essential when the victim address spans a range and the attacker must confirm the cache is clean. Those confirmation flushes are exactly what the penalty suppresses, which explains the 57% slowdown and non-convergence. The paper interprets this as an artifact, but it exposes a fundamental mismatch: the proxy (state change) fails exactly where attack-relevant actions are being suppressed. And since the evaluation reports only averages over 10 runs, with no variance or significance tests, the 4.84% geomean speedup is not clearly distinguishable from noise. There's also no sweep of the penalty magnitude; only -0.01 is used.

Who this is for: people working on RL-based hardware security or automated attack exploration. It will be useful as a cautionary example of reward-shaping pitfalls more than as a new method. As a stand-alone paper, the central claim is not established beyond a few favorable configs. But the idea is simple and the analysis is honest, so with a corrected abstract, variance reporting, and a discussion of when state-preserving actions matter, it could become a decent workshop paper. I'd send it to peer review if the venue expects work of this scope, but I'd advise the authors to address the No.10 issue head-on.

Referee Report

4 major / 4 minor

Summary. The paper targets inefficiency in AutoCAT, an RL-based cache-timing vulnerability exploration framework. It defines an action as 'useless' when it does not change the simulated cache state, and extends the environment to assign a small negative reward to such actions. Experiments on 17 cache configurations compare the useless-action ratio and total training time against vanilla AutoCAT; the paper reports that the penalization reduces useless actions by up to 43.08%, yields a best-case 28% training-time reduction, and a 4.84% geometric-mean reduction across 16 configurations. The method is evaluated only on a simulator, and the authors explicitly note that real-hardware state capture is future work.

Significance. The proposed intervention is simple and cheap: it requires only a state-hash comparison in the simulator and a configurable reward term. If the state-preservation criterion were reliably aligned with exploration value, the method would be a useful drop-in addition to simulator-based RL cache exploration. The paper has praiseworthy features: it builds on the public AutoCAT implementation and an open-source cache simulator, uses a non-trivial 17-configuration test suite, reports wall-clock training time as an external metric, and explicitly discusses configurations where the penalty fails (No.10 and No.15). These features make the negative results informative. However, the current evidence does not establish the claimed general efficiency improvement: the paper's own analysis of No.10 shows that the core identification rule mislabels essential actions, and the headline 'up to 43.08%' reduction is not supported by the tabulated numbers.

major comments (4)

[IV-B, IV-C, V-C] Section IV-B defines an action as useless iff it does not change the cache state, and Section IV-C penalizes exactly those actions. Section V-C's discussion of configuration No.10 concedes that when the secret address spans 0–7, the attacker must ensure or confirm that all relevant cache lines are empty before allowing the victim to run, and that such confirming flushes do not change the cache state and are therefore classified as useless. This is a direct counterexample to the sufficiency of the identification rule: state-preserving is not equivalent to non-contributing. Because the penalty suppresses exactly the actions that the No.10 setup requires, the observed 57% slowdown and non-convergence are consistent with a harmful reward signal rather than an anomaly. Conversely, a state-changing action such as reloading a line that is immediately evicted may still be redundant, so the rule is also not necessary. The general claim that the method 'improves exploration efficiency' therefore needs either a refined useless-action definition that accounts for confirmation/precondition flushes, or a more limited claim about configurations in which the state-hash proxy is known to align with attack relevance.
[Abstract, Table II, VI] The abstract's statement that the method 'reduces the number of useless actions by up to 43.08%' is not supported by Table II. The 43.08% figure is the baseline useless-action ratio in configuration No.15; the largest absolute reduction in that table is 10.39 percentage points, also for No.15. Moreover, 'ratio' and 'number' are conflated: in No.15 the proposal increases total actions from about 6.1 million to 10.9 million, so the estimated number of useless actions rises from about 2.64 million to 3.57 million even though the ratio falls. Section VI correctly describes the ratio numbers, and the abstract and Section I should be corrected to distinguish the baseline ratio, the point reduction, and the count reduction.
[V-A, V-C] The evaluation in Section V-A reports averages over 10 runs but gives no variance, confidence intervals, or significance tests, so it is impossible to determine whether the 4.84% geomean and the per-configuration speedups are distinguishable from run-to-run noise. In addition, the geomean in Section V-C is described as covering 'the 16 convergent configurations (No. 1 to No. 16)', yet Table II lists configuration No.10 as non-convergent under the proposal, and the row for No.17 is omitted because 'the training was non-convergent'. The exact set of runs included in the geomean and the treatment of non-convergent runs must be stated precisely; if non-convergent runs are excluded from the average, the headline 4.84% is conditional on a selected subset and should be presented as such.
[V-D] Section V-D's analysis weakens rather than strengthens the causal story. The paper finds no strong correlation between useless-action ratio reduction and training time, and uses configuration No.15 as an explicit counterexample: a 10.39-point ratio improvement is accompanied by a roughly 9% slowdown due to a much larger total action count. Since the reward penalty can affect total sequence length, episode structure, and the overall policy, the observed training-time changes may be driven by global policy shifts rather than by the intended selective suppression of useless actions. The paper should either provide evidence that the penalty's effect is attributable to reducing useless actions (for example, per-action time or episode-length comparisons) or weaken the causal claim accordingly.

minor comments (4)

[V-B, Table II] The text in Section V-B states that configuration No.2 changes from 33.17% to 26.35% and No.6 from 34.49% to 24.85%, but Table II lists 33.13 to 26.32 and 34.43 to 24.83; the text and table should be reconciled.
[Figure 1, V-C] The lower chart in Figure 1 includes configurations No.10 and No.17, but Table II does not report a useless-action ratio for No.17 and reports No.10 as non-convergent; the caption or text should explain what the No.17 bars represent and how non-convergent runs are plotted.
[IV-C, IV-D] Section IV-C states that actions allowing the victim to run and guess actions are exempt from the penalty, but Section IV-D describes comparing hash values for every action without restating this exemption; the implementation description should clarify which actions are excluded from the hash comparison.
[VI] The conclusion contains a typo: 'revealed that that up to 43.08%' should be 'revealed that up to 43.08%'.

Circularity Check

1 steps flagged · score 3.0 of 10

Secondary 'useless-action reduction' metric is the reward objective by definition; central training-time claim is independently wall-clock measured.

self definitional [Section II-D, IV-B, IV-C, and Section V-B (Table II)]
"We define an action as useless when it does not contribute to further exploration of the RL agent. In our context, this corresponds to actions that do not alter the cache states after its execution. ... Specifically, we assign an immediate negative reward whenever the agent executes a useless action. ... Table II shows the ratio of useless actions for the baseline and for our proposed method."

The reported 'reduction of useless action ratio' is the direct optimization target, not an independent consequence. 'Useless' is operationalized as 'cache-state hash unchanged' (IV-B), and the method's only intervention is a negative reward when that hash is unchanged (IV-C). Section V-B then evaluates the method by measuring that same ratio; a decrease is the reward-shaping objective itself. The paper's own Table II shows the ratio rises in 6 of the 16 convergent cases, confirming that the metric is a reward target that can fail, not a derived law. Therefore the 'reduces useless actions' headline is partly circular and definitional; the wall-clock training-time comparison (Fig. 1) remains an independent external metric and carries the paper's central claim.

full rationale

The paper's central efficiency claim is the reduction of total training time, measured by wall-clock time against the vanilla AutoCAT baseline across 17 cache configurations. That metric is independent of the proposed reward-shaping mechanism, so the main result is not circular. The circularity is confined to the secondary claim that the method 'reduces the number of useless actions': an action is defined as useless exactly when it does not change the cache-state hash, and the method assigns a negative reward exactly when that hash is unchanged, so the measured useless-action ratio is the same quantity the reward penalizes. The paper itself concedes the definitional proxy can misclassify essential actions: in Section V-C, configuration No.10 requires the attacker to confirm that all cache lines are empty before the victim runs, yet those confirmation flushes are classified as useless because they do not change the cache state; this is a correctness limitation, not circularity, but it reinforces that the useless-action metric is an internal proxy. The abstract's statement that the mechanism 'reduces the number of useless actions by up to 43.08%' is also a reporting error: 43.08% is the baseline useless-action ratio for configuration No.15, while the largest reduction shown in Table II is 10.39 percentage points; this inflates the headline but is not itself a circular step. No self-citations are load-bearing, and no fitted parameters are renamed as predictions. Overall, the derivation of the training-time speedup is self-contained and externally benchmarked, so the circularity score is modest.

Assumptions & free parameters 1 free parameters · 2 assumptions · 0 invented entities

The central efficiency claim rests on one hand-chosen reward hyperparameter and on the assumption that state change equals exploration value. The paper also assumes the simulator captures the behavior studied. The penalty value is a free parameter; the state-change assumption is load-bearing and partially contradicted by the paper's own No.10 results.

free parameters (1)

useless_action_penalty = -0.01
Manually chosen negative reward in a config file; the paper never sweeps its value, and the reward magnitude directly determines the trade-off between exploration and avoidance.

assumptions (2)

domain assumption An action that leaves the cache state unchanged contributes nothing to exploration.
Section IV-B defines useless this way; Section V-C (No.10) shows cases where preserving flushes are necessary, so the assumption can fail.
domain assumption The CacheSimulator's state and timing accurately represent the cache behavior relevant to attacks.
Section V-A uses an open-source simulator; real-hardware support is explicitly left to future work in Section IV-B.

how reviews work

0 comments

Cite this review

Pith. "Pith review of Efficient RL-based Cache Vulnerability Exploration by Penalizing Useless Agent Actions." pith.science (2026). https://pith.science/paper/JS37FG4D

@misc{pith2026250607200,
  author       = {Pith},
  title        = {Pith review of: Efficient RL-based Cache Vulnerability Exploration by Penalizing Useless Agent Actions},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/JS37FG4D}},
  note         = {Machine review of arXiv:2506.07200}
}

read the original abstract

Cache-timing attacks exploit microarchitectural characteristics to leak sensitive data, posing a severe threat to modern systems. Despite its severity, analyzing the vulnerability of a given cache structure against cache-timing attacks is challenging. To this end, a method based on Reinforcement Learning (RL) has been proposed to automatically explore vulnerabilities for a given cache structure. However, a naive RL-based approach suffers from inefficiencies due to the agent performing actions that do not contribute to the exploration. In this paper, we propose a method to identify these useless actions during training and penalize them so that the agent avoids them and the exploration efficiency is improved. Experiments on 17 cache structures show that our training mechanism reduces the number of useless actions by up to 43.08%. This resulted in the reduction of training time by 28\% in the base case and 4.84\% in the geomean compared to a naive RL-based approach.

Figures

Figures reproduced from arXiv: 2506.07200 by the authors.

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

20 extracted references · 20 canonical work pages

[1]

Cachesimulator: An open-source python cache simulator,

“Cachesimulator: An open-source python cache simulator,” https:// github.com/auxiliary/CacheSimulator, 2017

work page 2017
[2]

Reverse engineering of cache replacement policies in intel microprocessors and their evaluation,

A. Abel and J. Reineke, “Reverse engineering of cache replacement policies in intel microprocessors and their evaluation,” inInternational Symposium on Performance Analysis of Systems and Software (ISPASS), 2014, pp. 141–142

work page 2014
[3]

Validation of side- channel models via observation refinement,

P. Buiras, H. Nemati, A. Lindner, and R. Guanciale, “Validation of side- channel models via observation refinement,” inInternational Symposium on Microarchitecture (Micro), 2021, pp. 578–591

work page 2021
[4]

Afterimage: Leaking control flow data and tracking load operations via the hardware prefetcher,

Y . Chen, L. Pei, and T. E. Carlson, “Afterimage: Leaking control flow data and tracking load operations via the hardware prefetcher,” inInternational Conference on Architectural Support for Programming Languages and Operating Systems (ASPLOS), 2023, pp. 16 – 32

work page 2023
[5]

MACTA: A multi-agent reinforcement learning approach for cache timing attacks and detection,

J. Cui, X. Yang, M. Luo, G. Lee, P. Stone, H. S. Lee, B. Lee, G. E. Suh, W. Xiong, and Y . Tian, “MACTA: A multi-agent reinforcement learning approach for cache timing attacks and detection,” inInternational Conference on Learning Representations (ICLR), 2023, pp. 1–22

work page 2023
[6]

A benchmark suite for evaluating caches’ vulnerability to timing attacks,

S. Deng, W. Xiong, , and J. Szefer, “A benchmark suite for evaluating caches’ vulnerability to timing attacks,” inInternational Conference on Architectural Support for Programming Languages and Operating Systems (ASPLOS), 2020, p. 683–697

work page 2020
[7]

AutoCAT,

Facebook Research, “AutoCAT,” https://github.com/facebookresearch/ AutoCAT, 2023

work page 2023
[8]

2020 wilson research group functional verification study: Ic/asic functional verification trend report,

H. Foster, “2020 wilson research group functional verification study: Ic/asic functional verification trend report,” Siemens Digital Industries Software, White Paper, 2020. [Online]. Available: https://static.sw.cdn.siemens.com/siemens-disw- assets/public/1XOkQw0JbYBVvf35KEd5xP/en-US/ic-asic-trend- report 2020-wilson-research-verification-study hfoster.pdf

work page 2020

Show all 20 references

[9]

How secure is your cache against side-channel attacks?

Z. He and R. B. Lee, “How secure is your cache against side-channel attacks?” inInternational Symposium on Microarchitecture (Micro), 2017, pp. 341–353

2017
[10]

High performance cache replacement using re-reference interval prediction (rrip),

A. Jaleel, K. B. Theobald, S. C. Steely, and J. Emer, “High performance cache replacement using re-reference interval prediction (rrip),” in International Symposium on Computer Architecture (ISCA), 2010, pp. 60 – 71

2010
[11]

AR- Mageddon: Cache attacks on mobile devices,

M. Lipp, D. Gruss, R. Spreitzer, C. Maurice, and S. Mangard, “AR- Mageddon: Cache attacks on mobile devices,” inUSENIX Security Symposium, 2016, pp. 549–564

2016
[12]

Last-level cache side-channel attacks are practical,

F. Liu, Y . Yarom, Q. Ge, G. Heiser, and R. B. Lee, “Last-level cache side-channel attacks are practical,” inIEEE Symposium on Security and Privacy (SP), 2015, pp. 605–622

2015
[13]

AutoCAT: Reinforcement learning for automated exploration of cache-timing attacks,

M. Luo, W. Xiong, G. Lee, Y . Li, X. Yang, A. Zhang, Y . Tian, H.-H. S. Lee, and G. E. Suh, “AutoCAT: Reinforcement learning for automated exploration of cache-timing attacks,” inInternational Symposium on High-Performance Computer Architecture (HPCA), 2023, pp. 317–332

2023
[14]

Cache attacks and countermea- sures: the case of AES,

D. A. Osvik, A. Shamir, and E. Tromer, “Cache attacks and countermea- sures: the case of AES,” inInternational Workshop on Cryptographic Hardware and Embedded Systems, 2006, pp. 1–20

2006
[15]

Functional test generation for the plru replacement mechanism of embedded cache memories,

W. J. H. Perez, E. Sanchez, M. S. Reorda, A. Tonda, and J. V . Medina, “Functional test generation for the plru replacement mechanism of embedded cache memories,” in12th Latin American Test Workshop (LATW), 2011, pp. 1–6

2011
[16]

Checkmate: Automated synthesis of hardware exploits and security litmus tests,

C. Trippel, D. Lustig, and M. Martonosi, “Checkmate: Automated synthesis of hardware exploits and security litmus tests,” inInternational Symposium on Microarchitecture (Micro), 2018, p. 947–960

2018
[17]

Cachequery: Learning replacement policies from hardware caches,

P. Vila, P. Ganty, M. Guarnieri, and B. Kopft, “Cachequery: Learning replacement policies from hardware caches,” inConference on Program- ming Language Design and Implementation (PLDI), 2020, pp. 519–532

2020
[18]

PAPP: Prefetcher-aware prime and probe side-channel attack,

D. Wang, Z. Qian, N. Abu-Ghazaleh, and S. V . Krishnamurthy, “PAPP: Prefetcher-aware prime and probe side-channel attack,” inAnnual De- sign Automation Conference (DAC), 2019, pp. 1–6

2019
[19]

Speechminer: A framework for investigating and measuring speculative execution vulnerabilities,

Y . Xiao, Y . Zhang, and R. Teodorescu, “Speechminer: A framework for investigating and measuring speculative execution vulnerabilities,” inNetwork and Distributed Systems Security Symposium (NDSS), 2020, pp. 1 – 17

2020
[20]

Flush+reload: A high resolution, low noise, l3 cache side-channel attack,

Y . Yarom and K. Falkner, “Flush+reload: A high resolution, low noise, l3 cache side-channel attack,” inUSENIX Security Symposium, 2014, p. 719–732. 5

2014

Pith tools

Reviewed August 7, 2026 · model on record in the stance chip above.

[1] [1]

Cachesimulator: An open-source python cache simulator,

“Cachesimulator: An open-source python cache simulator,” https:// github.com/auxiliary/CacheSimulator, 2017

work page 2017

[2] [2]

Reverse engineering of cache replacement policies in intel microprocessors and their evaluation,

A. Abel and J. Reineke, “Reverse engineering of cache replacement policies in intel microprocessors and their evaluation,” inInternational Symposium on Performance Analysis of Systems and Software (ISPASS), 2014, pp. 141–142

work page 2014

[3] [3]

Validation of side- channel models via observation refinement,

P. Buiras, H. Nemati, A. Lindner, and R. Guanciale, “Validation of side- channel models via observation refinement,” inInternational Symposium on Microarchitecture (Micro), 2021, pp. 578–591

work page 2021

[4] [4]

Afterimage: Leaking control flow data and tracking load operations via the hardware prefetcher,

Y . Chen, L. Pei, and T. E. Carlson, “Afterimage: Leaking control flow data and tracking load operations via the hardware prefetcher,” inInternational Conference on Architectural Support for Programming Languages and Operating Systems (ASPLOS), 2023, pp. 16 – 32

work page 2023

[5] [5]

MACTA: A multi-agent reinforcement learning approach for cache timing attacks and detection,

J. Cui, X. Yang, M. Luo, G. Lee, P. Stone, H. S. Lee, B. Lee, G. E. Suh, W. Xiong, and Y . Tian, “MACTA: A multi-agent reinforcement learning approach for cache timing attacks and detection,” inInternational Conference on Learning Representations (ICLR), 2023, pp. 1–22

work page 2023

[6] [6]

A benchmark suite for evaluating caches’ vulnerability to timing attacks,

S. Deng, W. Xiong, , and J. Szefer, “A benchmark suite for evaluating caches’ vulnerability to timing attacks,” inInternational Conference on Architectural Support for Programming Languages and Operating Systems (ASPLOS), 2020, p. 683–697

work page 2020

[7] [7]

AutoCAT,

Facebook Research, “AutoCAT,” https://github.com/facebookresearch/ AutoCAT, 2023

work page 2023

[8] [8]

2020 wilson research group functional verification study: Ic/asic functional verification trend report,

H. Foster, “2020 wilson research group functional verification study: Ic/asic functional verification trend report,” Siemens Digital Industries Software, White Paper, 2020. [Online]. Available: https://static.sw.cdn.siemens.com/siemens-disw- assets/public/1XOkQw0JbYBVvf35KEd5xP/en-US/ic-asic-trend- report 2020-wilson-research-verification-study hfoster.pdf

work page 2020