KR20130048204A

KR20130048204A - 하드웨어 설계들의 혼합된 동시 및 순차 로직 시뮬레이션

Info

Publication number: KR20130048204A
Application number: KR1020127025921A
Authority: KR
Inventors: 키스 위스난트; 클라우디오 바실레; 자신토 파올로 사게세
Original assignee: 시놉시스, 인크.
Priority date: 2010-03-04
Filing date: 2011-03-04
Publication date: 2013-05-09
Also published as: EP2542969A4; JP5798132B2; US8738350B2; CN102782651B; KR101752943B1; WO2011109707A3; JP2013521583A; CN102782651A; US20110218792A1; WO2011109707A2; EP2542969A2

Abstract

HDL 에 기술된 설계를 시뮬레이션하는 방법이 제공된다. 이 방법에서, 설계의 모듈들은 순차 시뮬레이션 엔진에 의한 시뮬레이션을 위한 제 1 모듈들, 및 동시 시뮬레이션 엔진에 의한 시뮬레이션을 위한 제 2 모듈들로 파티셔닝될 수 있다. 제 1 모듈 및 제 2 모듈은 HDL의 실행 모델에 부합하는 클래스들의 이벤트들에 기초한 시뮬레이션을 위해 우선순위화될 수 있다. 순차 시뮬레이션 엔진 및 동시 시뮬레이션 엔진의 시뮬레이션들은 각각의 클래스의 이벤트들에 대해 동기화될 수 있다. 동기화하는 것은 순차 시뮬레이션 엔진과 동시 시뮬레이션 엔진 사이에, 제 1 모듈들의 적어도 서브세트 및 제 2 모듈들에 의해 공유되는 업데이트된 인터페이스 변수 값들을 전송하는 것을 포함할 수 있다. 이 전송하는 것은 업데이트된 인터페이스 변수 값들의 표현들을 번역하는 것을 포함할 수 있다.

Description

하드웨어 설계들의 혼합된 동시 및 순차 로직 시뮬레이션{MIXED CONCURRENT AND SERIAL LOGIC SIMULATION OF HARDWARE DESIGNS}

본 출원은 "MIXED CONCURRENT AND SERIAL LOGIC SIMULATION OF HARDWARE DESIGNS WITH BEHAVIORAL CHARACTERISTICS"의 발명의 명칭으로, 2010년 3월 4일자로 출원되어, 본원에 참고로 포함된, 미국 가특허출원 번호 제 61/339,391 호에 대해 우선권을 주장한다.

본 발명은 로직 시뮬레이션에 관한 것으로, 특히, 순차 시뮬레이션 엔진 및 동시 시뮬레이션 엔진을 포함하는 통합 로직 시뮬레이터에 관한 것이다.

로직 시뮬레이션은 전자 회로들의 설계 흐름에서 필수 단계이다. 로직 시뮬레이션은 대개 하드웨어 기술 언어 (HDL) 코드의 형태로 통상적으로 제공되는 하드웨어 설계들을 프로세싱하는, 로직 시뮬레이터들로서 지칭되는 전자 설계 자동화 (EDA) 소프트웨어 도구들에 의해 보통 수행된다. 하드웨어 설계자들은 하드웨어 설계를 실제 전자 회로를 제조하는 물리적 구현 단계 (phase) 로 보내기 전에, 하드웨어 설계가 그의 사양 (specification) 들을 따르는지를 검증하기 위해, 광범위한 로직 시뮬레이션들을 수행한다. 일반적인 하드웨어 설계 흐름에서는, 그의 사양들을 따르지 않는 회로를 제조할 위험을 최소화하기 위해, 그 설계 프로세스에 따라서 기능 검증 프로세스가 수행된다. 로직 시뮬레이션은 일반적으로 그의 결과들로서 사용자가 관측할 때에 흥미를 끄는 회로 신호들의 세트의 파형들을 발생한다. 사용자는 하드웨어 설계가 정확하게 동작하는지를 검증하기 위해, 그 발생된 파형들을 분석하고 시각화할 수 있다. 또한, 로직 시뮬레이터들은 임베딩된 어써션들 (embedded assertions) 에 의해 하드웨어 설계들을 설계하는 것을 지원하고, 이는 회로 오작동 (malfunctioning) 을 유발하는 조건들을 검출하기 위해 회로 신호들의 값들을 이용한다. 로직 시뮬레이터는 회로를 시뮬레이션하는 동안 그러한 어써션들을 평가하고, 사용자에게 그들의 위반들을 보고한다. 이들 위반 보고들에 기초하여, 사용자는 하드웨어 설계에서 설계 오류들을 알아내어, 수정한다.

하드웨어 기술 언어 (HDL) 를 통해 기입 (specify) 된 설계를 시뮬레이션하는 방법이 제공된다. 이 방법에서는, 통합 로직 시뮬레이터가 실행될 수 있다. 이 통합 로직 시뮬레이터는 순차 시뮬레이션 엔진 (serial simulation engine) 및 동시 시뮬레이션 엔진 (concurrent simulation engine) 을 포함할 수 있다. 순차 시뮬레이션 엔진은 한번에 하나의 시뮬레이션을 수행할 수 있는 반면, 동시 시뮬레이션 엔진은 다수의 동시 시뮬레이션들을 수행할 수 있다. 컴퓨터를 이용하여, 순차 시뮬레이션 엔진 및 동시 시뮬레이션 엔진의 시뮬레이션들은 HDL의 실행 모델에 의해 정의되는 클래스들의 이벤트들에 기초하여 동기화될 수 있다.

설계는 통합 로직 시뮬레이터에 의해 실행되는 모듈들의 2개의 그룹들로 파티셔닝될 수 있다. 모듈들의 제 1 그룹은 순차 시뮬레이션 엔진 상에서 실행할 수 있으며, 모듈들의 제 2 그룹은 동시 시뮬레이션 엔진 상에서 실행할 수 있다. 일 실시형태에서, 파티셔닝 (partitioning) 은 시뮬레이션 성능의 바람직한 레벨을 달성하기 위해, 순차 시뮬레이션 엔진의 능력들 및/또는 동시 시뮬레이션 엔진의 능력들에 기초하여 행해진다. 또 다른 실시형태에서, 파티셔닝은 사용자에 의해 수동으로 이루어질 수 있다.

순차 시뮬레이션 엔진 또는 동시 시뮬레이션 엔진 중 어느 하나가 통합 로직 시뮬레이터의 1차 시뮬레이션 엔진으로 지정될 수 있으며, 그 다음에, 다른 시뮬레이션 엔진은 2차 시뮬레이션 엔진으로 지정된다. 일 실시형태에서, 순차 시뮬레이션 엔진은 1차 시뮬레이션 엔진이고, 동시 시뮬레이션 엔진은 2차 시뮬레이션 엔진이다. 또 다른 실시형태에서, 동시 시뮬레이션 엔진은 1차 시뮬레이션 엔진이며, 순차 시뮬레이션 엔진은 2차 시뮬레이션 엔진이다. 1차 시뮬레이션 엔진은 동기화 지점들에서 2차 시뮬레이션 엔진을 인보크 (invoke) 한다. 일 실시형태에서, 동기화 지점들은 HDL의 실행 모델에 의해 정의되는 대로 큐 평가들 전에 있다. 또 다른 실시형태에서, 동기화 지점들은 HDL의 실행 모델에 의해 정의되는 대로 큐 평가들 후에 있다.

설계의 파티셔닝이 설계 계층을 고려하여 이루어질 수 있다는 점에 유의한다. 예를 들어, 일 실시형태에서, 제 1 모듈이 2차 시뮬레이션 엔진에 의해 시뮬레이션된다는 것은 그 제 1 모듈 아래의 설계 계층 내에 더 깊이 인스턴스화 (instantiate) 된 모든 하위-모듈들이 또한 2차 시뮬레이션 엔진에 의해 시뮬레이션된다는 것을 암시한다. 또 다른 실시형태에서, (2차 시뮬레이션 엔진에 의해 시뮬레이션되는) 제 1 모듈이 제 2 모듈을 인스턴스화하면, 제 2 모듈은 1차 시뮬레이션 엔진에 의해 시뮬레이션될 수 있다.

본 방법에 따르면, 2차 시뮬레이션 엔진 모듈들에서의 소정 변수 (certain variable) 들이 1차 시뮬레이션 엔진과 통신하기 위한 인터페이스 변수들로서 식별될 수 있다. 이들 인터페이스 변수들의 값들은 순차 시뮬레이션 엔진 및 동시 시뮬레이션 엔진 양쪽 모두에 저장될 수 있다.

인터페이스 변수 값들은 동기화 지점들에서 2차 시뮬레이션 엔진에서 이벤트들을 평가하기 전에, 2차 시뮬레이션 엔진으로 전송 (transfer) 될 수 있다. 이 전송 동안, 인터페이스 변수 값들은 1차 시뮬레이션 엔진 스토리지 (storage) 표현으로부터 2차 시뮬레이션 엔진 스토리지 표현으로 번역 (translate) 될 수 있다. 일 실시형태에서, 오직 변경된 인터페이스 변수 값들만이 동기화 지점들에서 전송된다.

또한, 인터페이스 변수 값들은 동기화 지점들에서 2차 시뮬레이션 엔진에서 이벤트들을 평가한 후, 1차 시뮬레이션 엔진으로 전송될 수 있다. 이 전송 동안, 인터페이스 변수 값들은 2차 시뮬레이션 엔진 스토리지 표현으로부터 1차 시뮬레이션 엔진 스토리지 표현으로 번역될 수 있다. 일 실시형태에서, 오직 변경된 인터페이스 변수 값들만이 동기화 지점들에서 전송된다.

실행 모델에서 동기화 지점들은 산업 표준 애플리케이션 프로그래밍 인터페이스를 통해서 확립될 수 있다는 점에 유의한다. 예시적인 산업 표준 애플리케이션 프로그래밍 인터페이스들은 프로그래밍 언어 인터페이스 (PLI) 및 검증 절차 인터페이스 (VPI) 를 포함하지만, 이에 한정되지 않는다. 또 다른 실시형태에서, 동기화 지점들은 전용 인터페이스 (proprietary interface) 들을 통해서 확립될 수 있다.

특히, 2차 시뮬레이션 엔진 모듈은 1차 시뮬레이션 엔진에서 스터브 모듈 (stub module) 로 표현될 수 있다. 이 스터브 모듈은 대응하는 2차 시뮬레이션 엔진 모듈에 대한 인터페이스 변수들을 포함한다. 스터브 모듈은 대응하는 2차 시뮬레이션 엔진 모듈의 HDL을 포함하지 않는다.

HDL에 기술된 설계를 시뮬레이션하는 또 다른 방법이 제공된다. 이 방법에서, 설계 모듈들은 순차 시뮬레이션 엔진에 의한 시뮬레이션을 위한 제 1 모듈들 및 동시 시뮬레이션 엔진에 의한 시뮬레이션을 위한 제 2 모듈들로 파티셔닝될 수 있다. 제 1 모듈 및 제 2 모듈은 HDL의 실행 모델과 일치하는 클래스들의 이벤트들에 기초하여, 시뮬레이션을 위해 우선순위화 (prioritize) 될 수 있다. 컴퓨터를 이용하여, 순차 시뮬레이션 엔진 및 동시 시뮬레이션 엔진의 시뮬레이션은 각각의 클래스의 이벤트들에 대해 동기화될 수 있다.

동기화는 업데이트된 인터페이스 변수 값들을 전송하는 것을 포함할 수 있으며, 그 변수값들은 순차 시뮬레이션 엔진과 동시 시뮬레이션 엔진 사이에, 제 2 모듈들 및 적어도 제 1 모듈들의 서브세트에 의해 공유된다. 이 전송하는 것은 업데이트된 인터페이스 변수 값들의 표현들을 번역하는 것을 포함할 수 있다.

각각의 제 2 모듈은 순차 시뮬레이션 엔진에서 스터브 모듈로서 표현될 수 있으며, 여기서 스터브 모듈은 제 1 모듈들 중 하나이다. 동시 시뮬레이션 엔진에서 인터페이스 변수에 대한 값들은 워드 (word) 로 저장될 수 있으며, 여기서 이들 값들은 순차 시뮬레이션 엔진에서 그 스터브 모듈의 다수의 인스턴스 (instance) 들과 연관된다.

동기화는 순차 시뮬레이션 엔진에서 하나의 클래스의 이벤트들의 평가를 종료한 후, 그 동일 클래스의 이벤트들의 평가를 위해 그 업데이트된 인터페이스 변수 값들을 동시 시뮬레이션 엔진으로 전송하는 것을 더 포함할 수 있다. 또한, 동기화는 동시 시뮬레이션 엔진에서 하나의 클래스의 이벤트들의 평가를 종료한 후 업데이트된 인터페이스 변수 값들을 순차 시뮬레이션 엔진으로 전송하여, (1) 그 클래스에서의 새로운 이벤트들이 동시 시뮬레이션 엔진에 의해 발생될 때 그 동일 클래스의 이벤트들, 또는 (2) 존재할 경우 다음 클래스의 이벤트들을, HDL의 실행 모델에 따라, 평가하는 것을 더 포함할 수 있다.

일 실시형태에서, HDL 은 Verilog 이며, 하나의 클래스의 이벤트들은 활성 이벤트들, 비활성 이벤트들, 및 비-블록킹 할당 업데이트 이벤트들 중 하나이다. 일 실시형태에서, 동기화하는 HDL에 의해 기입된 클래스들의 이벤트들의 우선순위들에 기초하여, 순차 시뮬레이션 엔진 및 동시 시뮬레이션 엔진을 이용하여 모든 클래스들의 이벤트들을 통해서 진행하는 것을 포함할 수 있다.

도 1 은 Verilog HDL 실행 모델에서 큐 평가들의 서브세트를 나타낸다.
도 2 는 모듈에 대해 인터페이스 변수들로서 작용하는 임베딩된 모듈의 포트 변수들을 도시한다.
도 3a 및 도 3b 는 종래의 상위 모듈 및 스터브 모듈을 포함하는 상위 모듈에 대한 예시적인 HDL을 각각 도시한다.
도 4a 및 도 4b 는 종래의 상위 모듈 및 스터브 모듈을 포함하는 상위 모듈의 블록도들을 각각 도시한다.
도 5a 및 도 5b 는 순차 시뮬레이션 엔진 및 동시 시뮬레이션 엔진에서의 인터페이스 변수 값들에 대한 예시적인 스토리지 표현들을 각각 도시한다.
도 6a 는 활성 이벤트 큐 평가를 위해 순차 시뮬레이션 엔진과 동시 시뮬레이션 엔진 사이에 번역하고 동기화하기 위한 예시적인 액션 (action) 들을 도시한다.
도 6b 는 다수의 이벤트 큐 평가들을 위해, 순차 시뮬레이션 엔진과 동시 시뮬레이션 엔진 사이에 번역하고 동기화하는 예시적인 액션들을 도시하며, 이벤트 큐들은 Verilog HDL 실행 모델에 의해 기입되는 큐 유형들에 기초한다.
도 6c 는 다수의 이벤트 큐 평가들을 위해, 순차 시뮬레이션 엔진과 동시 시뮬레이션 엔진 사이에 번역하고 동기화하는 예시적인 액션들을 도시하며, 이 이벤트 큐들은 VHDL 실행 모델에 의해 기입되는 큐 유형들에 기초한다.
도 7 은 순차 시뮬레이션 엔진 및 동시 시뮬레이션 엔진을 위한 데이터 스토리지를 도시한다. 특히, 동시 시뮬레이션 엔진을 위한 워드 (word) 스토리지는 하나의 실행 명령으로 하여금, 다수의 로직 함수 (logic function) 들을 시뮬레이션하여, 순차 시뮬레이션 엔진에서 다수의 로직 인스턴스들에 대응하는 다수의 출력들을 발생시키는 것을 허용한다.
도 8 은 순차 및 동시 시뮬레이션 엔진들에 의해 구현되는 경우 다양한 모듈들의 블록도를 도시한다. 특히, 순차 시뮬레이션 엔진에서의 모듈은 책무 (responsibility) 를 동시 시뮬레이션 엔진으로 이전하는 스터브 모듈을 포함하는 반면, 동시 시뮬레이션 엔진에서의 모듈은 책무를 순차 시뮬레이션 엔진으로 이전하는 스터브 모듈을 포함한다.
도 9 는 통합 로직 시뮬레이터를 포함하는 예시적인 디지털 ASIC 설계 흐름의 간략화된 표현을 도시한다.

종래의 로직 시뮬레이터는 본원에서 "순차 시뮬레이션 엔진"으로 지칭되는 기법으로 한번에 하나의 시뮬레이션을 실행한다. 적합한 성능을 달성하기 위해, 순차 시뮬레이션 엔진은 각각의 시뮬레이션을 가능한 한 빠르게 실행하도록 설계된다. "Concurrent Simulation Of Hardware Designs With Behavioral Characteristics"의 발명의 명칭으로, 2009년 9월 24일자로 출원되어, 본원에서 참조로 포함된, 계류중인 미국 특허출원 제 12/586,724 호가, 본원에서 "동시 시뮬레이션 엔진"으로 지칭되는, 하드웨어 설계의 동시 시뮬레이션들을 효율적으로 수행하는 기법을 기술하고 있다. 동시 시뮬레이션 엔진들은 몇몇의 시뮬레이션들을 한꺼번에 실행함으로써 성능을 달성한다.

순차 및 동시 시뮬레이션 엔진들의 구현들 뿐만 아니라, 시뮬레이션되는 하드웨어 설계의 특정한 특성들에 따라서, 순차 시뮬레이션 엔진을 이용하여 하드웨어 설계의 소정 부분들을 실행하고, 동시 시뮬레이션 엔진을 이용하여 하드웨어 설계의 소정 다른 부분들을 실행하는 것이 바람직할 수도 있다. 동시 시뮬레이션 엔진 및 순차 시뮬레이션 엔진을 단일 통합 로직 시뮬레이터로 통합하는 소프트웨어-기반의 기법이 아래에 설명된다. 이하에서, 이 통합으로부터 기인하는 로직 시뮬레이터는 "통합 로직 시뮬레이터"로서 지칭된다.

하드웨어 기술 언어 (HDL) 에 의해 지시될 때 로직 시뮬레이터들이 특정한 실행 모델을 실행한다는 점에 유의한다. 통합 로직 시뮬레이터를 설명하는 목적을 위해, Verilog HDL가 사용될 것이다. 그러나, 통합 로직 시뮬레이터는 다른 HDL들 및 이들 HDL들과 연관된 실행 모델들에 적용될 수 있다.

Verilog HDL은 기초를 이루는 별개의 이벤트 실행 모델에 따라서 해석된다. 여러가지 이벤트 큐들이 정의되고 그로부터 이벤트들이 실행된다. 이벤트들은 (1) 시뮬레이션이 진행함에 따라 발생되며, (2) 특정한 큐 상에 배치되며, (3) 실행 모델에 의해 지시되는 바대로 시뮬레이션 동안 특정한 시점에서 큐로부터 제거되며, (4) 실행된다. 실행되는 이벤트들은, 결국, 나중의 실행 동안 큐 상에 놓이는 추가적인 이벤트들을 발생시킬 수도 있다. 이벤트들을 수반하는 이 시퀀스는 이벤트들이 더 이상 발생되지 않을 때까지 계속되며, 이벤트들이 더 이상 발생되지 않는 시점에, 시뮬레이션이 종결된다.

전형적으로, 시뮬레이션될 하드웨어 설계는 Verilog HDL에서 다수의 모듈들로서 표현된다. 종종, Verilog 모듈들과 실제 하드웨어 하위 구성요소들 사이에 대응성이 있으나, 이것이 반드시 그 경우일 필요는 없다 (예컨대, Verilog 모듈이 단일 하드웨어 하위 구성요소에 의해 구현되지 않는 추상 기능성 (abstract functionality) 또는 행위를 나타낼 수도 있다). Verilog 모듈들은 한 계층 내에 배열되며, 모듈의 인스턴스가 또 다른 모듈 내에 "임베딩" 된다고 한다. 예를 들어, 마이크로프로세서를 위한 모듈이 다양한 연산 (arithmetic) 모듈들, 로직 모듈들, 제어 모듈들, 및 스토리지 모듈들로 분해될 수도 있다. 마이크로프로세서 모듈 내에는, 한 계층 내에 조직화된 각각의 구성 모듈의 임베딩 인스턴스들이 있다.

각각의 인스턴스화된 Verilog 모듈은 Verilog HDL 실행 모델의 사양에 따른 로직 시뮬레이터에 의한 실행을 위해 이벤트들을 발생한다. Verilog HDL 로직 시뮬레이터들은 오직 순차 시뮬레이션 엔진, 오직 동시 시뮬레이션 엔진, 또는 순차 시뮬레이션 엔진과 동시 시뮬레이션 엔진의 조합 (후자는, 본원에서 기술된 통합 로직 시뮬레이터임) 을 이용하여 구현되든지 간에, 실행 모델을 충실히 지켜야 한다.

예를 들어, 도 1 은 Verilog HDL 실행 모델에 의해 기입되는 큐들의 서브세트를 나타낸다. Verilog HDL 실행 모델은 로직 시뮬레이터의 비활성 이벤트 큐로부터의 임의의 비활성 이벤트들 (102) 이 실행되기 전에 로직 시뮬레이터의 활성 이벤트 큐로부터의 모든 활성 이벤트들 (101) 이 실행되는 것을 필요로 한다. 일단 활성 및 비활성 이벤트 큐들이 고갈 (exhausted) 되면, 비-블록킹 할당 (NBA; non-blocking assignment) 업데이트 이벤트 큐로부터의 NBA 업데이트 이벤트들 (103) 이 실행된다. 시뮬레이션이 진행함에 따라 하나의 큐로부터 또다른 큐로 전진시키기 위한 확립된 규칙들과 함께, 도 1 에 나타낸 것 이외에 Verilog HDL 실행 모델에 다른 큐들이 있다는 점에 유의해야 한다.

순차 시뮬레이션 엔진 및 동시 시뮬레이션 엔진 양자를 이용하는 통합 로직 시뮬레이터에서, 하드웨어 설계를 기술하는 HDL 프로그램은 모듈들의 2개의 그룹들로 파티셔닝될 수 있다. 모듈들의 한 그룹은 순차 시뮬레이션 엔진에 의해 실행되며, 모듈들의 또 다른 그룹은 동시 시뮬레이션 엔진에 의해 실행된다. 통합 로직 시뮬레이터에서 하나의 큐로부터 또 다른 큐로 전진하는 것은 순차 시뮬레이션 엔진 및 동시 시뮬레이션 엔진에 걸쳐 조정 (coordinate) 되어야 하므로, 통합 로직 시뮬레이터가 Verilog HDL 실행 모델을 위반하지 않는다 (예컨대, 순차 시뮬레이션 엔진 또는 동시 시뮬레이션 엔진 중 어느 하나에서 실행할 활성 이벤트들 및 비활성 이벤트들이 여전히 있는 동안에 NBA 업데이트 이벤트들이 실행되지 않는다).

Verilog 모듈들은 입력/출력 포트 변수들을 통해서 서로 상호작용한다. 또한, Verilog 모듈은 교차-모듈 참조들로서 알려진 기능 (facility) (당업자들에게 알려져 있어 본원에서 설명되지 않는 매커닉 (mechanics)) 을 통해서 다른 모듈 인스턴스들에서 내부 변수들로 직접, 판독 및 기록할 수 있다. 모듈간 상호작용들에 사용되는, 이들 내부 변수들은 식별될 수 있으며, 모듈을 위한 "인터페이스 변수들" 로서 지칭된다.

도 2 는 2개의 모듈들, 즉, 가산기 모듈 (202) 및 가산기 모듈 (202) 을 인스턴스화하는 상위 레벨 (top-level) 모듈 (201) 을 갖는 간단한 종래의 설계를 나타낸다. 상위 레벨 모듈 (201) 에서의 변수들과 임베딩된 가산기 모듈 (202) 에서의 변수들 사이의 접속들은 가산기 포트 변수들을 통해서 이루어진다. 이들 포트 변수들은 이 설계에서 인터페이스 변수들이다. 도 2 에 나타낸 바와 같이, 상위 모듈 (top module; 201) 에 대한 인터페이스 변수들 "clk", "input1", 및 "input2" 이 가산기 모듈 (adder module; 202) 에 대한 인터페이스 변수들 "clk", "a", 및 "b" 로 맵핑된다. 따라서, 예를 들어, 변수 input1 이 변할 때, 또한 변수 "a" 도 변한다. 이와 유사하게, 가산기 모듈 (202) 의 인터페이스 변수 "out" 은 상위 레벨 모듈 (201) 에 대한 인터페이스 변수 "sum" 에 맵핑된다.

특히, 순차 시뮬레이션 엔진에 할당된 모듈이 동시 시뮬레이션 엔진에 할당된 모듈과 인터페이스할 때, 순차 시뮬레이션 엔진 모듈은 동시 시뮬레이션 엔진 모듈에 대한 플레이스홀더 (placeholder) 로서 기능하는 스터브 모듈과 상호작용할 수 있다. 이 스터브 모듈은 임베딩된 모듈의 모든 인터페이스 변수들을 포함할 수 있다. 도 2 에 나타낸 설계를 다시 참조하면, 상위 레벨 모듈은 순차 시뮬레이션 엔진에 할당될 수 있으며, 가산기 모듈은 동시 시뮬레이션 엔진에 할당될 수 있다. 이 경우, 가산기 모듈 RTL을 보는 대신에, 순차 시뮬레이션은 그 가산기에 대한 스터브 모듈을 본다.

도 3a 는 설계 (200) (도 2) 에 대한 종래의 HDL (300) 을 도시하는 반면, 도 3b 는 통합 로직 시뮬레이터으로 시뮬레이션될 때 순차 시뮬레이션 엔진에 의해 보여지는 HDL (310) 을 도시한다. 가산기 모듈에 대한 인터페이스 변수들이 HDL (310) (또한, 스터브 모듈로 지칭됨) 에 남아 있지만, 가산기 모듈의 기능적 양태들 (functional aspects) (즉, "always @ (posedge_clk)" 및 "out = a + b") 이 순차 시뮬레이션 엔진에 더 이상 존재하지 않는다는 점에 유의한다. 특히, 도 4a 및 도 4b 를 참조하여 설명하는 바와 같이, 가산기 모듈의 기능적 양태들은 대신 동시 시뮬레이션 엔진에 정의된다.

도 4a 및 도 4b 는 상위 모듈 및 임베딩된 모듈의 예시적인 파티셔닝을 도시한다. 구체적으로, 도 4a 는 도 2 에 나타낸 설계의 종래의 로직 시뮬레이터 뷰 (view) 를 도시한다. 이 경우, 모든 모듈들 (즉, 상위 모듈 (201) 및 가산기 모듈 (202)) 이 순차 시뮬레이션 엔진 (401) 에 의해 시뮬레이션된다. 이와는 대조적으로, 도 4b 는 동시 시뮬레이션 엔진 (402) 이 임베딩된 가산기 모듈 (202) 을 담당하도록 할 때의 파티셔닝을 도시한다. 이 경우, 실제 가산기 모듈 HDL 은 동시 시뮬레이션 엔진 (402) 에 의해 시뮬레이션될 수 있으며, 순차 시뮬레이션 엔진 (401) 은 임베딩된 가산기 모듈을 위한 스터브 모듈 (202A) 과 상호작용할 수 있다.

도 4b 에 나타낸 구성에서, 순차 시뮬레이션 엔진 (401) 은 각각의 인터페이스 변수에 할당된 그의 자신의 스토리지 (403) 를 가질 수 있다 (하나가 도시됨). 값들이 스터브 모듈 (202A) 에의 입력들로서 작용하는 인터페이스 변수들에 기록될 수 있으며, 값들이 스터브 모듈 (202A) 로의 출력들로서 작용하는 인터페이스 변수들로부터 판독된다. 마찬가지로, 동시 시뮬레이션 엔진 (402) 은 각각의 인터페이스 변수에 할당된 그의 자신의 스토리지 (404) 를 가질 수 있다 (하나가 도시됨). 값들이 동시 시뮬레이션 엔진 모듈, 즉, 가산기 모듈 (202) 에의 입력들로서 작용하는 인터페이스 변수들로부터 판독될 수 있으며, 값들이 가산기 모듈 (202) 로의 출력들로서 작용하는 인터페이스 변수들에 기록될 수 있다. 위에서 나타낸 바와 같이, 가산기 모듈 (202) 에서의 인터페이스 변수들의 값 변화들이 스터브 모듈 (202A) 에 반영됨으로써, 상위 모듈 (201) 의 적절한 기능 (functioning) 을 보장할 것이다. 이와 유사하게, 스터브 모듈 (202A) 에서의 인터페이스 변수의 값 변화들이 가산기 모듈 (202) 에 반영되어, 그의 적절한 기능을 보장할 것이다.

인터페이스 변수들이 아닌 변수들은 순차 시뮬레이션 엔진 (401) 또는 동시 시뮬레이션 엔진 (402) 중 어느 하나에 저장되고, 양자 모두에 저장되지 않는다는 점에 유의한다. 즉, 통합 로직 시뮬레이터에서 순차 시뮬레이션 엔진 (401) 과 동시 시뮬레이션 엔진 (402) 사이의 공유되는 상태는 인터페이스 변수들로 제한된다.

특히, 순차 시뮬레이션 엔진 및 동시 시뮬레이션 엔진은 변수 값들을 저장하기 위해 상이한 표현들을 이용할 수 있다. 일 실시형태에서, 순차 시뮬레이션 엔진은 그 변수에 대한 다수의 값들이 각각의 시뮬레이션 마다 하나씩 저장되는 표현을 이용할 수 있다. 예를 들어, 도 5a 에 나타낸 순차 시뮬레이션 엔진 (500) 을 참조하면, 4개의 상이한 시뮬레이션들, 즉, 시뮬레이션 0, 시뮬레이션 1, 시뮬레이션 2, 및 시뮬레이션 3 에 대한 값들을 갖는, 8-비트 변수 V 에 대한 변수 값 표현을 고려하자. 변수 V 에 대한 각각의 시뮬레이션은 8 비트들을 저장한다. 대조적으로, 도 5b 에 나타낸 동시 시뮬레이션 엔진 (510) 을 참조하면, 4개의 시뮬레이션들의 값들이 다수의 4-비트 워드들 (words) 로 저장된다. 구체적으로, 변수 V (즉, V[0]-V[7]) 에서 각각의 비트에 대해 하나씩, 할당된 8 개의 이런 워드들이 존재한다. 도 5a 및 도 5b 에서 박스 501 및 박스 502 는, 각각, 다수의 시뮬레이션들을 통한 단일 비트에 대한 값들이 어떻게 순차 시뮬레이션 엔진 (500) 및 동시 시뮬레이션 엔진 (510) 에서 조직화되는지를 도시한다 (예컨대, 비트들 A, B, C, 및 D 참조).

인터페이스 변수들의 2개의 카피 (copy) 들, 즉, 순차 시뮬레이션 엔진에서 하나 및 동시 시뮬레이션 엔진에서 하나가 있기 때문에, 이들 2개의 복사본들은 통합 로직 시뮬레이터가 전체 시뮬레이션 상태의 일관된 뷰 (view) 를 유지하도록 업데이트될 때 동기화된 상태로 유지해야 한다. 일부 실시형태들에서, 인터페이스 변수 값들은 큐 평가들의 시작시와 종료시 동기화된다. 인터페이스 변수 값들을 동기화하는 것은 변수 값들을 저장하기 위해, 순차 시뮬레이션 엔진 표현 (예컨대, 도 5a 참조) 과 동시 시뮬레이션 엔진 표현 (예컨대, 도 5b 참조) 사이에 번역하는 것을 필요로 한다.

도 6a 는 Verilog HDL 실행 모델에서의 활성 이벤트 큐에 기초한, 순차 시뮬레이션 엔진 (600A) 과 동시 시뮬레이션 엔진 (600B) 사이의 예시적인 동기화를 도시한다. 각각의 시뮬레이션 엔진이 그의 자신의 활성 이벤트 큐를 갖는다는 점에 유의한다. 즉, 순차 시뮬레이션 엔진 (600A) 은 활성 이벤트들 (601) 을 갖고, 동시 시뮬레이션 엔진은 활성 이벤트들 (611) 을 갖는다. 일 실시형태에서, 순차 시뮬레이션 엔진 (600A) 에서 활성 이벤트 큐에 활성 이벤트들 (601) 이 더 이상 없을 때, 동시 시뮬레이션 엔진 (600B) 과 동기할 시간이다.

단계 630 에서, 동시 시뮬레이션 엔진 모듈에 대한 포트 인터페이스 변수 값들이 순차 시뮬레이션 엔진 (600A) 으로부터 번역 및 동기화 함수 (620) 로 전송된다. 이 번역 및 동기화 함수 (620) 는 순차 시뮬레이션 엔진 (600A) 에 의해 사용되는 스토리지 표현으로부터 동시 시뮬레이션 엔진 (600B) 에 의해 사용되는 스토리지 표현으로 (예컨대, 도 5a 에 나타낸 스토리지 표현으로부터 도 5b에 나타낸 스토리지 표현으로) 번역하는 것을 포함한다. 단계 631 에서, 활성 이벤트들 (611) 은 번역 전송된 포트 인터페이스 변수 값들에 기초하여 동시 시뮬레이션 엔진 (600B) 에서 실행된다. 단계 632 에서, 동시 시뮬레이션 엔진 모듈에 대한 포트 인터페이스 변수 값들이 번역 및 동기화 함수 (620) 를 경유해서 순차 시뮬레이션 엔진 (600A) 으로 전송된다. 이러한 방향 (direction) 에서, 번역 및 동기화 함수 (620) 는 동시 시뮬레이션 엔진 (600B) 에 의해 사용되는 스토리지 표현으로부터 순차 시뮬레이션 엔진 (600A) 에 의해 사용되는 스토리지 표현으로의 번역을 포함한다.

번역 및 동기화 함수 (620) 가 글루 로직 (640) 의 일부를 형성한다는 점에 유의한다. 이 글루 로직은 컴파일 타임 (compile time) 함수들 및 런타임 함수들 양자를 제공한다. 컴파일 타임 함수들은, 순차 시뮬레이션 엔진 (600A) 에 모든 모듈들에 대한 소스 코드가 주어질 때, 동시 시뮬레이션 엔진 (600B) 에 그에 할당된 모듈들의 정의들이 제공되지만, 순차 시뮬레이션 엔진 (600A) 에는 동일 모듈들에 대한 스터브 정의들이 제공되는 것을 보장하는 것을 포함한다. 런타임 함수들은 일단 시뮬레이터가 이벤트들을 실행 및 발생하기 시작하면, 순차 시뮬레이션 엔진과 동시 시뮬레이션 엔진 사이의 인터페이스 변수들의 번역이 제공된다는 것을 보장하는 것을 포함한다. 또한, 런타임 함수들은, 순차 시뮬레이션 엔진 (600A) 에서의 큐들의 실행이 Verilog HDL 실행 모델에 따르도록, 순차 시뮬레이션 엔진 (600A) 및 동시 시뮬레이션 엔진 (600B) 양자에서 시뮬레이션들의 적당한 동기화를 보장하는 것을 포함한다. 따라서, 번역 및 동기화 함수 (620) 는 글루 로직 (640) 의 런타임 함수들의 부분을 형성한다.

동시 시뮬레이션 엔진 (600B) 에서 활성 이벤트들 (611) 을 실행하는 것이 순차 시뮬레이션 엔진 (600A) 에서 추가적인 활성 이벤트들 (601) 을 발생할 수 있고, 이는 (번역 및 동기화 함수 (620) 를 이용하여 동기화되는) 단계 633 으로 표시된다는 점에 유의한다. 그후, Verilog HDL 실행 모델에 대해 이들 새로운 이벤트들이 실행된 후, 및 번역 및 동기화 함수 (620) 를 이용하여 단계들 630, 631, 632, 및 633 이 반복된다. (동시 시뮬레이션 엔진 (600B) 에 의해 발생된 추가적인 활성 이벤트들 또는 순차 시뮬레이션 엔진 (600A) 에서 이미 큐되어 있는 활성 이벤트들에 기초하여) 순차 시뮬레이션 엔진 (600A) 에 소정 활성 이벤트들 (601) 이 없으면, 순차 시뮬레이션 엔진 (600A) 의 비활성 이벤트 큐로부터의 비활성 이벤트들 (602) 이 Verilog HDL 실행 모델에 따라서 실행될 수 있다.

도 6a 에서의 활성 큐와 관련하여 설명한 동기화는 Verilog HDL 실행 모델에서 다른 큐 평가들로 확장될 수 있다. 예를 들어, 도 6b 는 순차 시뮬레이션 엔진 (600A) 및 동시 시뮬레이션 엔진 (600B) 에 대한 활성 이벤트 큐들 (활성 이벤트들 (601 및 611)), 비활성 이벤트 큐들 (비활성 이벤트들 (602 및 612)), 및 NBA 업데이트 이벤트 큐들 (NBA 업데이트 이벤트들 (603 및 613)) 을 포함하는 예시적인 확장 (extension) 을 도시한다. 순차 시뮬레이션 엔진 (600A) 과 동시 시뮬레이션 엔진 (600B) 사이의 활성, 비활성, 및 NBA 업데이트 큐들은 각각 (글루 로직 (640) 의 부분을 형성하는) 번역 및 동기화 함수들 (620, 621, 및 622) 를 이용하여 동기화된다.

큐가 순차 시뮬레이션 엔진 (600A) 에서 평가된 후, 인터페이스 변수 값들이 동시 시뮬레이션 엔진 (600B) 으로 전송된다. 그후, 이벤트들이 동시 시뮬레이션 엔진 (600B) 에서 대응하는 큐로부터 실행된다. 그후, 이벤트 실행들의 결과들을 포함하는 인터페이스 변수 값들이 순차 시뮬레이션 엔진 (600A) 으로 다시 전송되고, 이는 결국, Verilog HDL 실행 모델에 따라서 큐로부터 큐로 진행한다. 도 6b 에 나타낸 바와 같이, 순차 시뮬레이션 엔진 (600A) 또는 동시 시뮬레이션 엔진 (600B) 중 어느 하나에서 실행되는 임의의 이벤트가 더 높은 우선순위 또는 더 낮은 우선순위 중 어느 하나의 하나 이상의 이벤트들을 발생시킬 수도 있다는 점에 유의한다. 일반적으로, 번역 및 동기화 함수는 임의의 새로운 이벤트가 동시 시뮬레이션 엔진 (600B) 에 의해 발생될 때마다 통지되고, 그후, 그 새로운 이벤트는 순차 시뮬레이션 엔진 (600A) 의 적절한 큐에 놓인다.

위에서는, 활성 이벤트들, 비활성 이벤트들, 및 NBA 업데이트 이벤트들을 포함하여, Verilog HDL 에 기초한 예시적인 큐들이 기술되었다는 점에 유의한다. 그러나, 통합 로직 시뮬레이터는 다른 HDL들 및 이들 HDL들과 연관된 실행 모델들에 유리하게 적용할 수 있다. 따라서, 일반적으로, 통합 로직 시뮬레이터는 특정의 HDL 에 의해 제공되는 모든 클래스들의 이벤트들과 함께 작동될 수 있다. 더욱이, 각각의 특정의 HDL 은 통합 로직 시뮬레이터에 의해 이행될 수 있는 상이한 큐 전환 규칙들을 가질 수 있다.

예를 들어, 도 6c 는 VHDL (고속 집적 회로 (VHSIC) HDL) 모델에서의 예시적인 큐들의 시뮬레이션 실행 순서를 도시한다. VHDL 모델에서, 실행의 순서는 신호 업데이트 이벤트들, 기능 평가 이벤트들, 및 프로세스 평가 이벤트들을 통해서 진행하며, 또한, 이 방향으로 제어가 프로세스 실행의 종료에 도달할 때까지 흐르며, 프로세스 실행의 종료에 도달할 때, 제어는 신호 업데이트로 복귀한다는 점에 유의한다. 위에서 설명한 바와 같이, 순차 시뮬레이션 엔진 (600A) 과 동시 시뮬레이션 엔진 (600B) 사이의 각각의 실행 전환이, 번역 및 동기화 함수들 (620, 621, 및 622) 을 포함하는 글루 (glue) 로직 (640) 를 이용하여 용이하게 될 수 있다.

아래에서는, 관련된 활성 이벤트들 및 NBA 업데이트 이벤트들이 통합 로직 시뮬레이터에서 실행되는 일 예를 고려한다. 이들 이벤트들은 3개의 할당들 (여기서, Verilog 할당은 계산된 변수 값을 메모리 로케이션에 기록하는 것을 포함한다), 즉, 순차 시뮬레이션 엔진에 의해 시뮬레이션되는 모듈에서의 2개의 할당들, 및 동시 시뮬레이션 엔진에 의해 시뮬레이션되는 모듈로부터의 하나의 할당으로부터 유래한다:

순차 시뮬레이션 엔진

// 활성 이벤트.

always @(posedge CLK)

A = B + 1;

//NBA 업데이트 이벤트.

always @(posedge CLK)

C <= D;

동시 시뮬레이션 엔진

// 활성 이벤트.

always @(A)

B = A + 2;

상기 예에서, CLK 가 양 에지 (positive edge) 에서 트리거 (trigger) 할 때, 2개의 이벤트들이 발생된다. 하나의 이벤트는 순차 시뮬레이션 엔진 활성 이벤트 큐에 배치되며, 또 다른 이벤트는 순차 시뮬레이션 엔진 NBA 업데이트 이벤트 큐에 배치된다. 도 6b 에 대해 설명한 우선순위 시퀀스에 따라, 활성 이벤트가 Verilog HDL 실행 모델에 따라서 먼저 실행하며, 그후 순차 시뮬레이션 활성 이벤트 큐가 비게 된다. 이 빈 상태는 통합 로직 시뮬레이터가 도 6a 와 관련하여 설명한 4-단계 프로세스에 따라서 동시 시뮬레이션 엔진과 동기화할 수 있도록 한다.

구체적으로, 변수 A 에 대한 값이 순차 시뮬레이션 엔진으로부터 동시 시뮬레이션 엔진으로 전송된다.

동시 시뮬레이션 엔진에서 활성 이벤트들이 실행된다.

변수 B 에 대한 업데이트된 값이 동시 시뮬레이션 엔진으로부터 순차 시뮬레이션 엔진으로 전송된다.

동시 시뮬레이션에서 실행된 활성 이벤트들 때문에, 다음 큐 평가로 진행하기 전에 순차 시뮬레이션 엔진에서 행할 추가적인 작업 (즉, 새로운 활성 이벤트들) 이 있을 수도 있다. 따라서, 프로세스는 순차 시뮬레이션 엔진에서의 활성 이벤트 큐로 복귀한다.

이 지점에서는, 실행할 순차 시뮬레이션 엔진에서 활성 이벤트들이 더 이상 없다. 더욱이, 순차 시뮬레이션 엔진에 또는 동시 시뮬레이션 엔진에, 소정 비활성 이벤트들이 존재하지 않으며 (후자의 지점은 도 6a 에서 개요가 서술된 방식으로 비활성 이벤트 큐 상에서 동시 시뮬레이션 엔진과 동기화한 후에 결정된다), 이는 순차 시뮬레이션이 변수 C 로 기록하는 계류중인 NBA 업데이트 이벤트를 실행할 수 있다는 것을 의미한다.

일 실시형태에서, 행할 필요가 있는 작업량을 감소시키기 위해 오직 변경된 인터페이스 변수들 (또는, 대안으로, 인터페이스 변수들에서 오직 변경된 비트들) 만이 큐 평가 지점들에서 동기화된다. 다른 실시형태들에서, 변경된 인터페이스 변수들에 의한 시뮬레이션들만이 큐 평가 지점들에서 동기화된다. 큐 평가 지점은 하나의 시뮬레이션 엔진에서의 특정의 큐에서 모든 이벤트들이 종료될 때에 발생할 수 있다. 일 실시형태에서, 큐 평가 지점은 동기화, 즉, 다른 시뮬레이션 엔진에서의 실행을 위해 임의의 업데이트된 인터페이스 변수들을 대응하는 큐로 전송하는 글루 로직을 트리거할 수 있다. 그러나, 다른 실시형태들에서, 하나 이상의 인터페이스 변수들에서의 변화가 동기화를 트리거할 수 있다. 따라서, 동기화는 큐 평가들 전, 큐 평가들 후, 또는 큐 평가들 전 및 후 양자에서 (전체적으로 또는 부분적으로) 일어날 수 있다.

도 7 은 순차 시뮬레이션 엔진 (700A) 에 의해 시뮬레이션되는 상위 모듈 (701), 및 동시 시뮬레이션 엔진 (700B) 에 의해 시뮬레이션되는 가산기 모듈 (712) 을 도시한다. 이 실시형태에서, 상위 모듈 (701) 은 다수의 스터브 가산기 모듈들 (stub adder module; 702A, 702B, 702C, 및 702D) 을 포함한다. 특히, 순차 시뮬레이션 엔진 (700A) 에서 스터브 가산기 모듈들 (702A-702D) 의 모든 인스턴스들은 동시 시뮬레이션 엔진 (700B) 에서 가산기 모듈 (712) 의 단지 하나의 인스턴스에 의해 정의될 수 있다.

유리하게는, 이 양태는 통합 로직 시뮬레이터에 현저한 레버리지 (significant leverage) 를 제공한다. 구체적으로, 순차 시뮬레이터 엔진 (700A) 에서 각각의 스터브 모듈은 각각의 인터페이스 변수에 대해 별개의 스토리지를 가질 수 있는 반면, 동시 시뮬레이션 엔진 (700B) 에서 대응하는 모듈은 다수의 값들을 저장할 수 있는 하나의 워드를 가지며, 그에 의해 그 워드로 하여금, 다수의 스터브 모듈들과 연관된 인터페이스 변수 값들을 저장하는 것을 허용 수 있다. 예를 들어, 도 7 에서, 스터브 가산기 모듈들 (702A-702D) 은 각각의 인터페이스 변수에 대해, 스토리지 (703A-703D) 를 각각 가질 수 있다. 대조적으로, 동시 시뮬레이션 엔진 (700B) 에서 가산기 모듈 (712) 은 스터브 가산기 모듈들 (702A-702D) 각각으로부터 그들 인터페이스 변수들을 저장하기 위해 오직 하나의 워드 (713) 만을 필요로 한다.

스토리지 (703A-703D) 에 저장된 값들이 1-비트 값들 (예컨대, clk 값) 이라고 가정하면, 워드 (713) 의 각각의 비트는 특정의 스터브 모듈에 의해 저장된 값에 대응할 수 있다 (즉, 703A↔703A', 703B↔703B', 703C↔703C', 703D↔703D'). 따라서, 순차 시뮬레이션 엔진 (700A) 에서 스토리지 (703C) 에서의 인터페이스 변수 값이 이벤트의 실행 동안에 변화되면, 그 값은 동기화 동안에 동시 시뮬레이션 엔진 (700B) 에서 비트 (703C') 로 전송될 것이다. 이 전송이 도 5a 및 도 5b 와 관련하여 설명한 동일한 번역을 포함한다는 점에 유의한다. 또한, 다른 실시형태들이 멀티-비트 값들로서 동시 시뮬레이션 엔진 (700B) 의 하나의 워드의 위치들로 전송될 수 있는, 순차 시뮬레이션 엔진 (700A) 에 저장된 멀티-비트 값들을 가질 수도 있다는 점에 유의한다. 이 스토리지 구성 (configuration) 은 동시 시뮬레이션 엔진 (700B) 이 가산기 모듈 (712) 에서 다수의 (즉, 4) 값들로 다수의 (즉, 4) 동시 시뮬레이션들을 수행하는 것을 허용한다.

유리하게는, 로직 시뮬레이션에 이용되는 많은 컴퓨터들은 확장된 워드 값들, 예컨대, 32, 64, 또는 128 비트들의 레지스터들을 갖는다. 따라서, 통합 로직 시뮬레이터의 동시 시뮬레이션 엔진은 하나의 워드에 저장된 상당량의 데이터에 대해 동일한 동작을 동시에 적용할 수 있다.

위에서 설명한 실시형태에서, 순차 시뮬레이션 엔진은 동기화 지점들에서 동시 시뮬레이션 엔진을 인보크하는 순차 시뮬레이션 엔진이라는 의미에서, 통합 로직 시뮬레이터의 1차 시뮬레이션 엔진일 수 있다. 다른 실시형태에서, 동시 시뮬레이션 엔진이 1차 시뮬레이션 엔진이고, Verilog HDL 실행 모델에 따라서 큐로부터 큐로 진행하고, 적절한 동기화 지점들에서 순차 시뮬레이션 엔진을 인보크하는, 역의 구성이 또한 가능하다. 일 실시형태에서, 그 실행 모델에서 동기화 지점들은 Verilog 시뮬레이션으로의 사용자-정의 확장들을 구현하는데 사용되는, 산업 표준 애플리케이션 프로그래밍 인터페이스, 예컨대, 프로그래밍 언어 인터페이스 (PLI) 또는 검증 절차 인터페이스 (VPI) 를 통해서 확립될 수 있다. 또 다른 실시형태에서, 실행 모델에서 동기화 지점들은 하나 이상의 전용 인터페이스들을 통해서 확립될 수 있다.

일 실시형태에서, 어느 모듈들이 (동시 시뮬레이션 엔진에서 수행되는 연관된 동시 시뮬레이션로 그리고) 스터브 모듈들로서 인스턴스화될 수 있는지를 결정하기 위해 설계의 파티셔닝이 사용자에 의해 수동으로 수행될 수 있다. 또 다른 실시형태에서, 이 파티셔닝은 가능한 인스턴스들의 개수에 기초하여 시뮬레이션 툴에 의해 자동으로 수행될 수 있다 (즉, 인스턴스들의 개수가 더 많을 수록, 동시 시뮬레이션 엔진에 의해 달성가능한 레버리지가 커진다). 여전히 또 다른 실시형태에서, 파티셔닝은 시뮬레이션 성능의 바람직한 레벨을 달성하기 위해서, 순차 시뮬레이션 엔진의 능력들 및/또는 동시 시뮬레이션 엔진의 또는 능력들에 기초하여 행해질 수 있다. 예를 들어, 모듈이 PLI (프로그래밍 언어 인터페이스) 를 통해서 사용자-정의 C 함수들에 광범위한 콜들을 행하면, 그 모듈은 사용자-정의 함수가 동시 시뮬레이션 엔진의 값 표현을 이용하는 능력 없이 대개 기록되었을 가능성이 있기 때문에, 순차 시뮬레이션 엔진에 의한 실행에 더 적합할 수도 있다.

설계 계층을 고려하여 설계의 파티셔닝이 이루어질 수 있다는 점에 유의한다. 예를 들어, 일 실시형태에서, 제 1 모듈이 2차 시뮬레이션 엔진에 의해 시뮬레이션된다는 것은 그 제 1 모듈 아래의 설계 계층 내에 더 깊이 인스턴스화된 모든 하위-모듈들이 또한 2차 시뮬레이션 엔진에 의해 시뮬레이션된다는 것을 암시한다. 또 다른 실시형태에서, (2차 시뮬레이션 엔진에 의해 시뮬레이션된) 제 1 모듈이 제 2 모듈을 인스턴스화하면, 제 2 모듈이 1차 시뮬레이션 엔진에 의해 시뮬레이션된다. 위에서 언급한 바와 같이, 1차 시뮬레이션 엔진은 순차 시뮬레이션 엔진일 수 있으며, 제 2 시뮬레이션 엔진은 동시 시뮬레이션 엔진일 수 있다 (그리고, 반대도 마찬가지 이다).

예를 들어, 다음의 코드는 통합 로직 시뮬레이터에 내재하는 유연성의 예시적인 경우를 제공한다.

// 최초 Verilog

module top_module;

　 reg clk;

　 reg [7:0] input1;

　 reg [7:0] input2;

　 wire [7:0] sum;

　 wire [7:0] product;

　 adder_and_mult am(.clk(clk),

　　 .a(input1),

　　　　　 .b(input2),

　　　　　 .sum(sum),

　　　　 .product(product));

endmodule

module adder_and_mult(clk, a, b, sum, product);

　 input clk;

　 input [7:0] a;

　 input [7:0] b;

　 output [7:0] sum;

　 output [7:0] product;

　 always @(posedge clk)

　　　 sum = a + b;

　 multiplier mult(.clk(clk),

　　　　　　 .a(a),

　　　　　　　　　　 .b(b),

　　　　　　　　　 .product(product));

endmodule

module multiplier(clk, a, b, product);

　 input clk;

　 input [7:0] a;

　 input [7:0] b;

　 output [7:0] product;

　 always @(posedge clk)

　　　 product = a * b;

endmodule

// 순차 시뮬레이션 엔진에 의해 시뮬레이션되는 Verilog + 스터브 모듈들.

// 순차 시뮬레이션 엔진에 의해 시뮬레이션됨.

module top_module;

　 reg clk;

　 reg [7:0] input1;

　 reg [7:0] input2;

　 wire [7:0] sum;

　 wire [7:0] product;

　 adder_and_mult am(.clk(clk),

　　　　　　　　 .a(input1),

　　　　　　　　　　 .b(input2),

　　　　　　　　　　 .sum(sum),

　　　　　　　　　　 .product(product));

endmodule

// 동시 시뮬레이션 엔진에 의해 시뮬레이션됨.

module adder_and_mult(clk, a, b, sum, product);

　 input clk;

　 input [7:0] a;

　 input [7:0] b;

　 output [7:0] sum;

　 output [7:0] product;

　 multiplier mult(.clk(clk),

　　　　　　　　　 .a(a),

　　　　　　　　　 .b(b),

　　　　　　　　　　 .product(product));

endmodule

// 순차 시뮬레이션 엔진에 의해 시뮬레이션됨.

module multiplier(clk, a, b, product);

　 input clk;

　 input [7:0] a;

　 input [7:0] b;

　 output [7:0] product;

　 always @(posedge clk)

　　　 product = a * b;

endmodule

도 8 이 상술한 코드를 나타내는 블록도를 도시한다는 점에 유의한다. 이 실시형태에서, 순차 시뮬레이션 엔진 (811) 은 상위 모듈 (801) 을 담당하도록 이루어지며, 이 상위 모듈은 스터브 가산기 및 승산기 모듈 (stub adder and multiplier module; 802A) 을 포함한다. 동시 시뮬레이션 엔진 (812) 은 임베딩된 가산기 및 승산기 모듈 (802) 을 담당하도록 이루어진다. 이 경우, 실제 가산기 HDL 는 동시 시뮬레이션 엔진 (802) 에 의해 시뮬레이션될 수 있으며, 동시 시뮬레이션 엔진 (812) 은 임베딩된 승산기 모듈에 대한 스터브 모듈 (803A) 과 상호작용할 수 있다. 이 실시형태에서, 가산기 및 승산기 모듈 (802) 은 순차 시뮬레이션 엔진 (811) 에서의 승산기 모듈 (multiplier module; 803) 과 상호작용하는 스터브 승산기 모듈 (803A) 을 포함한다. 즉, 모듈 아래의 설계 계층 내에 더 깊이 인스턴스화된 임의의 하위-모듈들 (스터브 모듈로부터 시뮬레이션을 수행하도록 지시된 임의의 모듈) 은 순차 시뮬레이션 엔진 (811) 또는 동시 시뮬레이션 엔진 (812) 중 어느 하나에 의해 행해지도록 구조화될 수 있다. 일반적으로, 순차 시뮬레이션 엔진 (811) 과 동시 시뮬레이션 엔진 (812) 사이의 이러한 시뮬레이션 책무의 이전은 임의의 횟수로 수행될 수 있으며, 시스템 리소스들을 최적화하기 위해 구조화될 수 있다는 점에 유의한다.

동시 시뮬레이션 엔진이 상위 모듈에 임베딩된 가산기 모듈에 대해 이벤트들을 실행하는 것으로 위에서 설명되었지만, 통합 로직 시뮬레이션은 다른 유형들의 상부/임베딩된 모듈들에 동일하게 적용할 수 있다는 점에 유의한다. 예를 들어, 또 다른 임베딩된 모듈은 순차 시뮬레이션 엔진에서 스터브 모듈로서 표현될 수 있는 DUT (device under test) 를 포함할 수 있다. 이 경우, 상위 모듈은 테스트 벤치 (test bench) 를 포함할 수 있다.

도 9 는 통합 로직 시뮬레이터를 포함하는 예시적인 디지털 ASIC 설계 흐름의 간략화된 표현을 나타낸다. 하이 레벨에서, 프로세스는 제품 아이디어에서 시작하며 (단계 900), EDA 소프트웨어 설계 프로세스에서 달성된다 (단계 910). 설계가 종료되면, 테이프-아웃 (tape-out) 될 수 있다 (이벤트 940). 테이프 아웃 후, 제조 프로세스 (단계 950) 및 패키징 및 조립 프로세스들 (단계 960) 가 일어나, 궁극적으로, 완성된 칩들이 얻어진다 (결과 970).

EDA 소프트웨어 설계 프로세스 (단계 910) 는, 간결성을 위해 선형 형식으로 나타낸, 많은 단계들 912-930 로 실제로 구성된다. 실제 ASIC 설계 프로세스에서, 특정한 설계는 소정 테스트들이 통과될 때까지 단계들을 다시 거칠 수 있다. 이와 유사하게, 임의의 실제 설계 프로세스에서, 이들 단계들은 상이한 순서들 및 조합들로 일어날 수도 있다. 따라서, 이 설명은 특정한 ASIC 에 대한 특정의 또는 권장된 설계 흐름으로서 보다는, 문맥 및 일반적인 설명으로서 제공된다.

이하, EDA 소프트웨어 설계 프로세스 (단계 910) 의 구성요소 단계들의 간단한 설명이 제공된다:

시스템 설계 (단계 912): 설계자들은 그들이 구현하기를 원하는 기능을 기술하고, 그들은 기능을 리파인 (refine) 하고, 비용을 체크하는 등을 위해, 가정의 계획 (what-if planning) 을 수행할 수 있다. 하드웨어-소프트웨어 아키텍쳐 파티셔닝이 이 단계에서 일어날 수 있다. 이 단계에서 이용될 수 있는, Synopsys 사로부터의 예시적인 EDA 소프트웨어 제품들은 Model Architect, Saber, System Studio, 및 DesignWare? 제품들을 포함한다.

로직 설계 및 기능 검증 (단계 914): 이 단계에서, 시스템에서의 모듈들에 대한 VHDL 또는 Verilog 코드가 기록되며, 설계가 기능적 정확도에 대해 체크된다. 좀더 구체적으로는, 정확한 출력들을 발생하는 것을 보증하기 위해 설계가 체크된다. 이 단계에서 이용될 수 있는, Synopsys 사로부터의 예시적인 EDA 소프트웨어 제품들은 VCS, VERA, DesignWare?, Magellan, Formality, ESP 및 LEDA 제품들을 포함한다. 일 실시형태에서, 위에서 설명한 통합 로직 시뮬레이터가 로직 설계 및 기능 검증 단계 (914) 동안에 구현될 수 있다.

테스트를 위한 종합 (synthesis) 및 설계 (단계 916): 여기서, VHDL/Verilog 가 netlist 로 번역된다. netlist 는 목표 기술을 위해 최적화될 수 있다. 추가적으로, 마무리된 칩의 체킹을 허용하게 하기 위하여 테스트들의 설계 및 구현이 일어난다. 이 단계에서 이용될 수 있는, Synopsys 사로부터의 예시적인 EDA 소프트웨어 제품들은 Design Compiler?, Power Compiler, DFTMAX, TetraMAX, 및 DesignWare? 제품들을 포함한다.

Netlist 검증 (단계 918): 이 단계에서, netlist 가 타이밍 제약과의 호환성 (compliance) 에 대해, 그리고 VHDL/Verilog 소스 코드와의 대응성 (correspondence) 에 대해 체크된다. 이 단계에서 이용될 수 있는, Synopsys, Inc.부터의 예시적인 EDA 소프트웨어 제품들은 Formality, PrimeTime, 및 VCS 제품들을 포함한다.

설계 계획 (단계 920): 여기서, 칩에 대한 전체 평면도가 구성되어, 타이밍 및 상위 레벨 라우팅에 대해 분석된다. 이 단계에서 이용될 수 있는, Synopsys, Inc.로부터의 예시적인 EDA 소프트웨어 제품들은 Astro 및 IC Compiler 제품들을 포함한다.

물리적 구현 (단계 922): 배치 (회로 엘리먼트들의 위치 결정) 및 라우팅 (회로 엘리먼트들의 접속) 이 이 단계에서 일어난다. 이 단계에서 이용될 수 있는, Synopsys, Inc.로부터의 예시적인 EDA 소프트웨어 제품들은 Astro 및 IC Compiler 제품들을 포함한다.

분석 및 추출 (단계 924): 이 단계에서, 회로 기능이 트랜지스터 레벨에서 검증되며, 이것은 결국 가정의 리파인먼트 (refinement) 를 허용한다. 이 단계에서 이용될 수 있는, Synopsys, Inc.로부터의 예시적인 EDA 소프트웨어 제품들은 AstroRail, PrimeRail, Primetime, 및 Star RC/XT 제품들을 포함한다.

물리적 검증 (단계 926): 이 단계에서, 다양한 체킹 기능들이 제조, 전기적 문제들, 리소그래픽 문제들, 및 회로에 대한 정확성을 보증하기 위해 수행된다. 이 단계에서 이용될 수 있는, Synopsys, Inc.로부터의 예시적인 EDA 소프트웨어 제품들은 Hercules 제품을 포함한다.

해상도 향상 (단계 928): 이 단계는 설계의 제조성을 향상하기 위해 레이아웃의 기하학적 조작들을 수반한다. 이 단계에서 이용될 수 있는, Synopsys, Inc.로부터의 예시적인 EDA 소프트웨어 제품들은 Proteus, ProteusAF, 및 PSMGen 제품들을 포함한다.

마스크 데이터 준비 (단계 930): 이 단계는 완성된 칩들을 제조하기 위해, 리소그래픽 이용을 위한 마스크들의 제조에 "테이프-아웃 (tape-out)" 데이터를 제공한다. 이 단계에서 이용될 수 있는, Synopsys, Inc.로부터의 예시적인 EDA 소프트웨어 제품들은 CATS(R) 계 (family) 의 제품을 포함한다.

위에서 설명한 통합 로직 시뮬레이터는 데이터 스토리지 시스템, 적어도 하나의 입력 디바이스, 및 적어도 하나의 출력 디바이스로부터 데이터 및 명령들을 수신하고 데이터 스토리지 시스템으로 데이터 및 명령들을 송신하도록 커플링된 적어도 하나의 프로그래밍가능한 프로세서를 포함하는 프로그래밍가능한 시스템 상에서 실행하는 하나 이상의 컴퓨터 프로그램들을 이용하여 실행할 수 있다. 각각의 컴퓨터 프로그램은, 고급 (high-level) 절차 또는 객체 지향 프로그래밍 언어로, 또는 원할 경우 어셈블리 또는 기계 언어로 구현될 수 있다; 어쨌든, 언어는 컴파일 또는 해석 언어일 수 있다. 적당한 프로세서들은 예시적으로, 범용 및 특수 목적 마이크로프로세서들 양자, 뿐만 아니라, 다른 유형들의 마이크로-제어기들을 포함한다. 일반적으로, 프로세서는 판독전용 메모리 및/또는 랜덤 액세스 메모리로부터 명령들 및 데이터를 수신할 것이다. 일반적으로, 컴퓨터는 데이터 파일들을 저장하는 하나 이상의 대용량 스토리지 디바이스들을 포함할 것이다; 이런 디바이스들은 자기 디스크들, 예컨대 내부 하드 디스크들 및 착탈식 디스크들, 광자기 디스크들, 및 광학 디스크들을 포함한다. 컴퓨터 프로그램 명령들 및 데이터를 유형으로 구현하기에 적합한 스토리지 디바이스들은 예시적으로, EPROM, EEPROM, 및 플래시 메모리 디바이스들과 같은 반도체 메모리 디바이스들, 내부 하드 디스크들 및 착탈식 디스크들과 같은 자기 디스크들, 광자기 디스크들, 및 CD-ROM 디스크들을 포함한, 모든 유형들의 비휘발성 메모리를 포함한다. 전술한 것들 중 임의의 것이 주문형 집적 회로 (ASIC) 들에 의해 보충되거나 또는 주문형 집적 회로 (ASIC) 들에 통합될 수 있다.

위에서는, 본 발명의 하나 이상의 실시형태들의 상세한 설명이 본 발명의 원리들을 예시하는 첨부도면에 따라서 제공된다. 본 발명은 이런 실시형태들과 관련하여 설명되지만, 본 발명은 임의의 실시형태에 한정되지 않는다. 본 발명의 범위는 오직 청구항에 의해서만 한정되며, 본 발명은 많은 대체물들, 변형물들 및 균등물들을 포괄한다. 본 발명의 완전한 이해를 제공하기 위해, 다음의 설명에, 많은 특정의 세부 사항들이 개시된다. 이들 세부 사항들은 예시의 목적을 위해 제공되며, 본 발명은 이들 구체적인 세부 사항들의 일부 또는 전부 없이 청구범위에 따라서 실시될 수도 있다. 명료성의 목적을 위해, 본 발명에 관련된 기술분야들에 공지된 기술적 자료는 본 발명이 불필요하게 불명료하게되지 않도록 하기 위해서, 상세히 설명되지 않았다.

Claims

하드웨어 기술 언어 (HDL) 을 통해서 기입된 설계를 시뮬레이션하는 방법으로서,
순차 시뮬레이션 엔진 및 동시 시뮬레이션 엔진을 포함하는 통합 로직 시뮬레이터를 실행하는 단계;
한번에 하나의 시뮬레이션을 수행하는 상기 순차 시뮬레이션 엔진을 이용하여, 시뮬레이션을 수행하는 단계;
다수의 동시 시뮬레이션들을 수행하는 상기 동시 시뮬레이션 엔진을 이용하여, 시뮬레이션을 수행하는 단계; 및
상기 HDL의 실행 모델에 의해 정의된 클래스들의 이벤트들에 기초하여, 상기 순차 시뮬레이션 엔진과 상기 동시 시뮬레이션 엔진의 시뮬레이션들을 동기화하는 단계를 포함하는, 하드웨어 기술 언어 (HDL) 을 통해서 기입된 설계를 시뮬레이션하는 방법.
제 1 항에 있어서,
상기 설계를 상기 통합 로직 시뮬레이터에 의해 실행되는 모듈들의 2개의 그룹들로 파티셔닝하는 단계를 더 포함하고,
상기 2개의 그룹들은 상기 순차 시뮬레이션 엔진에 대한 평가를 위한 모듈들의 제 1 그룹, 및 상기 동시 시뮬레이션 엔진에 대한 평가를 위한 모듈들의 제 2 그룹을 포함하는, 하드웨어 기술 언어 (HDL) 을 통해서 기입된 설계를 시뮬레이션하는 방법.
제 2 항에 있어서,
상기 파티셔닝은 상기 설계의 설계 계층을 고려하여 수행되는, 하드웨어 기술 언어 (HDL) 을 통해서 기입된 설계를 시뮬레이션하는 방법.
제 3 항에 있어서,
제 1 모듈이 상기 동시 시뮬레이션 엔진에 의해 시뮬레이션될 때, 상기 제 1 모듈 아래의 상기 설계 계층 내에 더 깊이 인스턴스화된 임의의 하위-모듈이 또한 상기 동시 시뮬레이션 엔진에 의해 시뮬레이션되는, 하드웨어 기술 언어 (HDL) 을 통해서 기입된 설계를 시뮬레이션하는 방법.
제 3 항에 있어서,
제 1 시뮬레이션 엔진에 의해 시뮬레이션되는 제 1 모듈이 제 2 모듈을 인스턴스화할 때, 상기 제 2 모듈은 제 2 시뮬레이션 엔진에 의해 시뮬레이션되며,
상기 제 2 모듈은 상기 제 1 시뮬레이션 엔진에 의해 시뮬레이션되는 제 3 모듈을 인스턴스화하며,
상기 제 1 시뮬레이션 엔진 및 상기 제 2 시뮬레이션 엔진은, (1) 각각 상기 순차 시뮬레이션 엔진과 상기 동시 시뮬레이션 엔진, 및 (2) 각각 상기 동시 시뮬레이션 엔진 및 상기 순차 시뮬레이션 엔진 중 하나인, 하드웨어 기술 언어 (HDL) 을 통해서 기입된 설계를 시뮬레이션하는 방법.
제 3 항에 있어서,
상기 순차 시뮬레이션 엔진 및 상기 동시 시뮬레이션 엔진 중 하나를 상기 통합 로직 시뮬레이터의 1차 시뮬레이션 엔진으로 지정하는 단계, 및
다른 하나의 시뮬레이션 엔진을 상기 통합 로직 시뮬레이터의 2차 시뮬레이션 엔진으로 지정하는 단계를 더 포함하며,
상기 1차 시뮬레이션 엔진은 동기화 지점들에서 상기 2차 시뮬레이션 엔진을 인보크하는, 하드웨어 기술 언어 (HDL) 을 통해서 기입된 설계를 시뮬레이션하는 방법.
제 6 항에 있어서,
상기 동기화 지점들은 상기 HDL의 실행 모델에 의해 정의되는 대로 큐 평가들 전에 있는, 하드웨어 기술 언어 (HDL) 을 통해서 기입된 설계를 시뮬레이션하는 방법.
제 6 항에 있어서,
상기 동기화 지점들은 상기 HDL의 실행 모델에 의해 정의되는 대로 큐 평가들 후에 있는, 하드웨어 기술 언어 (HDL) 을 통해서 기입된 설계를 시뮬레이션하는 방법.
제 6 항에 있어서,
상기 2차 시뮬레이션 엔진 모듈들에서의 소정 변수들을, 상기 1차 시뮬레이션 엔진과 통신하기 위한 인터페이스 변수들로서 식별하는 단계를 더 포함하는, 하드웨어 기술 언어 (HDL) 을 통해서 기입된 설계를 시뮬레이션하는 방법.
제 9 항에 있어서,
상기 인터페이스 변수들의 값들을, 상기 순차 시뮬레이션 엔진 및 상기 동시 시뮬레이션 엔진에 저장하는 단계를 더 포함하는, 하드웨어 기술 언어 (HDL) 을 통해서 기입된 설계를 시뮬레이션하는 방법.
제 9 항에 있어서,
상기 동기화 지점들에서 상기 2차 시뮬레이션 엔진에서의 이벤트들을 평가하기 전에, 인터페이스 변수 값들을 상기 2차 시뮬레이션 엔진으로 전송하는 단계를 더 포함하는, 하드웨어 기술 언어 (HDL) 을 통해서 기입된 설계를 시뮬레이션하는 방법.
제 9 항에 있어서,
상기 동기화 지점들에서 상기 2차 시뮬레이션 엔진에서의 이벤트들을 평가한 후에, 인터페이스 변수 값들을 상기 1차 시뮬레이션 엔진으로 전송하는 단계를 더 포함하는, 하드웨어 기술 언어 (HDL) 을 통해서 기입된 설계를 시뮬레이션하는 방법.
제 12 항에 있어서,
2차 시뮬레이션 엔진 모듈은 상기 1차 시뮬레이션 엔진에서 스터브 모듈로 표현되는, 하드웨어 기술 언어 (HDL) 을 통해서 기입된 설계를 시뮬레이션하는 방법.
하드웨어 기술 언어 (HDL) 를 통해서 기입된 설계를 시뮬레이션하는 컴퓨터 실행가능 명령들을 저장한 컴퓨터 판독가능 매체로서,
상기 컴퓨터 실행가능 명령들은,
컴퓨터에 의해 실행될 때,
순차 시뮬레이션 엔진 및 동시 시뮬레이션 엔진을 포함하는 통합 로직 시뮬레이터를 실행하는 단계;
한번에 하나의 시뮬레이션을 수행하는 상기 순차 시뮬레이션 엔진을 이용하여, 시뮬레이션을 수행하는 단계;
다수의 동시 시뮬레이션들을 수행하는 상기 동시 시뮬레이션 엔진을 이용하여, 시뮬레이션을 수행하는 단계; 및
상기 HDL의 실행 모델에 의해 정의된 클래스들의 이벤트들에 기초하여, 상기 순차 시뮬레이션 엔진과 상기 동시 시뮬레이션 엔진의 시뮬레이션들을 동기화하는 단계를 포함하는 단계들을 수행하는, 컴퓨터 실행가능 명령들을 저장한 컴퓨터 판독가능 매체.
제 14 항에 있어서,
상기 설계를 상기 통합 로직 시뮬레이터에 의해 실행되는 모듈들의 2개의 그룹들로 파티셔닝하는 단계를 더 포함하고,
상기 2개의 그룹들은 상기 순차 시뮬레이션 엔진에 대한 평가를 위한 모듈들의 제 1 그룹, 및 상기 동시 시뮬레이션 엔진에 대한 평가를 위한 모듈들의 제 2 그룹을 포함하는, 컴퓨터 실행가능 명령들을 저장한 컴퓨터 판독가능 매체.
제 15 항에 있어서,
상기 파티셔닝은 상기 설계의 설계 계층을 고려하여 수행되는, 컴퓨터 실행가능 명령들을 저장한 컴퓨터 판독가능 매체.
제 16 항에 있어서,
제 1 모듈이 상기 동시 시뮬레이션 엔진에 의해 시뮬레이션될 때, 상기 제 1 모듈 아래의 상기 설계 계층 내에 더 깊이 인스턴스화된 임의의 하위-모듈이 또한 상기 동시 시뮬레이션 엔진에 의해 시뮬레이션되는, 컴퓨터 실행가능 명령들을 저장한 컴퓨터 판독가능 매체.
제 16 항에 있어서,
제 1 시뮬레이션 엔진에 의해 시뮬레이션되는 제 1 모듈이 제 2 모듈을 인스턴스화할 때, 상기 제 2 모듈은 제 2 시뮬레이션 엔진에 의해 시뮬레이션되며,
상기 제 2 모듈은 상기 제 1 시뮬레이션 엔진에 의해 시뮬레이션되는 제 3 모듈을 인스턴스화하며,
상기 제 1 시뮬레이션 엔진 및 상기 제 2 시뮬레이션 엔진은, (1) 각각 상기 순차 시뮬레이션 엔진과 상기 동시 시뮬레이션 엔진, 및 (2) 각각 상기 동시 시뮬레이션 엔진 및 상기 순차 시뮬레이션 엔진 중 하나인, 컴퓨터 실행가능 명령들을 저장한 컴퓨터 판독가능 매체.
제 15 항에 있어서,
상기 순차 시뮬레이션 엔진 및 상기 동시 시뮬레이션 엔진 중 하나를 상기 통합 로직 시뮬레이터의 1차 시뮬레이션 엔진으로 지정하는 단계, 및
다른 하나의 시뮬레이션 엔진을 상기 통합 로직 시뮬레이터의 2차 시뮬레이션 엔진으로 지정하는 단계를 더 포함하며,
상기 1차 시뮬레이션 엔진은 동기화 지점들에서 상기 2차 시뮬레이션 엔진을 인보크하는, 컴퓨터 실행가능 명령들을 저장한 컴퓨터 판독가능 매체.
제 19 항에 있어서,
상기 동기화 지점들은 상기 HDL의 실행 모델에 의해 정의되는 대로 큐 평가들 전에 있는, 컴퓨터 실행가능 명령들을 저장한 컴퓨터 판독가능 매체.
제 19 항에 있어서,
상기 동기화 지점들은 상기 HDL의 실행 모델에 의해 정의되는 대로 큐 평가들 후에 있는, 컴퓨터 실행가능 명령들을 저장한 컴퓨터 판독가능 매체.
제 19 항에 있어서,
상기 2차 시뮬레이션 엔진 모듈들에서의 소정 변수들을, 상기 1차 시뮬레이션 엔진과 통신하기 위한 인터페이스 변수들로서 식별하는 단계를 더 포함하는, 컴퓨터 실행가능 명령들을 저장한 컴퓨터 판독가능 매체.
제 19 항에 있어서,
상기 실행 모델에서의 상기 동기화 지점들은 산업 표준 애플리케이션 프로그래밍 인터페이스를 통해서 확립되는, 컴퓨터 실행가능 명령들을 저장한 컴퓨터 판독가능 매체.