{"id":398810,"date":"2024-10-20T04:38:48","date_gmt":"2024-10-20T04:38:48","guid":{"rendered":"https:\/\/pdfstandards.shop\/product\/uncategorized\/ieee-1647-2019-2\/"},"modified":"2024-10-26T08:26:27","modified_gmt":"2024-10-26T08:26:27","slug":"ieee-1647-2019-2","status":"publish","type":"product","link":"https:\/\/pdfstandards.shop\/product\/publishers\/ieee\/ieee-1647-2019-2\/","title":{"rendered":"IEEE 1647-2019"},"content":{"rendered":"

Revision Standard – Active. The e functional verification language is an application-specific programming language, aimed at automating the task of verifying a hardware or software design with respect to its specification. Verification environments written in e provide a model of the environment in which the design is expected to function, including the kinds of erroneous conditions the design needs to withstand. A typical verification environment is capable of generating user-controlled test inputs with statistically interesting characteristics. Such an environment can check the validity of the design responses. Functional coverage metrics are used to control the verification effort and gauge the quality of the design. e verification environments can be used throughout the design cycle, from a high-level architectural model to a fully realized system. A definition of the e language syntax and semantics and how tool developers and verification engineers should use them are contained in this standard.<\/p>\n

PDF Catalog<\/h4>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
PDF Pages<\/th>\nPDF Title<\/th>\n<\/tr>\n
1<\/td>\nIEEE Std 1647\u2122-2019 Front cover <\/td>\n<\/tr>\n
2<\/td>\nTitle page <\/td>\n<\/tr>\n
4<\/td>\nImportant Notices and Disclaimers Concerning IEEE Standards Documents <\/td>\n<\/tr>\n
7<\/td>\nParticipants <\/td>\n<\/tr>\n
8<\/td>\nIntroduction <\/td>\n<\/tr>\n
10<\/td>\nContents <\/td>\n<\/tr>\n
17<\/td>\n1. Overview
1.1 Introduction
1.2 Scope
1.3 Purpose
1.4 Verification environments <\/td>\n<\/tr>\n
18<\/td>\n1.5 Basic concepts relating to this standard <\/td>\n<\/tr>\n
24<\/td>\n1.6 Conventions used <\/td>\n<\/tr>\n
26<\/td>\n1.7 Use of color in this standard
1.8 Contents of this standard <\/td>\n<\/tr>\n
28<\/td>\n2. Normative references <\/td>\n<\/tr>\n
29<\/td>\n3. Definitions, acronyms, and abbreviations
3.1 Definitions <\/td>\n<\/tr>\n
30<\/td>\n3.2 Acronyms and abbreviations <\/td>\n<\/tr>\n
32<\/td>\n4. e basics
4.1 Overview
4.2 Lexical conventions <\/td>\n<\/tr>\n
39<\/td>\n4.3 Syntactic elements <\/td>\n<\/tr>\n
45<\/td>\n4.4 Struct hierarchy and name resolution <\/td>\n<\/tr>\n
51<\/td>\n4.5 Ranges <\/td>\n<\/tr>\n
52<\/td>\n4.6 Operator precedence <\/td>\n<\/tr>\n
53<\/td>\n4.7 Evaluation order of expressions <\/td>\n<\/tr>\n
54<\/td>\n4.8 Bitwise operators <\/td>\n<\/tr>\n
55<\/td>\n4.9 Boolean operators <\/td>\n<\/tr>\n
57<\/td>\n4.10 Arithmetic operators <\/td>\n<\/tr>\n
58<\/td>\n4.11 Comparison operators <\/td>\n<\/tr>\n
64<\/td>\n4.12 String matching <\/td>\n<\/tr>\n
67<\/td>\n4.13 Extraction and concatenation operators <\/td>\n<\/tr>\n
70<\/td>\n4.14 Scalar modifiers <\/td>\n<\/tr>\n
71<\/td>\n4.15 Parentheses
4.16 list.method() <\/td>\n<\/tr>\n
72<\/td>\n4.17 Special-purpose operators <\/td>\n<\/tr>\n
77<\/td>\n5. Data types
5.1 Overview
5.2 e data types <\/td>\n<\/tr>\n
85<\/td>\n5.3 Untyped expressions <\/td>\n<\/tr>\n
86<\/td>\n5.4 Assignment rules <\/td>\n<\/tr>\n
89<\/td>\n5.5 Real data type <\/td>\n<\/tr>\n
91<\/td>\n5.6 Precision rules for numeric operations <\/td>\n<\/tr>\n
93<\/td>\n5.7 Automatic type casting <\/td>\n<\/tr>\n
94<\/td>\n5.8 Defining and extending scalar types <\/td>\n<\/tr>\n
97<\/td>\n5.9 Referring to types in generic code <\/td>\n<\/tr>\n
98<\/td>\n5.10 Type-related constructs <\/td>\n<\/tr>\n
106<\/td>\n6. Structs, subtypes, and fields
6.1 Overview
6.2 Structs overview <\/td>\n<\/tr>\n
107<\/td>\n6.3 Defining structs: struct <\/td>\n<\/tr>\n
108<\/td>\n6.4 Extending structs: extend type <\/td>\n<\/tr>\n
109<\/td>\n6.5 Restrictions on inheritance
6.6 Extending subtypes
6.7 Creating subtypes with when <\/td>\n<\/tr>\n
111<\/td>\n6.8 Extending when subtypes <\/td>\n<\/tr>\n
112<\/td>\n6.9 Defining fields: field <\/td>\n<\/tr>\n
115<\/td>\n6.10 Defining list fields <\/td>\n<\/tr>\n
117<\/td>\n6.11 Projecting list of fields
6.12 Defining attribute fields <\/td>\n<\/tr>\n
118<\/td>\n6.13 Defining interface types: interface <\/td>\n<\/tr>\n
120<\/td>\n7. Units
7.1 Overview <\/td>\n<\/tr>\n
123<\/td>\n7.2 Defining units and fields of type unit <\/td>\n<\/tr>\n
126<\/td>\n7.3 Unit attributes <\/td>\n<\/tr>\n
128<\/td>\n7.4 Predefined methods of any_unit <\/td>\n<\/tr>\n
131<\/td>\n7.5 Unit-related predefined methods of any_struct <\/td>\n<\/tr>\n
133<\/td>\n7.6 Unit-related predefined routines <\/td>\n<\/tr>\n
135<\/td>\n8. Template types
8.1 Overview <\/td>\n<\/tr>\n
136<\/td>\n8.2 Defining a struct\/unit template type <\/td>\n<\/tr>\n
139<\/td>\n8.3 Defining a template interface type <\/td>\n<\/tr>\n
140<\/td>\n8.4 Defining a template numeric type <\/td>\n<\/tr>\n
141<\/td>\n8.5 Template parameters <\/td>\n<\/tr>\n
143<\/td>\n8.6 Extending a template struct <\/td>\n<\/tr>\n
145<\/td>\n8.7 Instantiating a template type <\/td>\n<\/tr>\n
146<\/td>\n8.8 Template subtype instances <\/td>\n<\/tr>\n
147<\/td>\n9. e ports
9.1 Overview
9.2 Introduction to e ports <\/td>\n<\/tr>\n
148<\/td>\n9.3 Using simple ports <\/td>\n<\/tr>\n
150<\/td>\n9.4 Using buffer ports <\/td>\n<\/tr>\n
151<\/td>\n9.5 Using event ports <\/td>\n<\/tr>\n
152<\/td>\n9.6 Using method ports <\/td>\n<\/tr>\n
154<\/td>\n9.7 Defining and referencing ports <\/td>\n<\/tr>\n
162<\/td>\n9.8 Port attributes <\/td>\n<\/tr>\n
174<\/td>\n9.9 Buffer port methods <\/td>\n<\/tr>\n
176<\/td>\n9.10 MVL methods for simple ports <\/td>\n<\/tr>\n
187<\/td>\n9.11 Global MVL routines <\/td>\n<\/tr>\n
190<\/td>\n9.12 Comparative analysis of ports and tick access <\/td>\n<\/tr>\n
191<\/td>\n9.13 e port binding declaration and methods <\/td>\n<\/tr>\n
198<\/td>\n9.14 Transaction-level modeling interface ports in e <\/td>\n<\/tr>\n
206<\/td>\n9.15 TLM sockets in e <\/td>\n<\/tr>\n
213<\/td>\n10. Constraints and generation
10.1 Overview
10.2 Types of constraints <\/td>\n<\/tr>\n
214<\/td>\n10.3 Generation concepts <\/td>\n<\/tr>\n
231<\/td>\n10.4 Type constraints <\/td>\n<\/tr>\n
233<\/td>\n10.5 Defining constraints <\/td>\n<\/tr>\n
240<\/td>\n10.6 Invoking generation <\/td>\n<\/tr>\n
242<\/td>\n11. Temporal struct members
11.1 Events <\/td>\n<\/tr>\n
246<\/td>\n11.2 on <\/td>\n<\/tr>\n
247<\/td>\n11.3 on event-port <\/td>\n<\/tr>\n
248<\/td>\n11.4 expect | assume <\/td>\n<\/tr>\n
250<\/td>\n11.5 Procedural API for temporal operators on event and expect struct members <\/td>\n<\/tr>\n
264<\/td>\n12. Temporal expressions
12.1 Overview <\/td>\n<\/tr>\n
266<\/td>\n12.2 Temporal operators and constructs <\/td>\n<\/tr>\n
281<\/td>\n12.3 Success and failure of a temporal expression <\/td>\n<\/tr>\n
283<\/td>\n13. Time-consuming actions
13.1 Overview
13.2 Synchronization actions <\/td>\n<\/tr>\n
285<\/td>\n13.3 Concurrency actions <\/td>\n<\/tr>\n
286<\/td>\n13.4 State machines <\/td>\n<\/tr>\n
291<\/td>\n14. Coverage constructs
14.1 Overview
14.2 Defining coverage groups: cover <\/td>\n<\/tr>\n
293<\/td>\n14.3 Defining basic coverage items: item <\/td>\n<\/tr>\n
298<\/td>\n14.4 Defining cross coverage items: cross <\/td>\n<\/tr>\n
300<\/td>\n14.5 Defining transition coverage items: transition <\/td>\n<\/tr>\n
302<\/td>\n14.6 Extending coverage groups: cover … using also … is also <\/td>\n<\/tr>\n
303<\/td>\n14.7 Extending coverage items: item … using also <\/td>\n<\/tr>\n
304<\/td>\n14.8 Coverage API <\/td>\n<\/tr>\n
310<\/td>\n14.9 Coverage methods for the covers struct <\/td>\n<\/tr>\n
318<\/td>\n15. Macros
15.1 Overview <\/td>\n<\/tr>\n
319<\/td>\n15.2 define-as statement
15.3 define-as-computed statement <\/td>\n<\/tr>\n
320<\/td>\n15.4 Match expression structure <\/td>\n<\/tr>\n
322<\/td>\n15.5 Interpretation of match expressions <\/td>\n<\/tr>\n
323<\/td>\n15.6 Macro expansion code <\/td>\n<\/tr>\n
326<\/td>\n16. Print, checks, and error handling
16.1 Overview
16.2 print
16.3 Handling DUT errors <\/td>\n<\/tr>\n
332<\/td>\n16.4 Handling user errors <\/td>\n<\/tr>\n
334<\/td>\n16.5 Handling programming errors: assert <\/td>\n<\/tr>\n
335<\/td>\n17. Methods
17.1 Overview
17.2 Rules for defining and extending methods <\/td>\n<\/tr>\n
344<\/td>\n17.3 Invoking methods <\/td>\n<\/tr>\n
348<\/td>\n17.4 Parameter passing <\/td>\n<\/tr>\n
350<\/td>\n17.5 Using the C interface <\/td>\n<\/tr>\n
352<\/td>\n18. Creating and modifying e variables
18.1 About e variables
18.2 var <\/td>\n<\/tr>\n
353<\/td>\n18.3 =
18.4 op= <\/td>\n<\/tr>\n
354<\/td>\n18.5 <= <\/td>\n<\/tr>\n
356<\/td>\n18.6 rgf= <\/td>\n<\/tr>\n
357<\/td>\n19. Packing and unpacking
19.1 Basic packing <\/td>\n<\/tr>\n
360<\/td>\n19.2 Predefined pack options <\/td>\n<\/tr>\n
361<\/td>\n19.3 Customizing pack options
19.4 Packing and unpacking specific types <\/td>\n<\/tr>\n
367<\/td>\n19.5 Implicit packing and unpacking <\/td>\n<\/tr>\n
368<\/td>\n20. Control flow actions
20.1 Conditional actions <\/td>\n<\/tr>\n
370<\/td>\n20.2 Iterative actions <\/td>\n<\/tr>\n
375<\/td>\n20.3 File iteration actions <\/td>\n<\/tr>\n
376<\/td>\n20.4 Actions for controlling the program flow <\/td>\n<\/tr>\n
378<\/td>\n21. Importing and preprocessor directives
21.1 Overview
21.2 Importing e modules <\/td>\n<\/tr>\n
379<\/td>\n21.3 #ifdef, #ifndef <\/td>\n<\/tr>\n
380<\/td>\n21.4 #define <\/td>\n<\/tr>\n
381<\/td>\n21.5 #undef <\/td>\n<\/tr>\n
382<\/td>\n22. Encapsulation constructs
22.1 Overview
22.2 package: package-name
22.3 package: type-declaration <\/td>\n<\/tr>\n
383<\/td>\n22.4 package | protected | private: struct-member <\/td>\n<\/tr>\n
384<\/td>\n22.5 Scope operator (::) <\/td>\n<\/tr>\n
385<\/td>\n23. Simulation-related constructs
23.1 Overview
23.2 force
23.3 release <\/td>\n<\/tr>\n
386<\/td>\n23.4 Tick access: ‘hdl-pathname’ <\/td>\n<\/tr>\n
387<\/td>\n24. Messages
24.1 Overview
24.2 Message model
24.3 Message execution <\/td>\n<\/tr>\n
388<\/td>\n24.4 Structured debug messages <\/td>\n<\/tr>\n
393<\/td>\n24.5 message and messagef <\/td>\n<\/tr>\n
394<\/td>\n24.6 Tag
24.7 Verbosity <\/td>\n<\/tr>\n
395<\/td>\n24.8 Predefined type sdm_handler <\/td>\n<\/tr>\n
397<\/td>\n24.9 Messages interface <\/td>\n<\/tr>\n
419<\/td>\n25. Sequences
25.1 Overview <\/td>\n<\/tr>\n
421<\/td>\n25.2 Sequence statement <\/td>\n<\/tr>\n
423<\/td>\n25.3 do sequence action <\/td>\n<\/tr>\n
424<\/td>\n25.4 Sequence struct types and members <\/td>\n<\/tr>\n
429<\/td>\n25.5 BFM-driver-sequence flow diagrams <\/td>\n<\/tr>\n
434<\/td>\n26. Tables
26.1 The table construct
26.2 table <\/td>\n<\/tr>\n
436<\/td>\n26.3 Table operators <\/td>\n<\/tr>\n
439<\/td>\n27. List pseudo-methods library
27.1 Pseudo-methods overview
27.2 Using list pseudo-methods
27.3 Pseudo-methods to modify lists <\/td>\n<\/tr>\n
448<\/td>\n27.4 General list pseudo-methods <\/td>\n<\/tr>\n
464<\/td>\n27.5 Math and logic pseudo-methods <\/td>\n<\/tr>\n
467<\/td>\n27.6 List CRC pseudo-methods <\/td>\n<\/tr>\n
468<\/td>\n27.7 Keyed list pseudo-methods <\/td>\n<\/tr>\n
471<\/td>\n28. Predefined methods library
28.1 Ovefview
28.2 Predefined methods of sys
28.3 Predefined methods of any_struct <\/td>\n<\/tr>\n
476<\/td>\n28.4 Methods and predefined attributes of unit any_unit
28.5 Set pseudo-methods <\/td>\n<\/tr>\n
483<\/td>\n28.6 Other pseudo-methods <\/td>\n<\/tr>\n
484<\/td>\n28.7 Coverage methods <\/td>\n<\/tr>\n
486<\/td>\n29. Predefined routines library
29.1 Overview
29.2 Deep copy and compare routines <\/td>\n<\/tr>\n
490<\/td>\n29.3 Integer arithmetic routines <\/td>\n<\/tr>\n
494<\/td>\n29.4 Real arithmetic routines <\/td>\n<\/tr>\n
495<\/td>\n29.5 bitwise_op() <\/td>\n<\/tr>\n
496<\/td>\n29.6 get_all_units()
29.7 String routines <\/td>\n<\/tr>\n
504<\/td>\n29.8 Output routines <\/td>\n<\/tr>\n
506<\/td>\n29.9 Operating system interface routines <\/td>\n<\/tr>\n
509<\/td>\n29.10 set_config() <\/td>\n<\/tr>\n
510<\/td>\n29.11 Randomization routines
29.12 Simulation-related routines <\/td>\n<\/tr>\n
512<\/td>\n29.13 Range-generated field routines <\/td>\n<\/tr>\n
514<\/td>\n30. Predefined file routines library
30.1 Overview
30.2 File names and search paths
30.3 File handles
30.4 Low-level file methods <\/td>\n<\/tr>\n
519<\/td>\n30.5 General file routines <\/td>\n<\/tr>\n
525<\/td>\n30.6 Reading and writing structs <\/td>\n<\/tr>\n
528<\/td>\n31. Predefined interfaces library
31.1 Interfaces for custom numeric types
31.2 base_numeric_i <\/td>\n<\/tr>\n
530<\/td>\n31.3 numeric_i <\/td>\n<\/tr>\n
534<\/td>\n31.4 Implementing numeric_i <\/td>\n<\/tr>\n
535<\/td>\n31.5 Predefined types related to custom numeric interface <\/td>\n<\/tr>\n
536<\/td>\n32. Predefined APIs and utilities library
32.1 Reflection API <\/td>\n<\/tr>\n
570<\/td>\n32.2 instance_iterator object hierarchy traversal API <\/td>\n<\/tr>\n
573<\/td>\n32.3 Procedural API for tables <\/td>\n<\/tr>\n
579<\/td>\n33. Predefined resource sharing control structs
33.1 Overview
33.2 Semaphore methods <\/td>\n<\/tr>\n
580<\/td>\n33.3 How to use the semaphore struct <\/td>\n<\/tr>\n
584<\/td>\n34. Intellectual property protection
34.1 Overview
34.2 Encryption <\/td>\n<\/tr>\n
585<\/td>\n34.3 Decryption
34.4 Reflection API
34.5 Encryption targets <\/td>\n<\/tr>\n
586<\/td>\n35. Annotations
35.1 Overview
35.2 annotation @annotation-type-name <\/td>\n<\/tr>\n
587<\/td>\n35.3 Using annotations <\/td>\n<\/tr>\n
589<\/td>\n35.4 Annotation API <\/td>\n<\/tr>\n
592<\/td>\nAnnex A (informative) Bibliography <\/td>\n<\/tr>\n
593<\/td>\nAnnex B (normative) Source code serialization <\/td>\n<\/tr>\n
601<\/td>\nAnnex C (informative) Comparison of when and like inheritance <\/td>\n<\/tr>\n
609<\/td>\nAnnex D (normative) Name spaces <\/td>\n<\/tr>\n
617<\/td>\nAnnex E (informative) Reflection API examples <\/td>\n<\/tr>\n
621<\/td>\nAnnex F (informative) Encryption targets <\/td>\n<\/tr>\n
622<\/td>\nBack cover <\/td>\n<\/tr>\n<\/table>\n","protected":false},"excerpt":{"rendered":"

IEEE Standard for the Functional Verification Language e<\/b><\/p>\n\n\n\n\n
Published By<\/td>\nPublication Date<\/td>\nNumber of Pages<\/td>\n<\/tr>\n
IEEE<\/b><\/a><\/td>\n2019<\/td>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n","protected":false},"featured_media":398814,"template":"","meta":{"rank_math_lock_modified_date":false,"ep_exclude_from_search":false},"product_cat":[2644],"product_tag":[],"class_list":{"0":"post-398810","1":"product","2":"type-product","3":"status-publish","4":"has-post-thumbnail","6":"product_cat-ieee","8":"first","9":"instock","10":"sold-individually","11":"shipping-taxable","12":"purchasable","13":"product-type-simple"},"_links":{"self":[{"href":"https:\/\/pdfstandards.shop\/wp-json\/wp\/v2\/product\/398810","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/pdfstandards.shop\/wp-json\/wp\/v2\/product"}],"about":[{"href":"https:\/\/pdfstandards.shop\/wp-json\/wp\/v2\/types\/product"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/pdfstandards.shop\/wp-json\/wp\/v2\/media\/398814"}],"wp:attachment":[{"href":"https:\/\/pdfstandards.shop\/wp-json\/wp\/v2\/media?parent=398810"}],"wp:term":[{"taxonomy":"product_cat","embeddable":true,"href":"https:\/\/pdfstandards.shop\/wp-json\/wp\/v2\/product_cat?post=398810"},{"taxonomy":"product_tag","embeddable":true,"href":"https:\/\/pdfstandards.shop\/wp-json\/wp\/v2\/product_tag?post=398810"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}