Cryptography and computational algebra designs are complex systems based on modular arithmetic and build on multi-level modules where bit-width is generally larger than 64-bit. Because of their particularity, such designs pose a real challenge for verification, in part because large-integer‘s functions are not supported in actual hardware description languages (HDLs), therefore limiting the HDL testbench utility. In another hand, high-level verification approach proved its efficiency in the last decade over HDL testbench technique by raising the latter at a higher abstraction level. In this work, we propose a high-level platform to verify such designs, by leveraging the capabilities of a popular tool (Matlab/Simulink) to meet the requirements of a cycle accurate verification without bit-size restrictions and in multi-level inside the design architecture. The proposed high-level platform is augmented by an assertion-based verification to complete the verification coverage. The platform experimental results of the testcase provided good evidence of its performance and re-usability.
The development of embedded applications (such as Wireless Sensor Network protocols) often
requires a shift to formal specifications. To insure the reliability and the performance of the
WSNs, such protocols must be designed following some methods reducing error rate. Formal
methods (as Automata, Petri nets, algebra, logics, etc.) were largely used in the specification of
these protocols, their analysis and their verification. After that, their implementation is an
important phase to deploy, test and use those protocols in real environments. The main
objective of the current paper is to formalize the transformation from high-level specification (in
Timed Automata) to low-level implementation (in NesC language and TinyOs system) and to
automate such transformation. The proposed transformation approach defines a set of rules that
allow the passage between these two levels. We implemented our solution and we illustrated the
proposed approach on a protocol case study for the "humidity" and "temperature" sensing in
WSNs applications.
Interprocedural Slicing Using Dependence Graphsjames marioki
This document summarizes the 1988 paper "Interprocedural Slicing Using Dependence Graphs". The paper introduced system dependence graphs (SDGs) to model interprocedural programs and defined an algorithm for interprocedural slicing. The algorithm correctly accounts for calling context by using a context-free language of matched parentheses to filter infeasible paths. Though quartic, the algorithm forms the basis for subsequent work on efficient context-sensitive program analysis using graph reachability and context-free languages.
An Adjacent Analysis of the Parallel Programming Model Perspective: A SurveyIRJET Journal
This document provides an overview and analysis of parallel programming models. It begins with an abstract discussing the growing demand for parallel computing and challenges with existing parallel programming frameworks. It then reviews several relevant studies on parallel programming models and architectures. The document goes on to describe several key parallel programming models in more detail, including the Parallel Random Access Machine (PRAM) model, Unrestricted Message Passing (UMP) model, and Bulk Synchronous Parallel (BSP) model. It discusses aspects of each model like architecture, communication methods, and associated cost models. The overall goal is to compare benefits and limitations of different parallel programming models.
This document summarizes a bachelor thesis that implemented and simulated various low-density parity-check (LDPC) codes in fast fading environments. The thesis first provides background on channel coding, LDPC codes, channel models, and performance metrics. It then describes generating a simulation model in MATLAB to test LDPC codes over Rayleigh fading channels and additive white Gaussian noise channels. Results are presented on bit error rate performance and extrinsic information transfer charts. The goal was to evaluate LDPC code performance and design an effective system concept validated through computer simulation.
Modeling and Evaluation of Performance and Reliability of Component-based So...Editor IJCATR
Validation of software systems is very useful at the primary stages of their development cycle. Evaluation of functional
requirements is supported by clear and appropriate approaches, but there is no similar strategy for evaluation of non-functional requirements
(such as performance and reliability). Whereas establishing the non-functional requirements have significant effect on success of software
systems, therefore considerable necessities are needed for evaluation of non-functional requirements. Also, if the software performance has
been specified based on performance models, may be evaluated at the primary stages of software development cycle. Therefore, modeling
and evaluation of non-functional requirements in software architecture level, that are designed at the primary stages of software systems
development cycle and prior to implementation, will be very effective.
We propose an approach for evaluate the performance and reliability of software systems, based on formal models (hierarchical timed
colored petri nets) in software architecture level. In this approach, the software architecture is described by UML use case, activity and
component diagrams, then UML model is transformed to an executable model based on hierarchical timed colored petri nets (HTCPN) by a
proposed algorithm. Consequently, upon execution of an executive model and analysis of its results, non-functional requirements including
performance (such as response time) and reliability may be evaluated in software architecture level.
This paper studies a new, quantitative approach using fractal geometry to analyse basic tenets
of good programming style. Experiments on C source of the GNU/Linux Core Utilities, a
collection of 114 programs or approximately 70,000 lines of code, show systematic changes in
style are correlated with statistically significant changes in fractal dimension (P≤0.0009). The
data further show positive but weak correlation between lines of code and fractal dimension
(r=0.0878). These results suggest the fractal dimension is a reliable metric of changes that
affect good style, the knowledge of which may be useful for maintaining a code base.
FAULT MODELING OF COMBINATIONAL AND SEQUENTIAL CIRCUITS AT REGISTER TRANSFER ...VLSICS Design
This document summarizes research on modeling faults at the register transfer level (RTL) for digital circuit testing. It proposes a new RTL fault model that models stuck-at faults by inserting buffers for each bit in the variables of the RTL code. Fault simulation is performed on faulty circuits generated from the RTL code to determine fault coverage. Results on combinational and sequential circuits show the RTL fault coverage obtained matches closely with gate-level fault coverage obtained through logic synthesis and gate-level fault simulation. The proposed RTL fault model provides a way to estimate fault coverage earlier in the design cycle compared to traditional gate-level fault simulation.
The development of embedded applications (such as Wireless Sensor Network protocols) often
requires a shift to formal specifications. To insure the reliability and the performance of the
WSNs, such protocols must be designed following some methods reducing error rate. Formal
methods (as Automata, Petri nets, algebra, logics, etc.) were largely used in the specification of
these protocols, their analysis and their verification. After that, their implementation is an
important phase to deploy, test and use those protocols in real environments. The main
objective of the current paper is to formalize the transformation from high-level specification (in
Timed Automata) to low-level implementation (in NesC language and TinyOs system) and to
automate such transformation. The proposed transformation approach defines a set of rules that
allow the passage between these two levels. We implemented our solution and we illustrated the
proposed approach on a protocol case study for the "humidity" and "temperature" sensing in
WSNs applications.
Interprocedural Slicing Using Dependence Graphsjames marioki
This document summarizes the 1988 paper "Interprocedural Slicing Using Dependence Graphs". The paper introduced system dependence graphs (SDGs) to model interprocedural programs and defined an algorithm for interprocedural slicing. The algorithm correctly accounts for calling context by using a context-free language of matched parentheses to filter infeasible paths. Though quartic, the algorithm forms the basis for subsequent work on efficient context-sensitive program analysis using graph reachability and context-free languages.
An Adjacent Analysis of the Parallel Programming Model Perspective: A SurveyIRJET Journal
This document provides an overview and analysis of parallel programming models. It begins with an abstract discussing the growing demand for parallel computing and challenges with existing parallel programming frameworks. It then reviews several relevant studies on parallel programming models and architectures. The document goes on to describe several key parallel programming models in more detail, including the Parallel Random Access Machine (PRAM) model, Unrestricted Message Passing (UMP) model, and Bulk Synchronous Parallel (BSP) model. It discusses aspects of each model like architecture, communication methods, and associated cost models. The overall goal is to compare benefits and limitations of different parallel programming models.
This document summarizes a bachelor thesis that implemented and simulated various low-density parity-check (LDPC) codes in fast fading environments. The thesis first provides background on channel coding, LDPC codes, channel models, and performance metrics. It then describes generating a simulation model in MATLAB to test LDPC codes over Rayleigh fading channels and additive white Gaussian noise channels. Results are presented on bit error rate performance and extrinsic information transfer charts. The goal was to evaluate LDPC code performance and design an effective system concept validated through computer simulation.
Modeling and Evaluation of Performance and Reliability of Component-based So...Editor IJCATR
Validation of software systems is very useful at the primary stages of their development cycle. Evaluation of functional
requirements is supported by clear and appropriate approaches, but there is no similar strategy for evaluation of non-functional requirements
(such as performance and reliability). Whereas establishing the non-functional requirements have significant effect on success of software
systems, therefore considerable necessities are needed for evaluation of non-functional requirements. Also, if the software performance has
been specified based on performance models, may be evaluated at the primary stages of software development cycle. Therefore, modeling
and evaluation of non-functional requirements in software architecture level, that are designed at the primary stages of software systems
development cycle and prior to implementation, will be very effective.
We propose an approach for evaluate the performance and reliability of software systems, based on formal models (hierarchical timed
colored petri nets) in software architecture level. In this approach, the software architecture is described by UML use case, activity and
component diagrams, then UML model is transformed to an executable model based on hierarchical timed colored petri nets (HTCPN) by a
proposed algorithm. Consequently, upon execution of an executive model and analysis of its results, non-functional requirements including
performance (such as response time) and reliability may be evaluated in software architecture level.
This paper studies a new, quantitative approach using fractal geometry to analyse basic tenets
of good programming style. Experiments on C source of the GNU/Linux Core Utilities, a
collection of 114 programs or approximately 70,000 lines of code, show systematic changes in
style are correlated with statistically significant changes in fractal dimension (P≤0.0009). The
data further show positive but weak correlation between lines of code and fractal dimension
(r=0.0878). These results suggest the fractal dimension is a reliable metric of changes that
affect good style, the knowledge of which may be useful for maintaining a code base.
FAULT MODELING OF COMBINATIONAL AND SEQUENTIAL CIRCUITS AT REGISTER TRANSFER ...VLSICS Design
This document summarizes research on modeling faults at the register transfer level (RTL) for digital circuit testing. It proposes a new RTL fault model that models stuck-at faults by inserting buffers for each bit in the variables of the RTL code. Fault simulation is performed on faulty circuits generated from the RTL code to determine fault coverage. Results on combinational and sequential circuits show the RTL fault coverage obtained matches closely with gate-level fault coverage obtained through logic synthesis and gate-level fault simulation. The proposed RTL fault model provides a way to estimate fault coverage earlier in the design cycle compared to traditional gate-level fault simulation.
Software effort estimation through clustering techniques of RBFN networkIOSR Journals
This document discusses using a radial basis function neural network (RBFN) to estimate software development effort based on the COCOMO II model. The RBFN uses COCOMO II data for training and has three layers - an input layer with COCOMO II parameters like size and scale factors, a hidden middle layer with Gaussian activation functions, and an output layer that calculates effort. Two clustering algorithms, K-means and APC-III, are used to determine the receptive fields of the hidden layer neurons. The K-means algorithm partitions the COCOMO II data into clusters and finds cluster centers to minimize distance between clusters. The RBFN is trained and tested on the COCOMO II data to evaluate its ability to accurately estimate software
- The question describes a software controller being developed for a coffee vending machine. It has slots for coins, buttons for change return and selecting three types of coffee.
- Requirements include accepting correct payment, dispensing the selected coffee, and returning correct change. Non-functional requirements include reliability, maintainability and real-time response.
- Possible models include use case diagrams, state diagrams and sequence diagrams. Testing would involve unit testing components, integration testing interactions, and system testing end-to-end functionality from payment to delivery.
The document contains a sample midterm examination for an introduction to software engineering course. It includes multiple questions asking students to draw diagrams related to an automated auction system and a car door locking system. For question 1, students are asked to draw collaboration and class diagrams modeling an automated auction system that uses email to communicate with bidders. For question 2, students are asked to draw use case, statechart, and class diagrams for a car door locking system called VeriLock.
Performance analysis of machine learning approaches in software complexity pr...Sayed Mohsin Reza
This video contains the presentation at TCCE 2020 by Sayed Mohsin Reza on his paper titled "Performance Analysis of Machine Learning Approaches in Software Complexity Prediction"
Keywords: Software Complexity, Software Quality, Machine Learning, Software Design, Software Reliability, etc
Authors :
1. Sayed Mohsin Reza, Ph.D. Student, University of Texas
2. Mahfujur Rahman, Lecturer, Daffodil International University
3. Hasnat Parvez, Student, Jahangirnagar University
4. Omar Badreddin, Professor, University of Texas
5. Shamim Al Mamun, Professor, Jahangirnagar University
Abstract: Software design is one of the core concepts in software engineering. This covers insights and intuitions of software evolution, reliability, and maintainability. Effective software design facilitates software reliability and better quality management during development which reduces software development cost. Therefore, it is required to detect and maintain these issues earlier. Class complexity is one of the ways of detecting software quality. The objective of this paper is to predict class complexity from source code metrics using Machine Learning (ML) approaches and compare the performance of the approaches. In order to do that, we collect ten popular and quality maintained open source repositories and extract 18 source code metrics that relate to complexity for class-level analysis. First, we apply statistical correlation to find out the source code metrics that impact most on class complexity. Second, we apply five alternative ML techniques to build complexity predictors and compare the performances. The results report that the following source code metrics: Depth Inheritance Tree (DIT), Response For Class (RFC), Weighted Method Count (WMC), Lines of Code (LOC), and Coupling Between Objects (CBO) have the most impact on class complexity. Also, we evaluate the performance of the techniques and results show that Random Forest (RF) significantly improves accuracy without providing additional false negative or false positive that work as false alarms in complexity prediction.
IJRET : International Journal of Research in Engineering and Technology is an international peer reviewed, online journal published by eSAT Publishing House for the enhancement of research in various disciplines of Engineering and Technology. The aim and scope of the journal is to provide an academic medium and an important reference for the advancement and dissemination of research results that support high-level learning, teaching and research in the fields of Engineering and Technology. We bring together Scientists, Academician, Field Engineers, Scholars and Students of related fields of Engineering and Technology
Fpga implementation of linear ldpc encodereSAT Journals
Abstract In this paper, a FPGA implementation of linear time LDPC encoder is presented. This encoder implementation can handle large size of input message. Linear Time encoder hardware architecture reduces the Complexity and area of encoder than generator matrix based encoder techniques. This encoder is simulated on different platform which includes Matlab & High level languages for 1/2 rate & up to 4096 code length. FPGA implementation of the encoder is done on Xilinx Spartan 3E Starter Kit. The result shows the speed & area comparison for different FPGA platform. Keywords— LDPC codes, dual-diagonal, Linear encoding, Generator matrix complexity, FPGA Implementation
Fault Modeling for Verilog Register Transfer Levelidescitation
As the complexity of Very Large Scale Integration
(VLSI) increases, testing becomes tedious. Currently fault
models are used to test digital circuits at gate level or at levels
lower than gate. Modeling faults at these levels, leads to
increase in the design cycle time period. Hence, there is a
need to explore new approaches for modeling faults at higher
levels. This paper proposes fault modeling at the Register
Transfer Level (RTL) for digital circuits. Using this level of
modeling, results are obtained for fault coverage, area and
test patterns. A software prototype, FEVER, has been developed
in C which reads a RTL description and generates two output
files: one a modified RTL with test features and two a file
consisting of set of test patterns. These modified RTL and test
patterns are further used for fault simulation and fault
coverage analysis. Comparison is performed between the RTL
and Gate level modeling for ISCAS benchmarks and the
results of the same are presented. Results are obtained using
Synopsys, TetraMax and it is shown that it is possible to achieve
100% fault coverage with no area overhead at the RTL level
The document is the midterm examination for an introduction to software engineering course. It contains instructions for the exam, which has multiple choice and essay questions. Students are to write their name, ID, and signature on the cover page and top of the exam booklet. The exam is closed book and has a duration of 75 minutes.
This document contains instructions for a final examination in an introduction to software engineering course. It provides the date, time, location of the exam, as well as instructions that students are to write their name, student ID, and signature on the cover and top of the exam. It also states that the exam is closed book and notes, calculators are permitted, and to circle one answer for multiple choice questions. The exam contains two sections - a multiple choice section and an essay question section where students should write their answers in a separate booklet.
Russell John Childs has over 10 years of experience in technical software engineering and modeling complex systems. He has extensive skills in C++, algorithms, data structures, physics, mathematics, and safety-critical programming. His career includes roles as a senior software engineer for several major tech companies, where he worked on projects such as concurrency optimization, statistical modeling, and automated testing. He holds a PhD in Particle Physics from Birmingham University and BSc in Physics from Liverpool University.
This document summarizes a research paper about introducing explicit phrase alignment to neural machine translation (NMT) models. The key ideas are: (1) To develop an NMT model that treats phrase alignment as a latent variable during decoding, allowing the use of a phrase-based search space where alignment is available; (2) To design a new decoding algorithm using the available phrase alignment that can impose lexical and structural constraints while maintaining translation quality. Experiments showed the approach makes NMT more interpretable without sacrificing performance, and significantly improves constrained translation tasks.
This document discusses pointer analysis techniques for object-oriented languages. It provides background on pointer analysis and its importance for program analysis and optimization. It also reviews related work on pointer analysis algorithms for both procedural and object-oriented languages. The document motivates the need for precise pointer analysis to enable optimizations like instruction scheduling and register allocation. It then provides an introduction to Binary Decision Diagrams which are used to represent pointer analysis results.
Presentation about an eclipse framework that allows to generate ecore model instances as input for tests and benchmarks. Held at the 3rd BigMDE workshop at STAF in L'Aquia, Italy in July 2015.
The document proposes an approach for identifying core designs for reconfigurable systems driven by specification self-similarity. It involves partitioning a specification's data flow graph (DFG) to identify recurrent subgraphs that can be implemented as reusable configurable modules. This is done through two phases: template identification to produce equivalence classes of isomorphic subgraphs, and graph covering to select templates for implementation. The approach was tested on real-world benchmarks, demonstrating coverage of 70-90% and runtimes of seconds to minutes. Future work includes refining template selection and online scheduling of reconfigurable cores.
COVERAGE DRIVEN FUNCTIONAL TESTING ARCHITECTURE FOR PROTOTYPING SYSTEM USING ...VLSICS Design
Time and efforts for functional testing of digital logic is big chunk of overall project cycle in VLSI industry. Progress of functional testing is measured by functional coverage where test-plan defines what needs to be covered, and test-results indicates quality of stimulus. Claiming closer of functional testing requires that functional coverage hits 100% of original test-plan. Depending on the complexity of the design, availability of resources and budget, various methods are used for functional testing. Software simulations using various logic simulators, available from Electronic Design Automation (EDA) companies, is primary method for functional testing. The next level in functional testing is pre-silicon verification using Field Programmable Gate Array (FPGA) prototype and/or emulation platforms for stress testing the Design Under Test (DUT). With all the efforts, the purpose is to gain confidence on maturity of DUT to ensuresfirst time silicon success that meets time to market needs of the industry. For any test-environment the bottleneck, in achieving verification closer, is controllability and observability that is quality of stimulus to unearth issues at early stage and coverage calculation. Software simulation, FPGA prototype, or emulation, each method has its own limitations, be it test-time, ease of use, or cost of software, tools and
hardware-platform. Compared to software simulation, FPGA prototyping and emulation methods pose greater challenges in quality stimulus generation and coverage calculation. Many researchers have identified the problems of bug-detection / localization, but very few have touched the concept of quality stimulus generation that leads to better functional coverage and thereby uncover hidden bugs in FPGA prototype verification setup. This paper presents a novel approach to address above-mentioned issues by embedding synthesizable active-agent and coverage collector into FPGA prototype. The proposed architecture has been experimented for functional and stress testing of Universal Serial Bus (USB) Link Training and Status State Machine (LTSSM) logic module as DUT in FPGA prototype. The proposed solution is fully synthesizable and hence can be used in both software simulation as well as in prototype system. The biggest advantage is plug and play nature of this active-agent component, that allows its reusability in any USB3.0 LTSSM digital core.
This document presents a methodology that uses a formal property checker to analyze uncovered branches from module-level simulation in order to more efficiently and effectively achieve coverage closure. The methodology generates simple formal properties for each uncovered branch based on temporal induction principles. If the properties pass, the branch can be proven unreachable and filtered from the coverage report. This allows automation of the analysis process and was found to identify a greater percentage of unreachable code compared to built-in formal tools. The methodology was applied successfully to coverage closure for the Infineon TriCore 1.6 microcontroller.
Accelerating system verilog uvm based vip to improve methodology for verifica...VLSICS Design
In this paper we present the development of Acceleratable UVCs from standard UVCs in System Verilog
and their usage in UVM based Verification Environment of Image Signal Processing designs to increase
run time performance. This paper covers development of Acceleratable UVCs from standard UVCs for
internal control and data buses of ST imaging group by partitioning of transaction-level components and
cycle-accurate signal-level components between the software simulator and hardware accelerator
respectively. Standard Co-Emulation API: Modeling Interface (SCE-MI) compliant, transaction-level
communications link between test benches running on a host system and Emulation machine is established.
Accelerated Verification IPs are used at UVM based Verification Environment of Image Signal Processing
designs both with simulator and emulator as UVM acceleration is an extension of the standard simulationonly
UVM and is fully backward compatible with it. Acceleratable UVCs significantly reduces development
schedule risks while leveraging transaction models used during simulation.
In this paper, we discuss our experiences on UVM based methodology adoption on TestBench-Xpress
(TBX) based technology step by step. We are also doing comparison between the run time performance
results from earlier simulator-only environment and the new, hardware-accelerated environment. Although
this paper focuses on Acceleratable UVC’s development and their usage for image signal processing
designs. Same concept can be extended for non-image signal processing designs.
Advanced Verification Methodology for Complex System on Chip VerificationVLSICS Design
This document describes an advanced verification methodology for complex system on chip verification. Key aspects of the methodology include:
1. Using constructs like sequencers, virtual sequencers, configuration databases, and channels to enable code reuse and reduce time to market.
2. Developing a reusable test bench architecture with components like drivers, monitors, agents, and an environment class.
3. Implementing a coverage-driven verification approach using phases like build, connect, end-of-elaboration, and run, along with self-checking scoreboards.
4. Applying the methodology resulted in 95% code coverage for verifying a communication system on chip design, with the methodology taking less time than alternatives like system
Improvement in Error Resilience in BIST using hamming codeIJMTST Journal
In the current scenario of IP core based SoC, to test the CUT we need to communication link between Circuit Under Test and ATPG, so before applying to actual DUT. If there is a problem with this link, there may be a lip in bit of test data. Compared to original test data, if there is a bit lip in the original data, the codeword may change and hence the decompressed data will have a large number of bit deviation. This deviation in bits can severely degrade the test quality and overall fault coverage which may affect yield. The error resilience is the capability of the test data to resist against such bit lips. Here in this paper, the earlier methods of error resilience is compared and a Hamming code based error resilience technique is proposed to improve the error resilience capacity of compressed test data. This method is applied on Huffman code based compressed test data of widely used ISCAS benchmark circuits. The fault coverage measurement results show the effectiveness of the proposed method. The basic goal here is to survey the effect of bit lips on fault coverage and prepare a platform for further development in this avenue.
This document summarizes a research paper that designed and implemented an embedded hardware accelerator to help diagnose HDL code during assertion-based verification. The hardware accelerator, called a multi-array processor (MAP), was programmed onto a FPGA chip to efficiently perform logical operations on large amounts of data generated during verification in parallel. Testing showed the MAP improved processing and analysis time over manual methods. The MAP can also be used for applications that compare output matrices for decision making.
COVERAGE DRIVEN FUNCTIONAL TESTING ARCHITECTURE FOR PROTOTYPING SYSTEM USING ...VLSICS Design
Time and efforts for functional testing of digital logic is big chunk of overall project cycle in VLSI industry. Progress of functional testing is measured by functional coverage where test-plan defines what needs to be covered, and test-results indicates quality of stimulus. Claiming closer of functional testing requires that functional coverage hits 100% of original test-plan. Depending on the complexity of the design, availability
of resources and budget, various methods are used for functional testing. Software simulations using various logic simulators, available from Electronic Design Automation (EDA) companies, is primary method for functional testing. The next level in functional testing is pre-silicon verification using Field
Programmable Gate Array (FPGA) prototype and/or emulation platforms for stress testing the Design Under Test (DUT). With all the efforts, the purpose is to gain confidence on maturity of DUT to ensures first time silicon success that meets time to market needs of the industry. For any test-environment the
bottleneck, in achieving verification closer, is controllability and observability that is quality of stimulus to unearth issues at early stage and coverage calculation. Software simulation, FPGA prototype, or emulation, each method has its own limitations, be it test-time, ease of use, or cost of software, tools and
hardware-platform. Compared to software simulation, FPGA prototyping and emulation methods pose greater challenges in quality stimulus generation and coverage calculation. Many researchers have identified the problems of bug-detection / localization, but very few have touched the concept of quality
stimulus generation that leads to better functional coverage and thereby uncover hidden bugs in FPGA prototype verification setup. This paper presents a novel approach to address above-mentioned issues by embedding synthesizable active-agent and coverage collector into FPGA prototype. The proposed
architecture has been experimented for functional and stress testing of Universal Serial Bus (USB) Link Training and Status State Machine (LTSSM) logic module as DUT in FPGA prototype. The proposed solution is fully synthesizable and hence can be used in both software simulation as well as in prototype system. The biggest advantage is plug and play nature of this active-agent component, that allows its
reusability in any USB3.0 LTSSM digital core.
COVERAGE DRIVEN FUNCTIONAL TESTING ARCHITECTURE FOR PROTOTYPING SYSTEM USING ...VLSICS Design
This document describes a proposed architecture for functional testing of a USB Link Training and Status State Machine (LTSSM) logic module using a synthesizable active agent embedded in an FPGA prototyping system. The active agent controls stimulus generation and injects errors to target time-sensitive link training and low power states. It also includes a coverage collector to provide observability for closed-loop functional testing. The active agent is fully synthesizable, making it reusable for both software simulation and FPGA prototyping. Experimental results showed the architecture was able to better generate stimuli and improve functional coverage for stress testing the LTSSM module.
Software effort estimation through clustering techniques of RBFN networkIOSR Journals
This document discusses using a radial basis function neural network (RBFN) to estimate software development effort based on the COCOMO II model. The RBFN uses COCOMO II data for training and has three layers - an input layer with COCOMO II parameters like size and scale factors, a hidden middle layer with Gaussian activation functions, and an output layer that calculates effort. Two clustering algorithms, K-means and APC-III, are used to determine the receptive fields of the hidden layer neurons. The K-means algorithm partitions the COCOMO II data into clusters and finds cluster centers to minimize distance between clusters. The RBFN is trained and tested on the COCOMO II data to evaluate its ability to accurately estimate software
- The question describes a software controller being developed for a coffee vending machine. It has slots for coins, buttons for change return and selecting three types of coffee.
- Requirements include accepting correct payment, dispensing the selected coffee, and returning correct change. Non-functional requirements include reliability, maintainability and real-time response.
- Possible models include use case diagrams, state diagrams and sequence diagrams. Testing would involve unit testing components, integration testing interactions, and system testing end-to-end functionality from payment to delivery.
The document contains a sample midterm examination for an introduction to software engineering course. It includes multiple questions asking students to draw diagrams related to an automated auction system and a car door locking system. For question 1, students are asked to draw collaboration and class diagrams modeling an automated auction system that uses email to communicate with bidders. For question 2, students are asked to draw use case, statechart, and class diagrams for a car door locking system called VeriLock.
Performance analysis of machine learning approaches in software complexity pr...Sayed Mohsin Reza
This video contains the presentation at TCCE 2020 by Sayed Mohsin Reza on his paper titled "Performance Analysis of Machine Learning Approaches in Software Complexity Prediction"
Keywords: Software Complexity, Software Quality, Machine Learning, Software Design, Software Reliability, etc
Authors :
1. Sayed Mohsin Reza, Ph.D. Student, University of Texas
2. Mahfujur Rahman, Lecturer, Daffodil International University
3. Hasnat Parvez, Student, Jahangirnagar University
4. Omar Badreddin, Professor, University of Texas
5. Shamim Al Mamun, Professor, Jahangirnagar University
Abstract: Software design is one of the core concepts in software engineering. This covers insights and intuitions of software evolution, reliability, and maintainability. Effective software design facilitates software reliability and better quality management during development which reduces software development cost. Therefore, it is required to detect and maintain these issues earlier. Class complexity is one of the ways of detecting software quality. The objective of this paper is to predict class complexity from source code metrics using Machine Learning (ML) approaches and compare the performance of the approaches. In order to do that, we collect ten popular and quality maintained open source repositories and extract 18 source code metrics that relate to complexity for class-level analysis. First, we apply statistical correlation to find out the source code metrics that impact most on class complexity. Second, we apply five alternative ML techniques to build complexity predictors and compare the performances. The results report that the following source code metrics: Depth Inheritance Tree (DIT), Response For Class (RFC), Weighted Method Count (WMC), Lines of Code (LOC), and Coupling Between Objects (CBO) have the most impact on class complexity. Also, we evaluate the performance of the techniques and results show that Random Forest (RF) significantly improves accuracy without providing additional false negative or false positive that work as false alarms in complexity prediction.
IJRET : International Journal of Research in Engineering and Technology is an international peer reviewed, online journal published by eSAT Publishing House for the enhancement of research in various disciplines of Engineering and Technology. The aim and scope of the journal is to provide an academic medium and an important reference for the advancement and dissemination of research results that support high-level learning, teaching and research in the fields of Engineering and Technology. We bring together Scientists, Academician, Field Engineers, Scholars and Students of related fields of Engineering and Technology
Fpga implementation of linear ldpc encodereSAT Journals
Abstract In this paper, a FPGA implementation of linear time LDPC encoder is presented. This encoder implementation can handle large size of input message. Linear Time encoder hardware architecture reduces the Complexity and area of encoder than generator matrix based encoder techniques. This encoder is simulated on different platform which includes Matlab & High level languages for 1/2 rate & up to 4096 code length. FPGA implementation of the encoder is done on Xilinx Spartan 3E Starter Kit. The result shows the speed & area comparison for different FPGA platform. Keywords— LDPC codes, dual-diagonal, Linear encoding, Generator matrix complexity, FPGA Implementation
Fault Modeling for Verilog Register Transfer Levelidescitation
As the complexity of Very Large Scale Integration
(VLSI) increases, testing becomes tedious. Currently fault
models are used to test digital circuits at gate level or at levels
lower than gate. Modeling faults at these levels, leads to
increase in the design cycle time period. Hence, there is a
need to explore new approaches for modeling faults at higher
levels. This paper proposes fault modeling at the Register
Transfer Level (RTL) for digital circuits. Using this level of
modeling, results are obtained for fault coverage, area and
test patterns. A software prototype, FEVER, has been developed
in C which reads a RTL description and generates two output
files: one a modified RTL with test features and two a file
consisting of set of test patterns. These modified RTL and test
patterns are further used for fault simulation and fault
coverage analysis. Comparison is performed between the RTL
and Gate level modeling for ISCAS benchmarks and the
results of the same are presented. Results are obtained using
Synopsys, TetraMax and it is shown that it is possible to achieve
100% fault coverage with no area overhead at the RTL level
The document is the midterm examination for an introduction to software engineering course. It contains instructions for the exam, which has multiple choice and essay questions. Students are to write their name, ID, and signature on the cover page and top of the exam booklet. The exam is closed book and has a duration of 75 minutes.
This document contains instructions for a final examination in an introduction to software engineering course. It provides the date, time, location of the exam, as well as instructions that students are to write their name, student ID, and signature on the cover and top of the exam. It also states that the exam is closed book and notes, calculators are permitted, and to circle one answer for multiple choice questions. The exam contains two sections - a multiple choice section and an essay question section where students should write their answers in a separate booklet.
Russell John Childs has over 10 years of experience in technical software engineering and modeling complex systems. He has extensive skills in C++, algorithms, data structures, physics, mathematics, and safety-critical programming. His career includes roles as a senior software engineer for several major tech companies, where he worked on projects such as concurrency optimization, statistical modeling, and automated testing. He holds a PhD in Particle Physics from Birmingham University and BSc in Physics from Liverpool University.
This document summarizes a research paper about introducing explicit phrase alignment to neural machine translation (NMT) models. The key ideas are: (1) To develop an NMT model that treats phrase alignment as a latent variable during decoding, allowing the use of a phrase-based search space where alignment is available; (2) To design a new decoding algorithm using the available phrase alignment that can impose lexical and structural constraints while maintaining translation quality. Experiments showed the approach makes NMT more interpretable without sacrificing performance, and significantly improves constrained translation tasks.
This document discusses pointer analysis techniques for object-oriented languages. It provides background on pointer analysis and its importance for program analysis and optimization. It also reviews related work on pointer analysis algorithms for both procedural and object-oriented languages. The document motivates the need for precise pointer analysis to enable optimizations like instruction scheduling and register allocation. It then provides an introduction to Binary Decision Diagrams which are used to represent pointer analysis results.
Presentation about an eclipse framework that allows to generate ecore model instances as input for tests and benchmarks. Held at the 3rd BigMDE workshop at STAF in L'Aquia, Italy in July 2015.
The document proposes an approach for identifying core designs for reconfigurable systems driven by specification self-similarity. It involves partitioning a specification's data flow graph (DFG) to identify recurrent subgraphs that can be implemented as reusable configurable modules. This is done through two phases: template identification to produce equivalence classes of isomorphic subgraphs, and graph covering to select templates for implementation. The approach was tested on real-world benchmarks, demonstrating coverage of 70-90% and runtimes of seconds to minutes. Future work includes refining template selection and online scheduling of reconfigurable cores.
COVERAGE DRIVEN FUNCTIONAL TESTING ARCHITECTURE FOR PROTOTYPING SYSTEM USING ...VLSICS Design
Time and efforts for functional testing of digital logic is big chunk of overall project cycle in VLSI industry. Progress of functional testing is measured by functional coverage where test-plan defines what needs to be covered, and test-results indicates quality of stimulus. Claiming closer of functional testing requires that functional coverage hits 100% of original test-plan. Depending on the complexity of the design, availability of resources and budget, various methods are used for functional testing. Software simulations using various logic simulators, available from Electronic Design Automation (EDA) companies, is primary method for functional testing. The next level in functional testing is pre-silicon verification using Field Programmable Gate Array (FPGA) prototype and/or emulation platforms for stress testing the Design Under Test (DUT). With all the efforts, the purpose is to gain confidence on maturity of DUT to ensuresfirst time silicon success that meets time to market needs of the industry. For any test-environment the bottleneck, in achieving verification closer, is controllability and observability that is quality of stimulus to unearth issues at early stage and coverage calculation. Software simulation, FPGA prototype, or emulation, each method has its own limitations, be it test-time, ease of use, or cost of software, tools and
hardware-platform. Compared to software simulation, FPGA prototyping and emulation methods pose greater challenges in quality stimulus generation and coverage calculation. Many researchers have identified the problems of bug-detection / localization, but very few have touched the concept of quality stimulus generation that leads to better functional coverage and thereby uncover hidden bugs in FPGA prototype verification setup. This paper presents a novel approach to address above-mentioned issues by embedding synthesizable active-agent and coverage collector into FPGA prototype. The proposed architecture has been experimented for functional and stress testing of Universal Serial Bus (USB) Link Training and Status State Machine (LTSSM) logic module as DUT in FPGA prototype. The proposed solution is fully synthesizable and hence can be used in both software simulation as well as in prototype system. The biggest advantage is plug and play nature of this active-agent component, that allows its reusability in any USB3.0 LTSSM digital core.
This document presents a methodology that uses a formal property checker to analyze uncovered branches from module-level simulation in order to more efficiently and effectively achieve coverage closure. The methodology generates simple formal properties for each uncovered branch based on temporal induction principles. If the properties pass, the branch can be proven unreachable and filtered from the coverage report. This allows automation of the analysis process and was found to identify a greater percentage of unreachable code compared to built-in formal tools. The methodology was applied successfully to coverage closure for the Infineon TriCore 1.6 microcontroller.
Accelerating system verilog uvm based vip to improve methodology for verifica...VLSICS Design
In this paper we present the development of Acceleratable UVCs from standard UVCs in System Verilog
and their usage in UVM based Verification Environment of Image Signal Processing designs to increase
run time performance. This paper covers development of Acceleratable UVCs from standard UVCs for
internal control and data buses of ST imaging group by partitioning of transaction-level components and
cycle-accurate signal-level components between the software simulator and hardware accelerator
respectively. Standard Co-Emulation API: Modeling Interface (SCE-MI) compliant, transaction-level
communications link between test benches running on a host system and Emulation machine is established.
Accelerated Verification IPs are used at UVM based Verification Environment of Image Signal Processing
designs both with simulator and emulator as UVM acceleration is an extension of the standard simulationonly
UVM and is fully backward compatible with it. Acceleratable UVCs significantly reduces development
schedule risks while leveraging transaction models used during simulation.
In this paper, we discuss our experiences on UVM based methodology adoption on TestBench-Xpress
(TBX) based technology step by step. We are also doing comparison between the run time performance
results from earlier simulator-only environment and the new, hardware-accelerated environment. Although
this paper focuses on Acceleratable UVC’s development and their usage for image signal processing
designs. Same concept can be extended for non-image signal processing designs.
Advanced Verification Methodology for Complex System on Chip VerificationVLSICS Design
This document describes an advanced verification methodology for complex system on chip verification. Key aspects of the methodology include:
1. Using constructs like sequencers, virtual sequencers, configuration databases, and channels to enable code reuse and reduce time to market.
2. Developing a reusable test bench architecture with components like drivers, monitors, agents, and an environment class.
3. Implementing a coverage-driven verification approach using phases like build, connect, end-of-elaboration, and run, along with self-checking scoreboards.
4. Applying the methodology resulted in 95% code coverage for verifying a communication system on chip design, with the methodology taking less time than alternatives like system
Improvement in Error Resilience in BIST using hamming codeIJMTST Journal
In the current scenario of IP core based SoC, to test the CUT we need to communication link between Circuit Under Test and ATPG, so before applying to actual DUT. If there is a problem with this link, there may be a lip in bit of test data. Compared to original test data, if there is a bit lip in the original data, the codeword may change and hence the decompressed data will have a large number of bit deviation. This deviation in bits can severely degrade the test quality and overall fault coverage which may affect yield. The error resilience is the capability of the test data to resist against such bit lips. Here in this paper, the earlier methods of error resilience is compared and a Hamming code based error resilience technique is proposed to improve the error resilience capacity of compressed test data. This method is applied on Huffman code based compressed test data of widely used ISCAS benchmark circuits. The fault coverage measurement results show the effectiveness of the proposed method. The basic goal here is to survey the effect of bit lips on fault coverage and prepare a platform for further development in this avenue.
This document summarizes a research paper that designed and implemented an embedded hardware accelerator to help diagnose HDL code during assertion-based verification. The hardware accelerator, called a multi-array processor (MAP), was programmed onto a FPGA chip to efficiently perform logical operations on large amounts of data generated during verification in parallel. Testing showed the MAP improved processing and analysis time over manual methods. The MAP can also be used for applications that compare output matrices for decision making.
COVERAGE DRIVEN FUNCTIONAL TESTING ARCHITECTURE FOR PROTOTYPING SYSTEM USING ...VLSICS Design
Time and efforts for functional testing of digital logic is big chunk of overall project cycle in VLSI industry. Progress of functional testing is measured by functional coverage where test-plan defines what needs to be covered, and test-results indicates quality of stimulus. Claiming closer of functional testing requires that functional coverage hits 100% of original test-plan. Depending on the complexity of the design, availability
of resources and budget, various methods are used for functional testing. Software simulations using various logic simulators, available from Electronic Design Automation (EDA) companies, is primary method for functional testing. The next level in functional testing is pre-silicon verification using Field
Programmable Gate Array (FPGA) prototype and/or emulation platforms for stress testing the Design Under Test (DUT). With all the efforts, the purpose is to gain confidence on maturity of DUT to ensures first time silicon success that meets time to market needs of the industry. For any test-environment the
bottleneck, in achieving verification closer, is controllability and observability that is quality of stimulus to unearth issues at early stage and coverage calculation. Software simulation, FPGA prototype, or emulation, each method has its own limitations, be it test-time, ease of use, or cost of software, tools and
hardware-platform. Compared to software simulation, FPGA prototyping and emulation methods pose greater challenges in quality stimulus generation and coverage calculation. Many researchers have identified the problems of bug-detection / localization, but very few have touched the concept of quality
stimulus generation that leads to better functional coverage and thereby uncover hidden bugs in FPGA prototype verification setup. This paper presents a novel approach to address above-mentioned issues by embedding synthesizable active-agent and coverage collector into FPGA prototype. The proposed
architecture has been experimented for functional and stress testing of Universal Serial Bus (USB) Link Training and Status State Machine (LTSSM) logic module as DUT in FPGA prototype. The proposed solution is fully synthesizable and hence can be used in both software simulation as well as in prototype system. The biggest advantage is plug and play nature of this active-agent component, that allows its
reusability in any USB3.0 LTSSM digital core.
COVERAGE DRIVEN FUNCTIONAL TESTING ARCHITECTURE FOR PROTOTYPING SYSTEM USING ...VLSICS Design
This document describes a proposed architecture for functional testing of a USB Link Training and Status State Machine (LTSSM) logic module using a synthesizable active agent embedded in an FPGA prototyping system. The active agent controls stimulus generation and injects errors to target time-sensitive link training and low power states. It also includes a coverage collector to provide observability for closed-loop functional testing. The active agent is fully synthesizable, making it reusable for both software simulation and FPGA prototyping. Experimental results showed the architecture was able to better generate stimuli and improve functional coverage for stress testing the LTSSM module.
A Unique Test Bench for Various System-on-a-Chip IJECEIAES
This paper discusses a standard flow on how an automated test bench environment which is randomized with constraints can verify a SOC efficiently for its functionality and coverage. Today, in the time of multimillion gate ASICs, reusable intellectual property (IP), and system-ona-chip (SoC) designs, verification consumes about 70 % of the design effort. Automation means a machine completes a task autonomously, quicker and with predictable results. Automation requires standard processes with welldefined inputs and outputs. By using this efficient methodology it is possible to provide a general purpose automation solution for verification, given today’s technology. Tools automating various portions of the verification process are being introduced. Here, we have Communication based SOC The content of the paper discusses about the methodology used to verify such a SOC-based environment. Cadence Efficient Verification Methodology libraries are explored for the solution of this problem. We can take this as a state of art approach in verifying SOC environments. The goal of this paper is to emphasize the unique testbench for different SOC using Efficient Verification Constructs implemented in system verilog for SOC verification.
SENSOR SIGNAL PROCESSING USING HIGH-LEVEL SYNTHESIS AND INTERNET OF THINGS WI...pijans
Sensor routers play a crucial role in the sector of Internet of Things applications, in which the capacity for transmission of the network signal is limited from cloud systems to sensors and its reversal process. It describes a robust recognized framework with various architected layers to process data at high level synthesis. It is designed to sense the nodes instinctually with the help of Internet of Things where the applications arise in cloud systems. In this paper embedded PEs with four layer new design framework architecture is proposed to sense the devises of IOT applications with the support of high-level synthesis DBMF (database management function) tool.
SENSOR SIGNAL PROCESSING USING HIGH-LEVEL SYNTHESIS AND INTERNET OF THINGS WI...pijans
This document summarizes a research paper that proposes a new four-layer design framework for processing sensor signals using high-level synthesis and internet of things. The framework includes an I/O circuitry layer, fine-grained layer, coarse-grained function definition layer, and bypass connection layer. It aims to optimize resource consumption by exploiting repetitive high-level synthesis and registering macro blocks in a database. The evaluation shows defining functions as operators and exploiting granularity in behavioral synthesis reduces logic utilization compared to using basic operations or FPGA libraries without these optimizations.
This document describes Flowtracer/TEM, a collaborative SystemC-based verification environment for distributed ASIC design teams. It addresses long simulation times, complex verification solutions, and large design sizes at the RTL level by using SystemC's higher abstraction and faster simulation. Flowtracer/TEM integrates revision control, batch processing, simulation, and a test database in a web interface to help teams coordinate verification work. It aims to streamline the verification process and improve productivity and communication for distributed teams.
Application-oriented ping-pong benchmarking: how to assess the real communica...Trieu Nguyen
Moving data between processes has often been discussed as one of the
major bottlenecks in parallel computing—there is a large body of research, striving
to improve communication latency and bandwidth on different networks, measured
with ping-pong benchmarks of different message sizes. In practice, the data to be
communicated generally originates from application data structures and needs to be
serialized before communicating it over serial network channels.
Digital Security by Design: Formal Verification with Broad-Spectrum ANSI-C Re...KTN
KTN ran a collaborators' workshop on 26 September 2019 in London to explain more about the Digital Security by Design Challenge announced by the government.
The Digital Security by Design challenge has been recently announced by the Department for Business, Energy & Industrial Strategy (BEIS). This challenge, amounting to £70 million of government funding over 5 years, was delivered by UK Research and Innovation (UKRI) through the Industrial Strategy Challenge Fund (ISCF).
This Collaborators' Workshop provides an opportunity to hear more details of the challenge and forthcoming competitions.
A Scoping Workshop for this challenge was held on 30th May: http://ow.ly/oz6230pHlGl
Find out more about the Defence and Security Interest Group at https://ktn-uk.co.uk/interests/defence-security
Join the Defence and Security Interest Group at https://www.linkedin.com/groups/8584397 or Follow KTN_UK Defence group on Twitter https://twitter.com/KTNUK_Defence
This document proposes a design procedure for a re-configurable convolutional neural network (CNN) engine for field-programmable gate array (FPGA) applications. The procedure includes developing an accurate CNN model using TensorFlow and Python, and implementing a re-configurable CNN engine from scratch using register-transfer level design. The proposed engine was synthesized for 180nm CMOS technology and achieved 96% accuracy on MNIST and CIFAR-10 datasets. A graphical user interface was also designed for loading and testing datasets on the hardware engine.
The document summarizes benchmarking results for four magnetic fusion simulation codes: GTS, TGYRO, BOUT++, and VORPAL. It was performed on the Cray XE6 "Hopper" supercomputer at NERSC to evaluate performance, scalability, memory usage, and communication overhead at large scales. For GTS, weak scaling tests showed computation time remained constant while communication time increased slightly with up to 49,152 cores. Testing also examined the codes' sensitivity to reduced memory bandwidth by increasing core count per node. Overall results provide insight to improve fusion code design and inform exascale co-design efforts.
A Transfer Learning Approach to Traffic Sign RecognitionIRJET Journal
This document presents a study on traffic sign recognition using transfer learning with three pre-trained convolutional neural network models: InceptionV3, Xception, and ResNet50. The models were trained on the German Traffic Sign Recognition Benchmark dataset containing 43 classes of traffic signs. InceptionV3 achieved the highest test accuracy of 97.15% for traffic sign classification, followed by Xception at 96.79%, while ResNet50 performed poorly with only 60.69% accuracy. Transfer learning with InceptionV3 is shown to be an effective approach for traffic sign recognition tasks.
The document presents a Petri net model for hardware/software codesign. Petri nets are used as an intermediate model to allow for formal qualitative and quantitative analysis in order to perform hardware/software partitioning. Quantitative metrics like load balance, communication cost, and mutual exclusion degree are computed from the Petri net model to guide the initial allocation and partitioning process. The approach also estimates hardware area and considers multiple software components in the partitioning method.
International Journal of Engineering Research and Applications (IJERA) is a team of researchers not publication services or private publications running the journals for monetary benefits, we are association of scientists and academia who focus only on supporting authors who want to publish their work. The articles published in our journal can be accessed online, all the articles will be archived for real time access.
Our journal system primarily aims to bring out the research talent and the works done by sciaentists, academia, engineers, practitioners, scholars, post graduate students of engineering and science. This journal aims to cover the scientific research in a broader sense and not publishing a niche area of research facilitating researchers from various verticals to publish their papers. It is also aimed to provide a platform for the researchers to publish in a shorter of time, enabling them to continue further All articles published are freely available to scientific researchers in the Government agencies,educators and the general public. We are taking serious efforts to promote our journal across the globe in various ways, we are sure that our journal will act as a scientific platform for all researchers to publish their works online.
This document summarizes the performance of HiFUN, a computational fluid dynamics (CFD) solver, on parallel computing platforms using Intel MPI library. It finds that HiFUN demonstrates high scalability, with a cell count of a few thousand achieving over 85% parallel efficiency. Testing on grids with 12.7 million to 63.5 million cells on platforms with up to 10,248 cores shows near ideal speedup and good parallel efficiency. HiFUN also exhibits strong algorithmic scalability, with convergence independent of core count. This makes HiFUN highly suitable for industrial CFD simulations.
This paper presents FACADE, a compiler framework that can generate highly efficient data manipulation code for big data applications written in managed languages like Java. FACADE transforms applications by separating data storage from data manipulation. Data is stored in native memory rather than Java heap objects, bounding the number of heap objects. This significantly reduces memory management overhead and improves scalability. The compiler locally transforms methods to insert data conversion functions. Experiments show the generated code runs faster, uses less memory, and scales to larger datasets than the original code for several real-world big data applications and frameworks.
Redefining brain tumor segmentation: a cutting-edge convolutional neural netw...IJECEIAES
Medical image analysis has witnessed significant advancements with deep learning techniques. In the domain of brain tumor segmentation, the ability to
precisely delineate tumor boundaries from magnetic resonance imaging (MRI)
scans holds profound implications for diagnosis. This study presents an ensemble convolutional neural network (CNN) with transfer learning, integrating
the state-of-the-art Deeplabv3+ architecture with the ResNet18 backbone. The
model is rigorously trained and evaluated, exhibiting remarkable performance
metrics, including an impressive global accuracy of 99.286%, a high-class accuracy of 82.191%, a mean intersection over union (IoU) of 79.900%, a weighted
IoU of 98.620%, and a Boundary F1 (BF) score of 83.303%. Notably, a detailed comparative analysis with existing methods showcases the superiority of
our proposed model. These findings underscore the model’s competence in precise brain tumor localization, underscoring its potential to revolutionize medical
image analysis and enhance healthcare outcomes. This research paves the way
for future exploration and optimization of advanced CNN models in medical
imaging, emphasizing addressing false positives and resource efficiency.
Embedded machine learning-based road conditions and driving behavior monitoringIJECEIAES
Car accident rates have increased in recent years, resulting in losses in human lives, properties, and other financial costs. An embedded machine learning-based system is developed to address this critical issue. The system can monitor road conditions, detect driving patterns, and identify aggressive driving behaviors. The system is based on neural networks trained on a comprehensive dataset of driving events, driving styles, and road conditions. The system effectively detects potential risks and helps mitigate the frequency and impact of accidents. The primary goal is to ensure the safety of drivers and vehicles. Collecting data involved gathering information on three key road events: normal street and normal drive, speed bumps, circular yellow speed bumps, and three aggressive driving actions: sudden start, sudden stop, and sudden entry. The gathered data is processed and analyzed using a machine learning system designed for limited power and memory devices. The developed system resulted in 91.9% accuracy, 93.6% precision, and 92% recall. The achieved inference time on an Arduino Nano 33 BLE Sense with a 32-bit CPU running at 64 MHz is 34 ms and requires 2.6 kB peak RAM and 139.9 kB program flash memory, making it suitable for resource-constrained embedded systems.
Advanced control scheme of doubly fed induction generator for wind turbine us...IJECEIAES
This paper describes a speed control device for generating electrical energy on an electricity network based on the doubly fed induction generator (DFIG) used for wind power conversion systems. At first, a double-fed induction generator model was constructed. A control law is formulated to govern the flow of energy between the stator of a DFIG and the energy network using three types of controllers: proportional integral (PI), sliding mode controller (SMC) and second order sliding mode controller (SOSMC). Their different results in terms of power reference tracking, reaction to unexpected speed fluctuations, sensitivity to perturbations, and resilience against machine parameter alterations are compared. MATLAB/Simulink was used to conduct the simulations for the preceding study. Multiple simulations have shown very satisfying results, and the investigations demonstrate the efficacy and power-enhancing capabilities of the suggested control system.
Neural network optimizer of proportional-integral-differential controller par...IJECEIAES
Wide application of proportional-integral-differential (PID)-regulator in industry requires constant improvement of methods of its parameters adjustment. The paper deals with the issues of optimization of PID-regulator parameters with the use of neural network technology methods. A methodology for choosing the architecture (structure) of neural network optimizer is proposed, which consists in determining the number of layers, the number of neurons in each layer, as well as the form and type of activation function. Algorithms of neural network training based on the application of the method of minimizing the mismatch between the regulated value and the target value are developed. The method of back propagation of gradients is proposed to select the optimal training rate of neurons of the neural network. The neural network optimizer, which is a superstructure of the linear PID controller, allows increasing the regulation accuracy from 0.23 to 0.09, thus reducing the power consumption from 65% to 53%. The results of the conducted experiments allow us to conclude that the created neural superstructure may well become a prototype of an automatic voltage regulator (AVR)-type industrial controller for tuning the parameters of the PID controller.
An improved modulation technique suitable for a three level flying capacitor ...IJECEIAES
This research paper introduces an innovative modulation technique for controlling a 3-level flying capacitor multilevel inverter (FCMLI), aiming to streamline the modulation process in contrast to conventional methods. The proposed
simplified modulation technique paves the way for more straightforward and
efficient control of multilevel inverters, enabling their widespread adoption and
integration into modern power electronic systems. Through the amalgamation of
sinusoidal pulse width modulation (SPWM) with a high-frequency square wave
pulse, this controlling technique attains energy equilibrium across the coupling
capacitor. The modulation scheme incorporates a simplified switching pattern
and a decreased count of voltage references, thereby simplifying the control
algorithm.
A review on features and methods of potential fishing zoneIJECEIAES
This review focuses on the importance of identifying potential fishing zones in seawater for sustainable fishing practices. It explores features like sea surface temperature (SST) and sea surface height (SSH), along with classification methods such as classifiers. The features like SST, SSH, and different classifiers used to classify the data, have been figured out in this review study. This study underscores the importance of examining potential fishing zones using advanced analytical techniques. It thoroughly explores the methodologies employed by researchers, covering both past and current approaches. The examination centers on data characteristics and the application of classification algorithms for classification of potential fishing zones. Furthermore, the prediction of potential fishing zones relies significantly on the effectiveness of classification algorithms. Previous research has assessed the performance of models like support vector machines, naïve Bayes, and artificial neural networks (ANN). In the previous result, the results of support vector machine (SVM) were 97.6% more accurate than naive Bayes's 94.2% to classify test data for fisheries classification. By considering the recent works in this area, several recommendations for future works are presented to further improve the performance of the potential fishing zone models, which is important to the fisheries community.
Electrical signal interference minimization using appropriate core material f...IJECEIAES
As demand for smaller, quicker, and more powerful devices rises, Moore's law is strictly followed. The industry has worked hard to make little devices that boost productivity. The goal is to optimize device density. Scientists are reducing connection delays to improve circuit performance. This helped them understand three-dimensional integrated circuit (3D IC) concepts, which stack active devices and create vertical connections to diminish latency and lower interconnects. Electrical involvement is a big worry with 3D integrates circuits. Researchers have developed and tested through silicon via (TSV) and substrates to decrease electrical wave involvement. This study illustrates a novel noise coupling reduction method using several electrical involvement models. A 22% drop in electrical involvement from wave-carrying to victim TSVs introduces this new paradigm and improves system performance even at higher THz frequencies.
Electric vehicle and photovoltaic advanced roles in enhancing the financial p...IJECEIAES
Climate change's impact on the planet forced the United Nations and governments to promote green energies and electric transportation. The deployments of photovoltaic (PV) and electric vehicle (EV) systems gained stronger momentum due to their numerous advantages over fossil fuel types. The advantages go beyond sustainability to reach financial support and stability. The work in this paper introduces the hybrid system between PV and EV to support industrial and commercial plants. This paper covers the theoretical framework of the proposed hybrid system including the required equation to complete the cost analysis when PV and EV are present. In addition, the proposed design diagram which sets the priorities and requirements of the system is presented. The proposed approach allows setup to advance their power stability, especially during power outages. The presented information supports researchers and plant owners to complete the necessary analysis while promoting the deployment of clean energy. The result of a case study that represents a dairy milk farmer supports the theoretical works and highlights its advanced benefits to existing plants. The short return on investment of the proposed approach supports the paper's novelty approach for the sustainable electrical system. In addition, the proposed system allows for an isolated power setup without the need for a transmission line which enhances the safety of the electrical network
Bibliometric analysis highlighting the role of women in addressing climate ch...IJECEIAES
Fossil fuel consumption increased quickly, contributing to climate change
that is evident in unusual flooding and draughts, and global warming. Over
the past ten years, women's involvement in society has grown dramatically,
and they succeeded in playing a noticeable role in reducing climate change.
A bibliometric analysis of data from the last ten years has been carried out to
examine the role of women in addressing the climate change. The analysis's
findings discussed the relevant to the sustainable development goals (SDGs),
particularly SDG 7 and SDG 13. The results considered contributions made
by women in the various sectors while taking geographic dispersion into
account. The bibliometric analysis delves into topics including women's
leadership in environmental groups, their involvement in policymaking, their
contributions to sustainable development projects, and the influence of
gender diversity on attempts to mitigate climate change. This study's results
highlight how women have influenced policies and actions related to climate
change, point out areas of research deficiency and recommendations on how
to increase role of the women in addressing the climate change and
achieving sustainability. To achieve more successful results, this initiative
aims to highlight the significance of gender equality and encourage
inclusivity in climate change decision-making processes.
Voltage and frequency control of microgrid in presence of micro-turbine inter...IJECEIAES
The active and reactive load changes have a significant impact on voltage
and frequency. In this paper, in order to stabilize the microgrid (MG) against
load variations in islanding mode, the active and reactive power of all
distributed generators (DGs), including energy storage (battery), diesel
generator, and micro-turbine, are controlled. The micro-turbine generator is
connected to MG through a three-phase to three-phase matrix converter, and
the droop control method is applied for controlling the voltage and
frequency of MG. In addition, a method is introduced for voltage and
frequency control of micro-turbines in the transition state from gridconnected mode to islanding mode. A novel switching strategy of the matrix
converter is used for converting the high-frequency output voltage of the
micro-turbine to the grid-side frequency of the utility system. Moreover,
using the switching strategy, the low-order harmonics in the output current
and voltage are not produced, and consequently, the size of the output filter
would be reduced. In fact, the suggested control strategy is load-independent
and has no frequency conversion restrictions. The proposed approach for
voltage and frequency regulation demonstrates exceptional performance and
favorable response across various load alteration scenarios. The suggested
strategy is examined in several scenarios in the MG test systems, and the
simulation results are addressed.
Enhancing battery system identification: nonlinear autoregressive modeling fo...IJECEIAES
Precisely characterizing Li-ion batteries is essential for optimizing their
performance, enhancing safety, and prolonging their lifespan across various
applications, such as electric vehicles and renewable energy systems. This
article introduces an innovative nonlinear methodology for system
identification of a Li-ion battery, employing a nonlinear autoregressive with
exogenous inputs (NARX) model. The proposed approach integrates the
benefits of nonlinear modeling with the adaptability of the NARX structure,
facilitating a more comprehensive representation of the intricate
electrochemical processes within the battery. Experimental data collected
from a Li-ion battery operating under diverse scenarios are employed to
validate the effectiveness of the proposed methodology. The identified
NARX model exhibits superior accuracy in predicting the battery's behavior
compared to traditional linear models. This study underscores the
importance of accounting for nonlinearities in battery modeling, providing
insights into the intricate relationships between state-of-charge, voltage, and
current under dynamic conditions.
Smart grid deployment: from a bibliometric analysis to a surveyIJECEIAES
Smart grids are one of the last decades' innovations in electrical energy.
They bring relevant advantages compared to the traditional grid and
significant interest from the research community. Assessing the field's
evolution is essential to propose guidelines for facing new and future smart
grid challenges. In addition, knowing the main technologies involved in the
deployment of smart grids (SGs) is important to highlight possible
shortcomings that can be mitigated by developing new tools. This paper
contributes to the research trends mentioned above by focusing on two
objectives. First, a bibliometric analysis is presented to give an overview of
the current research level about smart grid deployment. Second, a survey of
the main technological approaches used for smart grid implementation and
their contributions are highlighted. To that effect, we searched the Web of
Science (WoS), and the Scopus databases. We obtained 5,663 documents
from WoS and 7,215 from Scopus on smart grid implementation or
deployment. With the extraction limitation in the Scopus database, 5,872 of
the 7,215 documents were extracted using a multi-step process. These two
datasets have been analyzed using a bibliometric tool called bibliometrix.
The main outputs are presented with some recommendations for future
research.
Use of analytical hierarchy process for selecting and prioritizing islanding ...IJECEIAES
One of the problems that are associated to power systems is islanding
condition, which must be rapidly and properly detected to prevent any
negative consequences on the system's protection, stability, and security.
This paper offers a thorough overview of several islanding detection
strategies, which are divided into two categories: classic approaches,
including local and remote approaches, and modern techniques, including
techniques based on signal processing and computational intelligence.
Additionally, each approach is compared and assessed based on several
factors, including implementation costs, non-detected zones, declining
power quality, and response times using the analytical hierarchy process
(AHP). The multi-criteria decision-making analysis shows that the overall
weight of passive methods (24.7%), active methods (7.8%), hybrid methods
(5.6%), remote methods (14.5%), signal processing-based methods (26.6%),
and computational intelligent-based methods (20.8%) based on the
comparison of all criteria together. Thus, it can be seen from the total weight
that hybrid approaches are the least suitable to be chosen, while signal
processing-based methods are the most appropriate islanding detection
method to be selected and implemented in power system with respect to the
aforementioned factors. Using Expert Choice software, the proposed
hierarchy model is studied and examined.
Enhancing of single-stage grid-connected photovoltaic system using fuzzy logi...IJECEIAES
The power generated by photovoltaic (PV) systems is influenced by
environmental factors. This variability hampers the control and utilization of
solar cells' peak output. In this study, a single-stage grid-connected PV
system is designed to enhance power quality. Our approach employs fuzzy
logic in the direct power control (DPC) of a three-phase voltage source
inverter (VSI), enabling seamless integration of the PV connected to the
grid. Additionally, a fuzzy logic-based maximum power point tracking
(MPPT) controller is adopted, which outperforms traditional methods like
incremental conductance (INC) in enhancing solar cell efficiency and
minimizing the response time. Moreover, the inverter's real-time active and
reactive power is directly managed to achieve a unity power factor (UPF).
The system's performance is assessed through MATLAB/Simulink
implementation, showing marked improvement over conventional methods,
particularly in steady-state and varying weather conditions. For solar
irradiances of 500 and 1,000 W/m2
, the results show that the proposed
method reduces the total harmonic distortion (THD) of the injected current
to the grid by approximately 46% and 38% compared to conventional
methods, respectively. Furthermore, we compare the simulation results with
IEEE standards to evaluate the system's grid compatibility.
Enhancing photovoltaic system maximum power point tracking with fuzzy logic-b...IJECEIAES
Photovoltaic systems have emerged as a promising energy resource that
caters to the future needs of society, owing to their renewable, inexhaustible,
and cost-free nature. The power output of these systems relies on solar cell
radiation and temperature. In order to mitigate the dependence on
atmospheric conditions and enhance power tracking, a conventional
approach has been improved by integrating various methods. To optimize
the generation of electricity from solar systems, the maximum power point
tracking (MPPT) technique is employed. To overcome limitations such as
steady-state voltage oscillations and improve transient response, two
traditional MPPT methods, namely fuzzy logic controller (FLC) and perturb
and observe (P&O), have been modified. This research paper aims to
simulate and validate the step size of the proposed modified P&O and FLC
techniques within the MPPT algorithm using MATLAB/Simulink for
efficient power tracking in photovoltaic systems.
Adaptive synchronous sliding control for a robot manipulator based on neural ...IJECEIAES
Robot manipulators have become important equipment in production lines, medical fields, and transportation. Improving the quality of trajectory tracking for
robot hands is always an attractive topic in the research community. This is a
challenging problem because robot manipulators are complex nonlinear systems
and are often subject to fluctuations in loads and external disturbances. This
article proposes an adaptive synchronous sliding control scheme to improve trajectory tracking performance for a robot manipulator. The proposed controller
ensures that the positions of the joints track the desired trajectory, synchronize
the errors, and significantly reduces chattering. First, the synchronous tracking
errors and synchronous sliding surfaces are presented. Second, the synchronous
tracking error dynamics are determined. Third, a robust adaptive control law is
designed,the unknown components of the model are estimated online by the neural network, and the parameters of the switching elements are selected by fuzzy
logic. The built algorithm ensures that the tracking and approximation errors
are ultimately uniformly bounded (UUB). Finally, the effectiveness of the constructed algorithm is demonstrated through simulation and experimental results.
Simulation and experimental results show that the proposed controller is effective with small synchronous tracking errors, and the chattering phenomenon is
significantly reduced.
Remote field-programmable gate array laboratory for signal acquisition and de...IJECEIAES
A remote laboratory utilizing field-programmable gate array (FPGA) technologies enhances students’ learning experience anywhere and anytime in embedded system design. Existing remote laboratories prioritize hardware access and visual feedback for observing board behavior after programming, neglecting comprehensive debugging tools to resolve errors that require internal signal acquisition. This paper proposes a novel remote embeddedsystem design approach targeting FPGA technologies that are fully interactive via a web-based platform. Our solution provides FPGA board access and debugging capabilities beyond the visual feedback provided by existing remote laboratories. We implemented a lab module that allows users to seamlessly incorporate into their FPGA design. The module minimizes hardware resource utilization while enabling the acquisition of a large number of data samples from the signal during the experiments by adaptively compressing the signal prior to data transmission. The results demonstrate an average compression ratio of 2.90 across three benchmark signals, indicating efficient signal acquisition and effective debugging and analysis. This method allows users to acquire more data samples than conventional methods. The proposed lab allows students to remotely test and debug their designs, bridging the gap between theory and practice in embedded system design.
Detecting and resolving feature envy through automated machine learning and m...IJECEIAES
Efficiently identifying and resolving code smells enhances software project quality. This paper presents a novel solution, utilizing automated machine learning (AutoML) techniques, to detect code smells and apply move method refactoring. By evaluating code metrics before and after refactoring, we assessed its impact on coupling, complexity, and cohesion. Key contributions of this research include a unique dataset for code smell classification and the development of models using AutoGluon for optimal performance. Furthermore, the study identifies the top 20 influential features in classifying feature envy, a well-known code smell, stemming from excessive reliance on external classes. We also explored how move method refactoring addresses feature envy, revealing reduced coupling and complexity, and improved cohesion, ultimately enhancing code quality. In summary, this research offers an empirical, data-driven approach, integrating AutoML and move method refactoring to optimize software project quality. Insights gained shed light on the benefits of refactoring on code quality and the significance of specific features in detecting feature envy. Future research can expand to explore additional refactoring techniques and a broader range of code metrics, advancing software engineering practices and standards.
Smart monitoring technique for solar cell systems using internet of things ba...IJECEIAES
Rapidly and remotely monitoring and receiving the solar cell systems status parameters, solar irradiance, temperature, and humidity, are critical issues in enhancement their efficiency. Hence, in the present article an improved smart prototype of internet of things (IoT) technique based on embedded system through NodeMCU ESP8266 (ESP-12E) was carried out experimentally. Three different regions at Egypt; Luxor, Cairo, and El-Beheira cities were chosen to study their solar irradiance profile, temperature, and humidity by the proposed IoT system. The monitoring data of solar irradiance, temperature, and humidity were live visualized directly by Ubidots through hypertext transfer protocol (HTTP) protocol. The measured solar power radiation in Luxor, Cairo, and El-Beheira ranged between 216-1000, 245-958, and 187-692 W/m 2 respectively during the solar day. The accuracy and rapidity of obtaining monitoring results using the proposed IoT system made it a strong candidate for application in monitoring solar cell systems. On the other hand, the obtained solar power radiation results of the three considered regions strongly candidate Luxor and Cairo as suitable places to build up a solar cells system station rather than El-Beheira.
An efficient security framework for intrusion detection and prevention in int...IJECEIAES
Over the past few years, the internet of things (IoT) has advanced to connect billions of smart devices to improve quality of life. However, anomalies or malicious intrusions pose several security loopholes, leading to performance degradation and threat to data security in IoT operations. Thereby, IoT security systems must keep an eye on and restrict unwanted events from occurring in the IoT network. Recently, various technical solutions based on machine learning (ML) models have been derived towards identifying and restricting unwanted events in IoT. However, most ML-based approaches are prone to miss-classification due to inappropriate feature selection. Additionally, most ML approaches applied to intrusion detection and prevention consider supervised learning, which requires a large amount of labeled data to be trained. Consequently, such complex datasets are impossible to source in a large network like IoT. To address this problem, this proposed study introduces an efficient learning mechanism to strengthen the IoT security aspects. The proposed algorithm incorporates supervised and unsupervised approaches to improve the learning models for intrusion detection and mitigation. Compared with the related works, the experimental outcome shows that the model performs well in a benchmark dataset. It accomplishes an improved detection accuracy of approximately 99.21%.
artificial intelligence and data science contents.pptxGauravCar
What is artificial intelligence? Artificial intelligence is the ability of a computer or computer-controlled robot to perform tasks that are commonly associated with the intellectual processes characteristic of humans, such as the ability to reason.
› ...
Artificial intelligence (AI) | Definitio
Null Bangalore | Pentesters Approach to AWS IAMDivyanshu
#Abstract:
- Learn more about the real-world methods for auditing AWS IAM (Identity and Access Management) as a pentester. So let us proceed with a brief discussion of IAM as well as some typical misconfigurations and their potential exploits in order to reinforce the understanding of IAM security best practices.
- Gain actionable insights into AWS IAM policies and roles, using hands on approach.
#Prerequisites:
- Basic understanding of AWS services and architecture
- Familiarity with cloud security concepts
- Experience using the AWS Management Console or AWS CLI.
- For hands on lab create account on [killercoda.com](https://killercoda.com/cloudsecurity-scenario/)
# Scenario Covered:
- Basics of IAM in AWS
- Implementing IAM Policies with Least Privilege to Manage S3 Bucket
- Objective: Create an S3 bucket with least privilege IAM policy and validate access.
- Steps:
- Create S3 bucket.
- Attach least privilege policy to IAM user.
- Validate access.
- Exploiting IAM PassRole Misconfiguration
-Allows a user to pass a specific IAM role to an AWS service (ec2), typically used for service access delegation. Then exploit PassRole Misconfiguration granting unauthorized access to sensitive resources.
- Objective: Demonstrate how a PassRole misconfiguration can grant unauthorized access.
- Steps:
- Allow user to pass IAM role to EC2.
- Exploit misconfiguration for unauthorized access.
- Access sensitive resources.
- Exploiting IAM AssumeRole Misconfiguration with Overly Permissive Role
- An overly permissive IAM role configuration can lead to privilege escalation by creating a role with administrative privileges and allow a user to assume this role.
- Objective: Show how overly permissive IAM roles can lead to privilege escalation.
- Steps:
- Create role with administrative privileges.
- Allow user to assume the role.
- Perform administrative actions.
- Differentiation between PassRole vs AssumeRole
Try at [killercoda.com](https://killercoda.com/cloudsecurity-scenario/)
KuberTENes Birthday Bash Guadalajara - K8sGPT first impressionsVictor Morales
K8sGPT is a tool that analyzes and diagnoses Kubernetes clusters. This presentation was used to share the requirements and dependencies to deploy K8sGPT in a local environment.
Optimizing Gradle Builds - Gradle DPE Tour Berlin 2024Sinan KOZAK
Sinan from the Delivery Hero mobile infrastructure engineering team shares a deep dive into performance acceleration with Gradle build cache optimizations. Sinan shares their journey into solving complex build-cache problems that affect Gradle builds. By understanding the challenges and solutions found in our journey, we aim to demonstrate the possibilities for faster builds. The case study reveals how overlapping outputs and cache misconfigurations led to significant increases in build times, especially as the project scaled up with numerous modules using Paparazzi tests. The journey from diagnosing to defeating cache issues offers invaluable lessons on maintaining cache integrity without sacrificing functionality.
The CBC machine is a common diagnostic tool used by doctors to measure a patient's red blood cell count, white blood cell count and platelet count. The machine uses a small sample of the patient's blood, which is then placed into special tubes and analyzed. The results of the analysis are then displayed on a screen for the doctor to review. The CBC machine is an important tool for diagnosing various conditions, such as anemia, infection and leukemia. It can also help to monitor a patient's response to treatment.
International Conference on NLP, Artificial Intelligence, Machine Learning an...gerogepatton
International Conference on NLP, Artificial Intelligence, Machine Learning and Applications (NLAIM 2024) offers a premier global platform for exchanging insights and findings in the theory, methodology, and applications of NLP, Artificial Intelligence, Machine Learning, and their applications. The conference seeks substantial contributions across all key domains of NLP, Artificial Intelligence, Machine Learning, and their practical applications, aiming to foster both theoretical advancements and real-world implementations. With a focus on facilitating collaboration between researchers and practitioners from academia and industry, the conference serves as a nexus for sharing the latest developments in the field.
2. IJECE ISSN: 2088-8708
Functional Verification of Large-integers Circuits using a Cosimulation-based Approach (Nejmeddine Alimi)
2193
assertion languages. The goal was to make a complementary technology to the simulated-based one so that
the overall verification methodology could be enhanced.
Regarding simulation-based verification, running testbench in an HDL simulator is the common
approach to verify hardware designs and HDL packages (e.g. VHDL, Verilog, etc.) provide a range of
functions intended to help writing testbenchs. But, to the best of our knowledge, among those packages as
well as functional verification frameworks (e.g. Specman, Jove, etc.), there is no dedicated Application
Programming Interface (API) supporting large-integers operations. A workaround consists on verifying
against equivalent program written at a high-level language. Such programs are run on softwares called
Computer Algebra Systems (CAS) that supports a non-limited precision like MAPLE, MATHEMATICA and
the GMP library. In addition to CAS, there exist a number of domain-specific libraries like Crypto++ and
MIRACL that supplement traditional high level programming languages with large-integer support to target
specific domains like cryptography. Although using CAS and specific libraries to verify HDL designs may
meet the functional verification purpose for very basic and unit-level designs, it remains insufficient for more
complex designs. In fact, because the verification flow is disjoined (DUV and CAS are not ran
simultaneously), the verifcation and interaction with the Design Under Verification (DUV) is limited. On the
other hand, the large-integer data to be used as stimuli to DUV and CAS has to be constant and stored
beforehand. Therefore, guided testbenchs techniques with dynamic updated stimuli cannot be applied.
Co-simulating DUV and its Reference Model requires an efficient communication between the high-
level testbench and the HDL simulator. In this context, some works have been done. For example, the
cosimulation of VHDL designs and a C-based testbench using the Foreign Language Interface (FLI) provided
by ModelSim simulator was proposed in [13]. Similar projects based on FLI and/or PLI (for Verilog) and
written in other high-level languages (e.g. Python) were proposed in [14] and [15]. However because such
languages are architecture limited size, large-integer support in not supported natively. In the other hand,
formal verification techniques for large-integer HDL were applied in simple cases in [16], [17]. Despite
their proved performance, those frameworks remain insufficient to verify large-integer HDL designs of
certain complexity in standalone. In another hand, some works on large-integers using Matlab/Simulink, the
powerful pair of numerical computing and simulation softwares, have been conducted in the design field. As
examples, in [18]–[20] authors speeded up hardware implementations of cryptographic designs by modelling
the schemes in Simulink and generating synthesizable HDL using dedicated tools like HDL coder. Examples
of working around the size restriction has been reported in [18],where authors divided the large operands into
smaller size to take advantage of hardware DSP‘s multiplication capabilities in the target FPGA. In the same
context, in [19], authors used specific multiplication algorithm with a property of splitting up operands into
small size words. While in [20], authors bounded the operand sizes to ordinary bit-length to optimize the
HDL code generation in order to achieve efficient throughput. In verification, Matlab was separately used to
verify ECC (Elliptic Curve Cryptography) designs in [21] and [22] but no details on the evaluation process
or the interfacing with the HDL design were given.
Three challenges are still to take for designs involving large-integers: how to support a hardware
design testbench without size restriction? How to perform verification for complex designs where operations
run at different levels, and how to set the verification structure to verify the full design? In this paper, which
is a revised and extended version of the work presented in [23], we try to draw a path for a solution to those
challenges by introducing a high-level simulation-based verification platform based on Matlab and Simulink.
Besides generating stimuli and monitoring the verification flow, large integer‘s transactions and processing
are supported within the proposed platform. The platform features a high level generation of testbench, a
cross-level and a cycle-accurate verification. Furthermore, Matlab‘s support for large-integer, using its
Variable Precision Integer Arithmetic (VPI) package, is exploited. To complete the verification of a given
design, the control logic part of a DUV is verified formally using the same HDL simulator.
The rest of the paper is organised as follows, section 2 details the proposed platform where the
verification structure, data transformation across stages and the process of settings and controlling the
platform are explained. In section 3, a detailed testcase is given to illustrate the working of the platform
followed by results and discussion. Finally, a conclusion with future works ends the paper.
2. THE PROPOSED PLATFORM
2.1. Overview
The design methodology of the platform follows the Simulation-based approach, where stimuli are
generated, applied to the DUV and responses are compared to the expected ones. Typical verification
framework based on high level design language includes a stimuli generator, a Reference model (also
referred to as Golden Model) which is usually written at a higher level of abstraction, and a comparator. We
abstract the functional description of the platform into three flows, i.e., control flow, data flow and
3. ISSN: 2088-8708
IJECE Vol. 7, No. 4, August 2017 : 2192 – 2205
2194
verification flow, as shown in Figure 1. The Control flow controls the process of verification through the
platform. It fixes the settings; i.e. the parameters of the blocks constituting the platform, delay times,
sampling times, etc. Data flow represents the transformations that data undergoes, starting from the
generation of large-integer operands, passing through the input adapter, the DUV, the output adapter and,
finally, entering the comparison/checking blocks. The third flow, Verification flow, verifies the functional
correctness of the DUV. We chose to build the verification flow around two complementary simulation-
based verification approaches: testbench and assertion-based verification. We guide the testbench via a
verification structure with considerations of a coverage plan. When testbench is launched, outputs of DUV
and reference model are compared. Results are then transferred to a Scoreboard to be analyzed. We write
assertions in Property Specification Language (PSL) [24], standard assertion language, inside the DUV and
represent a precise description of the DUV‘s behavior. Note that we chose PSL for property description as
it‗s in widespread use in industry and compatible with many hardware description languages. PSL assertions
are checked by the HDL simulator during the simulation. The assertions verification results (pass/fail) are
also sent to the scoreboard to be analyzed and new stimuli are generated in the next testbench according to
the updated functional coverage.
Figure 1. Functional Description of the platform.
2.2. The Functional Verification Process
The purpose of the ―Functional‖ verification process is to verify that the DUV matches its
specification. This process should verify that the implemented functions behave correctly. The verification
technology used is the simulation-based verification, more precisely a cosimulation between
Matlab/Simulink and ModelSim, and simulated assertions written in PSL.
Globally, we followed a coverage-driven random-based verification approach. The level of
verification can be of unit/sub-unit or cores/blocks level and two simulation-based verification techniques are
used jointly, depending on the partition of DUV being verified. In fact, a common practice in the integrated
circuits design community is to divide designs into datapath and control logic (Figure 2). Because of their
differences, appropriate verification schemes can be applied to each. Datapath units which involve large-
integers processing can be verified using the Matlab/Simulink testbench where large-integers are supported
as will be detailed in the next section. Datapath usually consists of uniform arrays of cells, such as bits in a
register file, slices in an adder and so on. The remaining logic is regarded as control logic.
4. IJECE ISSN: 2088-8708
Functional Verification of Large-integers Circuits using a Cosimulation-based Approach (Nejmeddine Alimi)
2195
Figure 2. Datapath and control logic partition for verification
An advantage of using HDL cosimulation with Matlab/Simulink testbench is the possibility of
cross-level datapath verification, as will be more detailed later. This means that data‘s output of different
hierarchical level can be probed and compared in run-time against Matlab models. On the other hand, control
logic can be accurately specified by properties and assertions, and thus is verifiable using PSL. The DUV‘s
control logic is specified by a set of proprieties written in PSL assertions.
The verification structure is the set of Matlab Function Blocks within the platform in charge of the
verification plan. Figure 3 represents the architecture of the ―Verification structure‖. The latter is divided in
two block sets, connected to form a loop with the rest of the platform. The first set is composed of stimuli
generation blocks while the second is composed of analysis blocks (―Comparator‖, a ―Checker‖ and a
―Scoreboard‖). Within the first, the Data output of the DUV (Z_DUV), is verified against the Reference
Model output (Z_Ref), the result of the comparison is transferred to the Scoreboard. According to the
feedback, the first set generates new stimuli corresponding to the next coverage step and/or to the next
property to be verified. The DUV is here a modular arithmetic operation. The objective is to ensure that DUV
matches its specification.
The functional verification approach is a white-box approach (i.e. the HDL design is known to the
verifier). Because of sampling time difference, control signals and data were assigned to separate blocks
(Figure 3). Both blocks are driven by a block called ―Testbench Scenario Update‖. The role of the latter is to
update control signals and data according to verification coverage.
Figure 3. The verification structure
Inside the Data block, a Random Number Generator (RNG) produces constrained random large-
integer data (X,Y operands) using a VPI seed value. An overview of the functioning of the platform‘s blocks
is given in Table 1. The comparator receives data from DUV and Reference Model, converts it to VPI data
type, makes the comparison, and finally transfers the result to the Scoreboard. Sub-DUV Checker checks the
functional correctness of internal operations of DUV. It receives the probed metadata from the DUV,
5. ISSN: 2088-8708
IJECE Vol. 7, No. 4, August 2017 : 2192 – 2205
2196
converts it to VPI data type, calculates the internal operation bit-wise as a reference operation, makes the
comparison and finally transfers the result to the Scoreboard. As illustrated in Figure 3, the comparator and
the Sub-DUV Checker update the scoreboard with results as long as the cosimulation is going on. The control
logic verification, not represented in Figure 3, is done with PSL assertions simulated in the HDL Simulator.
Table 1. Functioning of platform blocks
Phase Block Corresponding pseudo-code
StimulipreparationandGeneration
Test-
bench
Scenario
Update
new_seed=Compute_seed(feedback(i)) //constraint on seed to hit specific data interval
Do{
CRLI_1 = randint(vpi(new_seed)); (*) // CRLI = Constrained Random Large-Integer
CRLI_2 = randint(vpi(new_seed));
OK = Verify_seed (new_seed, CRLI_1,CRLI_2); } // to verify that RLI is constrained as desired
While (NOT (OK)) // RLIs do not match the desired interval.
Signals
Reset <= ‗1‘;
When T = T0, Reset <= ‗0‘; // T0 = n0 * CLK Cycles
When T = T1, Start_frames <= ‗1‘ // T1 = n1 * CLK Cycles
When T = T‘1, Start_frames <= ‗0‘; // T’1 = T1 + 1 CLK Cycle
Data
X<= VPI_to_binary_matrix(CRLI_1);
Y<= VPI_to_binary_matrix(CRLI_2);
Signals
When T = T2, Start <= ‗1‘ // T2 = n2 * CLK Cycles
When T = T‘2, Start <= ‗0‘; // T’2= T2 + 1 CLK Cycle
Reference Model
X_vpi<= binary_matrix_to_VPI(X); // inside the Reference Model
Y_vpi<= binary_matrix_to_VPI(Y); // inside the Reference Model
Z_Ref<= Reference_Model(X_vpi,Y_vpi); // inside the Reference Model
Verificationexecutionandanalysis
Compar-
ator
Compare_res <= (Z_DUV == Z_Ref)?
Sub-DUV
Checker
Op_i,…,Op_k<= binary_matrix_to_VPI(Probe_i,…,Probe_k); // Operands of a selected internal operation
are probed from DUV
Int_Matlab_output<= Internal_operation(Op_i,…,Op_k); // The equivalent Matlab operation is calculated.
Int_DUV_output<= binary_matrix_to_VPI(Probe_n); // The result of the internal operation is also probed
Check_res<=(Int_DUV_output ==Int_Matlab_output)? // results are compared
Property
assertions
(**)
…
psl assert_done_pulse : assert always({done} |->
next {!done} abort !RST_N) @ (posedge CLK);-- signal DONE is a pulse of one clock cycle
…
Score-
board
Data_ coverage=Measure_coverage(Compare_res,Check_res,CRLI_(coverage_step ),
Total_Assertions_coverage)
feedback(i+1)=Compute_new_testbench_scenario(Data_ coverage);
* randint() is a random and uniformly distributed VPI number.
** ―Property Assertions‖ is not a block of the platform; it runs in HDL simulator.
2.3. Large-integer Data Processing
Large-integers data processing is an important part of the platform. Processing is carried out in
Matlab, Simulink and simulated hardware. We assume that the platform, shown in Figure 4, verifies the
operation f: Z = f(X,Y), where: X, Y and Z are three large-integers. Control signals are reset and start. Done is
an output signal that indicates the end of the DUV‘s operation. Simulation control is handled by Simulink.
The co-simulation stage (stage 5 in Figure 4) contains the Reference Model and the DUV. The
Reference Model is the DUV‘s equivalent model written in Matlab inside a Matlab Function block. The
DUV is represented by the HDL Cosimulation block. The DUV‘s simulator (ModelSim) is launched and
linked to Simulink using a Matlab code based on a TCL script. When communication is established, the
simulator functions as the server and Simulink as a client. The HDL simulator responds to simulation
requests it receives from the Simulink Client. The communication between the HDL Simulator and Simulink
is done through the HDL Verifier™ tool. The maximum length of integer data types supported by HDL
Cosimulation Block in Simulink is 128-bits. To work around this limitation, the DUV was masked in an
HDL wrapper that stacks the received data frames into a logic vector that matches the input data size of the
DUV and vice-versa for the output data. Two kinds of adapters were used in the platform (Frontend and
Backend adapters). The first one adapts data and control signals received in Matlab/Simulink formats to
DUV supported formats. Within this stage, each data matrix is converted into a sequence of scalars using the
Simulink‘s block ―Unbuffer‖. The Unbuffer unbuffers an M-by-N input into a 1-by-N output (Figure 5(a)).
That is, inputs are unbuffered row-wise so that each matrix row becomes an independent time-sample in the
6. IJECE ISSN: 2088-8708
Functional Verification of Large-integers Circuits using a Cosimulation-based Approach (Nejmeddine Alimi)
2197
output. As example, a 192-bit data fits into a 24-by-8 matrix, and the Unbuffer Block will unbuffer the 24-
by-8 input into an 8-bit length vector. Then, each data is converted to standard logic vector via the ―Data
Type Conversion‖ block. The Backend adapter adapts data and signals from DUV to the Comparator and
Checker blocks. In this stage, the HDL block output data is re-buffered into a decimal matrix using a
Simulink block ―Delay Line‖. The latter performs the reverse task of the ―Unbuffer Block‖, rebuffering a
sequence of Mi-by-N matrix inputs into a sequence of Mo-by-N matrix outputs (Figure 5(b)).
Figure 4. Block diagram of the proposed verification platform
Figure 5. The adapters
An attention should be given to the reading time of the ―Delay Line‖ output so that the data matrix
can be read entirely. In fact, the DUV wrapper, detailed in a latter paragraph, was designed to send each of
Z_DUV frames at every clock‘s positive edge starting from instant when the output signal ―done‖ is on and
according to the ―Delay Line‖ Block functioning, the entire matrix representing Z_DUV can be read by the
Comparator Block at time T calculated in formula 2:
T=Time(done=1)+Nbr_of_Z_frames*T(Z_sample_period) (2)
Unbuffer
N
M ...
N N
M
DUV Input
(HW)
Data Type
Conversion
Delay
Line
...
N N
Mi = 1
DUV ouput
(HW)
N
Mo
(a) The Frontend Adapter
(b) The Backend Adapter
Data matrix
Data frames
Data frames
Data matrix
Unbuffer
Data Type
Conversion
7. ISSN: 2088-8708
IJECE Vol. 7, No. 4, August 2017 : 2192 – 2205
2198
Where: Time(done=1) is the time when done is set to ‗1‘, Nbrof Z frames is the total number of Z frames outputted
from HDL Block, and T (Z sample period) is the sampling time of Z.
The Figure 6 illustrates the communication between Simulink and the DUV via the wrapper. As
shown, Inputs (reset, start_frames, start, X, Y) are stimuli from Matlab/Simulink, while Outputs (Done,
Z_DUV, Probe1… Probe n) are results sent back to Matlab/Simulink for comparison and internal checking.
The start_frames is an extra input to the DUV Wrapper to control the reception of frames from Data block.
The role of the Wrapper is to handle a cycle-accurate transfer of data between Simulink and the
DUV without modifying the latter‘s description. The wrapper , written in VHDL, is based on an Input
converter and two Output converters. One dedicated to DUV‘s result, the other to internal signals (Figure 7).
Figure 6. UML sequence diagram of Simulink – HDL block communication
Figure 7. The HDL Cosimulation block data flow
As illustrated in Figure 8(a), The ―Input Converter‖ module receives data (X,Y) from
Matlab/Simulink, stacks the w-bit length frames (fi) into Standard logic vector. The m-bit matching the size
of the expected DUV input data size (f0 to fk frames) are extracted (―unpadding‖ operation). When the
8. IJECE ISSN: 2088-8708
Functional Verification of Large-integers Circuits using a Cosimulation-based Approach (Nejmeddine Alimi)
2199
―Output Converter‖ module receives the result, bits are added to the logic vector to bring it to the required
size (fk+1 to fn frames) (―padding‖ operation). Then, the logic vector is sent in w-bit frames to the next stage
(Figure 8(b)). Similarly, the ―Debug Converter‖ module brings DUV‘s internal signals to the next stage.
Figure 8. The DUV‘s Wrapper units.
2.4. Platform Control, Settings and Execution
An essential side of the platform is the control and settings. Platform control consists in controlling
the execution of the testbench by scheduling the stimuli to the DUV/Reference Model and the outgoing
signals/data to be verified. The challenge here is to synchronize the Matlab/Simulink blocks, which are
inherently untimed, with an RTL-level design running in an event-based simulator (ModelSim). The Platform
Control process is abstracted in the timed finite state machine (TFSM) represented in Figure 9.
Figure 9. The finite state machine of the Platform Control
Because Matlab Function Block, and Matlab language in general, is untimed, the timing and the
delivery of the data is controlled by the HDL simulator (when Matlab Function Block is located after the
DUV) and/or by the Block‘s sampling time setting (when Matlab Function Block is located forward). Using a
Simulink Digital Clock, the stimuli (control signals and data) are generated in specific simulation times. The
transition delay times between the TFSM states are presented in Table 2.
Platform settings are the settings of parameters related to each block of the platform. That is, the
Simulink blocks parameters (Unbuffer, Delay Line, etc.) and the sampling times for Matlab function blocks
(Verification structure blocs). A graphical user interface (GUI) was developed to facilitate this task.
In addition to the choice of Simulink blocks and algorithms inside Matlab Function blocks, the
functioning of the platform relies on the timing settings. In fact, for each block, a sample time needs to be
specified. In Simulink, the sample time of a block is a parameter that indicates when, during simulation, the
block is active and if appropriate, updates its internal state. For HDL cosimulation Block, a sample time has
X
Y
X
Y
m
m
Reception Unpadding
Clk
reset
start_frame
done
Z
w
Z
w
w
m
TransmissionPadding
+...
f0
+
fk
w w
+...+
fn
w
+...
f0
+
fk
w w
+...+
fn
w
+...
fk
+
fn
w w
+...
f0
+
w
(a) The input converter
(b) The output converter
Data vectors
Data frames
Data vector
Data frames
...
f0f1fk
m
...
f0f1fk
m
...
f0f1fk
m
Start data
generation
process
Start test
bench
params
update
reset
reset = 0
reset = 1
start_frames = 1
sim_time = T0 sim_time = T1
Start data
generation
process
- finished
start_frames = 0
sim_time = T1' sim_time = T2
Start
Large-int
operation
start = 1
sim_time = T2'
Large-int
operation
start = 0
Start test
bench
params
update
- finished
Update = 1
Update = 0
sim_time = Tp
wait T1 wait T1'
wait T0
wait T2
wait T2'
wait Tp wait Tf
Comparison
&
verification
wait Td
init
Process results
& display
idle
sim_time = Tf sim_time = Td
9. ISSN: 2088-8708
IJECE Vol. 7, No. 4, August 2017 : 2192 – 2205
2200
to be set for each input/output. Sample times of platform blocks were set to HDL clock period except the
―reference model‖ whom the execution depends on the triggering signal received from the Stimuli Generator
Block. The sample time of Data block can be calculated using formula 5 derived from formula 4:
UBO_Sample_Time = UBI_Sample_Time / Data Matrix_rows_Nbr (4)
Where UBO is ―Unbuffered Block Output‖
UBI_sample_time = DUV_clk_period * Data Matrix_rows_Nbr (5)
Where UBI is ―Unbuffered Block Input‖
As UBI is connected to Data block, the value of Data block‘s sample time is the same as that of
UBI. Because the Unbuffer only accepts fixed-size input, output of Data sub-block cannot be set to variable
size type. Therefore, data bit-size (operands) has to be set manually by user for different operands bit-size. In
practice, Sample time can be set automatically by working around the restriction of the Unbuffer. To do so,
the size of all data transferred between blocks in the platform are chosen as a constant that holds all standard
sizes of finite-field commonly used in Public-key Cryptography (for instance, 1024). Therefore, the Number
of data matrix rows is also a constant (fixed size-input) and the Sample Time of UBI, becomes only DUV‘s
Clock dependent. The choice of a unique size simplifies the transmission/reception of data inside each block
and only bits corresponding to operands real size (e.g. 192-bit) are used. This task is done by the Wrapper as
it brings operands to the required size by the padding and unpadding processes previously detailed. User has
to place the VHDL design code(s) inside a specific folder for co-simulation, adjust wrapper‘s parameters to
the size of the HDL design operands and connect wrapper‘s probes (outputs) to desired DUV‘s internal
signals. The Output Data Adapter, represented by the Simulink block ―Delay Line‖, executes the reverse task
of the Unbuffer Block. That is, it transforms a sequence of data frames into a matrix.
When verification is launched, PSL assertions test results are processed in Matlab workspace. Then,
results are carried to Scoreboard along comparator and checker results. The Scoreboard computes the new
verification coverage and generates a feedback summarizing the coverage. According to the feedback, a new
testbench scenario and parameters targeting the uncovered assertions and/or datapath logic not yet verified
are set. Then, the next testbench will be ready to run.
Table 2. Time Periods of the TFSM
Delay time symbol Significance Value
T0 Time to wait before starting a new test T0 = n0 * CLK Cycles
T1 Time to wait before Starting Data generation process T1 = n1 * CLK Cycles
T2 Time to wait before Starting Data generation process T2 = n2 * CLK Cycles
Td Time to wait before Done = 1 Td = nd * CLK Cycles
Tf Time to wait before Feedback is ready Tf = nf * CLK Cycles
Tp Time to wait before Testbench Parameters are updated Tp = nd * CLK Cycles
Tx‘ One clock cycle after Tx Tx‘ = Tx + CLK Cycle
2.5. Verification Platform with FPGA in-the-loop
Another aspect of reusability of the proposed platform is the possibility to switch from HDL
cosimulation to real hardware testing while keeping the same verification platform. This option was tested
with the ―Hardware-in-the-loop‖ (HIL) option provided by Simulink for FPGA boards equipped with Gigabit
Ethernet port (an Altera DE2-115 board with Cyclone IV EP4CE115 FPGA was used). This way enables
controlling and verifying a design (a modular multiplier, more details in section 3) running on FPGA from
the Matlab/Simulink platform with the design‘s real execution time (Figure 10). However, this came at a cost
as that internal verification (Sub-DUV Probing) becomes inaccessible due to the FPGA development‘s tool
restrictions on design‘s coding style and wrapping.
To conclude this section, Table 3 gives a comparison between the present work and similar works
from literature. The Table shows that the proposed platform while sharing some features with other works
(supported HDL, cosimulation, etc.), stands out with more powerful HVL, unrestricted large-integer support
and adaptability to HIL.
10. IJECE ISSN: 2088-8708
Functional Verification of Large-integers Circuits using a Cosimulation-based Approach (Nejmeddine Alimi)
2201
Figure 10. Verification Platform with FPGA-in-the-loop
Table 3. Comparison with similar verification platforms
Verification
environment
HW Verification
Language (HVL)
Supported
HDL
Interfacing with
Simulator
Cosimulation with
VHDL simulator
Large-integer
support
DUV in
Hardware
[13] C VHDL FLI Yes Limited No
[14] Python VHDL/Verilog FLI/VPI Yes Limited No
[15] Python Verilog VPI No Limited No
[25] Python Verilog VPI No Limited No
[26] Ruby Verilog VPI No Limited No
This Work Matlab/Simulink VHDL/Verilog
HDL Verifier®
+ Wrapper
Yes Unlimited Yes (HIL)
VPI : Verilog Procedural Interface, FLI : Foreign Language Interface,
PLI : Procedural Language Interface , HIL : Hardware-in-the-loop.
3. CASE STUDY & RESULTS
As case study of the platform, we consider the operation Z = f(X,Y) , where X, Y and Z are three
large-integers. Control signals are reset and start, while Done is an output indicating the end of the operation.
The goal is to evaluate the cost of the bit-size, the number of assertions and the internal signal probing on the
platform.
3.1. Large-integer Arithmetic Background
Large-integer arithmetic has a variety of applications in cryptography. Among these, AES, RSA and
ECC. As illustrated in the Figure 11, ECC schemes are based on Point operations, primarily on the point
multiplication and also on the operations on which it point multiplication relies, i.e. point addition and
doubling. In turn, those point operations are made on finite-fields arithmetic, a particular field of large-
integers. This implies that finite-field arithmetic are determinant to design an efficient elliptic curve
cryptosystem. Finite-field arithmetic is the arithmetic of integers modulo a large prime p. Arithmetic in a
finite-field is different from standard integer arithmetic and all operations performed in the finite-field result
in an element within that field. Three kinds of fields that are used for efficient implementation of ECC
systems are prime fields (Fp), binary fields (F2
m
), and optimal extension fields (Fp
m
). Those fields were
extensively studied and this has resulted in numerous algorithms. Finite-field arithmetic is a practical
example of large-integer arithmetic usage and is the cornerstone of cryptographic schemes such as ECC.
11. ISSN: 2088-8708
IJECE Vol. 7, No. 4, August 2017 : 2192 – 2205
2202
Figure 11. Hierarchy of required underlying operations
3.2. The DUV
A hardware implementation of a Finite-field multiplication algorithm called the ―Double, add, and
reduce‖ (DAR) multiplier [27] was used as a DUV. The DAR multiplier is based on the Interleaving
Multiplication Algorithm [28]. Given a k-bit natural x and a natural y the product z = x . y can be computed
as follows formula 6:
x.y = (xk-1 2k-1
+ xk-2 2k-2
+ … +x0 20
).y (6)
The latter can also be expressed as in formula 7:
x.y = (… ((0.2+ xk-1 y )2+ xk-2 y)2+…+ x1y)2+x0y (7)
If all operations (addition and doubling) are executed mod m, the result is product = x .y mod m.
The corresponding (left to right) algorithm, written in ADA syntax, is presented in Listing 1. The function
―mod_m_addition(x, y, m, k)‖ computes x + y mod m ; x, y, and m being k-bit numbers, according to the
binary mod m Addition. This unit of the datapath represents an internal large-integer operation. In the design,
operands were set to recommended sizes (192, 384, 512, 1024) for cryptographic use by the NIST [29].
Listing 1 Double, add, and reduce (DAR) algorithm.
p := 0 ;
for i in 0 .. k-1 loop
p := mod_m_addition(p, p, m, k);
if x(k-i-1) = 1 then
p := mod_m_addition(p, y, m, k);
end if;
end loop;
product := p;
The datapath and a part of control logic corresponding to the hardware description of Algorithm 1
are shown in Figure 12. The DUV is an ideal case for the platform testing with internal large-integer
operation and a distinct control units and datapath. In practice, in addition to the functional validation
(comparing DUV against reference model), each partition modules were verified. For datapath, ―Mod m
Adder‖ module was the target of internal checking while the control logic units were verified with PSL
assertions.
12. IJECE ISSN: 2088-8708
Functional Verification of Large-integers Circuits using a Cosimulation-based Approach (Nejmeddine Alimi)
2203
Figure 12. The DAR multiplier (DUV)
3.3. Tests, Results and Discussion
The DAR multiplier was verified with the platform on an 32-bit Intel Pentium Dual-Core processor
(2,5 GHz, 2GB RAM, 2MB cache memory). The goal is to measure the cost over time of the bit-size, the
number of assertions and the number of probes. A campaign of tests was carried out for each parameter.
Detailed execution times of the platform as a function of operands sizes were measured using
Simulink's Profiler. The results are presented in Figure 13. The latter shows that the total recorded time
increases quite linearly with operands size but is still acceptable for an operation on 1024-bit. For the four
bit-sizes, the "HDL co-simulation block" occupies a small portion of the execution time (between 2.81 % and
5.18%) and remains rather constant. As can be seen in the same figure, the total recorded time is dominated
by the initialization in average sizes (192 and 384). This aspect decreases in larger sizes in favor of the group
of blocks " data, Scoreboard, and testbench Updater" reaching ≈40% of the total recorded time for 1024-bit
size. This can be explained by the fact that the time used to the guided generation, adaptation and
transmission of data stimuli increases with bit-size. It should be noted that in order to get a correct measure of
bit-size cost, data across the platform was transmitted/received in the exact bit-size without using the
padding/unpadding operations and related automated settings.
Figure 13. Execution time (in sec) of platforms‘ blocks
In order to evaluate the impact of the PSL assertions on the execution time of the platform,
measurements of the latter function of the number of PSL assertions were made and the results, for the 4
sizes, were plotted in Figure 14. To reach a high number of assertions, the assertions of the testcase were
replicated. As shown in the in the four curves, the number of PSL assertions checked during co-simulation is
fairly stable for assertions below 40 PSL assertions. From 40 assertions, the execution time increases
linearly but with a low slope for the 4 curves (0.0052 <αi <0.0381; i = 192; 384; 512; 1024). It can be
13. ISSN: 2088-8708
IJECE Vol. 7, No. 4, August 2017 : 2192 – 2205
2204
concluded that the PSL assertions increase the execution time but the more the number gets larger (> 100),
the more the impact on time is limited. It should be noted that the ―steep slope‖ aspect of the curve is due to
the high steps taken, on the horizontal axis, from the 200th
assertion.
To evaluate the impact of the number of Probes on the execution time, measurements of the
platform time for a fixed DUV bit-size (1024 bit) function of the number of probes were made and the results
are shown in Figure 15. In this test, the outputs of the "HDL co-simulation" block, the number of sub-blocks
of the "Backend Adapter" stage and the inputs of the "Checker" were adjusted to match the corresponding
number of probes. According to results, when the number of probes increases, the execution time increases
linearly but with a low slope (α ≈ 0.4). It can be said that the number of probes increases the execution time
of the verification process but does not penalize it especially because a small number of probes is generally
needed for verification.
Analysis of the three tests campaign results indicates that the parameters (bit-size, number of
assertions and number of probes) has only a moderate impact on the execution time of the verification
platform, thus justifying its efficiency.
Figure 14. Platform's execution time (in sec) as a
function of PSL assertions
Figure 15. Execution Time (in sec) as a function of
number of probes
4. CONCLUSION
In this paper, we have presented a novel platform intended to verify hardware large-integer based
designs, the first one based on Matlab/Simulink to the best of our knowledge. We demonstrated that the
proposed platform holds a number of interesting aspects for the task of verification. First, this is run time and
cycle-accurate verification. Second, flexibility, where minor adjustments in Matlab/Simulink blocks
parameters, different bit-length can be verified with a moderate impact on execution time. Besides, testbench
scenarios are adjustable to meet desired verification coverage where datapath and control logic can be
verified simultaneously and in different level of the design hierarchy. Third, reusability: In this paper, we
developed testcase on finite-field arithmetic but we also tested the platform to verify a scalar multiplication
(Figure 11) this proves that the platform is adapted to more complex systems like cryptographic primitives.
Future work will involve improvements like reducing synchronisation and data transfer overhead,
limiting the complexity of the wrapping module, and enabling internal verification in HIL. Furthermore, an
interesting area of application of the platform that would need further efforts is the verification of designs
under development, with possibility of replacing unachieved blocks with equivalent Matlab/Simulink
models. Another extension of the platform, in the field of cryptanalysis, could be using Matlab‘s data
processing features to verify design robustness to side-channel and fault injection attacks in HIL.
REFERENCES
[1] R. L. Rivest, A. Shamir, and L. Adleman, ―A method for obtaining digital signatures and public-key
cryptosystems,‖ Communications of the ACM, vol. 21, no. 2, pp. 120–126, Feb. 1978.
[2] Victor S. Miller, ―Use of Elliptic Curves in Cryptography,‖ in Advances in Cryptology — CRYPTO ’85
Proceedings, 1986, vol. 218.
[3] N. Koblitz, ―Elliptic curve cryptosystems,‖ Mathematics of Computation, vol. 48, no. 177, pp. 203–203, Jan. 1987.
[4] Y. Kong, S. Asif, and M. A. U. Khan, ―Modular multiplication using the core function in the residue number
system,‖ Applicable Algebra in Engineering, Communication and Computing, Jul. 2015.
[5] M. T. Hamood and S. Boussakta, ―Efficient algorithms for computing the new Mersenne number transform,‖
14. IJECE ISSN: 2088-8708
Functional Verification of Large-integers Circuits using a Cosimulation-based Approach (Nejmeddine Alimi)
2205
Digital Signal Processing, vol. 25, pp. 280–288, Feb. 2014.
[6] G. X. Yao, J. Fan, R. C. C. Cheung, and I. Verbauwhede, ―Novel RNS Parameter Selection for Fast Modular
Multiplication,‖ IEEE Transactions on Computers, vol. 63, no. 8, pp. 2099–2105, Aug. 2014.
[7] T. Wu, S. Li, and L. Liu, ―Fast RSA decryption through high-radix scalable Montgomery modular multipliers,‖
Science China Information Sciences, vol. 58, no. 6, pp. 1–16, Mar. 2015.
[8] S. Antão and L. Sousa, ―A Flexible Architecture for Modular Arithmetic Hardware Accelerators based on RNS,‖
Journal of Signal Processing Systems, vol. 76, no. 3, pp. 249–259, 2014.
[9] K. Jarvinen, V. Dimitrov, and R. Azarderakhsh, ―A Generalization of Addition Chains and Fast Inversions in
Binary Fields,‖ IEEE Transactions on Computers, vol. 64, no. 9, pp. 2421–2432, Sep. 2015.
[10] G. D. Sutter, J. Deschamps, and J. L. Imana, ―Efficient Elliptic Curve Point Multiplication Using Digit-Serial
Binary Field Operations,‖ IEEE Transactions on Industrial Electronics, vol. 60, no. 1, pp. 217–225, Jan. 2013.
[11] S. Suma and V. Sridhar, ―Design of Multiplier for Medical Image Compression Using Urdhava Tiryakbhyam
Sutra,‖ International Journal of Electrical and Computer Engineering (IJECE), vol. 6, no. 3, pp. 1140–1151, 2016.
[12] G. Arepalli and S. B. Erukula, ―Secure Multicast Routing Protocol in Manets Using Efficient ECGDH Algorithm,‖
International Journal of Electrical and Computer Engineering (IJECE), vol. 6, no. 4, pp. 1857–1865, 2016.
[13] A. Pool, ―Using ModelSim Foreign Language Interface for C – VHDL Co-Simulation and for Simulator Control on
Linux x86 Platform,‖ 2014.
[14] Potential Ventures, ―cocotb : COroutine based COsimulation TestBench environment for verifying VHDL/Verilog
RTL,‖ 2014.
[15] B. Smith, T. Loftus, J. Greene, and X. Wu, ―PyHVL, a verifcation tool,‖ 2007.
[16] F. Farahmandi and B. Alizadeh, ―Groebner basis based formal verification of large arithmetic circuits using
Gaussian elimination and cone-based polynomial extraction,‖ Microprocessors and Microsystems, vol. 39, no. 2,
pp. 83–96, Mar. 2015.
[17] T. Pruss, P. Kalla, and F. Enescu, ―Efficient Symbolic Computation for Word-Level Abstraction From
Combinational Circuits for Verification Over Finite Fields,‖ IEEE Transactions on Computer-Aided Design of
Integrated Circuits and Systems, vol. 35, no. 7, pp. 1206–1218, Jul. 2016.
[18] C. Siggaard, ―Using MatLab to aid the implementation of a fast RSA processor on a Xilinx FPGA,‖ in Nordic
MathWorks User Conference, 2008.
[19] D. B. Cousins, K. Rohloff, C. Peikert, and R. Schantz, ―An update on SIPHER (Scalable Implementation of
Primitives for Homomorphic EncRyption) — FPGA implementation using Simulink,‖ in 2012 IEEE Conference on
High Performance Extreme Computing, 2012, pp. 1–5.
[20] D. Cousins, J. Golusky, K. Rohloff, and D. Sumorok, ―An FPGA Co-Processor Implementation of Homomorphic
Encryption,‖ in 2014 IEEE High Performance Extreme Computing Conference, 2014.
[21] P. C. Realpe, V. Trujillo-Olaya, and J. Velasco-Medina, ―Design of elliptic curve cryptoprocessors over GF(2^163)
using the Gaussian normal basis,‖ Ingeniería e Investigación, vol. 34, no. 2, pp. 55–65, Jul. 2014.
[22] A. Kaleel Rahuman and G. Athisha, ―Reconfigurable Architecture for Elliptic Curve Cryptography Using FPGA,‖
Mathematical Problems in Engineering, vol. 2013, pp. 1–8, 2013.
[23] N. Alimi, Y. Lahbib, M. Machhout, and R. Tourki, ―Simulation-based verification of large-integer arithmetic
circuits,‖ in 2016 1st IEEE International Verification and Security Workshop, IVSW 2016, 2016, pp. 19–24.
[24] Accellera, ―Property Specification Language Reference Manual.‖ 2004.
[25] Decaluwe and Jan, ―MyHDL: a Python-based hardware description language,‖ Linux Journal, no. 127, p. 5, 2004.
[26] S. N. Kurapati, ―Specification-driven functional verification with Verilog PLI & VPI and SystemVerilog DPI,‖
2007.
[27] J.-P. Deschamps, Hardware Implementation of Finite-Field Arithmetic. McGraw Hill Professional, 2009.
[28] F. Rodriguez-Henriquez, N. A. Saqib, A. D. Pérez, and C. K. Koc, Cryptographic Algorithms on Reconfigurable
Hardware. Springer Science & Business Media, 2007.
[29] E. Barker, W. Barker, W. Burr, W. Polk, and M. Smid, ―NIST Special Publication 800-57, Recommendation for
Key Management Part 1: General (Revision 3),‖ 2012.