A SysML and CLEAN Based Methodology for RISC Processor Micro-Architecture Design (original) (raw)
Related papers
Modelling and verification of superscalar Micro-architectures functional approach
Most proof approaches verified a pipelined Micro-Architectural (MA) implementation against an Instruction-Set-Architecture (ISA) specification, and consequently, it was impossible to find a meaningful point where the implementation state and the specification state can be compared easily. An alternative solution to such problem is to verify a pipelined micro-architectural implementation against a sequential multi-cycle implementation. Because both models are formalised in terms of clock cycles, all synchronous intermediate states represent interesting points where the comparison could be achieved easily. Furthermore, by decomposing the state, the overall proof decomposes systematically into a set of verification conditions more simple to reason about and to verify. A major advantage of this elegant choice is the ability to carry out the proof by induction within the same specification language rather than by symbolic simulation through a proof tool which remains very tedious. Also, because both models relate to the MA level, there is no need for a data abstraction function, only a time abstraction function is needed to map between the times used by the two models. The potential features of the proposed proof methodology are demonstrated over the pipelined and the superscalar pipelined MIPS processors within Haskell framework.
Design and specification of microprogrammed computer architectures
ACM SIGMICRO Newsletter, 1985
This paper presents a hierarchical firmware design method. It allows to structure the design of a microprogrammed (level of a) computer architecture into independently verifiable modules. To specify the behaviour of the system we use the axiomatic architecture description language AADL. We illustrate the design and specification style using an emulation example.
A methodology for processor implementation verification
Lecture Notes in Computer Science, 1996
We address the problem of verification of implementations of complex processors using architectural level automatic test program generators. A number of automatic test program generators exist, and are widely used for verification of the compliance of complex processors with their architectures. We define a four stage verification process: (1) describing the processor implementation control as a Finite State Machine (2) deriving transition coverage on the FSM using methods from formal verification (3) translation of the covering tours to constraints on test programs (4) generation of test programs for each set of constraints. This process combines a high quality and well defined theoretical method along with tools used in industrial practice. There are a number of advantages of our Method: (a) The last three stages are automated (b) Implementing the FSM model involves relatively little expert designers time (c) The method is feasible for modern superscalar processors and was studied on an enhanced PowerPC processor. We describe a formal framework for the new process, identify the obstacles that are encountered in the modeling phase, and show how to overcome them.
Formal modeling and verification of microprocessors
IEEE Transactions on Computers, 1995
Formal verification has long been promised as a means of reducing the amount of testing required to ensure correct VLSI devices. Verification requires at least two mathematical models: one that describes the structure of a computer system and another that models its intended behavior. These models are called specijkations. Verification is a mathematical analysis showing that the behavior follows from the structure. Formal verification of microprocessor designs has been quite successful. Indeed, several verified microprocessors have been presented in the literature, and one microprocessor where formal modeling has been applied is commercially available. These efforts were virtuoso performances-largely academic exercises carried out by experts in logic and specification. This paper presents a methodology for microprocessor verification that significantly reduces the learning curve for performing verification. The methodology is formalized in the HOL theoremproving system. The paper includes a description of a large case study performed to evaluate the methodology. The novel aspects of this research include the use of abstract theories to formalize hardware models. Because our model is described using abstract theories, it provides a framework for both the specification and the verification. This framework reduces the number of ad hoc modeling decisions that must be made to complete the verification. Another unique aspect of our research is the use of hierarchical abstractions to reduce the number of difficult lemmas in completing the verification. Our formalism frees the user from directly reasoning about the difficult aspects of modeling the hierarchy, namely the temporal and data abstractions. We believe that our formalism, coupled with case studies and tools, allows microprocessor verification to be done by engineers with relatively little experience in microprocessor specification or logic. We are currently testing that hypothesis by using the methodology to teach graduate students formal microprocessor modeling. I. INTRODUCTION OMPUTERS are being used with increasing frequency C in areas in which the correct implementation of the computer hardware is critical. Testing has traditionally been used to exclude faults in computers; however, the effectiveness of testing is limited by the combinatorial explosion inherent in any testing technique. The limitations of testing, coupled with the ever-increasing size of VLSI devices, have led to a search for alternatives to testing, such as mathematical modeling and analysis.
A SysML and CLEAN-based methodology for digital circuits design
International Journal of High Performance Systems Architecture, 2016
Due to the ever complexity of digital systems, there is a noticeable need for more abstract and structural mechanisms as well as design methodologies that systematically and formally derive low level concrete designs from high level abstract ones. To this aim, we present a methodological design approach that automatically generates a functional HDL code from SysML diagrams modeling hardware designs. The generated HDL code is both reliable and executable. While the first feature remains crucial for low level design refinements, the second one enables evaluating design performances at early stages. A case study involving the functional implementation of an ALU (Arithmetic Logic Unit) through Clean code generated from high level SysML diagrams is given, to practically show the potential features of the proposed approach.
Lecture Notes in Computer Science, 2011
Verifying the functional correctness of a processor requires a sound and complete specification of its Instruction Set Architecture (ISA). Current industrial practice is to describe a processor's ISA informally using natural language often with added semi-formal notation to capture the functional intent of the instructions. This leaves scope for errors and inconsistencies. In this paper we present a method to specify, design and construct sound and complete ISAs by stepwise refinement and formal proof using the formal method Event-B. We discuss how the automatically generated Proof Obligations help to ensure self-consistency of the formal ISA model, and how desirable properties of ISAs can be enforced within this modeling framework. We have developed a generic ISA modeling template in Event-B to facilitate reuse. The key value of reusing such a template is increased model integrity. Our method is now being used to formalize the ISA of the XMOS XCore processor with the aim to guarantee that the documentation of the XCore matches the silicon and the silicon matches the architectural intent.
The development of a hardware abstraction layer generator for system-on-chip functional verification
2010 VI Southern Programmable Logic Conference (SPL), 2010
Nowadays functional verification of large system-on-chip has taken about 70% to 80% of the total design effort. The large amount of IP's of current SoC's makes the work of verification engineers quite hard due to the need to guarantee that the design is bug free before it is sent to tape out. In order to reduce the time spent in the functional verification and aid the verification engineers with their job, this work presents a Hardware Abstract Layer generator-HAL generator. The HAL generator is part of a methodology for SoC functional verification in development in STMicroelectronics. Such methodology is based on a typical verification flow and supported by IP-XACT; it aims automate tasks in the SoC functional verification flow. To handle these tasks some tools are needed; the HAL generator is one of these tools, being in charge of creating C functions that allow the manipulation of registers and their fields in a high level way. The HAL functions work as an API in C to access all their field present in a design, allowing the verification engineers to write their test cases without need to without worrying about masks, macros, define and/or pointers manipulation.
Modeling Modern Micro-architectures using CASL
2007 IEEE International Parallel and Distributed Processing Symposium, 2007
We overview CASL, the CoGenT Architecture Specification Language, a mixed behavioral-structure architecture description language designed to facilitate fast prototyping and tool generation for computer architectures with deep pipelines and complicated timing. We show how CASL can describe pipelines, dynamic information contexts, and contention using the DLX/MIPS architecture as an example.
Reconfigurable Model for RISC Processors
2016
The instruction set of a processor is embodied in the particular micro-architecture representing the processor hardware. Verifying proper operation of the instruction set for a particular processor hardware implementation requires exhaustive testing to expose unknown dependencies and other elusive design flaws. This paper presents the research and development of a flexible micro-architectural model written in SystemC for a RISC processor based upon a user defined configuration database; the RISC processor is based on an architecture assigned in course Design of Computer Systems (DCS) offered at Rochester Institute of Technology (RIT). This model will be tested by a test bench written in SystemVerilog, using randomly generated instructions, and results will be compared with various DCS student processors originally developed at the Register Transfer Level (RTL) in a Hardware Description Language (HDL) such as Verilog or VHDL. The test bench will provide stimulus such as the system cl...
An architecture synthesis system for embedded processors
2000
Design requirements for embedded systems call for architectures with small size, low power consumption and low cost. These requirements can be met by designing custom architectures for every single application. However, the commercial viability of embedded systems calls for short design cycles. These requirements are conflicting: custom architectures take a long time and substantial effort to produce, because of the need to manually generate design evaluation tools, such as simulators and compilers, for each architecture candidate. This conflict can be eliminated by providing a system capable of generating all design evaluation tools for a given candidate architecture. This thesis presents two components of the ARIES environment for architecture synthesis: the machine description language ISDL and the G ENSIM simulator generator system. We also briefly describe the H GEN hardware model generator. In the ARIES system, candidate architectures are described in the ISDL language. From t...