Available online www.jsaer.com

    Journal of Scientific and Engineering Research, 2017, 4(8):427-435
  4 NN

20 RN Research Article ISSN: 2394-2630 NEE)¹ V4] ] CODEN(USA): JSERBR AI based SystemVerilog TB generation

Bhavin Shah

Techvulcan Inc, USA Abstract: As the complexity of Application-Specific Integrated Circuit (ASIC) designs continues to escalate, functional verification has emerged as the most resource-intensive phase, consuming a substantial portion of the overall development effort. Traditional verification approaches, reliant on manually created SystemVerilog testbenches, are increasingly challenged to provide adequate coverage in a reasonable timeframe. This paper explores methodologies for automating verification testbenches using artificial intelligence techniques that predate modern large language models. A key area of investigation is the integration of static code analysis to identify critical verification areas and map dependencies between design inputs and internal state variables. Building on this analysis, the discussion examines how machine learning models can be trained on design specifications to automatically generate targeted test stimuli and verification components. The focus is on how such a data-driven approach can shift verification from a reactive to a more proactive process, potentially allowing for earlier bug detection and faster coverage closure. The overall objective is to examine how these AI- based techniques can reduce the manual effort in testbench creation and enhance the efficiency of the ASIC verification cycle.

Keywords: Artificial Intelligence, SystemVerilog, Testbench Generation, Functional Verification, Universal Verification Methodology (UVM), Machine Learning, Static Analysis, ASIC Design, Coverage Closure

1. Introduction Microprocessor verification is currently one of the major bottlenecks in the development of computing systems, consuming vast amounts of time and engineering effort. Despite the International Technology Roadmap for Semiconductors assessing that it takes thousands of engineer-years to develop top-end systems, processors still frequently reach the market with defects [1]. To address this, the industry relies heavily on simulation-based verification, often utilizing the SystemVerilog language and the Universal Verification Methodology (UVM) [2, 3]. In this context, functional verification is used to compare the behavior of the Device Under Verification (DUV) with a reference model, using coverage metrics to measure progress [3]. However, as chip complexity increases, traditional verification methods based on manually written tests find it difficult to provide the coverage needed to identify bugs. While simulation-based random testing is a long-standing approach, it tends to be myopic for complex microarchitectures where stateful logic blocks require long simulation times to be exercised. Consequently, to achieve good test coverage and expose hard-to-find bugs, engineers are often forced to develop specialized hand-written tests, requiring significant human intervention and resulting in a process that is not portable across different designs [1]. The current standard practice involves generating stimuli using pseudo-random generators (PRGs), applying them to processor inputs, and monitoring achieved coverage to determine verification completeness. A feedback-controlled method based on this analysis is known as Coverage-Driven Verification (CDV) [2]. However, a significant problem with this approach is the redundancy built into randomness; if coverage feedback is not properly propagated to the PRG to alter constraints, the same redundant stimuli can be applied to the DUV without increasing coverage [2]. Even intuitively, if the distribution of generated stimuli does not

a» Journal of Scientific and Engineering Research

    427

Shah B    Journal of Scientific and Engineering Research, 2017, 4(8):427-435

change reasonably in consequent generations, the verification process slows down. Therefore, new methods that target these issues are in great demand to automate routines like stimuli generation and targeting corner cases in coverage. The major drawback of the mainstream approach is the difficulty of producing effective stimuli for specific behaviors the designer wants to test. To enable accurate control over constraint-based random test generation, various tools have been developed, but many still require substantial manual effort to adjust constraints based on coverage results [1]. To overcome these limitations, researchers have explored methods based on artificial intelligence and combinatorial optimization to automate the verification process [2]. For instance, evolutionary computing, specifically the genetic algorithm (GA), has been applied for the automated generation of stimuli based on the source code of specific software applications. In some approaches, a genetic algorithm is utilized to enhance assertion coverage based on a community of random generators having a variety of information. A new method for the automation and optimization of coverage-driven verification based on evolutionary computing has shown that convergence to maximum coverage is much faster, requiring fewer input stimuli and no manual effort from the user [3]. In this context, the genetic algorithm serves as an optimizer running in the background of the functional verification process. By automating CDV, which is usually a manual process, these methods markedly reduce the effort needed for preparing comprehensive verification stimuli [3]. This shift represents a move from reactive, manual constraint adjustments to proactive, algorithmic optimization of the testbench. Beyond evolutionary algorithms, other machine learning models have been integrated into closed-loop verification architectures. For example, a tool called StressTest uses a Markov-model-driven random instruction generator coupled with activity monitors [1]. This engine uses closed-loop feedback techniques to transform the Markov model into one that effectively stresses user-selected points of interest within the design. By monitoring internal signals, the model dynamically adjusts probabilities to generate stimuli that maximize stress on specific nodes. Another technique proposes dynamically altering constraints for a PRG via a recurrent neural network (RNN), which receives coverage feedback from the simulation [2]. Neural networks, such as the Hopfield network, are capable of dealing with combinatorial optimization problems. By integrating an RNN into a closed- loop solution, the system can optimize PRG constraints on-the-fly to achieve coverage closure as fast as possible. Furthermore, these automated approaches can help seek the smallest set of stimuli which reaches coverage closure, which is ideal for regression testing [2]. Finally, the effectiveness of AI-driven generation relies heavily on the quality of the guidance metrics. While standard code coverage is common, it has weaknesses; a code segment might be covered, but its effect might not be observed at a circuit output [4]. To address this, observability-based metrics, such as "tag coverage," have been developed to guide biased random input pattern generation that targets non-covered portions of the circuit. An optimization algorithm can iteratively perturb the probability distributions of primary inputs to improve this estimated coverage [4]. Other novel approaches generate validation stimuli by reasoning only on the software application the processor is intended to execute, neglecting hardware details [5]. In such methods, high-level metrics applied to behavioral descriptions are used to drive the generation of input stimuli aimed at covering design errors. Building upon these diverse methodologies—ranging from feedback-adjusted Markov models to RNNs and genetic algorithms-this paper explores a unified approach for AI-based SystemVerilog testbench generation to further automate and optimize modern functional verification flows.

2. Related Works In order to increase functional coverage and verification efficiency, a substantial amount of research is devoted to using machine learning and artificial intelligence (AI) techniques to automate the creation of SystemVerilog testbenches. Using evolutionary and genetic algorithms (GAs) to traverse the enormous state space of contemporary ASICs is a key area of research. Goloubeva et al., for example, presented a novel method in which a GA creates validation stimuli by abstracting away the underlying hardware details and concentrating on the high-level software application that a processor will run [5]. By adapting the test generation to the processor's intended use, this technique showed remarkable efficacy on an 8051 soft core. A "cell-based" genetic algorithm (CGA), which divides the input domain into smaller subsets, or "cells," was created by Samarah et al. to build on this. The GA then provides a versatile and potent mechanism for coverage-directed test generation by optimizing the distribution of test stimuli among these cells. By iteratively improving

   Journal of Scientific and Engineering Research

    428
   

   Shah B Journal of Scientific and Engineering Research, 2017, 4(8):427-435

stimulus based on coverage feedback, these evolutionary approaches are excellent at finding complex scenarios that purely random or manually guided methods might overlook. Building on these evolutionary strategies, Habibi and Tahar's work in "Design and Verification of SystemC Transaction-Level Models" presents a novel verification technique that enhances functional coverage by fusing formal modeling with AI-driven simulation. In their approach, a system is first designed using UML, and then it is transformed into Abstract State Machines (ASM) using AsmL [6]. This enables the properties specified in PSL to be formally checked. Most significantly, they enhance assertion coverage during SystemC simulation by using a genetic algorithm. Their GA explores the state space to find edge-case behaviors by altering input vectors based on assertion monitor feedback, rather than merely employing random stimuli. This approach adheres to the guidelines for coverage-directed test generation and performs admirably for intricate transaction- level models that require expansion. Their framework, which abstracts hardware details and concentrates on high-level behavior, ensures that verification remains thorough and efficient [6]. Semantic consistency is also ensured by the bidirectional transformation between SystemC and AsmL, which enables the final SystemC implementation to incorporate verified properties as assertion monitors. Modern SoC designs can be robustly checked using this combination of formal methods and evolutionary AI techniques, particularly when traditional simulation is ineffective. Their work serves as a helpful guide for automating SystemVerilog testbenches by fusing intelligent stimulus generation with formal verification. Another well-known field of research closes the feedback loop between test generation and coverage analysis by using probabilistic graphical models, specifically Bayesian networks. A seminal example in this field is the work of Fine and Ziv [7]. The coverage-directed generation problem is framed by statistical inference in their methodology. In order to model the probabilistic relationships between test generator directives and the resulting coverage events, a Bayesian network is trained on data from initial simulation runs during the first learning phase of the process. In the second step, the most likely set of instructions to activate particular, inaccessible, or uncovered functional coverage points is inferred using this trained network. In addition to providing a methodical way to design directives that increase the rate of coverage closure, this approach offers a natural way to represent the intricate and frequently ambiguous dependencies in the verification process. More recently, the dynamic constraint generation problem has been tackled using machine learning models like Recurrent Neural Networks (RNNs) that can handle sequential data. Fajcik et al. presented a method for dynamically changing the constraints of a pseudo-random generator (PRG) by integrating an RNN into the verification loop [2]. In order to guide the testbench towards uncharted regions of the design's state space, the network learns to modify the PRG constraints based on the coverage data from the running simulation. This technique has the added advantage of finding a small but very powerful set of stimuli that can be extracted for more effective regression testing, in addition to speeding up coverage closure. This method signifies a move toward online learning platforms that are more flexible and capable of making wise choices in real time while simulating. Other AI-based methods have focused on various facets of the verification problem in addition to stimulus generation. The StressTest system was created by Wagner et al. and uses feedback-adjusted Markov models to direct a random instruction generator [1]. Through the use of activity monitors positioned at strategic design nodes, the system offers feedback that modifies a Markov model's transition probabilities, stressing particular microarchitecture components and revealing hidden design flaws. The fundamental issue of functional test generation has been addressed at a more formal level by researchers such as Zeng et al. using Constraint Logic Programming (CLP) [8]. In their work, test generation is formulated as a satisfiability (SAT) problem, which is then resolved through the application of CLP techniques. In contrast to conventional SAT solvers, this enables a more potent method of producing valid test vectors and preserves the high-level structure of the problem by handling designs that combine intricate word-level arithmetic with Boolean logic.

3. AI-Based Testbench Generation Framework This section outlines a conceptual framework for the automation of Universal Verification Methodology (UVM) compliant SystemVerilog testbenches. Traditional verification flows, while robust, often depend on substantial manual intervention for defining test plans, authoring stimuli, and analyzing coverage reports to achieve closure. The methodology under consideration here is a learning-based system intended to automate this entire loop. It

   Journal of Scientific and Engineering Research

    429
   

   Shah B Journal of Scientific and Engineering Research, 2017, 4(8):427-435

explores how artificial intelligence could be leveraged to intelligently guide the verification process, from the initial analysis of the design specification to the iterative refinement of the testbench. By postulating an architecture that combines design analysis, an artificial intelligence core, and a UVM code generation engine, we can investigate the potential for significantly reducing the manual effort in the verification timeline and enhancing the quality of pre-silicon validation. A potential framework for AI-driven testbench generation could be architected as a fully automated, closed-loop system, as illustrated in the conceptual block diagram (Fig. 1). In this model, the primary inputs would be the Design Under Verification (DUV)'s Register Transfer Level (RTL) code and its corresponding functional specification document. The intended output is a fully UVM-compliant SystemVerilog testbench, complete with stimulus sequences, a verification environment, and functional coverage models. Such a framework would be composed of three primary engines operating in a continuous cycle: a Design and Specification Analysis Engine to formalize the verification problem, an Artificial Intelligence (AI) Core to generate intelligent test directives, and a UVM Testbench Generation Engine to translate these directives into executable code. This architecture represents a conceptual evolution of the standard verification environment components, replacing the manual guidance of the stimulus generator and coverage plan with an autonomous cognitive agent. The ingestion and thorough analysis of the DUV and its specifications would be a critical step in this framework. To develop a comprehensive, multimodal understanding of the verification task, this engine would need to employ a two-pronged approach. First, a static analysis module must parse the RTL code to extract structural and functional primitives. This process would effectively convert the DUV into a formal graph structure, identifying all inputs, outputs, data paths, state-holding components (registers, memories), and key control logic. Concurrently, a streamlined Natural Language Processing (NLP) model would be required to parse the functional specification to incorporate functional intent into the structural view. This NLP component would be trained to identify keywords and semantic patterns to extract key behavioral requirements, operational scenarios, configuration spaces, timing constraints, and forbidden states. The features extracted from the RTL and specification would be combined into a single unified feature representation—a comprehensive input model that captures both implementation details and high-level design intent for the AI core. This mirrors the concept of reasoning about a higher-level software application to guide stimulus generation, abstracting away from raw hardware details. Figure 1 illustrates the architecture of the closed-loop system. The DUV RTL and its specification are fed into the Analysis Engine, which creates a unified feature set for the AI Core. The AI Core, powered by a GNN and RL agent, processes this data along with live coverage feedback to generate optimized directives. These directives are used by the UVM Generation Engine to produce specific UVM components (sequences, covergroups, scoreboard logic). The generated testbench is run in a simulation environment, and the loop continues until coverage goals are achieved. At the heart of this conceptual framework would be an AI core designed to intelligently navigate the DUV's massive state space. Using the analysis engine's feature representation as its input, the AI develops a policy to generate effective test stimuli and verification logic. A hybrid model that combines a Graph Neural Network (GNN) and a Reinforcement Learning (RL) agent looks promising for this core. The GNN is theoretically well- suited for this task because it can operate directly on the RTL's graph-based representation, learning the intricate dependencies between various design components. The RL agent's role would be to make sequential decisions, such as choosing constraints and stimulus parameters, in order to maximize a reward function defined by the rate of new functional coverage achieved. The core would take in static DUV features as well as live coverage data from the simulation environment. This feedback mechanism, which is central to the concept of coverage- directed generation pioneered by Fine and Ziv, allows the agent to learn which actions result in the discovery of new coverage points. The result would be a set of optimized randomization constraints and biasing parameters designed to direct the testbench toward interesting and previously unexercised corner cases—a principle also explored in constrained random simulation methodologies. This represents a significant evolution from earlier AI-based stimulus generation techniques, which used genetic algorithms to evolve effective test vectors.

Journal of Scientific and Engineering Research

    430

Shah B    Journal of Scientific and Engineering Research, 2017, 4(8):427-435










Analysis + NLP)










— +

Optimized Constraints & Verification Directives

UVM Generation Engine (Template-Based) - Sequences/Stimulus- Functional Covergroups - Scoreboard Logic

UVM Testbench Code    Live Coverage Feedback

    &      Loo





 —

Coverage D8 ucos

    Coverage Closure Check










You






Figure 1: UVM Verification Automation Flow

& Journal of Scientific and Engineering Research

    431

Shah B    Journal of Scientific and Engineering Research, 2017, 4(8):427-435





Start: Input DUV RTL &
    Specification





  Analyze Design & Spec

Extract structural and functional foatures

    Al Core Generates
    Verification Plan

Develops inital policy for tast directives

Auto-Generate Update UVM Testbench Instantiate templates for

sequences, coverage, scoreboard

Collect & Analyze Coverage Data Log resus to Unified Coverage Database

      No (Refine)  Yes
  Alagent           l
  Core Updates Policy
i     earns fom coverage
  feedback 1o target gaps


    Figure 2: Operational Flowchart of the Automated Verification Process

The Testbench Generation Engine's function is to convert the AI core's optimized constraints and abstract directives into synthesizable UVM SystemVerilog code. This engine would operate on a sophisticated template system, managing a library of pre-defined, parameterizable UVM components. This includes templates for the entire environment hierarchy, agents (drivers, monitors), sequences, and verification components like scoreboards and functional covergroups. The AI core's output would directly influence the parameterization and logic generation for these templates. For instance: • Sequences and Stimulus: If the AI identifies an untested combination of instruction opcodes, it may generate weights for a randomize() with {...} constraint block within a UVM sequence. The Generation Engine would then instantiate the appropriate sequence template and insert the AI-generated weights.

& Journal of Scientific and Engineering Research

      432

Shah B    Journal of Scientific and Engineering Research, 2017, 4(8):427-435


• Functional Coverage: The NLP analysis of the specification would directly inform the creation of
    covergroups, coverpoints, and cross coverage bins. The AI can identify critical cross-coverage points
    between different operational modes that a human engineer might overlook.
• Monitors and Scoreboards: Based on extracted behavioral requirements, the AI can generate the
    logic for monitors to sample transactions on interfaces and for scoreboards to predict expected
    outcomes based on the stimulus applied. This automates the creation of self-checking testbenches.

This modular design would effectively translate the high-level strategy from the AI core into a tangible and executable verification environment, allowing for the rapid creation of complex and diverse test scenarios without the need for manual coding. The suggested framework functions as a continuous, closed-loop verification system that minimizes the need for manual intervention, as shown in the operational flowchart (Figure 2). The process starts with the automated creation of a preliminary testbench. This environment is then compiled and executed in a simulation environment, where coverage monitors record structural and functional coverage data into a Unified Coverage Database (UCDB). This data is fed back in real-time to the AI core. Here, the reinforcement learning (RL) agent evaluates this feedback, modifies its internal policy to deprioritize previously covered states, and generates fine- tuned constraints and parameters to target remaining coverage gaps. The process iteratively cycles through generation, simulation, analysis, and refinement until coverage goals are met. Similar to dynamic feedback systems that use recurrent neural networks (RNNs), the framework eliminates a significant manual bottleneck in the coverage closure process by automating the feedback loop between coverage analysis and stimulus generation. This enables the framework to dynamically explore the state space of the design and continuously modify its approach to find corner-case bugs.

4. Analysis of Current Limitations and Future Trajectory Although the suggested framework is a big step in the direction of a completely autonomous verification flow, there are a number of inherent limitations that affect its scalability and practical application, which also determine the direction of future study. The Design and Specification Analysis Engine's dependence on Natural Language Processing (NLP) is one of the most difficult problems. Functional specifications are rarely clear-cut, formal documents; instead, they are usually written informally, with tables, diagrams, and implicit assumptions woven throughout [9]. While these elements are simple for human engineers to understand, they are extremely difficult for machines to understand. The suggested simplified NLP model might not be able to correctly parse semantic nuances, which could result in the creation of inaccurate or partial constraints. For instance, a performance requirement might be expressed in a way that depends on a diagrammatic representation of a system state, or a statement outlining timing might be unclear. When the AI core optimizes for a set of behaviors that do not accurately reflect the true design intent, misinterpretation at this early stage can result in a verification plan that is fundamentally flawed. In order to formalize the design intent before the learning process starts—a long-standing goal in the verification community—future iterations must go beyond basic keyword extraction and use more complex semantic parsing and entity recognition models that can comprehend context, resolve ambiguities, and possibly even interpret multi-modal data from diagrams. The development of specialized assertion languages and methodologies over the past few decades is evidence of the recurring theme in verification automation: the difficulty of converting high-level, frequently informal, specifications into a machine-readable format. The scalability of the Machine Learning Core in the face of the enormous complexity of contemporary System- on-a-Chip (SoC) designs represents a second major challenge. The introduction of AI does not solve the classic problem of state space explosion, which has long been the main obstacle in functional verification; rather, it shifts the burden from manual exploration to algorithmic search. Despite their strength, the suggested Reinforcement Learning (RL) and Graph Neural Network (GNN) agents come with high computational costs. A multi-billion gate design could result in a design graph that is too big for a GNN to process effectively, making the state-action space for an RL agent unmanageably large. The efficiency gains the framework is intended to offer may be negated if training an RL agent to navigate such a space requires an excessive number of simulation cycles. The use of hierarchical learning is a promising approach to lessen this problem. The AI could be trained to create customized policies for distinct sub-modules or IP blocks rather than trying to learn a single

   Journal of Scientific and Engineering Research

    433
   

   Shah B Journal of Scientific and Engineering Research, 2017, 4(8):427-435

monolithic policy for the entire DUV. The coordination of these sub-policies could then be learned by a higher- level meta-agent, simulating the hierarchical verification techniques used by human teams to handle complexity. The framework would be able to scale more successfully to industrial-sized designs with this method, which is comparable to dividing a large design into verifiable units as explained by Wile et al [9]. It may also facilitate transfer learning, in which the information gathered from verifying one unit is reused to speed up the verification of similar units. The type of feedback given to the ML core is crucial to the automated coverage closure loop's effectiveness, which poses a big challenge for the Reinforcement Learning agent when it comes to reward shaping. A sparse reward problem is one with a straightforward reward signal, like a binary value that indicates whether a new coverage point has been hit. The learning process is extremely inefficient in this scenario since the agent only gets positive feedback when it discovers a novel state. The agent does not understand what it means to be "close" to covering a point, and it is unable to distinguish between an action that moved the DUV into a promising area of the state space and one that was entirely ineffective. Therefore, creating denser and more informative reward shaping mechanisms is an important area for future research. This could entail employing feedback from dynamic activity monitors within the design, a method proven successful by Wagner et al. in their work on feedback-adjusted Markov models, or incorporating intermediate rewards based on structural coverage metrics, such as toggle or branch coverage [1]. A more nuanced feedback signal is also suggested by the probabilistic approach of Bayesian networks, which Fine and Ziv introduced [7]. Rather than a binary reward, the agent could be rewarded based on the estimated probability that its actions will result in new coverage, which would provide a much richer signal to direct the learning process. The fourth drawback, which is crucial for industry adoption, is that complex machine learning models are inherently "black box" in nature, making debugging and user trust difficult. Verification engineers must be able to identify the underlying cause of failures caused by stimulus sequences generated by the AI-driven testbench. The engineer must comprehend the particular situation that caused the failure if it is a true DUV bug. However, the engineer must debug the AI's decision-making process if the failure results from the AI producing an illegal or illogical stimulus. This is a challenging task when using deep learning models such as GNNs. Explainable AI (XAI), a rapidly developing field, is the path for overcoming this constraint. To make the behavior of the ML core interpretable, future frameworks must incorporate XAI techniques. This might entail producing a human- readable "rationale" that explains the RL agent's selection of a specific set of constraints or visualizing the GNN's attention mechanisms to demonstrate which aspects of the design it is concentrating on. In addition to increasing confidence in the automated system, this kind of openness would turn the AI from an enigmatic oracle into a cooperative verification partner that could even help engineers better understand their own designs [10]. Finally, the proposed framework in its current form is entirely based on dynamic, simulation-based verification and thus cannot provide the exhaustive proofs afforded by formal methods. Despite being an effective tool for finding bugs, it can never establish the lack of bugs on its own. This restriction implies that the synergistic fusion of formal and dynamic verification methods is the ultimate path towards a fully comprehensive AI-driven verification platform. It would be possible to improve the AI core so that it could function as a master verification strategist, determining when to use a formal engine and when to deploy simulation. For instance, the RL agent could learn to identify small, self-contained modules, such as arbiters or complex state machines, that are amenable to formal property checking. Instead of generating stimulus, the agent's action could be to automatically write and run a formal assertion for that module. Furthermore, the AI could learn from the results of formal tools; a counterexample from a failed proof could be used as a highly valuable seed to guide a new phase of simulation-based testing, focusing the search on scenarios related to the formal failure. Building on ideas from hybrid solvers and constraint-based generation [8], this hybrid, or semi-formal, approach would take advantage of the advantages of both paradigms—the scalability of simulation and the exhaustiveness of formal analysis. It also represents a potent path for future intelligent verification systems.

5. Conclusion In the ASIC design cycle, functional verification is still a crucial bottleneck due to its extreme complexity and dependence on labor-intensive, manual procedures. In order to overcome this difficulty, this paper suggests a

   Journal of Scientific and Engineering Research

    434
   

   Shah B Journal of Scientific and Engineering Research, 2017, 4(8):427-435

   novel framework for the artificial intelligence-based automated generation of SystemVerilog testbenches. Our
            approach combines natural language processing and static RTL analysis to produce a thorough feature
          representation of the DUV. This representation is fed into a hybrid machine learning core that uses a
   

   Reinforcement Learning agent and a Graph Neural Network to intelligently produce optimized test directives. A template-based engines then converts these instructions into UVM-compliant code, resulting in a completely self-sufficient, closed-loop system that continuously receives coverage data to improve the stimulus generation procedure. Our framework promises faster coverage closure and the ability to find intricate corner-case bugs that are difficult to find with conventional techniques by automating this feedback loop, which signifies a paradigm shift from reactive, manual verification to a proactive, learning-based approach. We do, however, recognize the inherent limitations, especially with regard to the computational scalability of the ML core for industrial-scale designs and the ambiguity of natural language specifications. Future research will concentrate on investigating hierarchical learning models and improving the specification analysis engine. The most promising course, however, is the combination of formal verification techniques with this dynamic, simulation- based approach, resulting in a hybrid system that combines the advantages of both paradigms to reach a new degree of efficiency and confidence in verification.

References [1]. Wagner, Ilya, Valeria Bertacco, and Todd Austin. "Microprocessor Verification via Feedback-Adjusted Markov Models." IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems, vol. 26, no. 6, June 2007, pp. 1126-1138. [2]. Fajcik, Martin, Pavel Smrz, and Marcela Zachariasova. "Automation of Processor Verification Using Recurrent Neural Networks." 2017 18th International Workshop on Microprocessor and SOC Test and Verification (MTV), IEEE, 2017, pp. 15-20. [3]. Šimková, Marcela, and ZdeněkKotásek. "Automation and Optimization of Coverage-driven Verification." 2015 Euromicro Conference on Digital System Design, IEEE, 2015, pp. 87-94. [4]. Tasiran, Serdar, et al. "A Functional Validation Technique: Biased-Random Simulation Guided by Observability-Based Coverage." Proceedings of the 2001 IEEE/ACM International Conference on Computer-Aided Design, IEEE Computer Society, 2001, pp. 418-425. [5]. Goloubeva, O., M. SonzaReorda, and M. Violante. "Automatic Generation of Validation Stimuli for Application-Specific Processors." Proceedings of the Design, Automation and Test in Europe Conference and Exhibition (DATE’04), IEEE Computer Society, 2004. [6]. Habibi, Ali, and Sofiène Tahar. "Design and Verification of SystemC Transaction-Level Models." IEEE Transactions on Very Large Scale Integration (VLSI) Systems, vol. 14, no. 1, Jan. 2006, pp. 57- 68.J. Clerk Maxwell, A Treatise on Electricity and Magnetism, 3rd ed., vol. 2. Oxford: Clarendon, 1892, pp.68–73. [7]. S. Fine and A. Ziv, "Coverage directed test generation for functional verification using Bayesian networks," in Proceedings of the 40th Design Automation Conference, 2003, pp. 286-291. [8]. Z. Zeng, M. Ciesielski, and B. Rouzeyre, "Functional test generation using constraint logic programming," in IFIP International Conference on VLSI, 2001, pp. 329-343. [9]. B. Wile, J. C. Goss, and W. Roesner, Comprehensive Functional Verification: The Complete Industry Cycle. Morgan Kaufmann, 2005. [10]. sN. Kitchen and A. Kuehlmann, "Stimulus Generation for Constrained Random Simulation," in 2007 IEEE/ACM International Conference on Computer-Aided Design, 2007, pp. 258-265.

Journal of Scientific and Engineering Research

    435