KR20070108303A - 체계적 점진적 구체화를 통한 전자시스템수준에서부터게이트수준까지의 검증 방법 - Google Patents

Abstract

본 발명은 추상화수준이 높은 시스템 수준으로부터 수차례의 구체화 과정을 통하여 이루어지는 디지털 시스템의 설계를 위한 설계 검증을 설계 전체 과정에서 체계적이며 효율적으로 수행하는 검증 장치와 이를 이용한 체계적이며 효과적인 검증 방법에 관한 것이다.

본 발명에서는 임의의 컴퓨터에서 수행되어지는 본 발명의 검증 소프트웨어로 하여금 원 설계 코드에 부가적인 코드나 부가적인 회로를 추가하고, 필요시에는 원 설계 코드로 구술된 모델보다 추상화 수준이 높은 모델을 생성하기 위하여 원 설계 코드와는 다른 코드로 본 발명의 검증 소프트웨어를 사용한 자동화된 방식 내지는 수동적 방식을 통한 모델링 과정을 통하여 얻게되는 상기 추상화 수준이 높은 모델을 대상으로 하는 1회 이상의 시뮬레이션도 수행하게 한다. 시뮬레이션 수행은 상이한추상수준 동일모델 내지는 후단 시뮬레이션 대상이 되는 모델을 이용하는 앞단 시뮬레이션과 앞단 시뮬레이션 대상이 되는 모델과 상이한추상수준 동일모델 내지는 앞단 시뮬레이션 대상이 되는 모델을 이용하는 후단 시뮬레이션으로 나누어지며, 앞단 시뮬레이션의 시뮬레이션 결과를 효과적으로 이용하는 후단 시뮬레이션은 1 내지는 2 이상의 컴퓨터에서 수행되는 1 회 이상의 시뮬레이션을 1 내지는 2 이상의 시뮬레이터를 이용하여 순차적 수행을 가능하게 할뿐만 아니라, 네트워크 상에서 연결된 2 이상의 컴퓨터에서 돌아가는 2 이상의 시뮬레이터를 이용하여 상호 최대한 독립적인 병렬적 수행을 가능하게 함으로서 전체 검증 시간과 검증 비용의 대폭적인 단축을 가능하게 하고, 검증의 효율성을 크게 높일 수 있게 한다.

하드웨어 검증

Description

체계적 점진적 구체화를 통한 전자시스템수준에서부터 게이트수준까지의 검증 방법 {Verification Method from Electronic System Level to Gate Level Using Systematic Progressive Refinement}

도1 은, 본 발명에 관한 설계 검증 장치의 일 예를 개략적으로 도시한 도면.

도2 는, 본 발명에 관한 설계 검증 장치의 또 다른 일 예를 개략적으로 도시한 도면.

도3 은, ESL 모델의 계층구조 일 예를 이에 대응되는 RTL 모델의 계층구조의 일 예와 비교하여서 개략적으로 도시한 도면.

도4 는, RTL 모델의 계층구조 일 예를 이에 대응되는 GL 모델의 계층구조의 일 예와 비교하여서 개략적으로 도시한 도면.

도5 는, 분산병렬 시뮬레이션의 수행이 2 이상의 컴퓨터들이 컴퓨터네트워크로 연결된 상황에서 수행되어지는 상황의 일 예를 개략적으로 도시한 도면.

도6 은, 추상화 상위수준 모델을 이용한 앞단 시뮬레이션에서 t-DCP를 획득하고 추상화 하위수준 모델을 이용한 후단 시뮬레이션을 시간분할적병렬수행으로 진행되는 일 예를 개략적으로 도시한 도면.

도 7은, 추상화 상위수준 모델을 이용한 앞단 시뮬레이션에서 s-DCP를 획득하고 추상화 하위수준 모델을 이용한 후단 시뮬레이션을 분산처리적병렬수행으로 진행되는 일 예를 개략적으로 도시한 도면.

도 8은, 본 특허에서 제시한 분산처리적병렬시뮬레이션을 위하여 부가되는 부가코드의 내부를 구성하는 컴퍼넌트들의 구성 일 예를 개략적으로 도시한 도면.

도9 는, 레지스터전송수준에서의 시그널 단위의 사이클정확한 버스 동작상황과 트란젝션수준에서의 트란젝션 단위의 사이클정확한 버스 동작상황의 일 예를 개략적으로 도시한 도면.

도10 은, 도 3에서 예시한 ESL 모델내의 설계객체들과 이에 대응되는 RTL 모델내의 설계객체들을 개략적으로 도시한 도면.

도11 은, 도 10에서 예시한 ESL 모델내의 설계객체들 각각을 대응되는 RTL 모델내의 설계객체로 대체하여서 추상화 중간수준의 혼합된 설계객체 DO_t_mixed(i)들을 생성하는 일 예를 개략적으로 도시한 도면.

도12 는, 도 11에서 예시한 여섯 개의 혼합된 설계객체 DO_t_mixed(1), DO_t_mixed(2), .., DO_t_mixed(6)를 이용한 여섯의 혼합 시뮬레이션의 독립적 병렬 실행과 이 실행 과정에서 1 내지는 2 이상의 시뮬레이션 시점들 내지는 구간들에서 수집된 상태정보들을 이용하여서 후단 시뮬레이션 단계인 RTL 모델에 대한 시뮬레이션을 시간분할적병렬수행으로 수행하는 일 예를 개략적으로 도시한 도면.

도13 은, 점진적 구체화 과정을 통하여 처음 추상화 수준에서부터 마지막 추상화 수준으로 진행되는 설계 및 검증 과정의 일 예를 개략적으로 도시한 도면.

도14 는, 점진적 구체화 과정을 거쳐서 트란젝션 수준의 모델에서부터 RTL 모델을 거쳐서 게이트수준의 모델까지 생성되는 과정의 일 예를 개략적으로 도시한 도면.

도15 는, 점진적 구체화 과정을 거쳐서 사이클정확 트란젝션 수준의 모델을 이용한 검증에서부터 RTL 모델을 이용한 검증을 거쳐서 게이트수준의 모델을 이용한 검증까지 진행되는 과정에 s-DCP 내지는 t-DCP를 이용하여서 추상화 하위수준 모델에 대한 시뮬레이션을 분산처리적병렬수행 내지는 시간분할적병렬수행으로 진행하는 것의 일 예를 개략적으로 도시한 도면.

도16 은, 본 특허에서의 시뮬레이션 방법을 진행하는 예제 모델의 일부분을 개략적으로 도시한 도면.

도17 은, 도16 에서 예시한 예제 모델을 분산처리적병렬시뮬레이션으로 수행시키기 위하여 본 특허의 검증 소프트웨어를 이용하여 부가 코드를 부가한 상황의 일 예를 부분적으로 개략적으로 도시한 도면

도18 은, 도16 에서 예시한 예제 모델을 분산처리적병렬시뮬레이션으로 수행시키기 위하여 본 특허의 검증 소프트웨어를 이용하여 부가 코드를 부가한 상황의 일 예를 또 다른 부분적으로 개략적으로 도시한 도면

도19 는, 도16 에서 예시한 예제 모델을 분산처리적병렬시뮬레이션으로 수행시키기 위하여 본 특허의 검증 소프트웨어를 이용하여 부가 코드를 부가한 상황의 일 예를 또 다른 부분적으로 개략적으로 도시한 도면

도20 은, 분산처리적병렬수행/단일수행 혼용방식의 수행 상황의 일 예를 개략적으로 도시한 도면.

도21 은, 시뮬레이션가속을 통한 시뮬레이션을 분산처리적병렬수행으로 진행함으로서 시뮬레이터와 하드웨어기반검증플랫폼 간의 동기 오버헤드 및 통신 오버헤드를 감소시키는 상황의 일 예를 개략적으로 도시한 도면.

도22 는, 본 특허에서의 분산처리적병렬수행 방식의 시뮬레이션을 위한 2 이상의 컴퓨터에 인스톨된 2 이상의 로컬컴퓨터들의 논리적연결구조 방식들의 몇가지 사례들을 개략적으로 도시한 도면.

도23 은, 분산병렬 시뮬레이션을 2 이상의 컴퓨터들과 이들 컴퓨터에 인스톨된 2 이상의 HDL 시뮬레이터들을 이용하여서 구성한 분산병렬 시뮬레이션 환경의 일 예를 개략적으로 도시한 도면.

도24 는, 통상적인 분산병렬 시뮬레이션의 전체 진행 흐름도의 일 예를 개략적으로 도시한 도면.

도25 는, 본 특허에서의 분산처리적병렬시뮬레이션의 전체 진행 흐름도의 일 예를 개략적으로 도시한 도면.

도26 은, 본 특허에서의 분산처리적병렬시뮬레이션 수행을 위한 각 로컬시뮬레이터로 실행되는 로컬시뮬레이션 수행의 흐름도의 일 예를 개략적으로 도시한 도면.

도27 은, 본 특허에서의 분산처리적병렬시뮬레이션 수행을 위한 각 로컬시뮬레이터로 실행되는 로컬시뮬레이션 수행의 흐름도의 또 다른 일 예를 개략적으로 도시한 도면.

도28 은 별방식의 논리적연결구조에서 로컬시뮬레이터로 실행되는 로컬시뮬레이션 수행의 흐름도의 일 예를 개략적으로 도시한 도면.

도29 는 별방식의 논리적연결구조에서 중앙컴퓨터에 존재하는 SW서버 모듈로 수행되는 과정의 흐름도의 일 예를 개략적으로 도시한 도면.

도30 은, 도 8의 본 특허에서 제시한 분산처리적병렬시뮬레이션을 위하여 부가되는 부가 코드 내부를 구성하는 컴퍼넌트들 일부분에 대하여 이들의 행태를 모조코드 형식으로 구술한 예를 개략적으로 도시한 도면.

도31 은, 도 8의 본 특허에서 제시한 분산처리적병렬시뮬레이션을 위하여 부가되는 부가 코드 내부를 구성하는 컴퍼넌트들 또 다른 일부분에 대하여 이들의 행태를 모조코드 형식으로 구술한 예를 개략적으로 도시한 도면.

<도면의 주요부분에 대한 부호의 설명>

32 : 검증 소프트웨어 34 : HDL 시뮬레이터

35 : 컴퓨터

37 : ESL 모델 38 : 설계블록을 나타내는 설계객체

39 : 설계모듈을 나타내는 설계객체

40 : RTL 모델 42 : 온칩 버스(On-chip bus)

50 : 예상입력 52 : 예상출력

54 : 예상입출력이용-런/실제입출력이용-런 제어모듈

56 : 예상입력/실제입력 선택모듈

58 : 예상출력/실제출력 비교모듈

59 : 예상입력/실제입력 비교모듈

60 : s-DCP 저장모듈

62 : 검증 소프트웨어로써 검증대상 설계코드에 부가되어진 부가 코드

64 : 분산병렬 시뮬레이션을 위한 통신 및 동기화 모듈

333 : 별방식의 연결구조에서 분산병렬 시뮬레이션 수행 시에 로컬시뮬레이션들의 제어와 로컬시뮬레이션들의 연결을 수행하는 중앙컴퓨터에 존재하는 SW서버 모듈

343 : 분산병렬 시뮬레이션 환경에서 로컬시뮬레이션을 수행하는 시뮬레이터

353 : 중앙컴퓨터

354 : 외곽컴퓨터

370 : GL 모델

380 : RTL 모델 내의 특정 설계객체

381 : RTL 모델 내의 또 다른 특정 설계객체

382 : RTL 모델 내의 또 다른 특정 설계객체

383 : RTL 모델 내의 또 다른 특정 설계객체

384 : RTL 모델 내의 또 다른 특정 설계객체

385 : RTL 모델 내의 또 다른 특정 설계객체

387 : RTL 모델에 존재하지 않으나 GL 모델에는 존재하는 설계모듈을 나타내는 설계객체

404 : 로컬시뮬레이터에서 수행되는 설계 검증 대상 모델의 일부분

420 : RTL 모델 내의 버스중재기 및 어드레스디코더를 포함하는 온칩 버스 설계객체

606 : s-DCP 저장버퍼

644 : 분산병렬 시뮬레이션을 위한 로컬시뮬레이션 런-타임 모듈

646 : 시뮬레이션가속을 위한 통신 및 동기화 모듈

648 : 하드웨어기반검증플랫폼

650 : 시뮬레이션가속 런타임 모듈

660 : 분산병렬 시뮬레이션에서 로컬시뮬레이터에 수행되도록 분할된 모델내의 설계객체

670 : VPI/PLI/FLI

674 : Socket API

676 : TCP/IP socket

678 : Device API

680 : Device Driver

682 : HAL(Hardware Abstraction Layer)

684 : Giga-bit LAN card

본 발명은 전자적 시스템 수준(Electronic System Level: 앞으로 ESL로 약칭함)에서부터 게이트 수준까지로의 설계를 시뮬레이션을 이용하여 체계적으로 검증하는 기술에 관한 것으로, 설계된 수백만 게이트급 이상의 디지털 시스템을 검증하고자 하는 경우에 검증의 성능과 효율성을 증가시키는 검증 방법에 관한 것이다. 반도체 설계 검증에서 시뮬레이션(simulation)이란 소프트웨어적으로 DUV(Design Under Verification) 내지는 DUV내의 1 이상의 설계객체(추후에 정의됨)와 이를 구동하는 테스트벤치를 컴퓨터로 실행가능한 모델(computer-executable model)로서 구성하고, 이와 같은 컴퓨터로 실행가능한 모델을 시뮬레이션 컴파일 과정을 통하여 컴퓨터의 기계언어(machine instruction)들의 시퀀스로 바꾸어서 컴퓨터를 이용하여서 실행시키는 과정이다. 따라서, 시뮬레이션의 실행은 기본적으로 컴퓨터의 기계언어들의 순차적인 수행(sequential execution)을 통하여 이루어지게 되는데, 현재 다양한 시뮬레이션 기술(이벤트-구동 시뮬레이션(event-driven simulation), 사이클-기반 시뮬레이션(cycle-based simulation), 컴파일방식 시뮬레이션(compiled simulation), 해석방식 시뮬레이션(interpreted simulation), 동시-시뮬레이션(co-simulation) 등)들이 존재하고 있다. 즉 시뮬레이션이란 설계대상 내지는 구현대상이 되는 설계객체를 적정한 추상화 수준(abstraction level, 반도체 설계에서는 게이트-수준, 레지스터전송-수준, 트란젝션-수준, 아키텍춰-수준, 행위-수준, 알고리즘-수준 등의 다양한 추상화 수준 등이 존재함)에서의 모델링 과정(modeling process)을 통하여 컴퓨터를 이용하여 소프트웨어적으로 수행시켜서 해당 설계객체의 동작기능 내지는 동작특성 등을 모의적으로 컴퓨터 상에서 실현시키는 다양한 과정들을 모두 통칭하는 것이다. 이와 같은 시뮬레이션의 장점은 설계객체를 실제적으로(physically) 구현하기 전에 이의 동작기능 내지는 동작특성 등을 가상적으로(virtually) 컴퓨터 상에서 미리 예측해볼 수 있을 뿐만 아니라 소프트웨어적인 방식임으로 높은 유연성을 제공받을 수 있다는 것이며, 단점으로는 시뮬레이션의 수행이 결국은 기계언어들의 시퀀스가 순차적인 수행을 통하여 이루어지게 됨으로 시뮬레이션 대상의 되는 설계객체의 복잡도가 큰 경우(예로 최근의 반도체는 1억 게이트급 이상의 설계들도 다수 존재함)에는 시뮬레이션의 수행 속도가 매우 느리다(예로 상기 1억 게이트급의 설계를 이벤트-구동 시뮬레이션으로 수행하는 경우의 시뮬레이션 속도가 1 cycle/sec가 되고 시뮬레이션을 100,000,000 사이클 수행하여야 한다면 약 3.2년이 소요됨)는 것이다. 따라서, 본 특허에서 시뮬레이션이라함은 DUV 내지는 DUV 내의 1 이상의 설계객체를 적정한 추상화 수준에서 소프트웨어적으로 모델링하여서 이를 소프트웨어적으로 실행시키는 모든 방법을 가르킨다. 좀 더 구체적으로 설명한다면, DUV 내지는 DUV 내의 1 이상의 설계객체의 특정 추상화 수준의 행태(behavior)를 궁극적으로 특정한 컴퓨터 자료구조(data structure)와 이 특정한 자료구조에 대한 일정한 오퍼레이션(operation)들로 정의되어지도록 구현함으로서 이를 컴퓨터 실현가능한(computer-executable) 형태로 만들고, 여기에 입력 값들이 인가되면서 컴퓨터로 동작시키는 과정 내지는 입력 값들로써 컴퓨터에서 일련의 연산(computation) 내지는 프로세싱(processing)을 포함하는 과정이라면 모두 시뮬레이션이라고 정의한다 (따라서, 상용 시뮬레이터를 이용하여 이루어지는 시뮬레이션뿐만 아니라, 상기 정의에 부합되는 과정이라면 자체적으로 제작한 시뮬레이터에 의한 시뮬레이션과 상기 시뮬레이션 프로세스와 동일한 과정을 통한 모델링을 통하여 컴퓨터 상에서 가상적으로 수행되어지는 소프트웨어 프로세스라면 모두 시뮬레이션으로 정의하기로 한다).

최근에 집적회로(IC: Integrated Circuit)의 설계 및 반도체 공정기술이 급격하게 발달함에 따라 디지털 회로 내지는 디지털 시스템 설계의 규모가 최소 수천만 게이트급에서 수억 게이트급까지 커짐은 물론 그 구성이 극히 복잡해지고 있는 추세이 고, 이와 같은 추세는 계속적으로 확대되고 있는 추세이다. 특히 SOC(System On Chip)으로 통칭되는 최근의 시스템급의 집적회로들은 대부분 1 이상의 프로세서 코어(RISC 코어 내지는 DSP 코어 등으로, 구체적 예로는 ARM사의 ARM11 코어 내지는 CEVA사의 Teak DSP 코어)를 내장하고 칩 기능의 상당 부분들을 소프트웨어로 구현하는 추세이다. 그리고, 시장에서의 경쟁은 더욱 더 치열해지므로 빠른 시간 내에 우수한 제품을 개발하여야만 함으로 설계 기간의 단축은 제품의 성공을 결정하는 매우 중요한 요소로 되어져 버렸다. 따라서 최근의 칩 설계에서는 ESL 설계 기법이 새로운 설계 방식으로 산업체에서 많은 주목을 받고 있다. 이와 같은 전통적인 디지털 하드웨어 설계에서 적용하여 왔던 RTL(Register Transfer Level) 설계기법보다 추상화 수준(abstraction level)(추후에 설명됨)이 높은 ESL 설계 기법을 적용하여 설계되는 칩들은 칩 설계와 더불어서 이 칩을 구동시키는 소프트웨어의 개발도 동시에 수행되어져야만 한다. 따라서, 하드웨어의 설계와 동시에 소프트웨어 개발을 진행시키기 위하여서 해당 하드웨어를 소프트웨어적으로 모델링한 가상 플랫폼(Virtual Platform, 앞으로 VP로 약칭함)을 만들어서 시스템 수준의 모델(ESL 모델)로 아키텍춰 탐색(architecture exploration), 소프트웨어 개발, 하드웨어/소프트웨어 동시 검증(HW/SW co-verification), 시스템 검증(system verification)에 사용하는 것이 최근의 추세인데, 이는 수행 가능한 스펙(executable specification)의 역할(즉 레퍼런스 모델의 역할)도 수행한다. 이와 같은 VP는 추상화 수준을 높여서 만들게 됨으로 신속하게 만들 수 있을 뿐만 아니라, 구현가능한 DUV를 설계하기 이전에 DUV에 대한 VP를 먼저 만들어 놓으면 이 VP를 이용하여 서 구현가능한 DUV가 존재하기 이전에 TB에 대한 검증을 미리 진행할 수도 있음으로 여러 면에서 유리하다. 이와 같은 VP는 현재 SOC 설계 방법에서 보편화된 플랫폼기반의 설계(PBS: Platform-based Design)에서 중요한 역할을 수행하는데, VP는 일반적으로 트란젝션(transaction) 수준에서 온-칩 버스(on-chip bus)를 정해진 버스규약(bus protocol)에 맞추어서 모델링한 버스 모델(이와 같이 트란젝션 수준에서 모델링된 것을 TLM 모델이라함)을 핵심 컴퍼넌트화 하여서 이 버스에 연결되어지는 설계블럭들을 트란젝션 수준(transaction level)에서 모델링하여 이들 트란젝션 수준의 설계블럭들을 추상화되어진 버스규약에 맞추어 버스 모델과 통신이 이루어질 수 있게 함으로서 상대적으로 높은 시뮬레이션 수행속도(대략 RTL 모델의 수행속도와 비교하여 100배-10,000배)를 가능하게 한다. 현재 이와 같은 VP를 생성시키고 수행시키는 상용 툴들로서는 ARM사의 MaxSim, CoWare사의 ConvergenSC, Cadence사의 Insicive, Summit Design사의 VisualElite, Vast Systems Technology사의 VSP, Synopsys사의 SystemStudio, TenisonEDA사의 VTOC, Carbon Design Systems사의 VSP 등이 있다. SOC 설계에서는 이 VP는 소프트웨어를 개발할 수 있을 정도의 빠른 수행 속도가 제일 중요함으로 Verilog나 VHDL과 같은 언어를 이용하여서 레지스터전송수준(RTL)에서 모델링하지 않고, C/C++ 내지는 SystemC와 같은 언어를 이용하여서 RTL 보다 추상화 수준이 높은 트란젝션 수준 내지는 알고리즘 수준(algorithmic level)에서 모델링하고 있다. 시스템 설계에서 매우 중요한 개념인 추상화 수준(abstraction level)이란 해당 설계객체(추후에 설명됨)의 구술의 구체화 정도를 표현하는 단계로, 디지털 시스템의 경우에는 추상화 수준이 낮은 단계에 서부터 높은 단계로 레이아웃-수준, 트란지스터-수준, 게이트-수준, RTL(레지스터전송-수준), 트란젝션 수준, 알고리즘 수준 등으로 나눌 수 있다. 즉, 게이트-수준은 RTL 보다 추상화 수준이 낮고, RTL 수준은 트란젝션 수준보다 추상화 수준이 낮으며, 트란젝션 수준은 알고리즘 수준보다 추상화 수준이 낮다. 따라서, 특정 설계객체 A 의 추상화 수준이 트란젝션이고, 이를 더욱 구체화시켜서 표현한 설계객체 B가 RTL이면 설계객체 A는 설계객체 B보다 추상화 수준이 높다고 정의 한다. 뿐만 아니라 설계객체 X가 내부에 설계객체 A와 설계객체 C를 가지고 있고 설계객체 Y는 내부에 A를 구체화한 설계객체 B와 설계객체 C를 가지고 있다면, 설계객체 X는 설계객체 Y보다 추상화 수준이 높다고 정의한다. 뿐만 아니라, 같은 게이트수준 내지는 같은 RTL에서는 지연시간 모델을 얼마나 더 정확이 하였느냐에 따라서 추상화 수준의 높고 낮음을 결정할 수 있다. 즉, 지연시간 모델이 정확한 것이 추상화 수준이 낮다고 이야기하는데, 예로서 같은 게이트수준이라고 하더라도 제로지연시간모델(zero-delay model)의 네트리스트가 단위지연시간모델(unit-delay model)의 네트리스트보다 추상화 수준이 높다고 하고, 단위지연시간모델의 네트리스트가 SDF(Standard Delay Format)를 이용한 풀타이밍모델(full-timing model)의 네트리스트보다 추상화 수준이 높다고 정의한다. 최근의 SOC 설계는 칩으로 최종적으로 구현되어져야 하는 대상을 시초 설계객체로 정의하고, 이 시초 설계객체를 처음 추상화 수준(예로 트란젝션 수준)에서부터 점진적 구체화 과정(progressive refinement process)를 통하여서 목표로 하는 마지막 추상화 수준(예로 게이트-수준)까지 구체화 시켜가는 과정이라고 정의될 수 있다 (도 14 참조). 점진적 구체 화(progressive refinement) 과정을 통한 설계 기법은 플랫폼 기반의 설계와 함께 최근의 SOC의 설계 복잡도에 효율적으로 대처하면서 설계를 진행시킬 수 있는 유일한 설계 기법으로 대부분의 SOC 설계들은 이와 같은 점진적 구체화 과정을 통하여 진행되어진다. 점진적 구체화 과정을 통한 설계 기법의 핵심은 추상화 상위 수준에서 모델링된 설계객체 MODEL_DUV(HIGH) 내에 존재하는 설계 블럭들을 단계별로 구체화시켜서 MODEL_DUV(HIGH)보다 추상화 하위 수준에서 모델링되는 설계객체 MODEL_DUV(LOW)를 자동화된 방식(예로 논리합성 내지는 상위수준합성)으로 내지는 수작업 방식으로 내지는 자동화된 방식과 수작업 방식을 혼용하여서 얻는 과정이라고 요약할 수 있다. 이의 구체적 예로서는 우선 ESL에서부터 RTL로 구체화하는 단계인 ESL 모델에서부터 구현가능한 RTL 모델을 얻는 과정(이 과정은 현재 수작업으로 진행되거나 내지는 상위수준합성 방식 내지는 이를 혼용한 방식으로 진행됨)에서는 ESL 모델이 MODEL_DUV(HIGH)가 되고, 구현가능한 RTL 모델이 MODEL_DUV(LOW)가 되는 것이며, 다시 RTL에서부터 게이트 수준으로 구체화하는 단계인 구현가능한 RTL 모델에서부터 게이트 수준 모델(즉, 게이트-수준 네트리스트)를 얻는 과정(이 과정은 현재 대부분 논리합성 방식으로 진행됨)에서는 구현가능한 RTL 모델이 MODEL_DUV(HIGH)가 되고, 게이트 수준 모델이 MODEL_DUV(LOW)가 된다. 이 게이트 수준 모델은 배치 및 배선(placement and routing) 과정에서 추출된 지연시간 정보(Standard Delay Format으로 표현됨)를 부가(back-annotation)함으로서 타이밍정확한 게이트 수준 모델이 된다 (앞으로는 모델이라고 하면 특별한 언급이 없는 한, DUV(Design Under Verification으로 추후에 설명됨)와 TB(Test Bench로 추후에 설 명됨)를 모두 포함하고 있는 것으로 정의한다).

여기에서 한가지 언급할 것은 ESL 모델이라고 하더라도 ESL 모델 내부에 존재하는 모든 설계객체들이 시스템 수준으로 존재하여야만 하는 것은 아니며, RTL 모델이라고 하더라도 RTL 모델 내부에 존재하는 모든 설계객체들이 레지스터전송 수준으로 존재하여야만 하는 것은 아니라는 것이다. 즉, ESL 모델이라고 하더라도 이 모델 내부의 특정 소수의 설계객체들은 레지스터전송 수준으로 존재하고 이들 설계객체들 추상화용 래퍼(wrapper)로 감싸버림으로서 시스템 수준으로 존재하는 다른 다수의 설계객체들과 추상화 수준을 맞추어 냄으로서 ESL 모델로서 취급되어질 수 있고, RTL 모델이라고 하더라도 이 모델 내부의 특정 소수의 설계객체들은 게이트 수준으로 존재하지만 RTL 수준으로 존재하는 다른 다수의 설계객체들과 같이 RTL 모델로서 취급되어질 수도 있다. 같은 이유에서 GL 모델에서도 특정 소수의 설계객체(예로서 논리합성으로 게이트수준의 네트리스트를 생성시키지 않는 메모리블럭)들은 레지스터전송 수준으로 존재할 수도 있다. 따라서 본 특허에서 "특정 추상화 수준의 모델" 이라고 하면 ESL에서부터 GL에까지 점진적 구체화 과정에서 존재할 수 있는 다양한 추상화 수준들(ESL, RTL, GL 추상화 수준뿐만 아니라 이들의 혼합된 형태의 추상화 수준들인 ESL/RTL 혼합된 추상화 수준, RTL/GL 혼합된 추상화 수준, ESL/RTL/GL 혼합된 추상화 수준 등도 모두 포함하는 추상화 수준들)에서 존재하는 설계 대상이 되는 어떠한 형태의 모델들 중에 하나를 특정하는 명칭이고, 일반적으로 지칭되어지는 “추상화 수준”이라고 하면 ESL, RTL, GL 뿐만 아니라 ESL에서부터 GL에까지 점진적 구체화 과정에서 존재할 수 있는 다양한 추상화 수준들 (예로, ESL/RTL 혼합된 추상화 수준, RTL/GL 혼합된 추상화 수준, ESL/RTL/GL 혼합된 추상화 수준 등)도 모두 포함되는 명칭임을 강조해 둔다. 예로서, DUV 내부에 4개의 설계객체 A, B, C, D가 서브모듈로서 존재하고 A와 B는 ESL, C는 RTL, 그리고 D는 GL 추상화 수준에서 구술됨으로서 DUV가 ESL/RTL/GL이 혼합된 형태의 추상화 수준 모델이라고 하더라도 이 DUV는 특정 추상화 수준의 모델이라고 지칭할 수 있다 (뿐만 아니라, 구체적으로 ESL/RTL/GL이 혼합된 추상화 수준의 모델이라고 구체적으로 지칭하는 것도 가능함). 앞으로, 추상화 수준이 혼합된 형태의 모델의 경우에 추상화 수준이 혼합된 형태임을 분명하게 이야기할 필요가 있는 경우에는 추상화 상위/하위 혼합수준 모델, 내지는 추상화 혼합수준 모델이라 칭하기로 한다.

ESL에서 중요한 개념인 트란젝션(transaction)이란 RTL의 시그널 내지는 핀(pin)과 대응되는 개념으로 시그널 내지는 핀 상에서 나타내어지는 정보는 비트 내지는 비트벡터로만 표현되어질 수 있는 것임에 반하여서, 트란젝션은 논리적 연관성이 있는 복수개의 시그널들 내지는 핀들을 하나의 단위로서 정의하여서 나타내어지는 정보를 의미한다. 예로 임의의 프로세서 모듈과 임의의 메모리 모듈로 구성된 설계에서 항상 존재하는 어드레스 시그널 N-비트, 데이터 시그널 M-비트, 제어 시그널 P-비트로 구성되는 총 (N+M+P)개의 시그널들을 논리적 연관성이 있는 N-비트 어드레스 버스, M-비트 데이터 버스, P-비트 제어 버스로 구성하게 되면 매 사이클을 (N+M+P) 비트벡터로 구성되는 의미 해석이 어려운 이진벡터 대신에 READ(ADDR(address_value), DATA(data_value)), 내지는 WRITE(ADDR(address_value), DATA(data_value)), 내지는 READ- WAIT(ADDR(address_value), DATA(data_value)), 내지는 WRITE-WAIT(ADDR(address_value), DATA(data_value)) 등과 같이 의미 해석이 가능한 심벌로서 나타낼 수 있는데, 이와 같은 것을 트란젝션이라 칭한다. 또한 트란젝션은 하나의 사이클 단위에서 뿐만 정의될 수 있을 뿐만 아니라(이를 단일사이클 단위의 트란젝션(cycle-accurate transaction)이라 칭하기로 하고, ca-트란젝션으로 약칭한다), 여러 사이클 단위로도 확장되어져서 정의되는 트란젝션(이를 여러사이클단위의 트란젝션(timed transaction 내지는 cycle-count transaction 내지는 PV-T transaction 등 여러 명칭으로 불림)이라 칭하기로 하고, 본 특허에서는 timed-트란젝션으로 단일명으로 약칭한다)도 있을 수도 있다 (이와 같이 여러 사이클 단위에서 정의되는 timed-트란젝션은 Transaction_name(start_time, end_time, other_attributes)로 표현되어질 수 있다). 또한 트란젝션은 시간개념이 없는 트란젝션(이를 untimed-트란젝션으로 약칭함)까지도 포함한다. 사실 트란젝션에 대한 표준화된 일관된 정의는 없으나, 위에서 설명한 것과 같이 untimed-트란젝션, timed-트란젝션, ca-트란젝션으로 나누는 것이 제일 일반적이다. 이와 같이 트란젝션 내에서도 추상화 수준에 따라서 추상화 수준이 제일 높지만 시간정확성이 제일 낮은 untimed-트란젝션에서부터 추상화 수준이 제일 낮지만 시간정확성이 제일 높은 ca-트란젝션, 그리고 추상화수준과 시간정확성이 이들의 중간수준이 timed-트란젝션으로 나누어 질 수 있다.

구체화 과정은 점진적 방식으로 일어남으로서 VP에 존재하는 트란젝션 수준의 설계객체들이 단계적으로 구체화를 위한 변환 과정을 통하여서 최소한 비트수준의 사이 클 정확도를 가지는(bit-level cycle-accurate) RTL 수준의 설계객체들로 바뀌어지게 된다. 이와 같은 변환 과정의 마지막에는 VP에 존재하는 모든 트란젝션 수준의 설계객체들이 RTL 수준의 설계객체들로 변환되어져서 존재하게(따라서 트란젝션 수준 VP가 구현가능한 RTL 모델로 변환되게) 된다. 또한 구현가능한 RTL 모델에 존재하는 RTL 수준의 설계객체들이 단계적으로 구체화를 위한 변환 과정을 통하여서 비트수준의 타이밍 정확도를 가지는(bit-level timing-accurate) 게이트 수준의 설계객체들로 바뀌어지게 된다. 이와 같은 변환 과정의 마지막에는 RTL 모델에 존재하는 모든 RTL 수준의 설계객체들이 게이트 수준의 설계객체들로 변환되어져서 존재하게(따라서 RTL 모델이 게이트 수준 모델로 변환되게) 된다. 도14 는 이와 같은 과정을 예로서 보여주고 있다. 트란젝션 수준 DUV(ESL) 내에 하위 블록으로 4개의 트란젝션 수준의 설계객체 DO_esl_1, DO_esl_2, DO_esl_3, DO_esl_4를 가지고 있다면, 이 4개의 트란젝션 수준의 설계객체들이 단계적으로 점진적 구체화 과정을 거침으로서 RTL 수준의 설계객체 DO_rtl_1, DO_rtl_2, DO_rtl_3, DO_rtl_4로 교체되면서 최종적으로는 RTL 수준의 설계객체 DO_rtl_1, DO_rtl_2, DO_rtl_3, DO_rtl_4들만으로 구성되는 레지스터전송수준 DUV(RTL)로 변환된다. 또한, 레지스터전송수준 DUV(RTL)내에 하위 블록으로 4개의 설계객체 DO_rtl_1, DO_rtl_2, DO_rtl_3, DO_rtl_4를 가지고 있다면, 이 4개의 RTL 설계객체들이 단계별로 점진적 구체화 과정을 거침으로서 게이트 수준의 설계객체 DO_gl_1, DO_gl_2, DO_gl_3, DO_gl_4로 교체되면서 최종적으로는 게이트 수준의 설계객체 DO_gl_1, DO_gl_2, DO_gl_3, DO_gl_4들만으로 구성되는 게이트수준 DUV(GL)로 변환된다.

SOC 설계에서는 설계되어져야 하는 대상이 두 가지가 있는데, 그 하나는 DUV(Design Under Verification)이고, 또 다른 하나는 DUV를 시뮬레이션하기 위한 테스트벤치(testbench, 앞으로는 이를 TB로 약칭함)이다. DUV는 궁극적으로 반도체 제조 공정을 거쳐서 칩으로 만들어지는 설계 대상이고, 테스트벤치는 구현된 해당 칩이 장착되어서 동작하는 주변상황을 모델링한 것으로서 DUV의 시뮬레이션에 사용된다. DUV를 시뮬레이션 하는 경우에 테스트벤치가 DUV에 입력을 인가하고 인가된 입력으로 DUV에서 출력되는 결과를 받아들여서 처리하는 것이 일반적이다. 이들 DUV와 테스트벤치는 일반적으로 계층적인 구조로 내부에 다양한 1 이상의 하위모듈들을 가지고 있는데, 이들 하위모듈 각각을 설계 블록이라고 할 수 있고, 설계 블록 내부에는 설계 모듈들이 존재하고, 설계 모듈 내부에는 서브모듈들이 존재한다. 이와 같은 설계 블록들, 내지는 설계 모듈들, 내지는 서브모듈들이나 DUV, 그리고 테스트벤치 각각이나 이들의 조합들을 모두 본 특허에서는 설계객체(design object)들 (구체적 예로는, Verilog의 경우에는 module, VHDL인 경우에는 entity, SystemC의 경우에는 sc_module들이 모두 설계객체의 일 예임)이라고 지칭하기로 한다. 따라서 VP도 설계객체의 하나로 볼 수 있으며 VP내의 설계 블록들이나 이 블록 내부의 설계 모듈들이나 이 설계 모듈 내부의 서브모듈들 등도 모두 설계객체로 볼 수 있다.

그러나, 이와 같은 현재의 점진적 구체화를 통한 설계에서는 추상화 상위수준에서의 검증이 매우 빠르게 수행될 수 있으나 추상화 하위수준에서의 검증은 상대적으로 느리게 수행되어짐으로 점진적 구체화 과정을 통하여 추상화 하위 단계로 진행 될수록 검증 속도가 크게 떨어지는 문제점이 있다. 일반적인 단일 시뮬레이션 방식(본 특허에서 단일 시뮬레이션 방식이란 넓은 의미로 정의되어져서 1개의 시뮬레이터를 사용하는 경우에 뿐만 아니라, 2 이상의 시뮬레이터를 사용하는 경우(예로 Verilog 시뮬레이터와 Vera 시뮬레이터를 동시에 사용하는 경우)라도 이 2 이상의 시뮬레이터를 하나의 CPU 상에서 수행시키는 것을 단일 시뮬레이션 방식으로 정의함)에 대비하여서, 검증 속도를 높이는 방법으로 2 이상의 시뮬레이터들을 분산병렬(distributed parallel) 방식으로 실행시키는 방법이 있다. 이 시뮬레이터의 일 예로들로는 HDL(Hardware Description Language, Cadence사의 NC-Verilog/Verilog-XL와 X-sim, Synopsys사의 VCS, Mentor사의 ModelSim, Aldec사의 Riviera/Active-HDL, Fintronic사의 FinSim 등이 있음) 시뮬레이터 내지는 HVL(Hardware Verification Language, Cadence사의 e 시뮬레이터, Synopsys사의 Vera 시뮬레이터 등이 있음) 시뮬레이터 내지는 SDL(System Description Language, SystemC 시뮬레이터, Cadence사의 Incisive 시뮬레이터 등이 있음) 시뮬레이터들이 있다. 또 다른 구분으로는 이벤트-구동(event-driven) 시뮬레이터 내지는 사이클-기반(cycle-based) 시뮬레이터들이 있는데, 본 특허에서 언급하는 시뮬레이터들은 이들 시뮬레이터들을 모두를 가르킨다. 따라서 2 이상의 시뮬레이터들을 사용하는 경우에는 상기에서 언급된 어떤 종류의 시뮬레이터들을 이용할 수 있을 뿐만 아니라, 이들 다른 종류의 시뮬레이터를 자유롭게 혼용하여 사용할 수 있다. 시뮬레이션의 분산수행(distributed processing) 방식인 분산병렬 시뮬레이션(distributed parallel simulation) (혹은 병렬분산 시뮬레이션(parallel distributed simulation)이라고 도 하거나 간략히 병렬 시뮬레이션(parallel simulation)이라고도 하는데, 본 특허에서는 분산병렬 시뮬레이션이라 명칭함)은 제일 일반적인 병렬시뮬레이션 방식으로 시뮬레이션 대상이 되는 DUV와 TB(즉 특정 추상화 수준의 모델)를 2 이상의 설계객체들로 나누어서 이들 나누어진 각각의 설계객체를 별도의 시뮬레이터에 분산시켜서 수행시키는 방식이다 (도 5 참조). 따라서 분산병렬 시뮬레이션을 위해서는 시뮬레이션 대상이 되는 모델을 2 이상의 설계객체들로 나누는 분할(partition) 과정이 필요하다. 최근에는 기가비트 이더넷 등의 고속의 컴퓨터네트워크로 2 이상의 컴퓨터들을 연결하고 이들 각각의 컴퓨터 상에서 시뮬레이터를 수행(본 특허에서는 이들 분산병렬 시뮬레이션을 가능하게 하는 2 이상의 시뮬레이터들 각각의 시뮬레이터에서 수행되는 시뮬레이션을 로컬시뮬레이션이라 칭하고, 해당 시뮬레이터를 로컬시뮬레이터라고 칭한다)하거나, 내지는 2 이상의 중앙처리장치(CPU)를 장착한 멀티프로세서 컴퓨터(예로, 펜티움 듀얼코어 칩과 AMD 듀얼코어 칩은 프로세서코어가 2개로 이를 이용하여도 멀티프로세서 컴퓨터를 구성할 수 있으며 1 이상의 시스템보드 상에 여러개의 CPU 칩들을 장착하여서도 멀티프로세서 컴퓨터를 구성할 수 있음)에서 이들 각각의 CPU 상에서 시뮬레이터를 수행시킴으로서 분산병렬 시뮬레이션을 수행하는 것이 가능하다. 그러나, 이와 같은 통상적인 분산병렬 방식을 통한 시뮬레이션은 시뮬레이터들 간의 통신 오버헤드 및 동기 오버헤드(communication overhead and synchronization overhead)로 인하여 성능 향상이 매우 제약적이라는 문제점이 있다. 분산병렬 시뮬레이션에서의 동기화 방법은 크게 두가지가 있는데 하나는 보수적(conservative) 방식(혹은 비관적 방식이라고도 함) 이고 또 다른 하나는 낙관적(optimistic) 방식이다. 보수적 방식의 동기화는 시뮬레이션 이벤트의 전후 인과관계(causality relation)가 시뮬레이터들 간에서도 반드시 유지됨으로서 롤백(roll-back)이 필요하지 않으나 분산병렬 시뮬레이션의 속도가 제일 느린 로컬 시뮬레이션으로 한정되어진다는 문제점과 과도한 동기화가 일어나는 문제점이 있고, 낙관적 방식의 동기화는 시뮬레이션 이벤트의 전후 인과관계가 시뮬레이터들간에 일시적으로 유지되지 못하게 될 수 있고 이를 수정하기 위한 롤백이 필요함으로서 전체의 롤백의 횟수를 줄이는 것이 분산병렬 시뮬레이션의 성능에 큰 영향을 미치게 된다. 그러나 지금까지의 낙관적 방식에 의한 분산병렬 시뮬레이션에서는 각 로컬 시뮬레이션이 다른 로컬 시뮬레이션들과의 동기화 과정 없이 진행하는 시뮬레이션 시점들이 롤백이 일어나는 것을 최소한으로 되도록 특별하게 고려되어진 것이 아님으로 인하여 과도한 롤백을 초래하게 되는 결과를 초래함으로서 전체 시뮬레이션의 성능을 크게 떨어뜨리게 한다. 통상적인 낙관적 방식의 분산병렬 시뮬레이션이나 보수적 방식의 분산병렬 시뮬레이션의 구체적 수행방법 및 구현방법은 여러 문헌들 내지는 논문들로 이미 잘 알려져 있음으로 본 특허에서 이의 자세한 설명은 생략하기로 한다. 단, 한가지 더 언급할 것은 분산병렬 시뮬레이션을 수행하는 프로세서들의 수는 분산병렬 시뮬레이션의 성능을 최대한으로 하기 위해서는 로컬 시뮬레이션의 수와 같게 하는 것이 바람직하지만, 프로세서들의 수가 2 이상(즉, 2 이상의 컴퓨터가 네트워크로 연결되어 있거나 내지는 멀티프로세서 컴퓨터에 프로세서가 2 이상)만 된다면 로컬 시뮬레이션의 수가 2 보다 많다고 하더라도 2 이상의 로컬 시뮬레이션을 하나의 프로세서로 수행하게 함으로 서 이와 같은 경우에도 분산병렬 시뮬레이션이 가능하다는 것이다. 결론적으로, 현재의 보수적 방식의 동기화 방법과 통신 방법이나 낙관적 방식의 동기화 방법이나 통신 방법들 모두 2 이상의 시뮬레이터들을 이용한 분산병렬 시뮬레이션의 성능을 크게 떨어뜨리는 제약 요소가 되는 문제점이 있다.

뿐만 아니라, 점진적 구체화 과정을 통한 설계에서는 추상화 상위 수준의 모델이 추상화 하위 수준의 모델의 레퍼런스 모델(reference model)의 역할을 수행하는 것이 매우 중요한데 이와 같이 레퍼런스 모델의 역할을 수행하기 위해서는 추상화 상위 수준의 모델과 추상화 하위 수준의 모델간의 모델 일관성(model consistency)을 유지시키는 것이 필요하다. 그러나, 현재의 점진적 구체화 방법에서는 이들 다른 추상화 수준들에서 존재하는 2 이상의 모델들간의 모델 일관성을 유지시키는 효과적인 방법이 없다.

뿐만 아니라, 점진적 구체화 과정을 통한 설계 과정에서 발견되는 설계오류들을 제거하는 디버깅 과정이 체계적이지 못함으로 인하여서 매우 많은 시간이 소요되는 문제점이 있다.

본 발명에서는 시스템 수준에서의 트란젝션 수준 모델(앞으로 이를 ESL 모델이라 약칭함)에서부터 시작하여 점진적 구체화 과정을 통한 설계로 구현가능한 레지스터전송 수준 모델(앞으로 이를 RTL 모델이라 약칭함)을 얻고, 다시 구현가능한 RTL 모델에서부터 점진적 구체화 과정을 통한 설계로 게이트 수준 모델(앞으로 이를 GL 모델이라 약칭함) (GL 모델은 배치 & 배선 과정을 수행할 수 있는 특정 구현라이브러리의 셀들의 연결구조를 표현한 게이트수준 네트리스트임)을 얻는 ESL-to-Gate 설계 과정을 크게 나누어서 두 단계로 보기로 한다. 우산 첫 번째 단계는 ESL 모델에서부터 RTL 모델을 구체화 시키는 과정으로 이를 ESL-to-RTL 설계 과정이라 칭하기로 한다. 두 번째 단계는 RTL 모델에서부터 GL 모델을 구체화 시키는 과정으로 이를 RTL-to-GL 설계 과정이라 칭하기로 한다. 또한 이들 점진적 구체화 과정 상에서 다양한 추상수준들에서 존재하는 복수개의 다양한 모델들을 본 특허에서는 “상이한추상수준 동일모델”들이라 통칭하기로 한다.

일반적으로 추상화 상위 수준의 모델을 추상화 하위 수준의 모델로 구체화시키는 과정에 있어서 추상화 상위 수준의 모델 MODEL_DUV(HIGH)과 추상화 하위 수준의 모델 MODEL_DUV(LOW) 모두에 일정한 정도로 동일한 내지는 유사한 계층구조가 존재하고 있도록 하는 것이 매우 중요하다 (도 3과 도 4 참조). SOC 설계에서는 설계 대상이 되는 DUV의 복잡도가 매우 높음으로 이와 같이 다른 추상화 수준들에서의 모델들이 계층 구조의 최상위에서부터 최하위까지에서 일정한 정도로 동일한 내지는 유사한 계층구조를 일반적으로 자연스럽게 가지고 있게 된다. 우선, 이와 같이 동일한 내지는 유사한 계층구조를 최상위수준에서부터 일정한 수준까지 가지고 있게 되면, 이들 다른 추상화 수준의 모델들내에 존재하는 1 이상의 설계객체들간에도 DUV와 동일하게 모델들 간에 대응되는 설계객체들이 존재하게 되는데 이와 같은 상황은 추상화 수준이 ESL 모델과 RTL 모델 사이와 RTL 모델과 계층구조를 허물지 않은 게이트수준 모델 사이에서 일반적으로 존재한다. 그리고, 게이트수준에서 바운 더리스캔(boundary scan) 구조를 삽입하고 혹은 수작업설계 과정등에 의하여 게이트수준 모델의 계층구조가 RTL 모델의 계층구조와 약간 달라질 수는 있지만 계층구조가 크게 달라지는 것은 아님으로 이와 같은 경우에도 게이트수준 모델의 계층구조와 RTL 모델의 계층구조는 극히 유사함으로 인하여 이들 계층구조하에서 존재하는 상위 추상화 수준에서의 설계객체와 대응되는 하위 추상화 수준에서의 설계객체를 쉽게 찾을 수 있다. 뿐만 아니라, 게이트수준 모델이 논리합성과정에서 계층구조를 보존하지 않도록 진행된 경우에도 게이트수준 모델에 존재하는 설계객체명(인스턴스명)들이 대응되는 RTL 모델의 설계객체에 대한 정보를 가지고 있음으로 이와 같은 경우에도 상위 추상화 수준에서의 설계객체와 대응되는 하위 추상화 수준에서의 설계객체를 쉽게 찾을 수 있다. 따라서, 본 특허에서는 이와 같이 다른 추상화수준에서 존재하는 모델들이 계층구조 상에서 최상위수준에서부터 일정한 수준까지 일정한 정도로 동일한 계층구조를 유지하고 있거나, 추상화 상위수준 모델에 존재하는 설계객체를 추상화 하위수준 모델에 존재하는 설계객체들에 대응(이를 부분계층대응관계라 칭하기로 함)시킬 수 있다고 가정한다. 예로, TLM 모델 DUV(TLM) 내에 4개의 설계블럭 B(1)_tlm, B(2)_tlm, B(3)_tlm, B(4)_tlm이 존재하고, DUV(TLM)

에서부터 점진적 구체화 과정을 통한 설계로서 DUV(RTL)를 설계한 경우에 DUV(RTL) 내에도 4개의 설계블럭 B(1)_rtl, B(2)_rtl, B(3)_rtl, B(4)_rtl이 존재하고, B(1)_tlm은 B(1)_rtl과 대응되고 B(2)_tlm은 B(2)_rtl과 대응되고 B(3)_tlm은 B(3)_rtl과 대응되고 B(4)_tlm은 B(4)_rtl과 대응된다. 또 다른 예로 RTL 모델 DUV(RTL) 내에 4개의 설계블럭 B(1)_rtl, B(2)_rtl, B(3)_rtl, B(4)_rtl이 존재하 고, RTL 모델에서부터 점진적 구체화 과정을 통한 설계로서 DUV(GL)을 설계하고 이 과정에서 바운더스스캔셀들이 추가된 경우에 게이트수준에 존재하는 계층구조가 B(0)_gl, B(1)_gl, B(2)_gl, B(3)_gl, B(4)_gl인 경우에는 B(1)_gl은 B(1)_rtl과 대응되고 B(2)_gl은 B(2)_rtl과 대응되고 B(3)_gl은 B(3)_rtl과 대응되고 B(4)_gl은 B(4)_rtl과 대응된다. 따라서 점진적 구체화 과정을 통한 설계는 이들 추상화 상위수준 모델에 존재하는 1 이상의 설계객체들이 추상화 하위수준 모델에 존재하는 설계객체들로 변환되어지는 과정이다. SOC 설계에서 이와 같은 설계객체들의 예들로는 RISC 프로세서코어, DSP 프로세서코어, 메모리블럭, MPEG 디코더블럭, JPEG 디코더블럭, MP3 디코더블럭, 이더넷 코어, PCI-X 코어, DMA 콘트롤러블럭, 메모리 콘트롤러블럭 등이 있으며 일반적으로 매우 복잡한 기능을 수행하는 설계블록들이 된다.

따라서 이들 DUV 내의 설계객체들 각각을 구체화시키는 과정에는 여러 설계자들이 참여하여 병렬적으로 진행하게 되는데, 설계자들의 개개 능력과 경험에 따라서 그리고 설계객체의 난이도에 따라서 개개의 설계객체들을 구체화시키는 과정에 소요되는 시간도 일정하지가 않게 된다. 이와 같은 구체화 과정은 설계자의 노하우에 크게 의존하는 매뉴얼 방식으로 진행될 수도 있으며, 상위수준 합성툴(예로 Forte Design사의 Cynthesizer 혹은 Mentor Graphic사의 Catapult C 등) 내지는 논리수준 합성툴(예로 Synopsys사의 DesignCompiler 혹은 Synplicity사의 Synplify 등) 등을 이용하는 자동화된 방식으로 진행될 수 있다. 그런데, 구체화 과정의 최종 단계에서는 구체화된 특정 설계객체가 올바르게 구체화되어졌는지를 검증하여야 하는데, 다른 설계객체들은 아직 구체화가 완료되지 않은 상황에서 특정 설계객체 B(i)_refined의 구체화가 올바르게 이루어졌는가를 효과적으로 검증하는 방법은 추상화 상위수준에서 이미 존재하고 있는 상위수준 모델에 존재하는 B(i)_refined와 대응되는 설계객체 B(i)_abst를 B(i)_refined로 대체하여서 추상화수준이 혼합된 모델 MODEL_DUV(MIXED)를 만들고 이를 수행시켜서 얻어지는 수행결과를 MODEL_DUV(HIGH)의 수행결과와 비교하는 것이다. 위에서 언급된 예를 가지고 설명한다면, DUV_TLM에 존재하는 B(1)_tlm, B(2)_tlm, B(3)_tlm, B(4)_tlm 각각을 구체화 하는 과정이 다수의 설계자들에 의하여서 병렬적으로 진행되어지나 시간 순으로 B(4)_rtl, B(3)_rtl, B(2)_rtl, B(1)_rtl의 순으로 구체화가 완료된다고 한다면, 우선 B(4)_rtl이 완료 되는대로 B(4)의 구체화를 담당한 설계자들은 MODEL_DUV(MIXED)_4 = (B(1)_tlm, B(2)_tlm, B(3)_tlm, B(4)_rtl)를 구성하여 이를 실행시켜서(즉 시뮬레이션하여서) MODEL_DUV(HIGH) = (B(1)_tlm, B(2)_tlm, B(3)_tlm, B(4)_tlm)의 시뮬레이션 실행결과와 비교하여 봄으로서 B(4)_rtl이 올바르게 구체화가 진행되었는지를 검증할 수 있다. 이와 같은 방식으로 나머지 B(3)_rtl, B(2)_rtl, B(1)_rtl들도 구체화가 완료 되는대로 각각 MODEL_DUV(MIXED)_3 = (B(1)_tlm, B(2)_tlm, B(3)_rtl, B(4)_tlm), MODEL_DUV(MIXED)_2 = (B(1)_tlm, B(2)_rtl, B(3)_tlm, B(4)_tlm), MODEL_DUV(MIXED)_1 = (B(1)_rtl, B(2)_tlm, B(3)_tlm, B(4)_tlm)를 구성하여서 해당 설계블럭이 올바르게 구체화가 진행되었는지를 검증할 수 있다. 또 다른 예를 가지고 설명한다면, DUV_RTL에 존재하는 B(1)_rtl, B(2)_rtl, B(3)_rtl, B(4)_rtl 각각을 구체화 하는 과정이 다수의 설계자들에 의하여서 병렬적으로 진행되어지나 시간 순으로 B(4)_gl, B(3)_gl, B(2)_gl, B(1)_gl의 순(gl은 게이트 수준을 나타내는 첨자임)으로 구체화가 완료된다고 한다면 우선 B(4)_gl이 완료 되는대로 B(4)의 구체화를 담당한 설계자들은 MODEL_DUV(MIXED)_4 = (B(1)_rtl, B(2)_rtl, B(3)_rtl, B(4)_gl)를 구성하여 이를 실행시켜서 MODEL_DUV(HIGH) = (B(1)_rtl, B(2)_rtl, B(3)_rtl, B(4)_rtl)의 시뮬레이션 실행결과와 비교하여 봄으로서 B(4)_gl이 올바르게 구체화가 진행되었는지를 검증할 수 있다. 이와 같은 방식으로 나머지 B(3)_gl, B(2)_gl, B(1)_gl들도 구체화가 완료 되는대로 각각 MODEL_DUV(MIXED)_3 = (B(1)_rtl, B(2)_rtl, B(3)_gl, B(4)_rtl), MODEL_DUV(MIXED)_2 = (B(1)_rtl, B(2)_gl, B(3)_rtl, B(4)_rtl), MODEL_DUV(MIXED)_1 = (B(1)_gl, B(2)_rtl, B(3)_rtl, B(4)_rtl)를 구성하여서 해당 설계블럭이 올바르게 구체화가 진행되었는지를 검증할 수 있다. 그런데, 여기에서 하나 언급하여야 할 것은 MODEL_DUV(MIXED)에 존재하는 설계객체들 중에서 구체화가 된 설계객체 B(i)_refined의 입출력 포트들의 추상화 수준이 구체화가 안되어진 설계객체들 B(k)_abst의 입출력 포트들의 추상화 수준과 맞지 않음으로 인하여 이들 B(i)_refined와 B(k)_abst 간의 연결에 추가적인 인터페이스가 필요할 수 있다.

예로, ESL에서 RTL로 구체화되어지는 경우에는 ESL에서는 트란젝션 수준이며 RTL에서는 핀 시그널 단위의 사이클 수준임으로 이들간의 인터페이스의 역할을 수행하는 트란젝터(transactor)가 필요하게 된다. 이와 같은 트란젝터는 ESL의 트란젝션의 추상화 정도에 따라서 달라질 수 있는데, 예로 ESL의 트란젝션의 추상화 정도가 단일사이클단위의(cycle-accurate) 트란젝션 수준이라고 한다면 아주 간단한 트란젝터를 사용할 수 있으며 만일 추상화 정도가 timed-트란젝션 수준이라고 한다면 상대적으로 복잡한 트란젝터를 사용하게 된다. 또한 RTL에서 GL로 구체화되어지는 경우에는 RTL의 입출력 포트와 GL의 입출력 포트는 모두 핀 시그널 단위에서는 동일함으로서 별도의 포트 인터페이스는 필요하지 않지만, 만일 GL에서 검증하고자 하는 것이 타이밍 검증의 경우에는 이 포트 인터페이스 경계에서 GL에서 맞는 타이밍을 가지는 시그널들을 생성시키기 위해서 이들 간의 타이밍 조정의 역할을 수행하는 타이밍조정기(timing adjustor)가 필요할 수 있다 (타이밍조정기에 사용되는 지연시간 값들은 SDF를 분석하거나, 내지는 라이브러리셀들의 지연시간 파라메터를 분석하거나, 내지는 SDF를 이용한 게이트수준의 타이밍시뮬레이션을 짧은 시뮬레이션 시간 구간만에서 수행하거나, 내지는 정적타이밍분석(static timing analysis)을 수행하거나, 내지는 이들을 조합적으로 이용하여서 얻을 수 있음). 이상과 같이, 점진적 구체화 과정에서 DUV에 존재하는 1 이상의 특정 설계객체가 B(i)_refined로 구체화된 경우에 이를 추상화 상위수준의 모델 MODEL_DUV(HIGH)에 존재하는 해당 설계객체 B(i)_abst와 대체하여서 추상화 중간수준의 모델 MODEL_DUV(MIXED)_i를 만들어 내는 구체화 단계를 “부분 구체화”(partial refinement) 단계라 칭하기로 하고 이와 같은 과정을 부분 구체화 과정이라 칭하기로 한다.

상기의 부분 구체화 단계 이후에는 추상화 상위수준의 모델 MODEL_DUV(HIGH)에 존 재하는 구체화 대상이 되는 모든 설계객체들을 구체화된 설계객체들로 대체(구체화 대상이 되지 않거나 구체화가 필요없는 설계객체가 존재할 수 있으며, 이와 같은 경우에는 해당 설계객체는 구체화하지 않음)하여서 추상화 하위수준의 모델 MODEL_DUV(LOW)를 만들어 내는 구체화 단계를 “완전 구체화”(complete refinement) 단계라 칭하기로 하고 이와 같은 과정을 완전 구체화 과정이라 칭하기로 한다. 즉, ESL에서 RTL로 구체화되는 단계에서는 완전 구체화 과정에서 MODEL_DUV(RTL)을 얻게되며, RTL에서 GL로 구체화되는 단계에서는 완전 구체화 과정에서 MODEL_DUV(GL)을 얻게 된다. 상기의 예로 설명하자면, ESL에서 RTL로 구체화되는 단계에서는 4개의 설계객체들이 모두 구체화되어야 하며 RTL에서 GL로 구체화되는 단계에서는 4개의 설계객체들 중에 B(3)_rtl은(예로 B(3)_rtl은 메모리모듈임으로) 구체화될 필요가 없다면 완전 구체화 과정을 통하여 MODEL_DUV(RTL) = (B(1)_rtl, B(2)_rtl, B(3)_rtl, B(4)_rtl)와 MODEL_DUV(GL) = (B(1)_gl, B(2)_gl, B(3)_rtl, B(4)_gl)가 구성되어지게 된다.

완전 구체화 과정을 통하여 얻어진 추상화 하위수준의 모델 MODEL_DUV(LOW)을 최종적으로 실행시켜 얻어진 결과를 추상화 상위수준의 모델 MODEL_DUV(HIGH)의 시뮬레이션 실행결과와 비교하거나 필요시 추가적으로 추상화 중간수준의 모델 MODEL_DUV(MIXED)_i과도 비교함으로서 점진적 구체화 과정을 통하여 설계가 올바르게 수행되었는지를 검증할 수 있다. 그러나, 이와 같이 점진적 구체화 과정으로 진행되는 설계에서 자연스럽게 적용되는 점진적 구체화 방식의 검증 과정에서 부분 구체화 과정에서 수행되는 검증은 추상화 중간수준의 모델 MODEL_DUV(MIXED)_i에 존재하는 설계객체들이 아직도 대부분 추상화 상위수준에서 존재하고 있음으로 MODEL_DUV(MIXED)_i를 대상으로 하는 검증 실행속도가 추상화 상위수준의 모델 MODEL_DUV(HIGH)를 대상으로 하는 검증 실행속도에 비하여 꽤 떨어지게 되고 (일반적으로 실제 SOC 설계에서 DUV에서 온칩버스를 통하여 연결되는 설계객체들의 수는 적게는 10개 많게는 100개 정도가 됨), 완전 구체화 과정에서 수행되는 검증은 MODEL_DUV(LOW)에 존재하는 설계객체들 전부 내지는 대부분이 추상화 하위수준에서 존재하고 있음으로 MODEL_DUV(LOW)를 대상으로 하는 검증 실행속도가 추상화 상위수준의 모델 MODEL_DUV(HIGH)를 대상으로 하는 검증 실행속도에 비하여 크게 떨어지게 됨으로서 효과적인 검증 진행에 큰 장해요소가 되게 된다. 구체적 예로서는 ESL 모델에 비하여 이를 구체화한 RTL 모델의 검증 실행속도는 ESL 모델의 검증 실행속도에 비하여 최소 10배에서 최대 10,000배 이상 느려지며, RTL 모델에 비하여 이를 구체화한 GL 모델의 검증 실행속도는 RTL 모델의 검증 실행속도에 비하여 최소 100배에서 최대 300배 이상 느려지게 됨으로서 이와 같은 점진적 구체화를 통한 검증에서 전체 검증 시간을 크게 늘리게 되는 큰 문제점이 되게 된다.

따라서, 본 발명의 목적은 시스템 수준에서부터 게이트 수준까지 진행되는 설계를 점진적 구체화를 통하여 진행하는 과정에 적용되는 검증 과정을 설계 과정과 같이 점진적 구체화를 통하여서 효과적으로 진행할 수 있는 체계적인 검증 방법을 제공함에 있다.

본 발명의 또 다른 목적은, 점진적 구체화를 통하여 진행되는 설계에서 진행되는 검증이 점진적 구체화 과정을 통하여 추상화 하위 단계로 진행될수록 검증 속도가 점차적으로 내지는 크게 떨어지는 문제점을 해결하는 체계적인 검증 방법을 제공함에 있다.

본 발명의 또 다른 목적은, 설계 및 검증을 추상화 상위수준에서부터 추상화 하위수준으로까지 점진적 구체화 방식으로 진행되는 전체 과정이 체계적이며 자동화된 방식으로 진행될 수 있도록 하는 것이다.

본 발명의 또 다른 목적은, 여러 추상화 수준들에서 존재하는 2 이상의 모델들간의 모델 일관성을 효과적으로 유지하는 체계적인 검증 방법을 제공함에 있다.

본 발명의 또 다른 목적은, 체계적으로 유지된 모델 일관성에 근거하여서 추상화 상위 수준에서의 모델을 레퍼런스 모델로 활용하여서 점진적 구체화 과정을 통하여 추상화 하위 수준의 모델을 효과적으로 검증하는 방법을 제공함에 있다.

본 발명의 또 다른 목적은, 분산병렬 시뮬레이션에서의 동기 오버헤드와 통신 오버헤드를 효과적으로 줄임으로서 분산병렬 시뮬레이션의 속도를 높이는 방법을 제공함에 있다.

본 발명의 또 다른 목적은, 점진적 구체화 과정을 통한 설계 과정에서 발견되는 설계오류들을 제거하는 디버깅 과정을 체계적으로 수행할 수 있도록 함으로서 신속한 디버깅을 통한 설계 오류를 수정하는 방법을 제공함에 있다.

상기 목적들을 달성하기 위하여, 본 발명에 따른 설계 검증 방법을 적용하기 위하여 필요한 설계 검증 장치는 검증 소프트웨어와 1 내지는 2 이상의 시뮬레이터가 인스톨된 1 내지는 2 이상의 컴퓨터로 구성될 수 있다. 본 발명에서의 설계 검증 방법을 적용할 수 있는 또 다른 설계 검증 장치는 검증 소프트웨어와 1 내지는 2 이상의 시뮬레이터가 인스톨된 1 내지는 2 이상의 컴퓨터와 상기 1 내지는 2 이상의 컴퓨터에 연결된 1 내지는 2 이상의 시뮬레이션가속기 내지는 FPGA 보드로 구성된다. 검증 소프트웨어는 컴퓨터에서 실행되며, 만일 상기 설계 검증 장치에 2 이상의 컴퓨터들이 있는 경우에는 이들 2 이상의 컴퓨터는 네트워크(예로 이더넷 혹은 기가비트이더넷)로 연결되어져서 컴퓨터들 간에 파일들 내지는 데이터의 이동을 네트워크를 통하여 가능하게 한다. 설계 검증 용도의 상기 1 내지는 2 이상의 시뮬레이터는 이벤트-구동 시뮬레이터(event-driven simulator)로만 구성(분산병렬 시뮬레이션을 이벤트-구동 시뮬레이터들로만 구성하여서 병렬 시뮬레이션하는 것을 PDES(Parallel Discrete Event Simulation)이라 함)될 수도 있고, 혹은 이벤트-구동 시뮬레이터와 사이클-기반 시뮬레이터(cycle-based simulator)로 같이 구성될 수도 있고, 혹은 사이클-기반 시뮬레이터로만 구성될 수도 있고, 혹은 사이클-기반 시뮬레이터와 트란젝션-기반 시뮬레이터(transaction-based simulator)로 같이 구성될 수도 있고, 혹은 트란젝션 시뮬레이터로만 구성될 수도 있고, 혹은 이벤트-구동 시뮬레이터와 트란젝션-기반 시뮬레이터로 같이 구성될 수도 있고, 혹은 이벤트-구동 시뮬레이터와 사이클-기반 시뮬레이터와 트란젝션-기반 시뮬레이터로 같이 구성될 수도 있는 등 본 특허에서의 시뮬레이터의 구성은 매우 다양한 방식으로 구성할 수 있다. 따라서, 상기 2 이상의 시뮬레이터가 이벤트-구동 시뮬레이터와 사이클-기반 시뮬레이터로 구성된 경우에는 이를 이용한 분산병렬 시뮬레이션이 부분 적으로는 이벤트-구동 시뮬레이션 방식으로 진행되고 다른 부분은 사이클-기반 시뮬레이션 방식으로 진행되는 동시-시뮬레이션(co-simulation) 모드로 진행되게 된다. 혹은 상기 2 이상의 시뮬레이터가 이벤트-구동 시뮬레이터와 사이클-기반 시뮬레이터와 트란젝션-기반 시뮬레이터로 구성된 경우에는 이를 이용한 분산병렬 시뮬레이션이 부분적으로는 이벤트-구동 시뮬레이션 방식으로 진행되고 다른 부분은 사이클-기반 시뮬레이션 방식으로 진행되고 또 다른 부분은 트란젝션-기반 시뮬레이션 방식으로 진행되는 동시-시뮬레이션 모드로도 진행되어질 수 있다.

구체적 예를 든다면, AMBA 플랫폼 기반의 특정 추상화수준 SOC 모델에 대한 통상적인 분산병렬 시뮬레이션 내지는 본 특허의 분산처리적병렬시뮬레이션(추후에 정의됨)의 경우에 버스중재기와 어드레스디코더를 포함하는 온칩 버스 설계객체는 ca-트란젝션수준에서 모델링된 블럭으로 이 블럭의 시뮬레이션을 담당하는 로컬시뮬레이션은 사이클-기반 시뮬레이션 방식으로 진행되고, 나머지 모든 설계객체들(ARM 코어, DSP, 메모리콘트롤러, DAM 콘트롤러, 기타주변장치들)은 RTL에서 모델링된 블럭들로 이들 블럭들 각각의 로컬시뮬레이션들은 이벤트-기반 시뮬레이션 방식으로 진행될 수 있다.

현재 레지스터전송수준에서의 칩 설계에서 사용되는 HDL(Haraware Description Language) 시뮬레이터들(구체적 예를 든다면, Cadence Incisive Simulator, Synopsys VCS, Mentor Graphic ModelSim, Aldec Active-HDL/Riviera 등)은 모두 이벤트-구동 방식의 시뮬레이터들이다. 사이클-기반의 시뮬레이터로는 대표적으로 Synopsys의 Scirocco가 있다.

본 특허에서 제안되는 점진적 구체화 과정을 통한 설계에서 적용되는 체계적인 점진적 구체화 검증 방식(Systematically Progressive Refinement Verification Method 앞으로는 이를 SPR 검증 방식으로 약칭함)은 RTL에서 구현가능한 RTL 모델을 대상으로 하는 RTL 검증 실행에 ESL 모델을 대상으로 하는 시스템수준 검증 실행의 결과 내지는 ESL에서 RTL로 점진적 구체화 과정을 진행하는 과정에서 구성되는 1 이상의 추상화 중간수준의 모델들인 MODEL_DUV(MIXED)_i들을 대상으로 하는 1 이상의 ESL/RTL 혼합검증 실행의 결과들을 활용하여서 RTL 검증 실행을 병렬적으로 실행하거나 부분적으로만 실행(부분적으로만 실행하는 것에서는 인크리멘탈 시뮬레이션 기법을 활용할 수 있는데, 인크리멘탈 시뮬레이션 기법을 추후에 설명함)함으로서 RTL 검증을 신속하게 수행하는 것이 가능하다. 뿐만 아니라, SPR 검증 방식은 GL에서 구현가능한 GL 모델을 대상으로 하는 GL 검증 실행에 RTL 모델을 대상으로 하는 RTL 검증 실행의 결과 내지는 RTL에서 GL로 점진적 구체화 과정을 진행하는 과정에서 구성되는 추상화 중간수준의 모델들인 1 이상의 MODEL_DUV(MIXED)_i들을 대상으로 하는 1 이상의 RTL/GL 혼합검증 실행의 결과들을 활용하여서 GL 검증 실행을 병렬적으로 실행하거나 부분적으로만 실행(부분적으로만 실행하는 것에서는 인크리멘탈 시뮬레이션 기법을 활용할 수 있는데, 인크리멘탈 시뮬레이션 기법을 추후에 설명함)함으로서 GL 검증을 신속하게 수행하는 것도 가능하다. 뿐만 아니라, ESL에서 다양한 트란젝션 수준의 ESL 모델을 대상으로 하는 ESL 검증 실행에 추상화가 높은 트란젝션 모델을 대상으로 하는 시스템수준 검증 실행의 결과 내지는 점진적 구체화 과정을 진행하는 과정에서 구성되는 추상화가 높은 트란젝션 모 델과 추상화가 낮은 트란젝션 모델을 혼용한 1 이상의 모델 MODEL_DUV(MIXED_AT_TLM)_i들을 대상으로 하는 1 이상의 트란젝션 혼합검증 실행(예로 MODEL_DUV(MIXED_AT_TLM)내의 특정 설계객체는 ca-트란젝션 수준의 설계객체이고 나머지 설계설계들은 timed-트란젝션 수준의 설계객체들로 구성하여 혼합검증 실행)의 결과들을 활용하여서 ESL 검증 실행을 병렬적으로 실행하거나 부분적으로만 실행(부분적으로만 실행하는 것에서는 인크리멘탈 시뮬레이션 기법을 활용할 수 있는데, 인크리멘탈 시뮬레이션 기법을 추후에 설명함)함으로서 ESL 검증을 신속하게 수행하는 것이 가능하다.

이와 같은 검증 실행은 기본적으로 1 내지는 2 이상의 시뮬레이터를 이용한 시뮬레이션 방식으로 진행되어지지만, 이뿐만 아니라 1 내지는 2 이상의 시뮬레이터에 1 내지는 2 이상의 시뮬레이션가속기 내지는 1 내지는 2 이상의 하드웨어에뮬레이터 내지는 1 내지는 2 이상의 FPGA 보드 등과 같은 하드웨어기반검증플랫폼을 시뮬레이터와 같이 사용한 시뮬레이션가속 방식으로 진행하는 것도 가능하다. 이와 같은 1 내지는 2 이상의 시뮬레이션가속기 내지는 1 내지는 2 이상의 하드웨어에뮬레이터 내지는 1 내지는 2 이상의 FPGA 보드를 1 내지는 2 이상의 시뮬레이터와 같이 사용하여 시뮬레이션의 수행속도를 높이는 시뮬레이션가속 방식도 넓은 의미에서는 시뮬레이션임으로 앞으로 본 특허에서는 특별한 언급이 없는 한 검증 이라는 용어와 시뮬레이션 이라는 용어는 서로 교환하여서 사용할 수 있는 것(즉, 본 특허에서는 정식검증(formal verification)은 고려하지 않기로 하며 따라서 검증이라하면 동적검증(dynamic verification) 기법인 시뮬레이션만을 생각하기로 함)으로 하여 서 지금부터는 검증 이라는 용어 대신에 시뮬레이션으로 대체하여서 사용하기로 하며, 이 시뮬레이션에는 시뮬레이터를 사용하는 시뮬레이션 뿐만 아니라 시뮬레이션가속기 내지는 하드웨어에뮬레이터 내지는 FPGA 보드를 시뮬레이터와 함께 사용하는 시뮬레이션가속까지도 포함되는 것으로 한다.

위에서 이미 언급된대로 본 특허에서의 SPR 검증 방식에서는 추상화 하위수준에서 이루어지는 시뮬레이션의 병렬적 실행 내지는 부분적으로만의 실행을 위하여 점진적 구체화 과정에서의 앞서서 수행된 추상화 상위수준에서 이루어지는 시뮬레이션 결과 내지는 추상화 중간수준에서 이루어지는 1 이상의 시뮬레이션 결과를 활용하거나, 내지는 동일한 추상화 수준에서 이루어지는 시뮬레이션의 병렬적 실행 내지는 부분적으로만의 실행을 위하여 점진적 구체화 과정에서의 동일한 추상화 수준에서 앞서서 수행된 시뮬레이션 결과를 활용한다. 뿐만 아니라, 드물게는 본 특허에서의 SPR 검증 방식에서는 특정 추상화 수준에서 이루어지는 시뮬레이션의 병렬적 실행 내지는 부분적으로만의 실행을 위하여 점진적 구체화 과정에서의 앞서서 수행된 추상화 하위수준에서 이루어진(통상적으로 설계 과정에서는 재반복(iteration)이 필요하게 되는데, 이 재반복 과정에서 추상화 하위수준의 시뮬레이션 수행 후에 추상화 상위수준의 시뮬레이션이 진행되어질 수 있음) 시뮬레이션 결과를 활용하기도 한다. 이상과 같이 본 특허에서의 핵심 사항 중의 하나는 앞서서 수행되어진 시뮬레이션의 결과를 활용하여서 나중에 수행되는 시뮬레이션을 신속하게 수행할 수 있게 하는 것인데, 앞서서 수행되어진 시뮬레이션이 나중에 수행되는 시뮬레이션에 비하여 상대적으로 추상화가 높은 수준 내지는 동일한 추상화 수준에서 수행되는 것이 일반적이지만, 경우에 따라서는 앞서서 수행되어진 시뮬레이션의 추상화 수준이 나중에 수행되는 시뮬레이션에 비하여 추상화 수준이 낮을 수도 있다. 뿐만 아니라, 앞서서 수행된 시뮬레이션과 나중에 수행되는 시뮬레이션 사이에 시뮬레이션 대상이 되는 1 이상의 모델내에 존재하는 1 이상의 설계객체들에 대한 수정이 가해질 수도 있다.

앞서서 수행되어진 시뮬레이션이 나중에 수행되는 시뮬레이션에 비하여 상대적으로 추상화가 높은 경우에 대해서는 좀 더 구체적으로 설명하면, 점진적 구체화 과정에서의 추상화 상위수준 모델을 이용한 추상화 상위수준에서 이루어지는 시뮬레이션에서 이 시뮬레이션 실행 도중의 1 이상의 시뮬레이션 특정 시점 내지는 특정 구간에서 수집된 추상화 상위수준 모델의 상태정보(추후에 설명됨)를 활용하거나 (이를 활용방법-1이라 칭함), 혹은 추상화 상위/하위 혼합수준 모델을 이용한 추상화 중간수준에서 이루어지는 2 이상의 시뮬레이션에서 이 2 이상의 시뮬레이션 실행 도중의 1 이상의 시뮬레이션 특정 시점 내지는 특정 구간에서 수집된 추상화 중간수준 모델의 설계 상태정보(design state information으로 앞으로는 상태정보로도 약칭하기로 함)를 활용하거나 (이를 활용방법-2라 칭함), 혹은 점진적 구체화 과정에서의 추상화 상위수준 모델을 이용한 추상화 상위수준에서 이루어지는 시뮬레이션에서 이 시뮬레이션 실행 도중에 전체 시뮬레이션 구간이나 내지는 특정 시뮬레이션 구간에서 수집된 추상화 상위수준 모델 내의 1 이상의 설계객체들의 입출력정보(추후에 설명됨)를 활용하거나 (이를 활용방법-3이라 칭함), 혹은 추상화 상위/하위 혼합수준 모델을 이용한 추상화 중간수준에서 이루어지는 2 이상의 시뮬레이 션에서 이 2 이상의 시뮬레이션 실행 도중에 전체 시뮬레이션 구간이나 내지는 특정 시뮬레이션 구간에서 수집된 2 이상의 추상화 상위/하위 혼합수준 모델들에 존재하는 추상화 하위수준의 설계객체들의 입출력정보를 활용하는 것이다 (이를 활용방법-4라 칭함). 모델의 상태정보란 특정 시뮬레이션 시점(예로, 시뮬레이션 시점 29,100,511 나노초) 내지는 일정 시뮬레이션 시간구간(예로 시뮬레이션 시점 29,100,200 나노초에서부터 29,100,300 나노초까지의 100 나노초 구간)에서의 모델에 존재하는 플립플롭 출력이나 래치 출력 혹은 메모리 혹은 궤환루프를 이루는 조합적 경로(combinational feedback loop)를 구술하고 있는 모든 변수나 시그널들의 값들을 포함한 동적정보(모델의 동적정보 내지는 설계객체의 동적정보란 시뮬레이션 과정에서 특정 시뮬레이션 시점 내지는 특정 시뮬레이션 구간(시뮬레이션 전체 구간일 수 있음)에서의 상기 모델 내지는 상기 설계객체에 존재하게 되는 1 이상의 시그널들 내지는 신호선들 상의 논리값들, 내지는 모델 내지는 설계객체에 존재하게 되는 1 이상의 변수들 상의 값 내지는 상수들 값을 말함. 이들 동적정보는 시뮬레이션 실행 과정에서 얻을 수 있는데, 시뮬레이션 실행 과정에서 동적정보를 얻는 실 예를 든다면 대표적인 방법이 Verilog 시뮬레이터에서는 $dumpvars, $dumpports, $dumpall, $readmemb, $readmemh 등의 시스템테스크 내지는 사용자정의 시스템테스크(user-defined system task)를 사용하여서 얻을 수 있으며(좀 더 구체적 방법들은 별도로 출원된 국내특허 10-2005-95803, 10-2005-116706, 10-2006-19738의 내용을 참조함), 얻어진 동적정보는 VCD 내지는 SHM 내지는 VCD+ 내지는 FSDB 형식 내지는 사용자가 정의한 임의의 이진형식 또는 텍스트형식 등으로 저장도 가능함)를 말한다. 설계객체의 상태정보란 특정 시뮬레이션 시점 내지는 일정 시뮬레이션 시간구간에서의 설계객체에 존재하는 플립플롭 출력이나 래치 출력 혹은 메모리 혹은 궤환루프는 이루는 조합적 경로를 구술하고 있는 모든 변수나 시그널들의 값들을 포함한 동적정보를 말한다.

또한 설계객체의 입력정보란 특정 시뮬레이션 시간구간(이 특정 시뮬레이션 시간구간은 시뮬레이션 전체 시간구간이 될 수 있음)에서의 설계객체의 모든 입력(input), 입출력(inout) 상에서의 값들을 말하고, 설계객체의 출력정보란 특정 시뮬레이션 시간구간(시뮬레이션 전체 시간구간이 될 수 있음)에서의 설계객체의 모든 출력(output), 입출력 상에서의 값들을 말하고, 설계객체의 입출력정보란 특정 시뮬레이션 시간구간(시뮬레이션 전체 시간구간이 될 수 있음)에서의 설계객체의 모든 입력, 출력, 입출력 상에서의 값들을 말한다.

본 특허에서 제시되는 시뮬레이션 방법은 앞서서도 이미 언급된 것과 같이 점진적 구체화 진행 과정 중에서 동일한 추상화수준 모델을 이용한 시간적으로 앞에서 수행된 시뮬레이션 결과를 이용하여서 동일한 추상화수준 모델을 이용한 나중에 수행되는 시뮬레이션을 병렬적 내지는 부분적으로 실행함으로서 시뮬레이션을 빠르게 수행하거나, 내지는 점진적 구체화 진행 과정 중에서 추상화 하위수준 모델을 이용한 시간적으로 앞에서 수행된 시뮬레이션 결과를 이용하여서 추상화 상위수준 모델을 이용한 나중에 수행되는 시뮬레이션을 병렬적 내지는 부분적으로 실행함으로서 시뮬레이션을 빠르게 수행하는 것도 가능하지만, 좀 더 일반적인 상황에서의 본 특허에서 제시되는 시뮬레이션 방법은 점진적 구체화 진행 과정 중에서 추상화 상위 수준 모델을 이용한 시뮬레이션 결과를 이용하여서 추상화 하위수준 모델을 이용한 시뮬레이션을 병렬적 내지는 부분적으로 실행함으로서 추상화 하위수준 모델을 이용한 시뮬레이션을 빠르게 수행하는 것이다. 즉. 본 특허에서는 추상화 상위수준 모델 M(HIGH)을 이용한 시뮬레이션 결과를 이용하여서 추상화 하위수준 모델 M(LOW)을 이용한 시뮬레이션을 빠르게 수행하는 것에 더 많은 촛점을 맞추고 있으며, 따라서 상기 추상화 상위수준 모델 M(HIGH)을 이용한 시뮬레이션을 빠르게 수행하는 방법은 본 특허에서의 방법을 연속적으로 적용하여서 상기 추상화 상위수준 모델 M(HIGH)보다 더 추상화 수준이 높은 모델 M(HIGHER)(이 경우에는 상대적으로 M(HIGHER)가 추상화수준이 높은 모델이고, M(HIGH)가 추상화수준이 낮은 모델이 됨)을 이용한 시뮬레이션 결과를 이용하거나, 내지는 통상적인 분산병렬 시뮬레이션을 이용하는 것도 가능하고, 내지는 일반적인 단일 시뮬레이션을 이용하는 것도 가능하다. 본 특허에서 특정 추상화 수준 모델을 이용한 시뮬레이션을 병렬적 실행하는 것에는 분산처리적병렬수행(distributed-processing-based parallel execution, 이를 앞으로 DPE로 약칭함)과 시간분할적병렬수행(timed-sliced parallel execution, 이를 앞으로 TPE로 약칭함)(추후 자세히 설명됨) 모두를 포함한다 (즉, 분산처리적병렬수행 방식의 병렬시뮬레이션과 시간분할적병렬수행 방식의 병렬시뮬레이션은 본 특허에서 제안하는 새로운 방식의 시뮬레이션만을 지칭하는 용어임). 자세한 설명을 위해서 우선 t-DCP(Temporal Design Check Point)와 s-DCP(Spatial Design Check Point)를 정의하기로 한다.

t-DCP란 DUV 내지는 DUV 내의 1 이상의 설계객체들을 대상으로 하는 시뮬레이션이 시뮬레이션 시간 0 이외의 임의의 시간 Ta에서부터 시작되어질 수 있도록 하는데 필요한 상기 DUV 내지는 DUV 내의 1 이상의 설계객체들에 관한 동적정보(dynamic information)로 정의된다 (설계객체의 동적정보란 시뮬레이션 과정에서 특정 시뮬레이션 시점 내지는 특정 시뮬레이션 구간(시뮬레이션 전체 구간일 수 있음)에서의 상기 설계객체에 존재하게 되는 1 이상의 시그널들 내지는 신호선들 상의 논리값들, 내지는 설계객체에 존재하게 되는 1 이상의 변수들 상의 값 내지는 상수들 값임). 따라서, 설계객체의 상태정보는 t-DCP의 구체적 일 예이다. 그런데, 시뮬레이션이 가능한 모델은 DUV와 TB를 모두 포함하고 있어야만 한다. 따라서 시뮬레이션이 시뮬레이션 시간 0 이외의 임의의 시간 Ta에서부터 시작되어질 수 있도록 하려면 DUV를 Ta에서부터 수행할 수 있어야 할 뿐만 아니라 TB도 고려하여 주어야 한다. 이를 위해서는 대략 3가지 방법을 생각할 수 있다. 그 첫번째 방법은 TB는 시뮬레이션 시간 0에서부터 실행시키고 DUV는 Ta에서부터 실행시키는 방식이다. 이를 위해서는 TB가 반응적 TB(reactive TB)인 경우에는 DUV의 출력정보(따라서 이 출력정보를 앞선 시뮬레이션에서 획득하는 것이 필요함)를 이용하여서 우선 TB만을 시뮬레이션 시간 0에서부터 Ta까지 진행시킨 이후에 Ta에서부터는 TB와 DUV가 함께 연동하면서 수행될 수 있게 하거나, 내지는 TB가 비반응적 TB(non-reactive TB)인 경우에는 우선 TB만을 시뮬레이션 시간 0에서부터 Ta까지 진행시킨 이후에 Ta에서부터는 TB와 DUV가 함께 연동하면서 수행될 수 있게 하면 된다. 그 두번째 방법은 TB도 시뮬레이션 시간 Ta에서부터 시작할 수 있도록 TB를 저장(save)하고 재시행(restart)하는 것이다. 즉 TB도 DUV와 유사하게 시뮬레이션의 상태를 저장하거나 TB의 상태(TB의 상태란 시뮬레이션 특정시점 내지는 일정기간에서의 TB내에 선언된 모든 변수들과 상수들의 값)를 저장함으로서 이를 이를 재설정함으로서 재시행되어진다. 그런데 하드웨어를 모델링한 DUV와는 달리 TB는 테스트 환경을 모델링한 것임으로 TB의 상태를 임의의 시점에서 재시행하려면 TB의 구술 형식을 제안하여야 하거나(예로, TB도 합성가능한 형식으로 구술) 내지는 추가적인 수작업 과정을 거치는 과정이 필요하다. 세번째로는, TB의 주요요소중의 하나인 입력생성서브컴퍼넌트를 알고리즘방식의 입력생성서브컴퍼넌트 대신에 패턴방식의 입력생성서브컴퍼넌트로 대체하는 것이다. 입력생성서브컴퍼넌트는 DUV에 입력스티뮬러스를 공급하는 역할을 담당하는데 알고리즘방식의 입력생성에서는 DUV로의 입력공급을 시뮬레이션 시점 0에서부터 시작하지 않고 임의의 시점 Ta에서부터 시작하는 것이 어려운데 비하여 패턴방식의 입력생성은 패턴 포인터등을 이용함으로서 DUV로의 입력공급을 시뮬레이션 임의의 시점 Ta에서부터 시작하는 것이 매우 용이하다. 따라서, 패턴방식의 입력생성서브컴퍼넌트를 이용하기 위해서는 앞서서 진행된 시뮬레이션 진행과정에서 원 TB에서 생성되어져서 DUV에 인가되어지는 입력정보들을 시뮬레이션 전구간에 걸쳐서 탐침하여 1 이상의 파일로 저장하고, 이를 이 후에 수행되는 시뮬레이션에서 활용함으로서 TB를 임의의 시점 Ta에서부터 동작시키는 것이 가능한데, 이와 같은 패턴방식의 TB는 리그레션 데스트(regression test)에서 많이 이용되어지는 방법이다. 이상의 방법들을 중 하나를 적용하기 위해서는 시뮬레이션 대상이 되는 모델 내지는 시뮬레이션 환경에 부가적인 코드인 부가 코드를 부가할 필요성이 있는데 이와 같은 부가 코드는 본 특허에서의 검증 소프트웨어를 통하여 자동적으로 부가시킬 수 있다 (부가 코드의 구체적 예는 도 16과 도 17과 도 18을 참조함). DUV 내지는 DUV 내의 1 이상의 설계객체들의 상태정보와 같은 t-DCP를 이용하여서 DUV 내지는 DUV 내의 1 이상의 설계객체들을 대상으로 하는 시뮬레이션이 시뮬레이션 시간 0 이외의 임의의 시간 Ta에서부터 시작되어질 수 있도록 하는 자세한 방법은 별도의 국내특허(10-2005-116706)에 이미 자세하게 설명되어져 있음으로 이를 참조하기로 하고 본 특허에서는 이에 대한 자세한 설명은 지면 제약상 생략하기로 한다.

이와 같은 t-DCP를 활용하게 되면 DUV에 대한 임의의 시뮬레이션을 시뮬레이션 시간 상에서 복수개의 시간 소구간(슬라이스)들로 나누고, 시뮬레이션시간소구간별로 독립적으로 시뮬레이션이 진행되어질 수 있음으로 시간병렬적인 시뮬레이션이 가능하게 된다. 다만, 별도의 국내특허 10-2005-116706에서도 이미 설명된대로 현재 대부분의 HDL 시뮬레이터들이 동작되어지는 방식인 시뮬레이션이 이벤트 발생에 의하여 진행되는 이벤트 구동(event driven) 방식의 시뮬레이션인 경우에는 DUV 내지는 DUV 내의 1 이상의 설계객체들의 상태정보와 같은 t-DCP를 이용하여서 DUV 내지는 DUV 내의 1 이상의 설계객체들을 대상으로 하는 시뮬레이션이 시뮬레이션 시간 0 이외의 임의의 특정 시간 Ta에서부터 재시작(re-start) 되더라도 이벤트의 손실이 전혀 발생하지 않고 상기 임의의 특정 시간 Ta에서부터 시뮬레이션이 Ta 이후로까지 진행되어지더라도 시뮬레이션 시간 0에서부터 시뮬레이션이 시작되어서 Ta까지 진행되어지고 Ta 이후로까지 계속 진행되는 것과 상기 Ta에서부터 시작하여서 그 이후로는 동일한 시뮬레이션 결과를 얻을 수 있도록 하는 것이 매우 중요하다. 상 기 별도의 특허 10-2005-116706에서는 이와 같은 것이 가능한 구체적 방법들을 자세히 설명하고 있는데 본 특허에서는 지면 제약상 자세한 설명은 생략하는 대신(자세한 것은 10-2005-116706을 참고)에, 핵심 사항에 대해서만 언급하기로 한다. 즉 상기 임의의 특정 시간 Ta에서부터 재시뮬레이션이 올바르게 되기 위해서는 앞서서 수행된 시뮬레이션에서 시점 Ta에서의 상태정보만을 저장하지 않고 일정한 시간구간 (Ta - d) (d는 모델에서 한 이벤트에 의하여 다른 이벤트가 트리거되는 최대 시간 간격으로 d 값은 시뮬레이션 대상이 되는 모델에 따라서 달라지는데 사용자로부터 받을 수 있거나 혹은 자동화된 방식으로 계산되어질 수 있음) 에서부터 Ta까지의 상태정보를 저장하고(예로, Ta가 10,000,000나노초인 경우에 상태정보 저장은 10,000,000나노초에서의 한 시점에서만 수행하지 않고 9,999,990나노초부터 10,000,000나노초까지의 10나노초 시간구간에 걸쳐서 진행함. 이 경우에 d = 10 나노초임) 이와 같이 일정한 시간구간에서 저장된 상태정보를 이용하여서 재-시작도 상기 일정한 시간구간에서 진행(앞서의 예로, 9,999,990나노초에서부터 10,000,000나노초까지에서 저장된 상태정보를 이용하여서 재-시작을 9,999,990나노초에서부터 10,000,000나노초까지에서 진행)한다. 본 특허에서의 분산처리적병렬시뮬레이션에서 1 이상의 로컬시뮬레이션이 이벤트-구동 방식의 시뮬레이션으로 수행되는 경우에는 이와 같은 이벤트 손실이 없는 재-시작이 올바른 롤백 수행에 있어서 매우 중요한데, 상기의 방법을 사용하게 되면 올바른 롤백 수행이 가능하게 된다.

s-DCP란 DUV 내지는 DUV 내의 2 이상의 설계객체들을 대상으로 하는 시뮬레이션을 2 이상의 시뮬레이터들에 나누어서 분산병렬 시뮬레이션을 수행하는 경우에 이들 2 이상의 시뮬레이터들에 나누어진 설계객체들간에 분산병렬 시뮬레이션 실행 과정에서 필요한 시그널값들의 올바른 전달 내지는 트란젝션값들의 올바른 전달을 위한 통신(communication) 및 동기화(synchronization)를 최소화 하는 것에 필요한 상기 DUV 내지는 TB의 상이한추상수준 동일모델에 관한 동적정보 내지는 이 상이한추상수준 동일모델 내의 1 이상의 설계객체들에 관한 동적정보, 내지는 상기 DUV 내지는 TB에 관한 동적정보 내지는 DUV 내지는 TB 내의 1 이상의 설계객체들에 관한 동적정보로 정의된다. 이와 같은 s-DCP는 분산병렬 시뮬레이션에서 특정 로컬시뮬레이터로 수행되는 특정 설계객체가 시뮬레이션되는 과정에서 함께 시뮬레이션되면서 상기 특정 설계객체의 로컬시뮬레이션 S_l(k) 수행의 예상입력(expected input)과 예상출력(expected output)(본 특허에서 "로컬시뮬레이션 수행의 예상입력과 예상출력"이라 함은 실제 수행에 앞서서 예측되어진 예상입력과 예상출력을 정의하는 용어임. 구체적으로 실제 수행에 앞서서 예측되어진 이라는 의미는 해당 시뮬레이션 실행 시작 전에 예측되어지거나, 내지는 해당 시뮬레이션의 실행 도중에 해당 입력을 인가하는 특정 시간에 앞서서 동적으로 예측되어지거나, 내지는 이 둘을 혼용한 방식으로 예측되어지는 것 모두를 포함하는 의미임)으로 사용되어져서, 우선 상기 예상입력을 상기 특정 설계객체에 인가하여 실제 로컬시뮬레이션 S_l(k)을 실행시켜 얻어진 상기 특정 설계객체의 실제 출력값이 상기 예상출력과 일치한다면 다른 로컬시뮬레이터들로 수행되는 시뮬레이션 대상이 되는 모델 내의 여타의 설계객체들과의 통신 및 동기화를 생략하고 이 특정 로컬시뮬레이션 S_l(k)의 시뮬레이션 시간을 독립적으로 앞으로 진행시킬 수 있는 역할을 수행하게 된다. 상기 특정 설계객체의 로컬시뮬레이션 수행의 예상입력과 예상출력으로 사용되어지는 상기 s-DCP 정보 제공과 이에 따른 시뮬레이션 진행을 제어(예상입출력이용-런 진행, 실제입출력이용-런 진행, 롤백 수행 등으로 각각은 추후에 설명됨)하는 기능을 위해서 별도의 코드(이 별도의 코드는 Verilog 내지는 SystemVerilog 내지는 VHDL과 같은 HDL로서 구술되어져서 HDL로 구술된 모델에 포함되어지거나, 혹은 C/C++로 구술되어져서 PLI/VPI/FLI 등을 통하여 HDL로 구술된 모델에 인터페이스되어지거나, 혹은 HDL과 C/C++ 혼용으로 구술되어져서 PLI/VPI/FLI 등을 통하여 HDL로 구술된 모델에 포함되는 동시에 인터페이스되어짐)가 시뮬레이션 대상이 되는 설계코드(통상 HDL 코드 내지는 SystemC 코드 내지는 C/C++ 코드 내지는 SDL 코드 내지는 HVL 코드 내지는 이들의 조합) 내지는 시뮬레이션 환경(예로, 시뮬레이션 컴파일 내지는 일레보레이션 내지는 실행을 위한 시뮬레이션스크립트)에 부가되어져야 하는데 통상적으로는 모델의 TB 부분(즉 DUV의 바깥 부분)에 부가되어지고 C/C++ 코드로서도 부가(본 특허에서 이 부가되는 코드 전체를 "부가 코드"로 통칭함)되어지는 것이 일반적이나 경우에 따라서는 DUV에도 일부분이 부가되어지며, 이와 같은 과정은 본 특허에서의 검증 소프트웨어가 시뮬레이션 대상이 되는 모델을 구술한 1 이상의 설계소스 파일 내지는 시뮬레이션 환경 파일 등을 읽어들여서 자동화된 방식으로 생성시킬 수 있다 (구체적인 예는 도 16, 도 17, 도 18, 도 19를 참조. 부가 코드의 내부구조와 내부기능은 도 8, 도 27을 참조). 이와 같은 부가 코드가 해당 로컬시뮬레이션 대상이 되는 설계객체에 우선 예상입력을 인가하고, 상기 설계객체가 시뮬레이션되면서 상기 설계객체에서 출력되는 실체 출력을 예상출력과 비교하여 이 비교가 일치하면 그 다음 예상입력을 인가하게 되는 것임으로 통상적인 테스트벤치의 기능(입력을 인가하고 출력이 예상대로 나오는지를 조사하는 기능이 일반적인 테스트벤치의 기본 기능임)과 매우 유사함으로 이와 같은 기능을 수행할 수 있는 부가 코드를 자동화된 방식으로 생성시키는 것이 어렵지 않게 가능하다. 뿐만 아니라, 롤포워드(roll-forward)가 필요한 경우(롤포워드가 필요한 경우란, 다른 로컬시뮬레이션에서 수행된 실제출력과 예상출력의 불일치가 발생하고 이 불일치 시뮬레이션 시점 t_d가 이 로컬시뮬레이션의 현재 시뮬레이션 시점 t_c보다 시간적으로 미래에 존재함으로 이 로컬시뮬레이션을 시뮬레이션 시점 t_d까지 진행시키도록 하여야 할 경우를 말함. 그러나 t_c에서부터 t_d까지 이 로컬시뮬레이션을 예상입출력이용-런 방식으로 진행하다가 t_c에서부터 t_d사이의 시뮬레이션 시점 t_b에서 이 로컬시뮬레이션에서 실제출력과 예상출력의 불일치가 발생하면 이 로컬시뮬레이션은 t_b에서 진행을 일시 정지하고 이 새로운 롤백가능 시점 t_b와 롤백가능성 발생을 다른 로컬 시뮬레이션들에게 알려야 함. 따라서, 롤포워드는 이 로컬시뮬레이션 입장에서는 예상입출력이용-런 방식으로 계속 시뮬레이션을 진행하는 것임으로 롤포워드를 특별하게 취급할 필요가 없음)에는 계속하여서 예상입출력이용-런을 진행하고 롤백이 필요한 경우에 롤백을 수행하고 이 롤백되어진 시점에서부터 실제입출력이용-런(본 특허에서 실제입출력이용-런 방식이란 분산병렬 시뮬레이션에서 각 로컬시뮬레이션들간의 데이터 - 각 로컬시뮬레이션들에 있어서 다른 로컬시뮬레이션들에서부터 오는 입력 내지는 다른 로컬시뮬레이션들로 나가는 출력 - 전달을 실제로 수행하며 이 과정에서 필요한 동기화를 위하여 통상적인 보수적 방식의 동 기화 내지는 낙관적 방식의 동기화로 동기화를 진행하는 방식을 말함. 데이터전달(통신) 및 동기화를 수행하는 간격은 시뮬레이션 최소 정밀도(precision) 단위일 수도 있고, 시뮬레이션 최소 시간(time unit) 단위일 수도 있고, 사이클 단위일 수도 있고, 트란젝션 단위일 수도 있는 등 다양함) 방식에 의한 통상적인 분산병렬 시뮬레이션(따라서 실제입출력이용-런 과정에서는 통상적인 보수적 분산병렬 시뮬레이션으로 진행할 수도 있을 뿐만 아니라, 통상적인 낙관적 분산병렬 시뮬레이션으로 진행할 수도 있음)이 수행되도록 제어하면 되는데, 이와 같이 제어하는 방법도 롤백을 위해서는 통상적인 낙관적 분산병렬 시뮬레이션에서 사용하는 롤백 방법들(낙관적 분산병렬 시뮬레이션에서는 반드시 롤백이 가능하도록 지원하여야 함으로, 롤백을 위한 다양한 방법들은 이미 많은 낙관적 분산병렬 시뮬레이션 관련 문헌들에서 자세히 설명되어 있음으로 이에 대한 자세한 설명은 지면 제약상 본 특허에서는 생략하며, 이를 위해서는 상기 문헌들을 참고하기로 함) 내지는 별도의 특허(10-2005-116706) 에서 이미 자세하게 설명된 저장(save) 및 재출발(re-start) 방법을 원용하면 되고 (예로, 설계 상태정보를 1 이상의 시뮬레이션 시점 내지는 시뮬레이션 일정구간에서 파일로 저장하고 롤백 시에 상기 설계 상태정보가 저장된 1 이상의 시뮬레이션 시점 내지는 구간 중의 특정 시뮬레이션 시점 내지는 구간에서 재출발시키는 구체적 방법은 Verilog의 경우에는 force/release 명령어 구문 내지는 PLI/VPI의 acc_set_value() 함수를 사용하여 상기 특정 시뮬레이션 시점 내지는 구간에서 설계 상태정보를 구성하는 해당 설계객체의 변수들에 상기 저장된 상태정보 정보를 다시 쓰는 것이다. 특히, 매 롤백 시마다 별도의 시뮬레이션 컴파일 을 다시 수행하지 않고서도 설계 상태정보를 해당 설계객체의 변수들에 재설정하는 방법은 VPI/PLI의 acc_set_value()를 사용하여서 파일로부터 상기 해당 설계객체들의 변수들에 재설정할 설계 상태정보 값들을 상기 특정 시뮬레이션 시점 내지는 구간에서 읽어들여서 해당 설계객체들의 변수들에 설정하게 하면서, 해당 설계 상태정보 값들을 가지고 되는 상기 파일의 내용이 시뮬레이션 재출발 시점 내지는 구간이 되는 상기 특정 시뮬레이션 시점 내지는 구간에서의 해당 설계객체들의 변수들 값을 가지도록끔 매 롤백 수행 전에 동적으로 바꿈으로서 가능하다), 통상적인 실제입출력이용-런 방식의 분산병렬 시뮬레이션은 이미 널리 알려져 있음으로 이 또한 상기 부가 코드와 이와 같은 기능을 수행하도록 자동화된 방식으로 상기 부가 코드를 생성하는 것이 어렵지 않게 가능하다 (구체적 예는 도 16, 도 17, 도 18, 도 19 참조하며, 이와 같은 기능을 수행하는 부가 코드의 구조적 구성은 도 8에, 모조코드는 도 27에 예시되어 있음). 즉, 분산병렬 시뮬레이션 환경에서 각기 다른 로컬시뮬레이터들에서 수행되는 설계객체들 각각은 본 특허의 분산처리적병렬수행 방식(추후에 정의됨)을 위하여 부가되어지는 부가 코드로 인하여 우선 s-DCP에서 구해지는 예상입력을 활용하여서 각 로컬시뮬레이터들 각각으로써 설계객체들 각각을 독립적으로 시뮬레이션 수행시켜서 각 설계객체들의 출력값들을 각각 구하게 되고, 이들 실제 출력값들 각각을 s-DCP에서 구해지는 예상출력들과 비교하여 이들 비교가 일치하게 되면 로컬시뮬레이터들간에 통신 및 동기화를 완전하게 내지는 최대한 생략하고 각 로컬시뮬레이션 시간을 앞으로 진행(이와 같은 진행 방식을 예상입출력이용-런 방식이라 칭하고, 아래에서 더 추가적으로 설명함)하게 됨으로서 시 뮬레이션 속도를 크게 높이는 것이 가능하게 되는 것이다. 만일, s-DCP의 예상출력들과 비교하여 이들 비교가 일치하지 않으면(이를 예상출력/실제출력 불일치시점이라 칭함) 이 경우에서만 로컬시뮬레이터들간에 통신 및 동기화 과정을 수행하면서 분산병렬 시뮬레이션을 진행하게 된다. 또한, 한번 로컬시뮬레이터들간에 통신 및 동기화 과정을 수행하는 실제입출력이용-런 방식으로 전환(이 전환시점을 앞으로는 실제입출력이용-런 적용시점이라고 칭함. 이 실제입출력이용-런 적용시점이 될 수 있는 시점은 일반적으로 분산병렬 시뮬레이션을 진행하는 로컬시뮬레이션들 각각의 상기 예상출력/실체출력 불일치시점들에서 제일 시간적으로 뒤에 있는 시점 - 즉, 제일 시간적으로 과거인 시점 - t_lock 내지는 이 t_lock 보다 시간적으로 뒤에 있는 임의의 시점 t_advance_lock이 될 수 있음. 그러나 시뮬레이션 성능 최적화를 위해서는 실제입출력이용-런 적용시점을 t_lock으로 설정하는 것이 시뮬레이션의 성능을 최적화할 수 있음. 따라서 각 로컬 시뮬레이션은 예상입출력이용-런 방식의 시뮬레이션 진행 과정에서 예상출력/실제출력 불일치시점을 만나게 되면 예상입출력이용-런 방식의 시뮬레이션 수행을 중지하고, 다른 모든 로컬 시뮬레이션들이 자

신의 예상출력/실제출력 불일치시점을 알 수 있도록 자신의 예상출력/실제출력 불일치시점을 다른 모든 로컬 시뮬레이션들에게 알려야 함. 또한 각 로컬 시뮬레이션은 t_lock 시점 내지는 t_advance_lock 시점으로 롤백할 수 있도록 로컬시뮬레이션의 시뮬레이션 상태 내지는 로컬시뮬레이션으로 수행되는 1 이상의 설계객체들의 상태정보를 t_lock 시점 내지는 1 이상의 t_advance_lock 시점에서 주기적으로 내지는 비주기적(실행에 앞서 설정한 특정조건 만족시 저장이 일아나도록)으로 저장 하는 것이 필요함)한 후에도 계속적으로 실제 시뮬레이션 과정에서 발생하는 실제 입력값들(이 실제 입력값들은 분산병렬 시뮬레이션이 실제입출력이용-런 방식으로 진행되면서 이 분산병렬 시뮬레이션 환경의 1 이상의 다른 로컬시뮬레이션에서부터 오게 됨)을 s-DCP에서 구해진 예상입력들과 비교하다가 혹은 실제 시뮬레이션 과정에서 발생하는 실제 출력값들을 s-DCP에서 구해진 예상출력들과 비교하다가(비교의 효율성을 위하여 예상값 - 예상출력 내지는 예상입력 - 들과 실제 시뮬레이션 과정에서 발생하는 실제값 - 실제출력 내지는 실제입력 - 들의 추상화 수준을 동일하게 맞추어서 비교하는 것도 가능한데, 이와 같이 예상값과 실제값의 추상화 수준을 맞추는 기능을 수행하는 모듈을 어뎁터(adaptor) 내지는 트란젝터(transactor)라 함. 예로 RTL에서 진행되는 분산병렬 시뮬레이션에서 예상값들과 실제값들의 비교는 실제값의 추상화 수준을 예상값과 같은 추상화 수준인 ca-트란젝션으로 올려서 비교하는 것도 가능할 뿐만 아니라, RTL 추상화 수준의 예상값들과 ca-트란젝션 수준의 실제값들을 모두 timed-트란젝션 추상화 수준으로 동일하게 올려서 비교하는 것도 가능), 일정횟수(이는 시뮬레이션 수행에 앞서서 입력으로서 설정하거나, 내지는 시뮬레이션 과정 중에서 순응적으로 변경하는 것도 가능함) 이상으로 상기 비교가 같아진다면 이 시점에서부터는(이 시점을 앞으로는 실제입출력이용-런 해제시점이라고 칭함) 로컬시뮬레이터들을 실제입출력이용-런 방식에서 다시 해제시켜서 통신 오버헤드 및 동기 오버헤드를 다시 제거하고 시뮬레이션이 진행(이 경우에는 분산병렬 시뮬레이션의 로컬 시뮬레이션들 각각이 다른 로컬 시뮬레이션들과의 통신 및 동기화를 생략하고 독립적으로 진행할 수 있음으로 매우 빠르게 진행되어짐. 위에 서 설명한 실제입출력이용-런 방식으로 진행되는 것과 대비하여서, 본 특허에서는 이와 같이 로컬시뮬레이션들 각각이 다른 로컬시뮬레이션들과의 통신 및 동기화를 생략하고 완전 독립적으로 진행하는 방식을 예상입출력이용-런 방식이라 칭함)되어질 수 있게 되며, 이상과 같은 예상입출력이용-런 방식의 시뮬레이션 진행과 실제입출력이용-런 방식의 시뮬레이션 진행 과정을 번갈아 가면서 반복함으로서 분산병렬 시뮬레이션의 성능을 크게 높일 수 있게 된다. DUV내에 존재하는 1 이상의 설계객체들에 대한 입출력정보는 s-DCP의 구체적 일 예이다. 뿐만 아니라 분산병렬 시뮬레이션에서 각 로컬시뮬레이션에서 수행되도록 나누어진 설계의 일부분(즉, 로컬시뮬레이터에 의하여 수행되는 설계의 일부분)이 DUV 내에 존재하는 설계객체들(예로 Verilog 설계의 경우에는 설계객체들은 module들, VHDL 설계의 경우에는 설계객체들은 entity들, SystemC 설계의 경우에는 설계객체들은 sc_module들임)의 경계(boundary)와 일치하지 않는 경우에는 상기 각 로컬시뮬레이션들에서 수행되도록 나누어진 각 설계의 일부분들(즉, 분산병렬 시뮬레이션을 위하여 각각의 로컬시뮬레이터에 존재하게 되는 전체설계의 일부분들) 각각의 입출력정보가 s-DCP가 된다.

위에서 설명된 s-DCP를 이용한 통신 오버헤드 및 동기 오버헤드를 최소화시키는 분산병렬 시뮬레이션 과정에서 한가지 더 생각하여야 할 것은 상기 예상출력/실제출력 불일치시점들이 각 로컬시뮬레이터에서 수행되는 각 설계객체마다 다를 수 있다는 것이다. 이와 같은 경우에는 적어도 이 2 이상의 예상출력/실제출력 불일치시점들 중에서 시뮬레이션 시간 상에서 제일 과거시점인 시점 t_e에서부터 모든 로컬시뮬레이터들을 상기 통신 및 동기화 과정을 거치는 실제입출력이용-런 방식으로 수 행하여야 한다. 이를 위해서 상기 제일 과거시점 t_e보다 더 진행된 모든 시뮬레이션들은 다시 상기 시점 t_e로 롤백(roll-back)시켜야 할 필요성이 있다 (구체적 예를 든다면 4개의 설계객체들이 통신 밑 동기를 진행하지 않고 각각 진행되어진 시뮬레이션 시간이 각각 설계객체1 = 1,000,000ns, 설계객체2 = 1,000,010ns, 설계객체3 = 1,000,020ns, 설계객체4 = 1,000,030ns인 경우에 t_e가 1,000,000ns이면 설계객체2, 설계객체3, 설계객체4들도 모두 1,000,000ns으로 롤백시키고, 모든 설계객체들을 대상으로 하는 분산병렬 시뮬레이션을 적어도 실제입출력이용-런 방식으로 실제입출력이용-런 적용시점인 1,000,000ns에서부터 다시 통신 및 동기화를 진행하지 않아도 되는 다음의 실제입출력이용-런 해제시점까지 진행한다). 이와 같은 롤백을 위해서는 시뮬레이션 저장 및 재출발(save & restart) 기능을 이용하면 되는데, 시뮬레이션 저장 및 재출발 방법은 시뮬레이션 상태(simulation state)를 시뮬레이션 과정에서 주기적으로 내지는 1 이상의 특정 시점에서 저장시켜서 이를 재로딩하여 재실행시키는 방법과 설계 상태(design state)(설계 상태는 해당 설계객체의 상태정보를 가르킴)를 시뮬레이션 과정에서 주기적으로 내지는 1 이상의 특정 시점 혹은 구간에서 저장시켜서 이를 재로딩하여 재실행시키는 방법 등이 있는데, 이에 대한 자세한 방법도 별도의 국내특허들(10-2005-116706, 10-2006-19738)에서 가시도(visibility)를 얻기 위하여 내지는 시뮬레이션을 신속하게 수행하기 위하여 사용한 방법을 적용하면 됨으로 본 특허에서는 이에 대한 자세한 설명은 지면 제약상 생략하기로 한다. 단, 상기 시뮬레이션 저장 및 재출발을 가능하게 하려면 시뮬레이션 수행 도중에 위에서 언급된 대로 주기적으로 내지는 1 이상의 특정 시점 혹 은 구간에서 시뮬레이션 상태나 설계 상태를 저장하는 과정이 필요한데(이와 같은 과정을 체크포인트(checkpoint) 과정이라 칭하고, 이 과정을 통하여 체크포인트를 생성한다고 칭함), 상기 1 이상의 특정 시뮬레이션 시점 혹은 구간에서 시뮬레이션의 상태나 설계 상태를 저장하여서 추후에 상기 1 이상의 특정 시뮬레이션 시점 혹은 구간에서부터 재-시뮬레이션(re-simulation)을 수행할 수 있게한 상기 1 이상의 특정 시뮬레이션 시점 혹은 구간 각각을 체크포인트라 칭한다. 따라서 상기 설명된 롤백이 수행되어져야 하는 경우에 실제 롤백이 이루어지는 시점은 예상출력과 실제출력의 불일치가 발생한 시점들 중에서 제일 시간적으로 과거인 불일치 시점 t_est이 아니고 이 t_est과 동일하거나 내지는 시간적으로 과거 방향으로 t_est와 제일 가까운 특정 체크포인트가 롤백 대상 시점이 된다.

본 특허에서의 분산처리적병렬수행 방식의 통신 오버헤드와 동기 오버헤드의 최소화를 위하여 사용되는 예상입력/예상출력은 비트/비트벡터 타입의 시그널 단위로 표현될 수도 있고, 혹은 상위 추상화 데이터구조(예로, 레코드 타입 등) 타입의 트란젝션 단위로 표현될 수도 있다. 트란젝션 단위의 경우에는 매사이클의 트란젝션일 수도 있고, 여러사이클의 트란젝션일 수도 있다. 따라서 예상입력과 실제입력의 비교 내지는 예상출력과 실제출력의 비교는 모델의 추상화 수준에 따라서 시그널 단위에서 수행되어지거나, 내지는 매사이클의 트란젝션 단위에서 수행되어지거나, 내지는 여러사이클의 트란젝션 단위 등 여러 추상화수준에서 수행되어질 수 있다. 따라서, 본 특허에서 예상출력과 실제출력의 비교 내지는 예상입력과 실제입력의 비교를 이야기하는 경우에는 상기의 비교들이 모델의 추상화 수준에 따라서 시그널 단위에서 수행되어지거나, 내지는 매사이클의 트란젝션 단위에서 수행되어지거나, 내지는 여러사이클의 트란젝션 단위에서 수행되어지거나, 내지는 시간개념이 없는 트란젝션(un-timed transaction) 단위에서 수행되어지는 것들 모두 포함하는 것이다.

위에서 설명한 본 특허에서의 분산병렬 시뮬레이션 방법을 본 특허에서는 s-DCP를 이용한 분산적병렬수행(Distributed Parallel Execution) 방식 내지는 줄여서 분산처리적병렬수행 방식 내지는 분산처리적병렬시뮬레이션(즉 분산처리적병렬수행 방식 내지는 분산처리적병렬시뮬레이션이란 통상적인 분산병렬 시뮬레이션 방식이 아니라 s-DCP를 활용한 예상입력과 예상출력을 사용하여 분산시뮬레이션의 통신 오버헤드와 동기 오버헤드를 최소화시키는 본 특허에서 제안되어지는 분산병렬 시뮬레이션 방식만을 말함)이라고 칭하기로 한다. 이와 같은 s-DCP를 이용한 분산적병렬수행 방식이 최대한의 성능을 내기 위해서는 실제입출력이용-런 해제의 총 횟수와 각각의 실제입출력이용-런 적용시점부터 실제입출력이용-런 해제시점까지의 전체 시간(즉, 실제입출력이용-런 방식으로 시뮬레이션이 수행되는 전체 시간)을 최소한으로 하는 것이 매우 중요하다. 이를 위해서는 각 로컬시뮬레이션 수행의 예상입력과 예상출력을 구하는데 사용되어지는 s-DCP의 정확도가 매우 중요하다. 즉 s-DCP의 정확도가 높을수록 시뮬레이션 전체 구간에서 실제입출력이용-런 방식으로 수행되는 구간은 최소한으로 할 수 있고 대부분의 구간을 예상입출력이용-런 방식으로 수행할 수 있음으로 인하여 분산병렬 시뮬레이션의 성능을 결정적으로 제약하는 요소인 통신 오버헤드와 동기 오버헤드를 크게 줄일 수 있기 때문에 분산병렬 시뮬레 이션의 성능을 크게 높일 수 있다. 그러나 s-DCP의 정확도뿐만 아니라 s-DCP를 획득하는데 필요한 시간, 즉 s-DCP 획득시간도 매우 중요하다. 왜냐하면, s-DCP의 정확도가 제일 높은 것은 똑같은 추상화 수준의 모델(즉, 분산병렬 시뮬레이션 대상이 되는 모델)로 시뮬레이션하면서 s-DCP를 얻는 것이 제일 정확하지만, 이 경우에는 s-DCP를 획득하는데 소요되는 시간이 일반적으로 매우 길어짐으로 대부분의 경우에는 많은 문제가 있다. 그러나, 최소한 똑같은 추상화 수준의 모델로 시뮬레이션하면서 s-DCP를 얻는 이와 같은 방법이 매우 효율적인 경우가 있는데, 리그레션 테스트(regression test)를 수행하는 경우 내지는 설계가 매우 국지적으로 변경된 경우 내지는 일반적으로 특정 테스트벤치를 사용한 시뮬레이션은 전체 검증 과정에서 오직 한번만 수행되지는 않음으로 먼저 앞서서 수행된 1 이상의 시뮬레이션 과정에서 기 획득된 s-DCP를 활용할 수 있는 경우들이 그와 같은 경우이다. 즉, 역호환성(back-ward compatibility)을 조사하는 리그레션 테스트에서는 대부분의 테스트들이 오류 발견 없이 패스되어지는데 이와 같은 리그레션 테스트 과정을 앞서서 같은 수준의 추상화 수준의 설계객체를 이용하여서 시뮬레이션하면서 얻어진 s-DCP를 활용하여서 본 특허에서의 s-DCP를 이용한 분산적병렬수행 방식 내지는 분산적병렬수행/단일수행 혼용방식(추후에 설명됨)으로 시뮬레이션을 수행하면 이 얻어진 s-DCP의 정확도가 매우 높음으로 대부분의 테스트에서 상기의 실제입출력이용-런 해제의 총 횟수와 각각의 실제입출력이용-런 해제시점부터 실제입출력이용-런 적용시점까지의 전체 시간이 최소한으로 할 수 있음으로 리그레션 테스트를 분산병렬 시뮬레이션 방식으로 시뮬레이션의 성능을 최대한으로 하여 매우 신속하게 수행하 는 것이 가능하다. 디버깅이나 스펙 변경 등으로 인하여 설계가 국지적으로만 변경된 경우에도 설계가 변경되기 이전의 시뮬레이션 과정에서 수집한 s-DCP를 이용하여서 분산적병렬수행 방식 내지는 분산적병렬수행/단일수행 혼용방식(추후에 설명됨) 내지는 인크리멘탈 시뮬레이션을 활용한 분산처리적병렬 방식(추후에 설명됨)으로 시뮬레이션을 수행하게 되면 시뮬레이션의 성능을 최대한으로 하여 매우 신속하게 수행하는 것이 가능하다.

뿐만 아니라 본 특허에서의 분산처리적병렬수행 방식에 의한 분산병렬 시뮬레이션을 수행 도중에 1 이상의 실제입출력이용-런 적용시점 t_lockstep부터 실제입출력이용-런 방식에 의한 분산병렬 시뮬레이션을 수행하는 것이 바람직스럽지 않은 경우(예로, 시뮬레이터의 라이센스 수가 많지 않아서 장시간 특정 시뮬레이션 태스크에 많은 시뮬레이터 라이센스를 할당할 수 없는 경우, 내지는 실제입출력이용-런 방식의 분산병렬 시뮬레이션을 수행하는 경우에 기대되는 시뮬레이션 성능 향상이 크지 않은 경우, 등)에는 상기 실제입출력이용-런 방식의 분산병렬 시뮬레이션을 수행할 수 있는 시점 t_lockstep에서부터 상기 실제입출력이용-런 방식의 분산병렬 시뮬레이션을 수행하는 대신 단일 시뮬레이터를 사용하여서 DUV에 대한 단일 시뮬레이션을 수행(이 경우에 TB에 대한 시뮬레이션은 상기 단일 시뮬레이터로 같이 시뮬레이션할 수도 있고, TB가 DUV를 수행하는 시뮬레이터와 다른 시뮬레이터(예로 HVL 시뮬레이터)로 수행하여야 하는 경우에는 TB는 다른 시뮬레이터로 연동시뮬레이션할 수도 있다. 이에 관한 좀 더 자세한 설명은 추후에 함)하는 것도 가능하다. 즉 이와 같은 수행에서는 전체 시뮬레이션 시간의 일정기간 동안(예로서는, 시뮬레 이션 시점 0에서부터 첫번째 예상출력/실제출력 불일치 시점까지)에서는 본 특허에서의 분산처리적병렬수행 방식을 채용한 분산병렬 시뮬레이션을 수행함으로서 로컬시뮬레이터들간의 동기 오버헤드와 통신 오버헤드를 최소화시키면서 분산병렬 시뮬레이션을 신속하게 수행하고 분산병렬 시뮬레이션의 끝에서 생성할 수 있는 DUV의 t-DCP(DUV의 t-DCP는 로컬시뮬레이션에서 수행되는 DUV내의 설계객체들의 t-DCP들을 모두 합치면 됨)를 생성하고, 이 생성된 DUV의 t-DCP를 이용하여서 DUV에 대한 시뮬레이션을 상기 실제입출력이용-런 적용시점에서부터는 단일 시뮬레이션으로 수행시키는 것도 가능하다 (즉 이 방식에서 실제적으로는 상기 실제입출력이용-런 적용시점에서부터는 분산병렬 시뮬레이션으로 진행하지 않고 단일 시뮬레이션이 진행됨). 이와 같은 본 특허에서의 방식을 앞으로는 "분산처리적병렬수행/단일수행 혼용방식"이라고 칭하기로 한다. 즉, 분산처리적병렬수행/단일수행 혼용방식에서는 s-DCP와 t-DCP를 모두 활용하게 된다 (단일 시뮬레이션을 위해서는 별도의 시뮬레이션 컴파일이 필요함).

뿐만 아니라, 또 다른 변형으로는, 상기 실제입출력이용-런 적용시점에서부터는 앞서의 분산처리적병렬수행 방식에서와는 다른 구성으로서 분산처리적병렬수행을 진행하는 것도 가능하다. 예로, DUV내에 4개의 설계객체 B0, B1, B2, B3가 존재하고 초기의 분산처리적병렬수행에서는 4대의 컴퓨터에서 수행되는 4개의 시뮬레이터 각각에 B0, B1, B2, B3를 할당하여서 실제입출력이용-런 적용시점까지 수행하고, 이 시점 이후부터는 2개의 시뮬레이터만을 사용하여서 첫번째 시뮬레이터에는 B0만을 할당하고(예로, B0는 TB 설계객체임) 두번째 시뮬레이터에는 B1과 B2와 B3를 할당 하여서 두 시뮬레이터만으로 실제입출력이용-런 방식의 분산병렬 시뮬레이션을 진행하고, 나머지 2개의 시뮬레이터들은 다른 시뮬레이션 태스크를 수행할 수 있게 하는 것도 가능한데 (이와 같은 경우에는 특정 로컬시뮬레이션에 대하여 시뮬레이션 컴파일이 새롭게 필요함. 예로 위 예에서는 B0에 대한 로컬시뮬레이션은 새로운 시뮬레이션 컴파일이 필요없이 계속적으로 시뮬레이션 진행이 가능하지만, B1과 B2와 B3에 대한 로컬시뮬레이션은 새로운 시뮬레이션 컴파일이 필요함), 이와 같은 방식은 모두 본 특허에서의 분산처리적병렬수행 방식에 포함되는 것으로 정의한다.

그러나, 상기와 같은 경우들 이외의 일반적 시뮬레이션 과정에서는 s-DCP를 얻는 것은 이를 얻기 위하여 매우 긴 시뮬레이션의 시간이 필요한 동일한 추상화 수준에서의 시뮬레이션을 수행하면서 얻는 것은 현실적으로 문제가 있다. 이와 같은 경우에는, 대신에 점진적 구체화 방식의 설계 과정에서 존재하는 추상화 상위수준에서의 모델을 이용한 시뮬레이션을 통하여 s-DCP를 얻는 것이 효율적이다 (앞에서 이미 언급된 활용방법-3, 활용방법-4). 예를 든다면, 게이트수준에서의 타이밍시뮬레이션을 위해서는 RTL 시뮬레이션 과정에서 얻어진 s-DCP를 활용하거나 내지는 RTL/게이트수준 혼합 시뮬레이션 과정에서 얻어진 s-DCP(예로, 1 이상의 RTL/게이트수준 혼합 모델들의 각 모델 내에 존재하는 게이트수준 설계객체의 입출력 정보를 상기 1 이상의 RTL/게이트수준 혼합 모델들 모두에 대하여 합한 것. 구체적 예로 앞에서 이미 설명된 GL 모델의 예 DUV(GL) = (B(1)_gl, B(2)_gl, B(3)_gl, B(4)_gl)로 구성되고 RTL 모델은 DUV(RTL) = (B(1)_rtl, B(2)_rtl, B(3)_rtl, B(4)_rtl)으로 구성되어 있는 경우에, 4개의 RTL/GL 혼합 모델들을 DUV(MIXED)_4 = (B(1)_rtl, B(2)_rtl, B(3)_rtl, B(4)_gl), DUV(MIXED)_3 = (B(1)_rtl, B(2)_rtl, B(3)_gl, B(4)_rtl), MODEL_DUV(MIXED)_2 = (B(1)_rtl, B(2)_gl, B(3)_rtl, B(4)_rtl), MODEL_DUV(MIXED)_1 = (B(1)_gl, B(2)_rtl, B(3)_rtl, B(4)_rtl)의 4 모델들로 구성하고, 이들 4개의 ESL/RTL 혼합 모델들 중 모델 DUV(MIXED)_1을 이용한 시뮬레이션에서는 B(1)_gl의 입출력 정보, 모델 DUV(MIXED)_2을 이용한 시뮬레이션에서는 B(2)_gl의 입출력 정보, DUV(MIXED)_3을 이용한 시뮬레이션에서는 B(3)_gl의 입출력 정보, DUV(MIXED)_4를 이용한 시뮬레이션에서는 B(4)_gl의 입출력 정보를 얻고 이들 4개의 입출력 정보들을 모두 합친 것이 s-DCP)를 활용하고, RTL 시뮬레이션을 위해서는 ESL 시뮬레이션 과정에서 얻어진 s-DCP를 활용하거나 내지는 ESL/RTL 혼합 시뮬레이션 과정에서 얻어진 s-DCP(예로, 1 이상의 ESL/RTL 혼합 모델들의 각 모델 내에 존재하는 RTL 설계객체의 입출력 정보를 상기 1 이상의 ESL/RTL 혼합 모델들 모두에 대하여 합한 것. 구체적 예로 앞에서 이미 설명된 RTL 모델의 예 DUV(RTL) = (B(1)_rtl, B(2)_rtl, B(3)_rtl, B(4)_rtl)로 구성되고 ESL 모델은 DUV(ESL) = (B(1)_tlm, B(2)_tlm, B(3)_tlm, B(4)_tlm)으로 구성되어 있는 경우에, 4개의 ESL/RTL 혼합 모델들을 DUV(MIXED)_4 = (B(1)_tlm, B(2)_tlm, B(3)_tlm, B(4)_rtl), DUV(MIXED)_3 = (B(1)_tlm, B(2)_tlm, B(3)_rtl, B(4)_tlm), MODEL_DUV(MIXED)_2 = (B(1)_tlm, B(2)_rtl, B(3)_tlm, B(4)_tlm), MODEL_DUV(MIXED)_1 = (B(1)_rtl, B(2)_tlm, B(3)_tlm, B(4)_tlm)의 4 모델들로 구성하고, 이들 4개의 ESL/RTL 혼합 모델들 중 모델 DUV(MIXED)_1을 이용한 시뮬레이션에서는 B(1)_rtl의 입출력 정보, 모델 DUV(MIXED)_2을 이용한 시뮬레이션에서는 B(2)_rtl의 입출력 정보, DUV(MIXED)_3을 이용한 시뮬레이션에서는 B(3)_rtl의 입출력 정보, DUV(MIXED)_4를 이용한 시뮬레이션에서는 B(4)_rtl의 입출력 정보를 얻고 이들 4개의 입출력 정보들을 모두 합친것이 s-DCP)를 활용하고, ESL 시뮬레이션을 위해서는 현 ESL 수준보다 상위수준의 트란젝션 모델을 이용한 ESL 시뮬레이션

과정에서 얻어진 s-DCP를 활용하거나 내지는 현 ESL 수준보다 상위수준의 트란젝션 모델(TLM 모델)과 현 ESL 수준과 같은 트란젝션수준 모델(TLM 모델)을 혼용한 혼합 시뮬레이션 과정에서 얻어진 s-DCP(예로, 1 이상의 timed-트란젝션/ca-트란젝션 혼합 모델들의 각 모델 내에 존재하는 ca-트란젝션 수준의 설계객체의 출력 정보를 상기 1 이상의 timed-트란젝션/ca-트란젝션 혼합 모델에 대하여 합한 것. 구체적 예로 앞에서 이미 설명된 ca-tlm 수준의 ESL 모델의 예 DUV(ca-tlm) = (B(1)_ca-tlm, B(2)_ca-tlm, B(3)_ca-tlm, B(4)_ca-tlm)로 구성되고 timed-tlm 수준의 ESL 모델 DUV(timed-tlm) = (B(1)_timed-tlm, B(2)_timed-tlm, B(3)_timed-tlm, B(4)_timed-tlm)으로 구성되어 있는 경우에, 4개의 timed-tlm/ca-tlm 혼합 모델들을 DUV(MIXED)_4 = (B(1)_timed-tlm, B(2)_timed-tlm, B(3)_timed-tlm, B(4)_ca-tlm), DUV(MIXED)_3 = (B(1)_timed-tlm, B(2)_timed-tlm, B(3)_ca-tlm, B(4)_timed-tlm), MODEL_DUV(MIXED)_2 = (B(1)_timed-tlm, B(2)_ca-tlm, B(3)_timed-tlm, B(4)_timed-tlm), MODEL_DUV(MIXED)_1 = (B(1)_ca-tlm, B(2)_timed-tlm, B(3)_timed-tlm, B(4)_timed-tlm)의 4 모델들로 구성하고, 이들 4개의 timed-트란젝션/ca-트란젝션 혼합 모델들 중 모델 DUV(MIXED)_1을 이용한 시뮬레이션에서는 B(1)_ca-tlm의 출력 정보, 모델 DUV(MIXED)_2을 이용한 시뮬레이션 에서는 B(2)_ca-tlm의 출력 정보, DUV(MIXED)_3을 이용한 시뮬레이션에서는 B(3)_ca-tlm의 출력 정보, DUV(MIXED)_4를 이용한 시뮬레이션에서는 B(4)_ca-tlm의 출력 정보를 얻고 이들 4개의 출력 정보들을 모두 합친것이 s-DCP. 또 다른 예로, 1 이상의 ca-트란젝션/RTL 혼합 모델들의 각 모델 내에 존재하는 RTL 수준의 설계객체의 출력 정보를 상기 1 이상의 ca-트란젝션/RTL 혼합 모델에 대하여 합한 것. 구체적 예로 앞에서 이미 설명된 ca-tlm 수준의 ESL 모델의 예 DUV(ca-tlm) = (B(1)_ca-tlm, B(2)_ca-tlm, B(3)_ca-tlm, B(4)_ca-tlm)로 구성되고 RTL 모델 DUV(rtl) = (B(1)_rtl, B(2)_rtl, B(3)_rtl, B(4)_rtl)으로 구성되어 있는 경우에, 4개의 ca-tlm/RTL 혼합 모델들을 DUV(MIXED)_4 = (B(1)_ca-tlm, B(2)_ca-tlm, B(3)_ca-tlm, B(4)_rtl), DUV(MIXED)_3 = (B(1)_ca-tlm, B(2)_ca-tlm, B(3)_rtl, B(4)_ca-tlm), MODEL_DUV(MIXED)_2 = (B(1)_ca-tlm, B(2)_rtl, B(3)_ca-tlm, B(4)_ca-tlm), MODEL_DUV(MIXED)_1 = (B(1)_rtl, B(2)_ca-tlm, B(3)_ca-tlm, B(4)_ca-tlm)의 4 모델들로 구성하고, 이들 4개의 ca-트란젝션/RTL 혼합 모델들 중 모델 DUV(MIXED)_1을 이용한 시뮬레이션에서는 B(1)_rtl의 출력 정보, 모델 DUV(MIXED)_2을 이용한 시뮬레이션에서는 B(2)_rtl의 출력 정보, DUV(MIXED)_3을 이용한 시뮬레이션에서는 B(3)_rtl의 출력 정보, DUV(MIXED)_4를 이용한 시뮬레이션에서는 B(4)_rtl의 출력 정보를 얻고 이들 4개의 출력 정보들을 모두 합친것이 s-DCP. 또 다른 예로, 1 이상의 RTL/GL 혼합 모델들의 각 모델 내에 존재하는 GL 수준의 설계객체의 출력 정보를 상기 1 이상의 RTL/GL 혼합 모델에 대하여 합한 것. 구체적 예로 앞에서 이미 설명된 RTL 모델의 예 DUV(rtl) = (B(1)_rtl, B(2)_rtl, B(3)_rtl, B(4)_rtl)로 구성되고 GL 모델 DUV(rtl) = (B(1)_gl, B(2)_gl, B(3)_gl, B(4)_gl)으로 구성되어 있는 경우에, 4개의 RTL/GL 혼합 모델들을 DUV(MIXED)_4 = (B(1)_rtl, B(2)_rtl, B(3)_rtl, B(4)_gl), DUV(MIXED)_3 = (B(1)_rtl, B(2)_rtl, B(3)_gl, B(4)_rtl), MODEL_DUV(MIXED)_2 = (B(1)_rtl, B(2)_gl, B(3)_rtl, B(4)_rtl), MODEL_DUV(MIXED)_1 = (B(1)_gl, B(2)_rtl, B(3)_rtl, B(4)_rtl)의 4 모델들로 구성하고, 이들 4개의 RTL/GL 혼합 모델들 중 모델 DUV(MIXED)_1을 이용한 시뮬레이션에서는 B(1)_gl의 출력 정보, 모델 DUV(MIXED)_2을 이용한 시뮬레이션에서는 B(2)_gl의 출력 정보, DUV(MIXED)_3을 이용한 시뮬레이션에서는 B(3)_gl의 출력 정보, DUV(MIXED)_4를 이용한 시뮬레이션에서는 B(4)_gl의 출력 정보를 얻고 이들 4개의 출력 정보들을 모두 합친것이 s-DCP)를 활용하는 것이다. 이와 같이 추상화 상위수준에서의 모델을 이용한 시뮬레이션을 통하여 s-DCP를 얻게되면 이 추상화 상위수준의 모델을 이용한 시뮬레이션의 속도가 매우 빠름으로 s-DCP를 얻는 과정이 매우 신속하게 이루어 질 수 있다. 따라서 이와 같이 얻어진 s-DCP의 정확도가 만족할 수준이 되는 것이 문제인데, 논리적으로 점진적 구체화 과정을 통하여 구체화되어지는 추상화 상위수준 모델과 하위수준 모델 간에는 모델 일관성이 존재하게 됨으로서 추상화 상위수준의 모델을 수행하여 얻어진 s-DCP의 정확도는 매우 높다고 생각할 수 있다. 이상적으로 이들 점진적 구체화 과정에서 존재하는 모델간의 일관성이 완벽하게 존재하게 되면 실제입출

력이용-런 방식을 한 번도 적용하지 않고 전체 시뮬레이션이 수행되는 것도 가능하며, 이들 모델간의 일관성이 높으면 높을수록 실제입출력이용-런 해제의 총 횟수와 각각의 실제입출력이용-런 적용시점부터 실제입출력이용-런 해제시점까지의 전체 시간을 최소한으로 하는 것이 가능함으로 모델간의 일관성을 높이는 것이 중요하다. 그러나, 점진적 구체화 과정을 통한 설계에서 존재하는 다양한 추상화 수준들에서 바로 인접한 추상화 수준들(예로, ca-트란젝션 모델과 RTL 모델, 내지는 RTL 모델과 게이트수준 모델 등)에서의 모델들 간에는 매우 높은 모델 일관성을 유지시키는 것이 가능한 동시에, 이와 같은 상황이 자연스럽게 만족되게 된다. 만일, 추상화 상위수준의 모델을 시뮬레이션하여 얻어진 s-DCP의 정확도가 만족스럽지 못한 경우(추상화 상위수준의 모델의 모델링이 잘못된 경우 내지는 상위수준에서의 추상화로 인하여 상위수준의 특성상 추상화 상위수준의 모델을 시뮬레이션하여 얻어진 s-DCP의 정확도가 낮을 수 밖에 없는 경우)에는 s-DCP의 정확도를 높이는 과정을 진행하여야 한다. 따라서 처음부터 정확도가 높은 추상화 상위수준의 모델을 사용하거나 내지는 이와 같이 추상화 상위수준의 모델의 모델링이 잘못된 경우에는 추상화 상위수준의 모델을 수정하여 올바른 추상화 상위수준의 모델을 얻고 이 올바른 상위수준의 모델을 시뮬레이션하여 s-DCP의 정확도를 높이거나 내지는 모델링이 잘못된 추상화 상위수준의 모델을 시뮬레이션하여 얻어진 s-DCP를 수정하여서 정확도가 높은 s-DCP를 얻거나 내지는 정확도가 상대적으로 떨어지는 추상화 상위수준의 모델을 시뮬레이션하여 얻어진 s-DCP를 동적으로(dynamically)나 정적으로(statically) 수정하여서 정확도가 높은 s-DCP를 얻을 수도 있다. 정확도가 높은 추상화 상위수준의 모델을 상대적으로 적은 노력을 들이고 만드는 방법의 일 예는 최근들어 트란젝션수준모델(TLM: Transaction-Level Model) 방법에서 많이 사용되 는 모델 내의 특정블럭을 외부와 인터페이스되는 통신모듈(communication module)과 내부 계산모듈(computation module)로 나누고 이 특정모듈의 입출력 타이밍정확도는 내부 계산모듈은 그대로 두고(예로 내부 계산모듈은 untimed-트란젝션 수준으로 구술된 것을 사용) 외부와 인터페이스되는 통신모듈에 희망하는 수준의 타이밍 정보를 부가(timing annotation)함으로서, 입출력 관점에서 보면 해당 모듈수준에서 필요한 타이정확도(예로 매사이클 단위의 정확도 내지는 여러사이클 단위의 정확도 등)를 달성할 수 있으면서도 높은 시뮬레이션 속도를 달성할 수 있는데, 이와 같은 모델을 시뮬레이션하면 정확도가 높은 s-DCP를 얻을 수 있다. 또한 이와 같은 모델의 특정 트란젝션수준 통신모듈에 트란젝터를 부가하여서 입출력 관점에서 해당 모듈의 추상화 수준을 다른 추상화수준의 트란젝션수준 내지는 레지스터전송수준으로 변환시키는 것도 가능하고, 상위수준 합성툴(예로 Forte Design사의 Cynthesizer의 TLM synthesis 등)을 사용하면 해당 TLM 통신모듈을 하드웨어적으로 구현가능한 시그널단위의 사이클정확성을 가지는 통신모듈로 합성하여 내는 것도 가능함으로서 이를 이용하여서도 s-DCP의 정확도가 높은 모델을 생성시키는 것도 가능하다. s-DCP를 수정하여서 정확도가 높은 s-DCP를 얻을 수 있는 상황의 구체적 예를 든다면, 상기 추상화 상위수준에서의 모델이 ca-트란젝션 수준이거나 timed-트란젝션 수준인 경우에 이와 같은 트란젝션이 온칩 버스 프로토콜(on-chip bus protocol)(예로 AMBA 버스 프로토콜) 규약을 만족하여야 함으로 이 버스 프로토콜 규약에 위배되는 s-DCP를 이 버스 프로토콜 규약에 맞는 s-DCP로 수정함으로서 s-DCP의 정확도를 높일 수 있다. s-DCP를 수정하여서 정확도가 높은 s-DCP를 얻을 수 있는 상황의 또 다른 구체적 예른 든다면, GL 모델에 대한 분산처리적병렬시뮬레이션(분산처리적병렬시뮬레이션이란 본 특허에서의 분산처리적병렬수행 방식을 통한 분산병렬 시뮬레이션을 의미함. 따라서 분선처리적병렬수행 방식의 시뮬레이션, 분산처리적병렬시뮬레이션, 분산처리적병렬수행 방식의 분산병렬 시뮬레이션은 모두 본 특허에서 제시한 새로운 방식의 분산병렬 시뮬레이션을 가르키는 같은 용어들임)을 수행하고자 하는 경우에 RTL 시뮬레이션 내지는 RTL/GL 혼합 시뮬레이션에서 얻어진 s-DCP에 대한 정확도를 높이기 위해서 SDF를 분석하거나 내지는 라이브러리셀들의 지연시간 파라미터를 분석하거나 내지는 SDF를 이용한 게이트수준의 타이밍시뮬레이션을 짧은 시뮬레이션 시간 구간만에서 수행하거나 내지는 정적타이밍분석(static timing analysis)을 수행하거나 내지는 이들을 조합적으로 이용하여서 설계객체내의 특정한 신호선들만(예로 클럭신호선들, 각 로컬시뮬레이션의 입력정보를 구성하는 플립플롭 출력신호선들 등)에 대해서는 정확한 지연시간 정보(예로, 플립플롭의 경우에 플립플롭 클럭입력의 지연시간 값(clock skew delay), 포지티브에지센시티브 플립플롭 출력이 클럭입력의 라이징에지 발생 후에 얼마의 지연시간을 가지고 변하는가의 clock-to-Q 지연시간(clock-to-Q(high_to_low), clock-to-Q(low_to_high)), 네가티브에지센시티브 플립플롭 출력이 클럭입력의 폴링에지 발생 후에 얼마의 지연시간을 가지고 변하는가의 clock-to-Q 지연시간(clock-to-Q(high_to_low), clock-to-Q(low_to_high)), 플립플롭의 비동기 셋 인에블 에지에서 플립플롭 출력이 변하는 시점까지의 aset_to_Q 지연시간, 플립플롭의 비동기 리셋 인에블 에지에서 플립플롭 출력이 변하는 시점까지의 areset_to_Q 지연시간, 등)를 얻고 이를 s-DCP에 반영함으로서 s-DCP의 정확도를 높일 수 있다 (즉 위 예를 든 경우의 게이트수준 타이밍시뮬레이션을 분산병렬 시뮬레이션으로 수행하기 위한 각 로컬시뮬레이션들을 위한 모델의 분할은 분할을 통하여 얻어지는 각 로컬시뮬레이션의 해당 설계객체의 출력들이 모두 플립플롭의 출력들이 되도록 분할함). s-DCP를 수정하여서 정확도가 높은 s-DCP를 얻을 수 있는 상황의 또 다른 구체적 예른 든다면, RTL 모델에 대한 분산처리적병렬시뮬레이션을 수행하고자 하는 경우에 ESL 시뮬레이션 내지는 ESL/RTL 혼합 시뮬레이션에서 얻어진 s-DCP에 대한 정확도를 높이기 위해서 RTL 함수적시뮬레이션을 짧은 시뮬레이션 시간 구간만에서 수행하여서 ESL 모델에는 존재하지 않는 정확한 타이밍 정보(예로, 클럭이 라이징된 후에 플립플롭의 출력이 변하는데 걸리는 시간, 비동기 클럭들간의 위상차이 등)를 얻고 이를 s-DCP에 반영함으로서 s-DCP의 정확도를 높일 수 있다.

뿐만 아니라 이와 같은 s-DCP의 수정은 분산병렬 시뮬레이션 시작 전에 정적 방식으로(statically) 진행되어질 수 있을 뿐만 아니라, 필요에 따라서는 분산병렬 시뮬레이션의 실행 도중에 동적 방식으로도(dynamically)(즉, 분산병렬 시뮬레이션이 진행되면서 s-DCP의 수정이 이루어짐) 진행되어질 수 있다. 분산병렬 시뮬레이션의 실행 도중에 동적으로 s-DCP의 수정이 이루어지고 이를 예상입력 내지는 예상출력으로 사용하는 일 예를 구체적으로 든다면, ca-트란젝션 수준에서 수행되어진 앞단 시뮬레이션에서 수집된 예상입력과 예상출력을, 후단 시뮬레이션인 RTL에서 이벤트 구동 방식의 시뮬레이션을 이용한 분산처리적병렬시뮬레이션에서 이용하는 경우에 시뮬레이션 초기에는 ca-트란젝션 수준에서 수행되어진 시뮬레이션에서 수집된 정 확도가 떨어지는 s-DCP로부터의 예상입력과 예상출력을 이용하여 RTL에서의 분산처리적병렬시뮬레이션을 수행하면서 이 분산처리적병렬시뮬레이션의 결과를 동적으로 반영하여서 상기 정확도가 떨어지는 s-DCP의 정확도를 높이고(구체적 예로서, ca-트란젝션 수준에서는 존재하지 않는 타이밍 파라메터인 모델내의 사용자 클럭이 라이징되고 모델내의 플립플롭의 출력이 클럭 라이징된 시점부터 1 나노초(Verilog 구문으로 #1) 이후에 변화가 되어지도록 RTL 모델이 구술된 경우에 이와 같은 상황(clock-to-Q 지연시간 이벤트 상황)을 RTL 시뮬레이션 실행 초기에 RTL 시뮬레이션 결과에서부터 동적으로 알아내어서 ca-트란젝션 수준에서의 시뮬레이션에서 수집된 s-DCP에 이를 반영(즉, ca-트란젝션 수준에서의 시뮬레이션에서 수집된 s-DCP에는 없는 타이밍 정보인 1나노초의 clock-to-Q 지연시간을 반영)하여 s-DCP의 정확도를 높이고, 이 정확도가 높아진 s-DCP로부터의 예상입력과 예상출력을 이용함) 이 동적방식을 통하여 정확도가 높아진 s-DCP에서부터 얻어진 예상입력과 예상출력을 시뮬레이션 초기 이후부터에서의 예상입력과 예상출력으로 이용하게되면 시뮬레이션 초기 이후부터에서는 정확도가 동적으로 높아진 s-DCP를 이용하는 효과적인 분산처리적병렬시뮬레이션이 가능해진다 (즉 이와 같은 방식은 시뮬레이션 초기에는 s-DCP의 정확도가 상대적으로 낮아서 실제입출력이용-런 방식의 수행이 진행되어지면서, 이 실제입출력이용-런 방식의 수행 과정에서 정확도가 낮은 s-DCP의 정확도를 상기 실제입출력이용-런 방식의 수행 중에서 즉각적으로(on-the-fly) 수집되는 동적정보를 이용하여서 높이는 과정 - 이와 같은 과정을 동적배움(dynamic learning) 과정이라고 생각할 수 있음 -을 거쳐서 이 정확도가 높아진 s-DCP를 활 용한 예상입출력이용-런 방식의 수행이 진행되어지게 함으로서 상기 시뮬레이션 초기 이후부터에서는 예상입출력이용-런 방식의 수행이 극대화가 될 수 있게 진행된다). 이와 같은 기법은 상기에서 설명된 RTL에서의 분산처리적병렬시뮬레이션에서뿐만 아니라, GL에서의 타이밍을 고려한 분산처리적병렬시뮬레이션에서도 적용되어질 수 있다. 즉, 앞단 시뮬레이션 단계인 RTL 시뮬레이션에서 수집된 정확도가 상대적으로 떨어지는 s-DCP를 활용한 후단 시뮬레이션 단계인 GL에서의 타이밍을 고려한 분산처리적병렬시뮬레이션 과정 중에서 시뮬레이션 진행과 동시에 상기 정확도가 상대적으로 떨어지는 원 s-DCP를 실제입출력이용-런 방식으로 진행되는 타이밍시뮬레이션 실행 중에 동적으로 획득되는 시뮬레이션의 결과(이 시뮬레이션의 결과는 실제입출력이용-런 방식으로 진행되는 분산처리적병렬시뮬레이션에서 취득되는 동적정보임으로 GL에서의 정확한 타이밍 정보를 모두 포함하고 있는 시뮬레이션의 결과임)를 이용하여서 정확도가 높은 s-DCP로 바뀌어내고, 이 정확도가 높은 s-DCP에서의 예상입력과 예상출력을 활용한 분산처리적병렬시뮬레이션을 이후부터 진행함으로서 예상입출력이용-런 방식의 진행을 극대화시킬 수 있다.

따라서, 본 특허에서는 위에서 설명한 s-DCP의 정확도를 높이는 이와 같은 과정들 모두를 통칭하여서 앞으로 "s-DCP 정확도증강 과정"이라 칭한다. 특히 위에서 방금 설명된 후단 시뮬레이션의 시뮬레이션 진행 초기에 동적으로 수집되어지는 동적정보를 활용하여서 후단 시뮬레이션이 진행되어지고 있는 과정에서의 앞단 시뮬레이션에서 구해진 정확도가 떨어지는 s-DCP의 정확도를 높이는 본 특허에서의 s-DCP 정확도증강 과정을 "동적배움을 이용한 s-DCP 정확도증강 과정"이라고 칭하기로 한 다.

s-DCP의 정확도증강 과정의 또 다른 구체적 예는 몇가지만 더 들면 다음과 같다. 우선 추상화 상위수준의 모델(이 추상화 상위수준의 모델은 원 시뮬레이션 대상이 되는 추상화 하위수준의 모델과 부분계층대응관계가 있음)을 시뮬레이션하여 얻어진 1차 s-DCP 내지는 1차 t-DCP를 이용하여서 원 시뮬레이션 대상이 되는 추상화 하위수준의 모델인 DUV내에 존재하는 설계객체들(이들 설계객체들 각각은 부분계층대응관계에 의하여 상위수준의 모델에서도 동일하게 존재함)내지는 DUV를 대상으로 하는 병렬적으로 진행 가능한 시뮬레이션을 1회 이상 진행하여서 정확도가 향상된 2차 s-DCP를 얻을 수 있다. 구체적 예로서는, 1차 s-DCP를 사용하여서 각 설계객체들 각각에 예상입력을 인가하면서 시뮬레이션(이 시뮬레이션은 각 설계객체별로 완전히 독립적임으로 병렬시뮬레이션으로 수행 가능함)하는 것이 가능하고 이 시뮬레이션 과정에서 이들 각 설계객체들의 출력들을 취합하게 되면 2차 s-DCP를 얻게되는데 이 2차 s-DCP는 원 시뮬레이션 대상이 되는 모델내에 존재하는 설계객체들을 대상으로 하여서 얻어지는 것임으로 매우 높은 정확도를 얻는 것이 가능하다. 다른 구체적 예로서는, 상기 추상화 상위수준의 모델을 시뮬레이션하여 얻어진 1차 t-DCP를 이용하여서 추상화 하위수준의 모델인 DUV에 대한 시뮬레이션을 시간상에서 복수개 시뮬레이션시간소구간들로 나누어서 병렬적으로 진행(TPE 방식의 병렬시뮬레이션)하면서 이 시뮬레이션 과정에서 DUV내의 각 설계객체들의 입력과 출력들을 취합하게 되면 정확도가 향상된 2차 s-DCP를 얻는 것이 가능하다. s-DCP 정확도증강의 또 다른 구체적 예로서는, 추상화 상위수준으로 구술된 다수의 설계객체들과 추상화 하위수준으로 구술된 소수의 설계객체들로 구성된 2 이상의 혼합된 추상화 수준의 모델들을 대상으로 진행하는 2 이상의 병렬시뮬레이션에서 수집된 상기 추상화 하위수준으로 구술된 모든 설계객체들(이 모든 설계객체들로 상기 하위 추상화 수준의 모델이 구성됨)의 2 이상의 동적정보들을 시뮬레이션 시간 상에서 시간맞춤(time alignment)함(시간맞춤이란 상기 추상화 하위수준의 설계객체들 각각에 대한 동적정보들이 추상화 상위수준의 모델의 부정확성으로 인해서 시뮬레이션 시간 상에서 서로간에 어긋나있을 수 있음으로 이 동적정보들을 시뮬레이션 시간 상에서 일치시키는 것을 말함. 이 시간맞춤은 트란젝션 수준에서 수행하게 되면 용이하게 수행할 수 있음. 예로, 1 이상의 모델들을 대상으로 하는 1 이상의 시뮬레이션에서 수집된 모델 내의 1 이상의 설계객체들의 동적정보들에서 동일한 특정 트란젝션의 시작시점을 찾아서 이 시점에 맞추면 됨)으로서 정확도가 증강된 s-DCP를 얻을 수 있다. s-DCP 정확도증강의 또 다른 구체적 예로서는, 추상화 상위수준의 모델을 대상으로 진행하는 시뮬레이션 내지는 추상화 상위수준으로 구술된 다수의 설계객체들과 추상화 하위수준으로 구술된 소수의 설계객체들로 구성된 2 이상의 혼합된 추상화 수준의 모델들을 대상으로 진행하는 2 이상의 병렬시뮬레이션에서 수집된 모델 내의 설계객체들에 대한 동적정보들을 분산처리적병렬수행 방식에서의 각 로컬시뮬레이션의 예상입력과 예상출력으로 사용하여 실제입력 내지는 실제출력과 비교하는 과정을 트란젝션 수준에서 진행하는 것이다. 즉 이들 예상입력과 실제입력 내지는 예상출력과 실제출력이 핀수준의 사이클 단위에서는 다르다고 하더라도 트란젝션수준의 여러 사이클 단위에서는 동일할 수 있음으로 예상입력과 실제입 력과의 비교 내지는 예상출력과 실제출력과의 비교를 핀수준의 사이클 단위로 하지않고 트란젝션수준의 여러 사이클 단위로 한다면 s-DCP의 정확도를 높일 수 있다. 즉, 사이클 단위의 핀수준 s-DCP 정확도를 높이는 것은 상대적으로 오버헤드가 크기 때문에, 이 대신에 예상입력과 실제출력과의 비교 내지는 예상출력과 실제출력과의 비교를 트란젝션단위 s-DCP 정확도 수준으로 진행(구체적 방법의 예로는, 예상값과 실제값 비교를 우선 트란젝션단위로 진행하여 실제트란젝션에 매칭되는 예상트란젝션을 찾고, 이 매칭된 예상트란젝션에서 실제트란젝션과 사이클단위로 비교하여 같은지 틀린지를 판단함. 따라서 이와 같은 트란젝션단위로 예상값과 실제값을 비교하는 경우에는 절대적 시뮬레이션 시간을 기준으로 예상트란젝션과 실제트란젝션을 비교하지 않고, 해당 트란젝션 단위에서의 어의(語義)를 기준으로 예상트란젝션과 실제트란젝션을 비교함. 예로, 특정 예상트란젝션의 시작시간이 1,080ns이고 종료시간이 1,160ns이고, 특정 실제트란젝션의 시작시간이 1,000ns이고 종료시간이 1,080ns이라고 하더라도 이 예상트란젝션과 실제트란젝션이 트란젝션 단위에서의 어의가 일치한다면 이 예상트란젝션과 실제트란젝션은 매칭되는 것 임. 이와 같이 매칭되는 예상트란젝션과 실제트란젝션의 절대적 시뮬레이션 시간이 달라질 수 있는 이유는 추상화 상위수준 모델의 부정확성 내지는 추상화로 인한 정보의 소실 등에서 찾을 수 있음. 따라서 트란젝션 수준에서의 예상값과 실제값의 매칭은 이를 고려하여야 함. 또한, 다른 추상화 수준의 트란젝션들 간 내지는 특정 추상화 수준의 트란젝션과 이를 구체화시킨 RTL의 이벤트시퀀스간에는 이들이 나타나는 시뮬레이션 시간 뿐만 아니라 이들 트란젝션들이 나타나는 순서 내지는 트란 젝션과 이벤트시퀀스가 나타나는 순서도 달라질 수 있다. 예로 timed-트란젝션 수준에서의 트란젝션 T_timed = {T1, T2, T3, T4}과 이것을 구체화시킨 ca-트란젝션 수준에서의 트란젝션 T_ca에서 나타나는 트란젝션은 T_timed의 트란젝션 순서인 T1, T2, T3, T4의 순서가 아닌 다른 순서 T3 = {t31, t32}, T1 = {t11, t12, t13, t14}, T4 = {t41, t42}, T2 = {t21, t22, t23} (tij는 사이클단위의 ca-트란젝션임. 예로 timed-트란젝션 T3는 ca-트란젝션 t31과 t32의 2개로 이루어짐)로 트란젝션이 나타날 수 있음으로 이와 같은 경우에서도 예상트란젝션과 실제트란젝션의 절대적 시뮬레이션 시간이 달라질 수 있다. 따라서 이 경우에도 트란젝션 수준에서의 예상값과 실제값의 매칭은 이를 고려하여야 함)하게 되면 예상값(예상입력 내지는 예상출력)이 온-칩 버스 규격에 위배되는지 여부를 쉽게 파악하고 필요시 이를 수정할 수 있는 등의 과정을 통하여 효과적으로 s-DCP의 정확도를 높이는 것이 가능하며, 이와 같은 트란젝션수준의 s-DCP를 이용함으로서 s-DCP의 정확도를 증강하는 본 특허에서의 s-DCP 정확도증강 과정을 "트란젝션화를 통한 s-DCP 정확도증강 과정"이라 칭하기로 한다.

또 한가지 언급할 것은, 상기에서 설명된 예상입력과 예상출력을 이용하는 시뮬레이션 방식은 이미 설명된 것과 같이 2 이상의 프로세서를 이용한 분산병렬 시뮬레이션의 성능을 높일 수 있을 뿐만 아니라, 단일 프로세서(여기에는 최근의 인텔사의 펜티엄 듀얼코어도 포함됨)를 이용하는 경우에도 시뮬레이션이 2 이상의 프로세스나 쓰레드(thread)로 나누어져서 수행되어야 하는 경우에서도 상기 2 이상의 프로세스와 쓰레드간의 프로세스간통신(Inter-Process Communication) 오버헤드와 프 로세스동기(Process Synchronization) 오버헤드도 크게 낮출 수 있다는 것이다.

t-DCP를 이용하게 되면 TPE 방식의 병렬시뮬레이션이 가능하고, s-DCP를 이용하게 되면 DPE 방식의 병렬시뮬레이션이 가능하다. TEP 방식의 병렬시뮬레이션은 전체 시뮬레이션 시간구간을 2 이상의 시뮬레이션시간소구간(이를 슬라이스라 칭함)으로 나누어서 이들 2 이상의 시뮬레이션소구간들 각각을 독립적으로 수행하는 것이다. DEP 방식의 병렬시뮬레이션은 시뮬레이션 대상이 되는 전체 설계객체(DUV와 TB)를 2 이상의 부분설계객체들로 나누어서 이들 2 이상의 부분설계객체들 각각을 별도의 시뮬레이터에서 분산병렬 방식으로 수행하는 것이다. 앞에서 이미 언급한 대로 t-DCP와 s-DCP의 정확도가 매우 중요한데, 이외에도 이들을 획득하는 것에 소요되는 시간이 과도하지 않아야 하는 것도 매우 중요하다. 따라서, 시뮬레이션 대상이 되는 특정 추상화수준의 설계객체를 시뮬레이션하여서 t-DCP와 s-DCP를 획득하는 것이 가능한 경우는 리그레션 테스트 내지는 설계변경이 국지적으로 이루어진 경우이며. 이외의 경우들에서는 상기 특정 추상화수준보다 높은 단계의 모델을 시뮬레이션하여서 t-DCP와 s-DCP를 획득하는 것이 빠른 획득시간과 더불어 이들의 정확도도 높일 수 있는 효율적 방법이다. TPE 방식의 병렬시뮬레이션에서 위에서 언급한 세가지의 활용방법들에 대하여 좀 더 자세하게 설명하면 다음과 같다. 우선 활용방법-1에서는 추상화 상위수준 모델을 대상으로 하는 시뮬레이션 과정에서 1 이상의 시뮬레이션 특정시점 내지는 특정구간에서의 추상화 상위수준 모델의 상태정보를 수집하고 이 추상화 상위수준 모델의 상태정보를 상기 1 이상의 시뮬레이션 특정시점 내지는 특정구간에서의 추상화 하위수준 모델의 상태정보로 변환(변환 방법의 구체 적 내용은 국내특허(10-2005-116706)에서 설명된 것을 참조)하고 이 변환된 추상화 하위수준 모델의 상태정보들을 이용하여서 추상화 하위수준 모델에 대한 시뮬레이션을 슬라이스별로 병렬적으로 수행하거나 내지는 특정 슬라이스만을 수행함으로 상기 추상화 하위수준 모델에 대한 시뮬레이션을 신속하게 수행하는 것이 가능하다. 활용방법-2에서는 2 이상의 추상화 중간수준 모델(추상화 상위수준 설계객체들과 추상화 하위수준 설계객체를 동시에 가지고 있는 DUV)을 독립적으로 병렬수행하고 이와 같은 병렬수행 과정에서 추상화 하위수준 설계객체들에 대한 상태정보들을 모두 합하여서 추상화 하위수준 모델에 대한 상태정보를 얻고, 이 추상화 하위수준 모델에 대한 시뮬레이션을 슬라이스별로 병렬적으로 수행하거나 내지는 특정 슬라이스만을 수행함으로 상기 추상화 하위수준 모델에 대한 시뮬레이션을 신속하게 수행하는 것이 가능하다 (도6 참조). 이들 추상화 상위수준 모델을 수행하거나 내지는 2 이상의 추상화 중간수준 모델들을 병렬적 내지는 순차적으로 수행하여서 얻어진 t-DCP를 활용하여서 추상화 하위수준 모델을 시뮬레이션 시간 상에서 2 이상의 시뮬레이션시간소구간들인 슬라이스로 나누어서 병렬적으로 수행하거나 나누어진 슬라이스들만을 순차적으로 수행함으로서 추상화 하위수준 모델에 대한 시뮬레이션을 신속하게 수행시키는 구체적 방법은 국내특허(10-2005-116706)와 국내특허(10-2006-19738)에 자세히 언급되어 있음으로 본 특허에서는 자세한 설명은 생략하기로 한다. 다만, 추상화 상위수준에서 s-DCP를 획득하는 경우와 같이 추상화 상위수준에서 t-DCP를 획득하는 경우에 t-DCP를 신속하게 획득하는 것은 가능하나 t-DCP의 정확도가 낮을 수 있음으로 이 경우에도 s-DCP와 같이 정확도를 높이는 방법이 필 요하다. 이를 위해서, 앞단 시뮬레이션에서 추상화 상위수준 모델에 대한 T_f 시점에서부터 T_r 시점까지에서 저장된 상태정보를 재차 추상화 상위수준 모델에 T_f 시점에서(혹은 이전 시점에서부터) force하고 T_r 시점에서 release한 후에 T_r 시점의 추상화 상위수준 모델의 입력정보(이 입력 정보는 앞단 시뮬레이션에서 수집되어서 저장된 것)를 T_r 시점 이후에도 계속 그대로 유지(단, TB에서부터 모든 사용자클럭들이 공급되지 않고, PLL과 같이 DUV 내부에 사용자클럭 소스가 존재하는 경우에는 이 사용자클럭 시그널들도 T_r 시점 이후에 계속 T_r 시점에서의 값을 유지하도록 함)하면서 상기 T_r 시점에서의 상태정보가 더 이상 변하지 않고 안정될 시점 T_s까지 기다리면 된다 (즉 더 이상 변하지 않는 시점에서의 상태정보가 정확도가 증강된 상태정보임). 단, 비동기적인 사용자클럭들(이들 사용자클럭들은 완전 독립적)이 2 이상 존재하고 T_r과 상기 변하지 않는 시점 T_s 사이에 사용자클럭들의 이벤트가 존재한 경우에는 위에서 언급된 과정을 반복적으로 진행하여야 한다. 또한, 추상화 상위수준 모델을 대상으로 한 시뮬레이션 과정에서 얻어진 1차 t-DCP를 활용한 추상화 하위수준 모델을 대상으로 한 TPE 방식의 시뮬레이션에서도 상기 추상화 상위수준 모델의 낮은 정확도로 인하여 상기 추상화 상위수준 모델 내에 존재하는 1 이상의 설계객체들에서 수집된 동적정보들이 시뮬레이션 시간 상에서 어긋나 있을 수 있으며 이로 인하여 상기 1차 t-DCP의 정확도가 떨어질 수 있다. 따라서 이와 같은 경우에도 s-DCP 정확도증강 과정에서 설명한 시간맞춤(time alignment)함으로서 t-DCP 정확도를 높일 수도 있다. 따라서 이와 같은 t-DCP 정확도를 높이는 모든 과정을 본 특허에서는 t-DCP 정확도증강 과정이라 칭한다. 위에 서 설명한 본 특허에서의 t-DCP를 이용한 병렬 시뮬레이션 방법을 본 특허에서는 t-DCP를 이용한 시간적병렬수행(Timed Parallel Execution) 방식 내지는, 이를 줄여서 시간분할적병렬수행 방식(즉 시간분할적병렬수행 방식이란 t-DCP를 활용하여 전체 시뮬레이션 구간을 2 이상의 슬라이스로 나누고 이 슬라이스별로 병렬수행을 진행하는 본 특허에서 제안한 병렬시뮬레이션 방식만을 말함)이라 칭하기로 한다.

이와 같은 추상화 상위수준 모델 내지는 추상화 중간수준 모델을 이용한 시뮬레이션 결과를 추상화 하위수준 모델을 이용한 시뮬레이션에 활용하는 본 특허에서의 시뮬레이션 방법을 통해서 추상화 하위수준 모델을 이용한 시뮬레이션의 속도를 높일 수 있을 뿐만 아니라, 추상화 상위수준 모델과 추상화 하위수준 모델 간의 일관성 여부를 효과적으로 조사할 수 있다. 즉 추상화 상위수준 모델 내지는 추상화 중간수준 모델을 이용한 시뮬레이션 결과를 이용한 추상화 하위수준에서의 추상화 하위수준 모델을 대상으로 하는 시뮬레이션 결과가 추상화 상위수준 모델 내지는 추상화 중간수준 모델을 이용한 시뮬레이션 결과와 맞지 않는 결과이면 이는 바로 추상화 상위수준 모델과 추상화 하위수준 모델 간의 불일관성의 구체적 사례를 예시하는 것임으로 이의 원인을 분석하여 제거함으로서 다른 추상화 수준들에서 존재하는 모델 간의 일관성을 효과적으로 유지할 수 있다.

위에서 언급된 두가지 방식의 병렬시뮬레이션인 DPE와 TPE에서는 앞단 시뮬레이션과 후단 시뮬레이션이 동일한 추상화 수준의 동일한 설계검증 대상으로 시뮬레이션을 하는 것도 가능하지만, 일반적으로는 앞단 시뮬레이션과 후단 시뮬레이션이 동일한 추상화 수준의 동일한 설계검증 대상으로 시뮬레이션을 하는 것이 아니고 다 른 추상화 수준의 설계검증 대상으로 시뮬레이션을 하는 것이다. 즉, s-DCP 내지는 t-DCP를 신속하게 획득하기 위한 목적의 앞단 시뮬레이션은 상대적으로 추상화 수준이 높은 상위수준에서 모델링된 모델을 대상으로 하여서 이루어지는 것이 일반적이고, 원래의 시뮬레이션 목적을 위한 후단 시뮬레이션은 상대적으로 앞단 시뮬레이션에서 사용된 모델보다 추상화 수준이 낮은 하위수준에서 모델링된 모델을 대상으로 하여서 이루어진다는 것이다. 또한, 본 특허에서는 시간적으로 앞서서 수행된 시뮬레이션 결과를 이용하여서 시간적으로 후에 수행되어지는 시뮬레이션을 빠르게 수행하는 것에 촛점을 맞추고 있으며, 따라서 상기 시간적으로 앞서서 수행되는 시뮬레이션을 빠르게 수행하는 방법은 이 시뮬레이션보다 시간적으로 더 앞서서 수행되는 시뮬레이션 결과에서 s-DCP를 구하고 이를 이용한 본 특허에서의 분산처리적병렬방식의 시뮬레이션을 이용하거나 혹은 통상적인 다양한 분산병렬 시뮬레이션(일반적인 분산병렬 시뮬레이션) 방식을 이용하는 것도 가능하다.

뿐만 아니라, 본 특허에서 제안하는 분산처리적병렬시뮬레이션과 별도의 특허 10-2004-93310에서 제시한 앞서서 수행된 시뮬레이션의 결과를 재활용하여서 1 이상의 설계객체가 수정된 경우에 수행되어지는 시뮬레이션을 신속하게 수행하는 인크리멘탈 시뮬레이션(incremental simulation)을 같이 활용하면 또 다른 효율적인 시뮬레이션이 가능하다. 즉 앞서서 수행된 시뮬레이션에서 수집된 1 이상의 설계객체들에 대한 동적정보(상태정보, 입력정보, 출력정보 등)을 활용하여서 디버깅 내지는 스펙 변경 등으로 인하여 1 이상의 설계객체들에 대한 수정이 이루어지고 난 후에 수행되는 시뮬레이션을 본 특허에서의 분산처리적병렬시뮬레이션으로 수행하는 경우 에 시뮬레이션 처음(시뮬레이션 시간 0)에서부터 2 이상의 로컬시뮬레이션을 이용한 분산병렬시뮬레이션을 수행하는 대신에 특허 10-2004-93310에서 제시한 인크리멘탈 시뮬레이션 기법을 사용하여서 시뮬레이션 시간 0에서부터 특정 시뮬레이션 시점 ts까지는 수정이 이루어진 1 이상의 설계객체들과 이들의 입력정보를 이용하거나 내지는 수정이 이루어진 1 이상의 설계객체들과 수정이 이루어지지 않은 설계객체들의 일부분(예로 상태정보 저장이 용이하지 않은 테스트벤치 등과 같은 설계객체)들과 이들의 입력정보들을 이용하여서 단일 시뮬레이션 S_s으로 진행하고 ts 이후부터는 상기 단일 시뮬레이션을 분산처리적병렬시뮬레이션의 한 로컬시뮬레이션 S_l(i)으로 전환(2 이상의 로컬시뮬레이션들로 전환시키는 것도 가능)하는 동시에(단일 시뮬레이션 S_s를 한 로컬시뮬레이션 S_l(i)로 전환시키면 추가적인 컴파일이 필요없이 ts에서부터 중단없이 시뮬레이션을 진행할 수 있음), 상기 분산처리적병렬시뮬레이션의 1 이상의 다른 로컬시뮬레이션들에서는 상기 S_l(i)에서 수행되어지는 설계객체들 이외의 설계객체들(이 설계객체들은 수정이 이루어지지 않은 설계객체들임)이 이들의 수정이 이루어지기 전 시뮬레이션 과정에서 수집된 ts(이벤트 구동 시뮬레이션의 경우에는 ts은 한 시점이 아니고 일정한 구간임)에서의 상태정보들을 가지고 ts에서부터 시뮬레이션을 진행하도록 한다면 시뮬레이션 시간 0에서부터 ts까지는 시뮬레이션 수행에 필요한 시뮬레이터의 라이센스 숫자를 최소화시킬 수 있는 추가적인 이점이 있다 (여기서 ts을 결정하는 것이 중요한데, ts은 시간적으로 시뮬레이션 시간 0에서 최대한 멀리 떨어져있으면서 동시에 ts까지는 수정에 의한 변경 이후의 시뮬레이션에서 수정이 이루어지지 않은 설계객체들의 시 뮬레이션 결과는 수정 이전의 시뮬레이션 결과들과 동일하다는 조건을 만족하는 특정 체크포인트여야 함. 구체적 결정 방법은 특허 10-2004-93310을 참조). 본 특허에서 이와 같은 시뮬레이션 방식을 "인크리멘탈 시뮬레이션을 활용한 분산처리적병렬시뮬레이션" 내지는 "인크리멘탈 시뮬레이션을 활용한 분산처리적병렬수행 방식의 시뮬레이션"이라고 칭하기로 하며, 인크리멘탈 시뮬레이션의 자세한 방법은 별도의 특허 10-2004-93310을 참조하기로 한다.

상기 목적 외에 본 발명의 다른 목적 및 이점들은 첨부한 도면을 참조한 실시 예에 대한 상세한 설명을 통하여 명백하게 드러나게 될 것이다.

도1 은, 본 발명에 관한 설계 검증 장치의 일 예를 개략적으로 도시한 도면이다.

도2 는, 본 발명에 관한 설계 검증 장치의 또 다른 일 예를 개략적으로 도시한 도면이다.

도3 은, ESL 모델의 계층구조 일 예를 이에 대응되는 RTL 모델의 계층구조의 일 예와 비교하여서 개략적으로 도시한 도면이다.

도4 는, RTL 모델의 계층구조 일 예를 이에 대응되는 GL 모델의 계층구조의 일 예와 비교하여서 개략적으로 도시한 도면이다. 이 예에서는 GL 모델에 바운더리 스캔셀을 가지고 있는 추가적인 계층구조를 나타내는 설계객체 387이 존재한다.

도5 는, 분산병렬 시뮬레이션의 수행이 2 이상의 컴퓨터들이 컴퓨터네트워크로 연결된 상황에서 수행되어지는 상황의 일 예를 개략적으로 도시한 도면이다.

도6 은, 추상화 상위수준 모델을 이용한 앞단 시뮬레이션에서 t-DCP를 획득하고 추상화 하위수준 모델을 이용한 후단 시뮬레이션을 시간분할적병렬수행으로 진행되는 일 예를 개략적으로 도시한 도면이다.

도7 은, 추상화 상위수준 모델을 이용한 앞단 시뮬레이션에서 s-DCP를 획득하고 추상화 하위수준 모델을 이용한 후단 시뮬레이션을 분산처리적병렬수행으로 진행되는 일 예를 개략적으로 도시한 도면이다.

도8 은, 본 특허에서 제시한 분산처리적병렬시뮬레이션을 위하여 부가되는 설계코드(부가 코드) 내부를 구성하는 컴퍼넌트들의 구성 일 예를 개략적으로 도시한 도면이다. 즉, 분산병렬 시뮬레이션 환경을 구성하는 각 로컬시뮬레이터 내지는 로컬하드웨어기반검증플랫폼(본 특허에서 하드웨어기반검증플랫폼은 하드웨어에뮬레이터 내지는 시뮬레이션가속기 내지는 FPGA 보드를 통칭하며, 현재 이와 같은 하드웨어기반검증플랫폼의 예로서는 Cadence사의 Palladium 시리즈/Extreme 시리즈, Mentor사의 Vstation 시리즈, Tharas사의 Hammer 시리즈, Fortelink사의 Gemini 시리즈, Aptix사의 SystemExplorer 시리즈, EVE사의 ZeBu 시리즈, Aldec사의 HES 시리즈, ProDesign사의 CHIPit 시리즈, HARDI사의 HAPS 시리즈, S2CInc사의 IP porter 시리즈 등이 있음)에서 수행되는 검증 대상 모델 M의 일부분(404)(이들 로컬시뮬레이터들과 로컬하드웨어기반검증플랫폼들에서 수행되는 검증 대상 모델의 일부분들을 모두 모아서 합치게 되면 검증 대상 모델 M이 됨)에 부가되어지는 부가 코드(62)의 행태(behavior)를 컴퍼넌트들로 구성한 일 예를 개략적으로 도시한 도면이다. 따라서 상기의 부가 코드(62)는 모델에 부가되어져서 도8 에 보이는 컴퍼넌트들(예상입출력이용-런/실제입출력이용-런 제어모듈(54), 예상입력/실제입력 선택모듈(56), 예상출력/실제출력 비교모듈(58), 예상입력/실제입력 비교모듈(59), s-DCP 저장모듈(60))의 기능을 수행할 수 있어야 한다. 상기 각 모듈별로 행태를 다시 정리하면 다음과 같다. 예상입출력이용-런/실제입출력이용-런 제어모듈(54)은 예상출력/실제출력 비교모듈(58)과 예상입력/실제입력 비교모듈(59)과 분산병렬 시뮬레이션을 위한 통신 및 동기화 모듈(64)로부터 입력들을 받아서 이 입력들의 값들과 현재 로컬시뮬레이션이 예상입출력이용-런 방식으로 진행되는지 혹은 실제입출력이용-런 방식으로 진행되는지의 현 상태(따라서, 예상입출력이용-런/실제입출력이용-런 제어모듈(54)은 내부적으로 현재 로컬시뮬레이션이 예상입출력이용-런 방식으로 진행되는지 혹은 실제입출력이용-런 방식으로 진행되는지를 판단할 수 있는 상태변수를 가지고 있음)에 따라서 예상입력/실제입력 선택모듈(56)로 출력을 생성하여 예상입력/실제입력 선택모듈(56)이 예상입력을 선택하게 하던지, 내지는 실제입력을 선택하게 하던지, 내지는 실제입력을 선택하기 전에 롤백이 필요하게 되면 롤백 수행을 제어하게 된다. 즉, 현재 로컬시뮬레이션이 예상입출력이용-런 방식으로 진행 중에 있으면서(따라서 예상입출력이용-런/실제입출력이용-런 제어모듈(54)은 현재 예상입력/실제입력 선택모듈(56)이 예상입력을 선택하도록 하는 출력을 예상입력/실제입력 선택모듈(56)에 보내어 제어 중) 동시에 예상출력/실제출력 비교모듈(58)에서부터 예상출력과 실제출력이 다르다는 판단이 입력으로서 오게되면 예상입출력이용-런/실제입출력이용-런 제어모듈(54)은 예상입력/실제입력 선택모듈(56)이 실제입력을 선택하도록 출력을 예상입력/실제입력 선택모듈(56)에 보내고 내부의 현재 상태변수를 예상입출력이용-런에서 실제입출력이용-런으로 스위칭하고 동시에 분산병렬 시뮬레이션을 위한 통신 및 동기화 모듈(64)로부터 롤백을 위한 특정 롤백 시간이 입력되면 상기 특정 롤백 시간으로 롤백을 수행할 수 있게 제어도 수행하며, 현재 로컬시뮬레이션이 실제입출력이용-런 방식으로 진행되고 있으면서(따라서 예상입출력이용-런/실제입출력이용-런 제어모듈(54)은 현재 예상입력/실제입력 선택모듈(56)이 실제입력을 선택하도록 하는 출력을 예상입력/실제입력 선택모듈(56)에 보내어 제어 중) 동시에 예상입력/실제입력 비교모듈(59)에서부터 예상입력과 실제입력이 일정 횟수 이상 같다는 판단이 입력으로 오게되면 예상입출력이용-런/실제입출력이용-런 제어모듈(54)은 예상입력/실제입력 선택모듈(56)이 예상입력을 선택하도록 출력을 예상입력/실제입력 선택모듈(56)에 보내고 동시에 내부의 현재 상태변수를 실제입출력이용-런에서 예상입출력이용-런으로 스위칭하게 된다. 뿐만 아니라, 예상입출력이용-런/실제입출력이용-런 제어모듈(54)은 내부의 현재 상태를 분산병렬 시뮬레이션을 위한 통신 및 동기화 모듈(64)를 통하여 다른 로컬시뮬레이션들에게 알리기 위한 두개의 출력(실제입출력이용-런 필요, 예상입출력이용-런 가능)을 분산병렬 시뮬레이션을 위한 통신 및 동기화 모듈(64)로 보내고, s-DCP 저장모듈(60)을 제어하여서 s-DCP 저장모듈(60)이 맞는 예상입력 내지는 예상출력을 맞는 타이밍에 출력하도록 한다. 예상출력/실제출력 비교모듈(58)은 s-DCP 저장모듈(60)에 저장된 예상출력과 로컬시뮬레이터에서 수행되는 설계 검증 대상 모델의 일부분(404)에서부터 로컬시뮬레이션 실행 과정에서 실제적으로 나오게 되는 실제출력을 비교하여, 이 비교가 일치하면 예상입출력이용-런/실제입출력이용-런 제어모듈(54)에 일치함을 출력으로 보내고 이 비교가 불일치하면 예상입출력이용-런/실제입출력이용-런 제어모듈(54)에 불일치함을 출력으로 보내는 동시 에 분산병렬 시뮬레이션을 위한 통신 및 동기화 모듈(64)로 롤백을 위한 현재의 시뮬레이션 시간을 보내어 다른 로컬 시뮬레이션들에게 이들 정보(롤백을 위한 현재의 시뮬레이션 시간)를 보낼 수 있게 한다. 예상입력/실제입력 비교모듈(59)는 s-DCP 저장모듈(60)에 저장된 예상입력과 분산병렬 시뮬레이션을 위한 통신 및 동기화 모듈(64)로부터 오는 다른 1 이상의 로컬시뮬레이션으로부터의 실제입력을 비교하여 이 비교가 일정 횟수만큼 일치하게 되면 이를 예상입출력이용-런/실제입출력이용-런 제어모듈(54)에 출력으로 보내게 된다. 예상입력/실제입력 비교모듈(59)과 예상출력/실제출력 비교모듈(58)은 비트 시그널 단위와 시뮬레이션 절대시간만을 기준으로 하여서 실제값과 예상값을 비교하는 것이 아니라, 앞서서 이미 설명한대로 "시간맞춤"과 "트란젝션화를 통한 s-DCP 정확도증강 과정" 등을 통하여 실제값과 예상값의 같음과 다름을 판단한다는 것에 유의한다. 마지막으로, 예상입력/실제입력 선택모듈(56)은 예상입출력이용-런/실제입출력이용-런 제어모듈(54)의 출력으로써 통신 및 동기화 모듈(64)로부터 오는 실제입력과 s-DCP 저장모듈(56)에 저장된 예상입력 중에서 하나를 선택하여서 이 로컬시뮬레이터에서 수행되는 설계 검증 대상 모델의 일부분(404)에 입력으로 인가한다. 만일, 검증 대상 모델 M의 일부분(404)이 로컬하드웨어기반검증플랫폼 상에서 시뮬레이션가속모드로 수행되는 경우에는 부가되는 부가 코드(62)는 합성가능한(synthesizable) 형태로 존재하여야 하며, 검증 대상 모델 M의 일부분(404)이 로컬시뮬레이터 상에서 수행되는 경우에는 부가되는 부가 코드(62)는 시뮬레이션가능한 형태로 존재하기만 하면 됨으로 이

부가되는 부가 코드는 HDL(예로 Verilog, VHDL 등) 코드 내지는 SDL(예로 SystemC, SystemVerilog 등) 코드 내지는 C/C++ 코드 내지는 이들의 조합 형태로 다양하게 존재할 수 있다. 뿐만 아니라, 이와 같은 부가되는 부가 코드(62)는 본 특허의 검증 소프트웨어에 의하여 자동적으로 생성되어진다. 도 8에서 예시한 예에서는 부가 코드(62) 전체가 HDL 시뮬레이터 외부에서 C/C++ 코드 형태로 존재하여서 VPI/PLI/FLI를 통하여 HDL로 표현된 검증 대상 모델 M의 일부분(404)과 인터페이스되어 연동되어지는 상황을 나타내고 있지만, 앞서서 이미 언급되어진 것과 같이 부가 코드(62)의 일부분은 HDL도 표현되어지고 나머지는 C/C++ 코드 형태로 표현되어지는 것도 가능하다. 또한 도 8에서 통상적인 분산병렬 시뮬레이션에서 필요한 통상적인 통신 및 동기화 모듈은 분산병렬 시뮬레이션을 위한 통신 및 동기화 모듈(64)로 표시되어 있다. 뿐만 아니라, 예상입력(50)과 예상출력(52)은 파일형태로 저장되어져서 HDL 코드(예로, Verilog에서의 $readmemb, 혹은 $readmemh) 내지는 VPI/PLI/FLI를 이용하여 C/C++ 코드에 의하여 읽어지도록 하는 것도 가능하다.

특히, 도8 과 같은 구성으로 분산처리적병렬시뮬레이션에서의 각 로컬시뮬레이션들을 위한 부가 코드를 구성하게 되면 예상입출력이용-런 수행을 모든 로컬시뮬레이션들이 일관되게 똑같이 예상입출력이용-런 수행으로 진행할 수 있을 뿐만 아니라(즉 예상입출력이용-런 수행이 되는 경우는 로컬시뮬레이션들 모두가 함께 예상입출력이용-런 방식으로 수행됨), 각 로컬시뮬레이션별로도 예상입출력이용-런 수행을 진행(예로, 특정한 로컬시뮬레이션들은 실제입출력이용-런 방식으로 진행되고 나머지 로컬시뮬레이션들은 예상입출력이용-런 방식으로 진행)할 수도 있다. 이와 같이 각 로컬시뮬레이션별로도 예상입출력이용-런 수행을 진행하게 되는 경우에 분 산병렬 시뮬레이션 전체로 보면 분산병렬 시뮬레이션의 통신 오버헤드 내지는 동기 오버헤드를 완전하게 제거할 수는 없지만(모든 로컬시뮬레이션들이 모두 동일하게 예상입출력이용-런 방식으로 수행하게 되는 상황에서는 통신 오버헤드와 동기 오버헤드는 전혀 없게 되지만, 이 경우에는 특정 로컬시뮬레이션들은 실제입출력이용-런 방식으로 진행되고 다른 로컬시뮬레이션들은 예상입출력이용-런 방식으로 진행됨) 통신 오버헤드 내지는 동기 오버헤드를 상당하게 낮추는 것이 가능함으로 큰 이득을 기대할 수 있다.

도9 는, 레지스터전송수준에서의 시그널 단위의 사이클정확한 버스 동작상황과 트란젝션수준에서의 트란젝션 단위의 사이클정확한 버스 동작상황의 일 예를 개략적으로 도시한 도면이다.

도10 은, 도 3에서 예시한 ESL 모델내의 설계객체들과 이에 대응되는 RTL 모델내의 설계객체들을 개략적으로 도시한 도면이다.

도11 은, 도 10에서 예시한 ESL 모델내의 설계객체들 각각을 대응되는 RTL 모델내의 설계객체로 대체하여서 추상화 중간수준의 혼합된 설계객체 DO_t_mixed(i)들을 생성하는 일 예를 개략적으로 도시한 도면이다. 도 11에서 예시한 경우와 같이 ESL 모델에서부터 점진적 구체화 과정으로 생성된 ESL/RTL 추상화 혼합수준의 모델(예로 DO_t_mixed(2))을 생성한 경우에 이 ESL/RTL 추상화 혼합수준의 모델의 시뮬레이션 속도가 추상화 상위수준의 ESL 모델의 시뮬레이션 속도에 비하여 상당히 떨어지는 경우에도 본 특허에서의 분산처리적병렬수행 방식을 통하여 ESL/RTL 추상화 혼합수준의 모델에 대한 시뮬레이션 속도를 높일 수 있다.

구체적 예로, 도 11에서 DO_t_mixed(2)의 경우에 분산처리적병렬수행 방식의 분산병렬 시뮬레이션을 두개의 로컬시뮬레이션으로 구성하고, 하나의 로컬시뮬레이션에서는 설계객체 DO2_rtl와 트란젝션과 RTL간의 변환을 위한 트란젝터를 수행시키고 나머지 하나의 로컬시뮬레이션에서는 다른 모든 트란젝션 수준의 설계객체들을 수행시키도록 구성하게 되면 ESL/RTL 추상화 혼합수준의 모델 DO_t_mixed(2)의 시뮬레이션 속도를 모델 DO_t_mixed(2) 전체를 하나의 시뮬레이션으로 수행하는 것에 비하여 효과적으로 높일 수 있다. 물론, 3 이상의 로컬시뮬레이션으로 구성되는 분선처리적병렬시뮬레이션 방식의 분산병렬 시뮬레이션을 이용하여서 추상화 혼합수준의 모델의 시뮬레이션 속도를 높이는 것도 일반적으로 가능하다.

도12 는, 도 11에서 예시한 여섯 개의 혼합된 설계객체 DO_t_mixed(1), DO_t_mixed(2), .., DO_t_mixed(6)를 이용한 여섯의 혼합 시뮬레이션의 독립적 병렬 실행과 이 실행 과정에서 1 이상의 시뮬레이션 시점들에서 수집된 상태정보들을 이용하여서 후단 시뮬레이션 단계인 RTL 모델에 대한 시뮬레이션을 시간분할적병렬수행으로 수행하는 일 예를 개략적으로 도시한 도면이다.

도13 은, 점진적 구체화 과정을 통하여 처음 추상화 수준에서부터 마지막 추상화 수준으로 진행되는 설계 및 검증 과정의 일 예를 개략적으로 도시한 도면이다.

도14 는, 점진적 구체화 과정을 거쳐서 트란젝션 수준의 모델에서부터 RTL 모델을 거쳐서 게이트수준의 모델까지 생성되는 과정의 일 예를 개략적으로 도시한 도면이다.

도15 는, 점진적 구체화 과정을 거쳐서 사이클정확 트란젝션 수준의 모델을 이용한 검증에서부터 RTL 모델을 이용한 검증을 거쳐서 게이트수준의 모델을 이용한 검증까지 진행되는 과정에 s-DCP 내지는 t-DCP를 이용하여서 추상화 하위수준 모델에 대한 시뮬레이션을 분산처리적병렬수행 내지는 시간분할적병렬수행으로 진행하는 상황의 일 예를 개략적으로 도시한 도면이다. 도면에서 DCP는 s-DCP 내지는 t-DCP를 가르킨다.

도16 은, 본 특허에서의 시뮬레이션 방법을 진행하는 예제 모델의 일부분을 개략적으로 도시한 도면이다.

도17 과 도18 과 도19 는, 도16 에서 예시한 예제 모델을 분산처리적병렬시뮬레이션으로 수행하기 위하여 본 특허의 검증 소프트웨어를 이용하여 부가 코드를 부가한 상황의 일 예를 부분적으로 나누어서 개략적으로 도시한 도면들이다.

도20 은, 분산처리적병렬수행/단일수행 혼용방식의 수행 상황의 일 예를 개략적으로 도시한 도면이다.

도21 은, 시뮬레이션가속을 통한 시뮬레이션을 분산처리적병렬수행으로 진행함으로서 시뮬레이터와 하드웨어기반검증플랫폼 간의 동기 오버헤드 및 통신 오버헤드를 감소시키는 상황의 일 예를 개략적으로 도시한 도면이다. 즉 통상적인 시뮬레이션가속 기법은 모델에서 합성가능한 설계객체(통상적으로 DUV)는 하드웨어기반검증플랫폼 내의 1 이상의 FPGA 내지는 1 이상의 불리안프로세서에 구현하고 합성가능하지 않은 설계객체(통상적으로 TB)는 시뮬레이터에 구현하여 이들을 물리적으로 연결(예로 PCI를 통하여 연결)하여 하드웨어기반검증플랫폼과 시뮬레이터를 병렬적으로 연동시키는 것임으로 2개의 로컬시뮬레이션을 통한 분산병렬 수행되어지는 것과 동일하다. 따라서 본 특허에서 제안한 분산처리적병렬수행 방식을 통상적인 시뮬레이션가속에서 아무 변경없이 적용가능하며, 이를 통하여 통상적인 시뮬레이션가속에서 존재하는 하드웨어기반검증플랫폼과 시뮬레이터 간의 통신 오버헤드와 동기 오버헤드를 최소화시키는 것도 가능하다.

이와 같은 시뮬레이션가속에서의 특정한 시뮬레이션 수행 SA_run(j)에서 사용되는 예상입력과 예상출력은 다른 경우들과 마찬가지로 SA_run(j)보다 시간적으로 앞서서 수행되어진 선행 시뮬레이션 수행 SIM_run(i)의 시뮬레이션 과정에서 수집된 동적정보로부터 얻어진다 (SIM_run(i)과 SA_run(j) 사이에 스펙 변경 내지는 디버깅 과정을 통하여 모델 내의 1 이상의 설계객체에 대한 부분적 변경이 일어날 수도 있다). 또한, 상기 선행 시뮬레이션 수행 SIM_run(i)는 SA_run(j)가 수행되는 동일한 하드웨어기반검증플랫폼을 시뮬레이터와 같이 이용하여서 수행되어질 수 있고, 이 뿐만 아니라, SA_run(j)가 수행되는 동일한 하드웨어기반검증플랫폼이 아닌 별도의 1 내지는 2 이상의 시뮬레이터만을 이용(이 경우 모델 전체가 상기 1 내지는 2 이상의 시뮬레이터만을 사용해서 시뮬레이션되어짐)하여서 시뮬레이션되는 것 또한 가능한데 이와 같은 경우에는 상기 별도의 1 내지는 2 이상의 시뮬레이터만을 이용하여서 시뮬레이션되는 모델의 추상화수준이 하드웨어기반검증플랫폼으로 수행되는 설계객체와 같은 추상화 수준일 수도 있지만 시뮬레이션의 속도를 높이기 위하여서 하드웨어기반검증플랫폼으로 수행되는 설계객체보다 높은 추상화 수준일 수도 있다. 예로, 하드웨어기반검증플랫폼으로 수행되는 설계객체 DUV가 RTL이면 시뮬레이션되는 모델(이 모델은 DUV를 포함하고 있음)의 추상화 수준은 ca-트란젝션수준 모 델이거나, 하드웨어기반검증플랫폼으로 수행되는 설계객체 DUV가 GL이면 시뮬레이션되는 모델(이 모델은 DUV를 포함하고 있음)의 추상화 수준은 RTL 모델일 수 있다. 즉, 통상적인 시뮬레이션가속의 경우에도 본 특허에서의 분산처리적병렬수행 방식을 채용함으로서 시뮬레이션가속의 진행 전 과정을 1회 이상의 예상입출력이용-런 진행 과정과, 필요시에 1회 이상의 실제입출력이용-런 진행 과정이 번갈아 가면서 진행되는 것으로 수행가능하며, 이전 시뮬레이션 진행에서 수집된 동적정보에서부터 얻어진 높은 정확도의 예상 입력과 예상 출력을 사용함으로서 시뮬레이션가속 진행의 대부분의 시간을 예상입출력이용-런 방식으로 진행 가능하게 함으로서 통신 오버헤드와 동기 오버헤드를 크게 감소시켜서 시뮬레이션가속의 속도를 크게 높이는 것이 가능하다.

단, 이와 같은 예상 입력과 예상 출력을 저장하기 위한 하드웨어기반검증플랫폼에 존재하는 메모리의 용량이 충분이 큰 경우에는 모든 예상 입력과 예상 출력을 하드웨어기반검증플랫폼에 존재하는 메모리에 이들 전부를 한번에 저장시키고, 하드웨어기반검증플랫폼에 존재하는 메모리의 용량이 크지 않은 경우에는 모든 예상 입력과 예상 출력을 하드웨어기반검증플랫폼에 연결되어진 컴퓨터 상의 대용량의 기억장치(하드디스크 내지는 주기억장치)에 우선 저장시키고, 하드웨어기반검증플랫폼에는 예상 입력과 예상 출력의 일부분만을 저장할 수 있는 일정크기의 버퍼를 두고 시뮬레이션가속 실행 과정에서 필요한 부분만을 동적으로 상기 컴퓨터 상의 대용량의 기억장치에서부터 상기 버퍼로 버스트(burst) 방식으로 옮겨서 처리하는 방식을 채용할 수도 있다.

그리고 하드웨어기반검증플랫폼 상에서 수행되는 설계객체에 대한 롤백이 필요한 경우에는 상용 하드웨어기반검증플랫폼(예로 Cadence사의 Palladium 시리즈/Extreme 시리즈, Mentor사의 Vstation 시리즈, EVE사의 ZeBu 시리즈, Fortelink사의 Gemini 시리즈, Tharas사의 Hammer 시리즈 등)에서 제공하는 롤백 기능을 이용하거나 내지는 별도의 특허(US 6,701,491)에서 제안된 출력탐침/입력탐침 기능을 이용하거나 내지는 설계객체 내에 존재하는 플립플롭들 내지는 래치들에 대하여 쉐도우레지스터(shadow register)를 두고 이용함으로서 롤백 기능을 손쉽게 구현 가능하다.

본 특허에서 언급하는 분산병렬 시뮬레이션 환경에서 1 이상의 특정 로컬시뮬레이션은 시뮬레이터로 수행되거나 이 로컬시뮬레이션에서 수행되는 검증 대상 모델의 일부분이 합성가능한 경우에는 하드웨어기반검증플랫폼(시뮬레이션가속기 내지는 하드웨어에뮬레이터 내지는 FPGA 보드를 통칭)으로 수행되어질 수 있고, 시뮬레이터로 수행되는 경우에는 이 시뮬레이터로는 이벤트-구동 Verilog 시뮬레이터 내지는 SystemVerilog 시뮬레이터 내지는 VHDL 시뮬레이터 내지는 SystemC 시뮬레이터, 혹은 사이클-기반 SystemC 시뮬레이터 내지는 VHDL 시뮬레이터 내지는 Verilog 시뮬레이터 내지는 SystemVerilog 시뮬레이터가 사용될 수 있을 뿐만 아니라, Vera 시뮬레이터 내지는 e 시뮬레이터 등의 여타 임의의 반도체설계용 시뮬레이터까지도 사용될 수 있다. 따라서 분산병렬 시뮬레이션을 수행하는 1 이상의 로컬시뮬레이션들에서 특정 로컬시뮬레이션들은 이벤트-구동 방식으로 진행되고, 분산병렬 시뮬레이션 과정에서 이들과 연동하는 다른 로컬시뮬레이션들은 사이클-기반 방식으로 진 행(예로, 도 5에서 온-칩 버스 설계객체(420) 사이클-기반으로 동작하고, 나머지 설계객체들(380, 381, 382, 383, 384, 385)은 이벤트-구동 방식으로 동작)될 수도 있다. 물론, 분산병렬 시뮬레이션을 수행하는 모든 로컬 시뮬레이션들이 이벤트-구동 방식으로 진행(이와 같은 이벤트-구동 방식의 분산병렬 시뮬레이션은 PDES(Parallel Distributed Event-driven Simulation)이라고 한다)될 수도 있고, 분산병렬 시뮬레이션을 수행하는 모든 로컬 시뮬레이션들이 사이클-기반 방식으로 진행될 수도 있다.

도22 는, 본 특허에서의 분산처리적병렬수행 방식의 시뮬레이션을 위한 2 이상의 컴퓨터에 인스톨된 2 이상의 로컬컴퓨터들의 논리적연결구조 방식들의 몇가지 사례들을 예시한 도면이다. 도22 에서 도시한 로컬컴퓨터들의 논리적연결구조 방식들 이외에도 로컬컴퓨터들의 다양한 논리적연결구조 방식들이 있을 수 있으며, 본 특허에서 언급한 분산처리적병렬수행 방식의 시뮬레이션은 로컬컴퓨터들의 다양한 논리적연결구조 방식들에 적용되어질 수 있다.

도23 은, 분산병렬 시뮬레이션을 2 이상의 컴퓨터들과 이들 컴퓨터에 인스톨된 2 이상의 HDL 시뮬레이터들을 이용하여서 구성한 분산병렬 시뮬레이션 환경의 일 예를 개략적으로 도시한 도면으로, 본 특허에서의 분산처리적병렬수행 방식의 분산병렬 시뮬레이션도 이와 같은 환경에 적용할 수 있다.

도24 는, 통상적인 분산병렬 시뮬레이션의 전체 진행 흐름도의 일 예를 개략적으로 도시한 도면이다. 따라서 분산병렬 시뮬레이션의 전체 진행을 위한 다른 여러 진행 흐름도들도 얼마든지 존재할 수 있다.

도25 는, 본 특허에서의 분산처리적병렬시뮬레이션의 전체 진행 흐름도의 일 예를 개략적으로 도시한 도면이다. 따라서 분산처리적병렬시뮬레이션의 전체 진행을 위한 다른 여러 진행 흐름도들도 얼마든지 존재할 수 있다. 뿐만 아니라, 전체 진행 흐름도에서의 각 서브블럭(예로, 도25 에서 S200 내지는 S202 내지는 S204 내지는 S206내지는 S208 내지는 S210 내지는 S212)의 실행 순서는 전체 진행의 올바른 수행을 방해하지 않는 한 변화될 수 있고, 혹은 2 이상의 서브블럭들도 전체 진행의 올바른 수행을 방해하지 않는 한 동시에 수행되어질 수도 있다.

도25 에서 예시된 분산처리적병렬시뮬레이션의 전체 진행 흐름도를 설명하면, 시작과 종료를 제외하고 총 8개의 서브블럭들로 구성되어 있다. S200 단계에서 분산처리적병렬시뮬레이션 하고자 하는 모델을 읽어들이고 S202 단계로 진행한다. S202 단계에서는 분산처리적병렬시뮬레이션 대상 모델에 대한 분할 수행하여 각 로컬시뮬레이션 대상이 되는 설계객체를 생성하고, 분산병렬시뮬레이션의 각 로컬시뮬레이션 대상이 되는 설계객체 내지는 시뮬레이션 환경(예로 별방식의 논리적연결구조에서 중앙컴퓨터에 존재하는 SW서버 모듈)을 위한 부가코드를 생성하고 S204 단계로 진행한다. S204 단계에서는 s-DCP 획득을 위한 앞단 시뮬레이션 대상 모델을 읽어들이고 S206 단계로 진행한다. S206 단계에서는 앞단 시뮬레이션 대상 모델에 대한 시뮬레이션컴파일 수행하고 S208 단계로 진행한다. S208 단계에서는 앞단 시뮬레이션 수행하면서, s-DCP 획득하고 S210 단계로 진행한다. S210 단계에서는 분산처리적병렬시뮬레이션을 위한 각 로컬시뮬레이션 대상 설계객체별 시뮬레이션컴파일 수행하고 S212 단계로 진행한다. 이와 같은 분산처리적병렬시뮬레이션을 위한 각 로컬시뮬레이션 대상 설계객체별 시뮬레이션컴파일 수행 시에 상기 S202 단계에서 부가되어진 부가코드들도 같이 컴파일되어진다. S212 단계에서는 분산처리적병렬시뮬레이션을 수행하고 전체 과정을 종료하게 된다.

도26 은, 본 특허에서의 분산처리적병렬시뮬레이션 수행(도25 에서의 서브블럭 S212)을 위한 각 로컬시뮬레이터로 실행되는 로컬시뮬레이션 수행의 흐름도의 일 예를 개략적으로 도시한 도면이다. 따라서 분산처리적병렬시뮬레이션 수행을 위한 다른 여러 진행 흐름도들도 얼마든지 존재할 수 있다. 뿐만 아니라, 이 분산처리적병렬시뮬레이션 수행을 위한 진행 흐름도에서의 각 서브블럭의 실행 순서는 전체 진행의 올바른 수행을 방해하지 않는 한 변화될 수 있고, 혹은 2 이상의 서브블럭들도 전체 진행의 올바른 수행을 방해하지 않는 한 동시에 수행되어질 수도 있다.

도26 에서 예시된 분산처리적병렬시뮬레이션 수행의 전체 진행 흐름도를 설명하면, 시작과 종료를 제외하고 총 15개의 서브블럭들로 구성되어 있다.

S398 단계에서 현재 시뮬레이션시간을 0으로 설정하고, S402 단계로 진행한다. S402 단계에서 로컬시뮬레이션의 현재 시뮬레이션시점이 체크포인트를 생성하여 하는 시점이고 사전에 이 시점에서 체크포인트가 생성이 않되었으면 지금 체크포인트를 생성하고 지금 체크포인트를 생성한 경우에만 다른 로컬시뮬레이션에서부터 롤백가능성이 발생하였는지를 조사하여 롤백가능성이 발생한 경우에는 S410 단계로 진행하고, 롤백가능성이 발생하지 않은 경우에는 로컬시뮬레이션의 현재 시뮬레이션시간이 실제롤포워드-시점과 같으면 S418 단계로 진행하고 시뮬레이션 종료시간과 같거나 크면 S422 단계로 진행하고 그렇치 않으면 예상입력을 이용하여 시뮬레 이션 진행하여 실제출력 얻음과 동시에 실제출력과 예상출력을 비교하고 S406 단계로 진행한다. S406 단계에서는 S402 단계의 시뮬레이션에서 얻어진 실제출력과 예상출력 비교하여 일치하면 S404 단계로 진행하고, 이 비교가 일치하지 않으면 S408 단계로 진행한다. S404 단계에서는 실제출력의 이벤트시간(변화가 발생한 시간)을 로컬시뮬레이션의 현재 시뮬레이션시간으로 설정하고 S402 단계로 진행한다. S408 단계에서는 시뮬레이션을 일시적으로 멈추고, 다른 로컬시뮬레이션들에게 롤백가능성 발생을 전달하고 현재 시뮬레이션시간(롤백가능 시점)도 다른 로컬시뮬레이션들에 전달하고 S410 단계로 진행한다. S410 단계에서는 롤백가능성이 발생한 모든 로컬시뮬레이션들의 현재 시뮬레이션시간(롤백가능 시점)들을 획득하여, 이것들로부터 로컬시뮬레이션의 롤백/롤포워드 필요성을 판단하고 동시에 실제롤백-시점/실제롤포워드-시점을 결정하고 S412 단계로 진행한다. 즉, 롤백가능성이 발생한 모든 로컬시뮬레이션들별로 각 로컬시뮬레이션시간들 T_rb = (t_rb(1), t_rb(2), .., t_rb(N-1), t_rb(N)) (t_rb(i)은 롤백가능성이 발생한 로컬시뮬레이션 i의 롤백가능시점을 표시함)이 롤백가능시점들이 되는데, 실제롤백-시점은 t_rb(1), t_rb(2), .., t_rb(N-1), t_rb(N)들 중에서 제일 작은 값(즉, 시간적으로 제일 과거시간)인 T_rb(FINAL) = min(t_rb(1), t_rb(2), .., t_rb(N-1), t_rb(N))이 되고 도26 을 수행하는 특정 로컬시뮬레이션 LP(k)의 현재 시뮬레이션시간 t_c(k)이 T_rb(FINAL)보다 크거나 같으면 상기 특정 로컬시뮬레이션 LP(k)는 롤백을 수행하여야 하고, t_c(k)가 T_rb(FINAL)보다 작으면 상기 특정 로컬시뮬레이션 LP(k)는 롤포워드를 수행하여야 한다. S412 단계에서는 롤백이 필요하면 S414 단계로 진행 하고, 롤백이 필요하지 않으면 S416 단계로 진행한다. S416 단계에서는 롤포워드가 필요하면 S402 단계로 진행하고, 롤포워드가 필요하지 않으면 S418 단계로 진행한다. S414 단계에서는 로컬시뮬레이션의 롤백을 실행하고 S418 단계로 진행한다. S418 단계에서는 실제입력을 이용하여 시뮬레이션하고 얻어진 실제출력을 입력으로 사용하는 다른 로컬시뮬레이션으로 전달함과 동시에, 실제입력과 예상입력을 비교하며, 로컬시뮬레이션의 현재 시뮬레이션 시간이 시뮬레이션 종료시간과 같으면 종료하고, 같지 않으면 S420 단계로 진행한다. S420 단계에서는 상기 S418 단계에서 실제입력과 예상입력을 비교하여서 일치된 횟수가 미리 정해진 일정횟수(예로, 3번)이상 일치한지를 판단하여 일정횟수 일치하게 되었으면 S421 단계로 진행하고 그렇치 않으면 S418 단계로 진행한다. S422 단계에서는 다른 로컬시뮬레이션들이 모두 종료되었으면 이 로컬시뮬레이션 수행도 종료하게 되고, 그렇치 않으면 S424 단계로 진행한다. S424 단계에서는 이 로컬시뮬레이션의 롤백의 필요성이 있는지로 조사하여 필요하지 않으면 S422 단계로 진행하고 롤백의 필요성이 있으면 S426 단계로 진행한다. S426 단계에서는 실제롤백-시점 결정 후에 롤백을 실행하고, S418 단계로 진행한다.

도27 은, 본 특허에서의 분산처리적병렬시뮬레이션 수행(도25 에서의 서브블럭 S212)을 위한 각 로컬시뮬레이터로 실행되는 로컬시뮬레이션 수행의 흐름도의 또 다른 일 예를 개략적으로 도시한 도면이다. 따라서 분산처리적병렬시뮬레이션 수행을 위한 다른 여러 진행 흐름도들도 얼마든지 존재할 수 있다. 뿐만 아니라, 이 분산처리적병렬시뮬레이션 수행을 위한 진행 흐름도에서의 각 서브블럭의 실행 순서 는 전체 진행의 올바른 수행을 방해하지 않는 한 변화될 수 있고, 혹은 2 이상의 서브블럭들도 전체 진행의 올바른 수행을 방해하지 않는 한 동시에 수행되어질 수도 있다.

도27 에서 예시된 분산처리적병렬시뮬레이션 수행의 전체 진행 흐름도를 설명하면, 시작과 종료를 제외하고 총 16개의 서브블럭들로 구성되어 있다.

S298 단계에서 현재 시뮬레이션시간을 0으로 설정하고, S300 단계로 진행한다. S300 단계에서 다른 로컬시뮬레이션에서부터 롤백가능성 발생이 전달되어지면 S310 단계로 진행하고, 그렇치 않은 경우에는 S302 단계로 진행한다. S302 단계에서는 로컬시뮬레이션의 현재 시뮬레이션 시점이 체크포인트를 생성하여야 하는 시점이고 사전에 이미 체크포인트가 생성 않되었으면 체크포인트를 생성하고, 로컬시뮬레이션의 현재 시뮬레이션 시점이 실제롤포워드-시점과 같으면 S318 단계로 진행하고 시뮬레이션 종료시간과 같거나 크면 S318 단계로 진행하고 그렇치 않으면 예상입력을 이용하여 시뮬레이션 진행하여 실제출력 얻음과 동시에 실제출력과 예상출력을 비교하고 S306 단계로 진행한다. S306 단계에서는 S302 단계의 시뮬레이션에서 얻어진 실제출력과 예상출력 비교하여 일치하면 S304 단계로 진행하고, 이 비교가 일치하지 않으면 S308 단계로 진행한다. S304 단계에서는 실제출력의 이벤트시간(변화가 발생한 시간)을 로컬시뮬레이션의 현재 시뮬레이션시간으로 설정하고 S300 단계로 진행한다. S308 단계에서는 시뮬레이션을 일시적으로 멈추고, 다른 로컬시뮬레이션들에게 롤백가능성 발생을 전달하고 현재 시뮬레이션시간(롤백가능 시점)도 다른 로컬시뮬레이션들에 전달하고 S310 단계로 진행한다. S310 단계에서는 롤백가 능성이 발생한 모든 로컬시뮬레이션들의 현재 시뮬레이션 시간(롤백가능 시점)들을 획득하여, 이것들로부터 로컬시뮬레이션의 롤백/롤포워드 필요성을 판단하고 동시에 실제롤백-시점/실제롤포워드-시점을 결정하고 S312 단계로 진행한다. 즉, 롤백가능성이 발생한 모든 로컬시뮬레이션들별로 각 로컬시뮬레이션시간들 T_rb = (t_rb(1), t_rb(2), .., t_rb(N-1), t_rb(N)) (t_rb(i)은 롤백가능성이 발생한 로컬시뮬레이션 i의 롤백가능시점을 표시함)이 롤백가능시점들이 되는데, 실제롤백-시점은 t_rb(1), t_rb(2), .., t_rb(N-1), t_rb(N)들 중에서 제일 작은 값(즉, 시간적으로 제일 과거시간)인 T_rb(FINAL) = min(t_rb(1), t_rb(2), .., t_rb(N-1), t_rb(N))이 되고 도27 을 수행하는 특정 로컬시뮬레이션 LP(k)의 현재 시뮬레이션시간 t_c(k)이 T_rb(FINAL)보다 크거나 같으면 상기 특정 로컬시뮬레이션 LP(k)는 롤백을 수행하여야 하고, t_c(k)가 T_rb(FINAL)보다 작으면 상기 특정 로컬시뮬레이션 LP(k)는 롤포워드를 수행하여야 한다. S312 단계에서는 롤백이 필요하면 S314 단계로 진행하고, 롤백이 필요하지 않으면 S316 단계로 진행한다. S316 단계에서는 롤포워드가 필요하면 S302 단계로 진행하고, 롤포워드가 필요하지 않으면 S318 단계로 진행한다. S314 단계에서는 로컬시뮬레이션의 롤백을 실행하고 S318 단계로 진행한다. S318 단계에서는 실제입력을 이용하여 시뮬레이션하고 얻어진 실제출력을 입력으로 사용하는 다른 로컬시뮬레이션으로 전달함과 동시에, 실제입력과 예상입력을 비교하며, 로컬시뮬레이션의 현재 시뮬레이션 시간이 시뮬레이션 종료시간과 같으면 종료하고, 같지 않으면 S320 단계로 진행한다. S320 단계에서는 상기 S318 단계에서 실제입력과 예상입력을 비교하여서 일치된 횟수가 미리 정해진 일정 횟수(예로, 3번)이상 일치한지를 판단하여 일정횟수 일치하게 되었으면 S321 단계로 진행하고 그렇치 않으면 S318 단계로 진행한다. S322 단계에서는 다른 로컬시뮬레이션들이 모두 종료되었으면 이 로컬시뮬레이션 수행도 종료하게 되고, 그렇치 않으면 S324 단계로 진행한다. S324 단계에서는 이 로컬시뮬레이션의 롤백의 필요성이 있는지로 조사하여 필요하지 않으면 S322 단계로 진행하고 롤백의 필요성이 있으면 S326 단계로 진행한다. S326 단계에서는 실제롤백-시점 결정 후에 롤백을 실행하고, S318 단계로 진행한다.

도26 과 도27 은 분산병렬 시뮬레이션에서 로컬시뮬레이션들의 제어와 로컬시뮬레이션들의 연결을 수행하는 중앙컴퓨터에서 존재하는 SW서버 모듈을 사용하지 않음(도22 참조)으로 이와 같은 분산병렬 시뮬레이션에서 로컬시뮬레이션들의 제어와 로컬시뮬레이션들의 연결을 각 분산병렬 시뮬레이션의 로컬시뮬레이션 런-타임 모듈들에 분산시켜서 수행되도록 하여야 함으로서 흐름도가 상대적으로 복잡해진다. 별방식의 논리적연결구조(star-based logical interconnection architecture)(도22 참조)에서 분산병렬 시뮬레이션 수행 시에 로컬시뮬레이션들의 제어와 로컬시뮬레이션들의 연결을 수행하는 중앙컴퓨터에 존재하는 SW서버 모듈을 이용하는 경우의 분산처리적병렬시뮬레이션 수행(도25 에서의 서브블럭 S212)의 또 다른 예는 도28 과 도 29에 예시되어 있다. 도28 은 로컬시뮬레이터로 실행되는 로컬시뮬레이션 수행의 흐름도의 일 예를 개략적으로 도시한 도면이고 도29 는 상기 중앙컴퓨터에 존재하는 SW서버 모듈로 수행되는 과정의 흐름도의 일 예를 개략적으로 도시한 도면이다.

위 여러 예들에서 알 수 있는 것과 같이 분산처리적병렬시뮬레이션 수행을 위한 다양한 여러 진행 흐름도들이 존재할 수 있다. 뿐만 아니라, 이 분산처리적병렬시뮬레이션 수행을 위한 진행 흐름도에서의 각 서브블럭의 실행 순서는 전체 진행의 올바른 수행을 방해하지 않는 한 변화될 수 있고, 혹은 2 이상의 서브블럭들도 전체 진행의 올바른 수행을 방해하지 않는 한 동시에 수행되어질 수도 있다.

도28 에서 예시된 분산처리적병렬시뮬레이션 수행을 위한 로컬시뮬레이션 수행의 전체 진행 흐름도를 설명하면, 시작과 종료를 제외하고 총 15개의 서브블럭들로 구성되어 있다.

S498 단계에서 현재 시뮬레이션시간을 0으로 설정하고, S502 단계로 진행한다. S502 단계에서는 로컬시뮬레이션의 현재 시뮬레이션시간 정보를 생성하고, 로컬시뮬레이션의 현재 시뮬레이션시점이 체크포인트를 생성하여야 하는 시점이고 사전에 이미 체크포인트가 생성이 않되었으면 체크포인트를 생성하고, 로컬시뮬레이션의 현재 시뮬레이션시점이 실제롤포워드-시점과 같으면 S518 단계로 진행하고 시뮬레이션 종료시간과 같거나 크면 S522 단계로 진행하고 그렇치 않으면 예상입력을 이용하여 시뮬레이션 진행하여 실제출력 얻음과 동시에 실제출력과 예상출력을 비교하고 S306 단계로 진행한다. S506 단계에서는 S502 단계의 시뮬레이션에서 얻어진 실제출력과 예상출력 비교하여 일치하면 S504 단계로 진행하고, 이 비교가 일치하지 않으면 S508 단계로 진행한다. S504 단계에서는 실제출력의 이벤트시간(변화가 발생한 시간)을 로컬시뮬레이션의 현재 시뮬레이션시간으로 설정하고 S502 단계로 진행한다. S508 단계에서는 시뮬레이션을 일시적으로 멈추고, SW서버 모듈에 롤백 가능성 발생을 전달하고 현재 시뮬레이션시간(롤백가능 시점)도 SW서버 모듈에 전달하고 S510 단계로 진행한다. S510 단계에서는 SW서버 모듈로부터 실제롤백-시간/실제롤-포워드시간을 획득하고 S512 단계로 진행한다. S512 단계에서는 롤백이 필요하면 S514 단계로 진행하고, 롤백이 필요하지 않으면 S516 단계로 진행한다. S516 단계에서는 롤포워드가 필요하면 S502 단계로 진행하고, 롤포워드가 필요하지 않으면 S518 단계로 진행한다. S514 단계에서는 로컬시뮬레이션의 롤백을 실행하고 S518 단계로 진행한다. S518 단계에서는 다른 로컬시뮬레이션에서부터 SW서버 모듈을 통하여 전달되는 실제입력을 이용하여 시뮬레이션하고 얻어진 실제출력을 SW서버 모듈을 통하여 이를 입력으로 사용하는 다른 로컬시뮬레이션으로 전달함과 동시에, 실제입력과 예상입력을 비교하며, 로컬시뮬레이션의 현재 시뮬레이션 시간이 시뮬레이션 종료시간과 같으면 종료하고, 같지 않으면 S520 단계로 진행한다. S520 단계에서는 상기 S518 단계에서 실제입력과 예상입력을 비교하여서 일치된 횟수가 미리 정해진 일정횟수(예로, 3번)이상 일치한지를 판단하여 일정횟수 일치하게 되었으면 S521 단계로 진행하고 그렇치 않으면 S518 단계로 진행한다. S522 단계에서는 다른 로컬시뮬레이션들이 모두 종료되었으면 이 로컬시뮬레이션 수행도 종료하게 되고, 그렇치 않으면 S524 단계로 진행한다. S524 단계에서는 이 로컬시뮬레이션의 롤백의 필요성이 있는지로 조사하여 필요하지 않으면 S522 단계로 진행하고 롤백의 필요성이 있으면 S526 단계로 진행한다. S526 단계에서는 실제롤백-시점 결정 후에 롤백을 실행하고, S518 단계로 진행한다.

도29 에서 예시된 분산처리적병렬시뮬레이션 수행을 위한 SW서버 모듈의 로컬시뮬 레이션 수행의 전체 진행 흐름도를 설명하면, 시작과 종료를 제외하고 총 10개의 서브블럭들로 구성되어 있다. S598 단계에서 현재 시뮬레이션시간을 0으로 설정하고, S602 단계로 진행한다. S602 단계에서 모든 로컬시뮬레이션들을 예상입출력이용-런 방식으로 진행되도록 제어하면서 각 로컬시뮬레이션들의 현재 시뮬레이션시간들을 조사하고 S606 단계로 진행한다. S606 단계에서는 현재 예상입출력이용-런 방식으로 진행되는 1 이상의 로컬시뮬레이션에서 롤백가능성이 발생했는지를 조사하여 발생하지 않은 경우에는 S604 단계로 진행하고 발생한 경우에는 S608 단계로 진행한다. S604 단계에서는 모든 로컬시뮬레이션들의 현재 시뮬레이션시간들이 시뮬레이션 종료시간이 되면 종료하고, 그렇치 않으면 S602 단계로 진행한다. S608 단계에서는 모든 롤백가능성 발생한 로컬시뮬레이션들에서부터 롤백가능 시점들 획득하여 실제롤백-시간/실제롤-포워드시간 계산하고, 각 로컬시뮬레이션들별로 예상입출력이용-런 방식 수행 내지는 실제입출력이용-런 방식 수행을 결정하고, 실제입출력이용-런 방식으로 수행되어야 하는 로컬시뮬레이션들 각각에 대하여 각 로컬시뮬레이션들별로 롤백 내지는 롤포워드 결정하고, 실제입출력이용-런 방식으로 수행되어야 하는 각 로컬시뮬레이션들별로 롤백 실행 내지는 롤포워드가 수행되도록 각각 제어하고 S610 단계로 진행한다. S610 단계에서는 1 이상의 로컬시뮬레이션에서 실제입출력이용-런 방식에서 예상입출력이용-런 방식으로의 전환 조건이 만족하는지를 조사하여서 만족하면 S612 단계로 진행하고 만족하지 않으면 S614 단계로 진행한다. S612 단계에서는 예상입출력이용-런 방식으로 전환 가능한 로컬시뮬레이션의 수행 방식을 예상입출력이용-런 방식으로 전환하고 S614 단계로 진행한다. S614 단계에서는, 로컬시뮬레이션들 개개별로 예상입출력이용-런 방식 수행 가능 로컬시뮬레이션은 예상입출력이용-런 방식의 수행, 나머지 로컬시뮬레이션들은 실제입출력이용-런 방식의 수행이 진행되도록 제어하면서, 각 로컬시뮬레이션들의 현재 시뮬레이션시간들을 조사하고 S616 단계로 진행한다. S616 단계에서는 현재 예상입출력이용-런 방식으로 진행되는 1 이상의 로컬시뮬레이션에서 롤백가능성이 발생한지를 조사하여, 발생한 경우에는 S608 단계로 진행하고 발생하지 않은 경우에는 S618 단계로 진행한다. S618 단계에서는 모든 로컬시뮬레이션들의 현재 시뮬레이션시간들이 시뮬레이션시간이 되면 종료하고, 그렇치 않으면 S610 단계로 진행한다.

도29 에서 예시된 분산처리적병렬시뮬레이션 수행을 위한 SW서버 모듈의 로컬시뮬레이션 수행의 전체 진행 흐름도에서는 각 로컬시뮬레이션별로 독립적으로 예상입출력이용-런 방식의 진행 내지는 실제입출력이용-런 방식의 진행이 가능하도록 SW서버 모듈이 분산처리적병렬시뮬레이션 수행을 제어하고 있다. 그러나, 앞서서 이미 설명한 것과 같이 또 다른 구성에서는 분산처리적병렬시뮬레이션 수행을 위한 SW서버 모듈의 분산처리적병렬시뮬레이션 수행제어가 모든 로컬시뮬레이션들이 모두 다 예상입출력이용-런 방식으로 진행되는 경우에만 예상입출력이용-런 방식의 진행이 이루어지도록 하고, 나머지 상황에서는 실제입출력이용-런 방식으로 모든 로컬시뮬레이션들이 진행되도록 제어될 수 있도록 하는 것도 가능한데, 이 같은 경우는 시뮬레이션의 성능을 최대화하는 것에는 약점이 있으나 제어의 단순함에 있어서 장점이 있다.

도 30과 도 31은, 도 8의 본 특허에서 제시한 분산처리적병렬시뮬레이션을 위하여 부가되는 부가 코드 내부를 구성하는 컴퍼넌트들 각각에 대하여 이들의 행태를 모조코드(pseudo code) 형식으로 구술한 예를 개략적으로 도시한 도면이다. 이와 같은 부가 코드의 컴퍼넌트들을 최대한 합성가능한 형태로 만들어서 부가한다면 하드웨어기반검증플랫폼상에서도 구현되어질 수 있는 추가적인 장점을 가질 수 있다. 따라서 다시 한번 강조할 것은, 본 특허에서 “시뮬레이션”이라 함은 1 내지는 2 이상의 시뮬레이터만을 이용한 순수한 시뮬레이션뿐만 아니라 1 내지는 2 이상의 시뮬레이터와 1 내지는 2 이상의 하드웨어기반검증플랫폼을 이용한 시뮬레이션가속도 포함하는 것이라는 것이다. 따라서, 본 특허에서의 분산처리적병렬시뮬레이션 환경을 구성하는 각 로컬시뮬레이션은 로컬시뮬레이터에서 수행되어질 수 있을 뿐만 아니라, 로컬하드웨어기반검증플랫폼에서 시뮬레이션가속 방식으로 수행되어 질 수도 있다는 것도 다시 한번 강조한다.

뿐만 아니라, 본 특허에서 제시한 분산처리적병렬시뮬레이션 방법은 트란젝션 수준에서부터 게이트 수준으로까지의 구체화 과정에 적용되어질 수 있을 뿐만 아니라, 다른 추상화 수준들에서의 구체화 과정에서도 적용되어질 수 있다.

상술한 바와 같이, 본 발명의 효과는 초대규모급 설계를 ESL 기반에서 수행하는 경우에 추상화 상위수준 모델을 이용한 시뮬레이션의 결과를 활용하여서 추상화 하위수준 모델에 대한 검증을 신속하게 수행하는 것이 가능함으로서 전체 설계 검증의 시간을 대폭적으로 단축하고 검증의 효율성을 크게 높이는 것이 가능하다.

뿐만 아니라, 본 발명의 또 다른 효과는 시스템 수준에서부터 게이트 수준까지 진행되는 설계를 점진적 구체화를 통하여 진행하는 과정에 적용되는 검증 과정을 설계 과정과 같이 점진적 구체화를 통하여서 효과적으로 진행할 수 있는 체계적인 검증 방법을 제공한다.

본 발명의 또 다른 효과는, 점진적 구체화를 통하여 진행되는 설계에서 진행되는 검증이 점진적 구체화 과정을 통하여 추상화 하위 단계로 진행될수록 검증 속도가 크게 떨어지는 문제점을 해결하는 체계적인 검증 방법을 제공한다.

본 발명의 또 다른 효과는, 설계 및 검증을 추상화 상위수준에서부터 추상화 하위수준으로까지 점진적 구체화 방식으로 진행되는 전체 과정이 체계적이며 자동화된 방식으로 진행될 수 있도록 한다.

본 발명의 또 다른 효과는, 여러 추상화 수준들에서 존재하는 2 이상의 모델들간의 모델 일관성을 효과적으로 유지하는 체계적인 검증 방법을 제공한다.

본 발명의 또 다른 효과는, 체계적으로 유지된 모델 일관성에 근거하여서 추상화 상위 수준에서의 모델을 레퍼런스 모델로 활용하여서 점진적 구체화 과정을 통하여 추상화 하위 수준의 모델을 효과적으로 검증하는 방법을 제공한다.

본 발명의 또 다른 효과는, 분산병렬 시뮬레이션에서의 동기 오버헤드와 통신 오버헤드를 효과적으로 줄임으로서 분산병렬 시뮬레이션의 속도를 높이는 방법을 제공한다.

본 발명의 또 다른 효과는, 점진적 구체화 과정을 통한 설계 과정에서 발견되는 설계오류들을 제거하는 디버깅 과정을 체계적으로 수행할 수 있도록 함으로서 신속한 디버깅을 통한 설계 오류를 수정하는 방법을 제공한다.

이상 설명한 내용을 통해 당업자라면 본 발명의 기술사상을 일탈하지 아니하는 범위에서 다양한 변경 및 수정이 가능함을 알 수 있을 것이다. 따라서, 본 발명의 기술적 범위는 실시 예에 기재된 내용으로 한정되는 것이 아니라 특허 청구의 범위에 의하여 정하여져야만 한다.

Claims (66)

1. 검증 소프트웨어와 1 내지는 2 이상의 시뮬레이터를 구비하는 설계검증 장치에 있어서,

   상기 검증 소프트웨어는 설계검증 대상이 되는 시뮬레이션이 가능한 1 이상의 모델 내지는 시뮬레이션 환경 내지는 시뮬레이션이 가능한 1 이상의 모델과 시뮬레이션 환경에 부가적인 부가 코드를 추가하여, 상기 1 이상의 모델 중에서 특정한 모델을 이용한 앞단 시뮬레이션을 수행하면서 상기 1 이상의 모델 중에서 상기 특정한 모델 내지는 다른 특정한 모델 전체 내지는 모델 내에 존재하는 1 이상의 설계객체를 대상으로 하는 후단 시뮬레이션을 시뮬레이션 전체 시간구간에서 병렬적으로 수행하거나 내지는 시뮬레이션 특정 시간구간에서만 수행하는데 필요한 동적정보를 상기 앞단 시뮬레이션 과정에서 자동적으로 수집할 수 있도록 하고, 앞단 시뮬레이션을 상기 동적정보를 수집하면서 빠르게 수행하고, 이 수집된 동적정보를 이용하여 상기 1 이상의 모델 중에서 상기 특정한 모델 내지는 다른 특정한 모델 전체 내지는 모델 내에 존재하는 1 이상의 설계객체를 대상으로 하는 상기 후단 시뮬레이션을 신속하게 수행하는 설계 검증 장치.
2. 검증 소프트웨어와 1 내지는 2 이상의 시뮬레이터와 1 내지는 2 이상의 하드웨어기반검증플랫폼을 구비하는 설계검증 장치에 있어서,

   상기 검증 소프트웨어는 설계검증 대상이 되는 시뮬레이션이 가능한 1 이상의 모델 내지는 시뮬레이션 환경 내지는 시뮬레이션이 가능한 1 이상의 모델과 시뮬레이션 환경에 부가적인 부가 코드를 추가하여, 상기 1 이상의 모델 중에서 특정한 모델을 이용한 앞단 시뮬레이션을 수행하면서 상기 1 이상의 모델 중에서 상기 특정한 모델 내지는 다른 특정한 모델 전체 내지는 모델 내에 존재하는 1 이상의 설계객체를 대상으로 하는 후단 시뮬레이션을 시뮬레이션 전체 시간구간에서 병렬적으로 수행하거나 내지는 시뮬레이션 특정 시간구간에서만 수행하는데 필요한 동적정보를 상기 앞단 시뮬레이션 과정에서 자동적으로 수집할 수 있도록 하고, 앞단 시뮬레이션을 상기 동적정보를 수집하면서 빠르게 수행하고, 이 수집된 동적정보를 이용하여 상기 1 이상의 모델 중에서 상기 특정한 모델 내지는 다른 특정한 모델 전체 내지는 모델 내에 존재하는 1 이상의 설계객체를 대상으로 하는 상기 후단 시뮬레이션을 신속하게 수행하는 설계 검증 장치.
3. 설계 검증을 위하여 1 이상의 모델을 대상으로 하는 시뮬레이션에 있어서,

   상기 시뮬레이션을 앞단 시뮬레이션 단계와 후단 시뮬레이션 단계로 나누어서 수행하며, 상기 앞단 시뮬레이션을 상기 1 이상의 모델중의 특정 모델을 대상으로 수행하면서 상기 후단 시뮬레이션을 시뮬레이션 전체 시간구간에서 병렬적으로 수행하거나 내지는 시뮬레이션 특정 시간구간에서만 수행하는데 필요한 동적정보를 상기 앞단 시뮬레이션 과정에서 자동적으로 수집하는 단계와, 이 수집된 동적정보를 이용하여 상기 1 이상의 모델 중의 동일 특정 모델 내지는 별도의 특정 모델 전체 내지는 모델 내에 존재하는 1 이상의 설계객체를 대상으로 하는 상기 후단 시뮬레이 션을 시뮬레이션 전체 시간구간에서 병렬적으로 수행하거나 내지는 시뮬레이션 특정 시간구간에서 신속하게 수행하는 단계를 포함하는 시뮬레이션 방법.
4. 설계 검증을 위하여 1 이상의 모델을 대상으로 하는 시뮬레이션에 있어서,

   상기 시뮬레이션을 앞단 시뮬레이션 단계와 후단 시뮬레이션 단계로 나누어서 수행하며, 상기 앞단 시뮬레이션을 상기 1 이상의 모델중의 특정 모델을 대상으로 수행하면서 상기 후단 시뮬레이션을 시뮬레이션 전체 시간구간에서 병렬적으로 수행하거나 내지는 시뮬레이션 특정 시간구간에서만 수행하는데 필요한 동적정보를 상기 앞단 시뮬레이션 과정에서 자동적으로 수집하는 단계와, 상기 앞단 시뮬레이션에서 수집된 동적정보를 s-DCP 정확도증강 과정을 통하여 정확도가 향상된 동적정보로 변환하는 단계 내지는 t-DCP 정확도증강 과정을 통하여 정확도가 향상된 동적정보로 변환하는 단계와, 상기 정확도가 향상된 동적정보를 이용하여 상기 1 이상의 모델 중의 동일 특정 모델 내지는 별도의 특정 모델 전체 내지는 모델 내에 존재하는 1 이상의 설계객체를 대상으로 하는 상기 후단 시뮬레이션을 시뮬레이션 전체 시간구간에서 병렬적으로 수행하거나 내지는 시뮬레이션 특정 시간구간에서 신속하게 수행하는 단계를 포함하는 시뮬레이션 방법.
5. 제 3 항 내지는 제 4 항에 있어서,

   상기 앞단 시뮬레이션에서 사용하는 모델과 후단 시뮬레이션에서 사용하는 모델의 추상화 수준이 다른 시뮬레이션 방법.
6. 제 3 항 내지는 제 4 항에 있어서,

   상기 앞단 시뮬레이션에서 사용하는 모델의 추상화 수준이 후단 시뮬레이션에서 사용하는 모델의 추상화 수준보다 높으며, 후단 시뮬레이션에서 사용하는 모델의 추상화 수준이 원래의 설계 검증 대상이 되는 모델의 추상화 수준과 동일하며 후단 시뮬레이션에서 사용하는 모델이 원래의 설계 검증 대상인 시뮬레이션 방법.
7. 제 3 항 내지는 제 4 항에 있어서,

   상기 앞단 시뮬레이션에서 사용하는 모델과 후단 시뮬레이션에서 사용하는 모델의 추상화 수준이 동일한 시뮬레이션 방법.
8. 제 3 항 내지는 제 4 항에 있어서,

   상기 앞단 시뮬레이션에서 수집되는 동적정보가 s-DCP 내지는 t-DCP인 시뮬레이션 방법.
9. 제 3 항 내지는 제 4 항에 있어서,

   상기 동적정보가 1 이상의 시뮬레이션 특정 시점 내지는 1 이상의 시뮬레이션 특정 구간들에서의 모델 전체 내지는 모낼 내에 존재하는 1 이상의 설계객체에 존재하는 상태정보를 포함하는 시뮬레이션 방법.
10. 제 3 항 내지는 제 4 항에 있어서,

    상기 동적정보가 모델 내에 존재하는 1 이상의 설계객체의 입출력정보 내지는 입력정보 내지는 출력정보를 포함하는 시뮬레이션 방법.
11. 제 3 항 내지는 제 4 항에 있어서,

    상기 동적정보가 모델 내에 존재하는 1 이상의 설계객체의 시뮬레이션 전체 시간구간 내지는 1 이상의 특정 시간구간의 입출력정보 내지는 입력정보 내지는 출력정보를 포함하는 시뮬레이션 방법.
12. 제 3 항 내지는 제 4 항에 있어서,

    상기 동적정보가 추상화 상위수준 모델 내에 존재하는 부분계층대응관계에 있는 모든 설계객체들의 시뮬레이션 전체 시간구간 내지는 1 이상의 특정 시간구간의 입출력정보 내지는 입력정보 내지는 출력정보를 포함하는 시뮬레이션 방법.
13. 제 3 항 내지는 제 4 항에 있어서,

    상기 병렬적으로 수행되는 후단 시뮬레이션이 분산처리적병렬수행인 시뮬레이션 방법.
14. 제 3 항 내지는 제 4 항에 있어서,

    상기 병렬적으로 수행되는 후단 시뮬레이션이 시간분할적병렬수행인 시뮬레이션 방 법.
15. 제 3 항 내지는 제 4 항 내지는 제 13 항에 있어서,

    상기 병렬적으로 수행되는 후단 시뮬레이션이 분산처리적병렬수행인 검증 방법이며 앞단 시뮬레이션에서 수집된 s-DCP를 이용하거나 내지는 정확도를 증강시킨 s-DCP를 이용하여서 분산처리적병렬수행으로 진행되는 후단 시뮬레이션에서 예상입출력이용-런 방식으로 진행되는 시뮬레이션 시간구간을 최대한으로 하는 시뮬레이션 방법.
16. 제 3 항 내지는 제 4 항 내지는 제 13 항에 있어서,

    상기 병렬적으로 수행되는 후단 시뮬레이션이 분산처리적병렬수행인 검증 방법이며 앞단 시뮬레이션에서 수집된 s-DCP를 이용하거나 내지는 정확도를 증강시킨 s-DCP를 이용하여서 분산처리적병렬수행으로 진행되는 후단 시뮬레이션에서 롤백 실행 횟수를 최소화하는 시뮬레이션 방법.
17. 제 3 항 내지는 제 4 항 내지는 제 13 항에 있어서,

    상기 병렬적으로 수행되는 후단 시뮬레이션이 분산처리적병렬수행인 검증 방법이며 앞단 시뮬레이션에서 수집된 s-DCP를 이용하거나 내지는 정확도를 증강시킨 s-DCP를 이용하여서 분산처리적병렬수행으로 진행되는 후단 시뮬레이션에서 예상출력/실제출력 불일치 횟수를 최소화하는 시뮬레이션 방법.
18. 설계 검증을 위하여 특정 게이트수준 모델을 대상으로 하는 게이트수준 타이밍 시뮬레이션에 있어서,

    상기 게이트수준 타이밍 시뮬레이션을 위하여 앞단 시뮬레이션 단계와 후단 시뮬레이션 단계를 수행하며, 상기 앞단 시뮬레이션을 상기 특정 게이트수준 모델보다 추상화수준이 높은 상이한추상수준 동일모델로 수행하면서 상기 후단 시뮬레이션을 분산병렬 게이트수준 타이밍 시뮬레이션으로 수행하는데 필요한 동적정보를 상기 앞단 시뮬레이션 과정에서 자동적으로 수집하는 단계와, 상기 앞단 시뮬레이션에서 수집된 동적정보를 s-DCP 정확도증강 과정을 통하여 정확도가 향상된 동적정보로 변환하는 단계로서 상기 특정 게이트수준 모델에 존재하는 2 이상의 설계객체들을 대상으로 상기 앞단 시뮬레이션에서 수집된 동적정보를 입력정보로 이용하여서 수행하는 2 이상의 게이트수준 타이밍 시뮬레이션들 각각을 독립적으로 진행함으로서 정확도가 향상된 동적정보를 얻는 단계와, 상기 정확도가 향상된 동적정보에서부터 구해지는 분산병렬 시뮬레이션의 각 로컬시뮬레이션의 예상입력과 예상출력을 이용하여 상기 특정 게이트수준 모델 전체를 대상으로 하는 상기 후단 시뮬레이션을 통신 오버헤드 내지는 동기 오버헤드를 최소화한 분산병렬 게이트수준 타이밍 시뮬레이션으로 수행하는 단계를 포함하는 시뮬레이션 방법.
19. 설계 검증을 위하여 특정 추상화 수준의 모델을 대상으로 하는 분산병렬 시뮬레이션에 있어서 상기 분산병렬 시뮬레이션의 1 이상의 로컬시뮬레이션이 시뮬레이션 수행의 예상입력과 예상출력을 이용하는 분산병렬 시뮬레이션에 있어서,

    상기 분산병렬 시뮬레이션 수행이 상기 1 이상의 로컬시뮬레이션 수행을 다른 로컬시뮬레이션들과의 통신과 동기화를 생략하고 상기 예상입력으로 독립적으로 진행할 수 있는지를 판단하는 단계와, 상기 1 이상의 로컬시뮬레이션 수행에 의하여 얻어지는 실제출력과 상기 예상출력이 일치하는지를 판단하는 단계와, 예상입출력이용-런 방식의 수행에서 실제입출력이용-런 방식으로의 전환을 판단하는 단계와, 롤백이 필요한지를 판단하고 롤백이 필요시에 롤백을 수행하는 단계와, 실제입출력이용-런 방식의 수행에서 예상입출력이용-런 방식으로의 전환을 판단하는 단계를 포함하는 분산병렬 시뮬레이션 방법.
20. 설계 검증을 위하여 특정 추상화 수준의 모델을 대상으로 하는 분산병렬 시뮬레이션에 있어서 상기 분산병렬 시뮬레이션에서의 1 이상의 로컬시뮬레이션이 분산병렬 시뮬레이션 수행에 앞서서 상기 특정 추상화 수준의 모델 내지는 상이한추상수준 동일모델을 대상으로 하여서 수행된 1 이상의 이전 시뮬레이션 수행과정에서 얻어진 동적정보에서부터 구해지는 상기 1 이상의 로컬시뮬레이션 수행의 예상입력과 예상출력을 이용하는 분산병렬 시뮬레이션에 있어서,

    상기 분산병렬 시뮬레이션 수행이 상기 1 이상의 로컬시뮬레이션 수행을 다른 로컬시뮬레이션들과의 통신과 동기화를 생략하고 상기 예상입력으로 독립적으로 진행할 수 있는지를 판단하는 단계와, 상기 1 이상의 로컬시뮬레이션 수행에 의하여 얻어지는 실제출력과 상기 예상출력이 일치하는지를 판단하는 단계와, 예상입출력이용- 런 방식의 수행에서 실제입출력이용-런 방식으로의 전환을 판단하는 단계와, 롤백이 필요한지를 판단하고 롤백이 필요시에 롤백을 수행하는 단계와, 실제입출력이용-런 방식의 수행에서 예상입출력이용-런 방식으로의 전환을 판단하는 단계를 포함하는 분산병렬 시뮬레이션 방법.
21. 설계 검증을 위하여 특정 추상화 수준의 모델을 대상으로 하는 시뮬레이션에 있어서,

    상기 시뮬레이션을 분산병렬 시뮬레이션으로 수행하며, 상기 시뮬레이션을 분산병렬 시뮬레이션으로 수행하는 과정에서 1 이상의 로컬시뮬레이션이 상기 시뮬레이션 수행에 앞서서 상기 특정 추상화 수준의 모델 내지는 상이한추상수준 동일모델을 대상으로 하여서 수행된 1 이상의 이전 시뮬레이션 수행과정에서 얻어진 동적정보를 이용함으로서 상기 분산병렬 시뮬레이션의 수행속도를 높이는 시뮬레이션 방법.
22. 제 21 항 내지는 제 49 항에 있어서,

    상기 이전 시뮬레이션 수행과정에서 얻어진 동적정보를 이용함으로서 분산병렬 시뮬레이션의 동기 오버헤드 내지는 통신 오버헤드를 최소화함으로서 분산병렬 시뮬레이션의 수행속도를 높이는 시뮬레이션 방법.
23. 제 21 항 내지는 제 22 항 내지는 제 49 항에 있어서,

    상기 이전 시뮬레이션 수행과정에서 얻어진 동적정보가 해당 모델에 존재하는 1 이 상의 설계객체들에 존재하는 입출력정보 내지는 입력정보 내지는 출력정보이며 이 입출력정보 내지는 입력정보 내지는 출력정보를 이용함으로서 분산병렬 시뮬레이션의 동기 오버헤드 내지는 통신 오버헤드를 최소화함으로서 분산병렬 시뮬레이션의 수행속도를 높이는 시뮬레이션 방법.
24. 제 21 항 내지는 제 22 항 내지는 제 23 항 내지는 제 49 항에 있어서,

    상기 이전 시뮬레이션 수행과정에서 얻어진 동적정보가 해당 모델에 존재하는 1 이상의 설계객체들에 존재하는 입출력정보 내지는 입력정보 내지는 출력정보이며 이 입출력정보 내지는 입력정보 내지는 출력정보를 상기 1 이상의 로컬시뮬레이션에서의 예상입력과 예상출력 내지는 예상입력 내지는 예상출력으로 이용함으로서 분산병렬 시뮬레이션의 동기 오버헤드 내지는 통신 오버헤드를 최소화함으로서 분산병렬 시뮬레이션의 수행속도를 높이는 시뮬레이션 방법.
25. 제 21 항 내지는 제 22 항 내지는 제 23 항 내지는 제 49 항에 있어서,

    상기 이전 시뮬레이션 수행과정에서 얻어진 동적정보에서부터 구해지는 상기 분산병렬 시뮬레이션의 1 이상의 로컬시뮬레이션에서의 예상입력과 예상출력을 이용하거나 내지는 예상입력을 이용하거나 내지는 예상출력을 이용함으로서 분산병렬 시뮬레이션의 동기 오버헤드 내지는 통신 오버헤드를 최소화함으로서 분산병렬 시뮬레이션의 수행속도를 높이는 시뮬레이션 방법.
26. 제 21 항 내지는 제 22 항 내지는 제 23 항 내지는 제 24 항 내지는 제 25 항 내지는 제 48 항 내지는 제 49 항 내지는 제 52 항에 있어서,

    상기 이전 시뮬레이션 수행이 상기 설계 검증을 위하여 특정 추상화 수준의 모델을 대상으로 하는 시뮬레이션의 대상이 되는 모델의 특정 추상화 수준보다 추상화 수준이 높은 모델을 이용한 시뮬레이션인 검증 방법.
27. 추상화 상위 수준에서 존재하는 모델 내지는 이 모델 내의 1 이상의 설계객체들을 대상으로 하는 1회 이상의 시뮬레이션에서 얻어지는 상기 모델 내지는 이 모델 내의 1 이상의 설계객체들의 s-DCP 내지는 t-DCP를 활용하여서 상기 추상화 상위 수준보다 추상화 수준이 낮은 하위 수준에서 존재하는 모델 내지는 이 모델 내의 1 이상의 설계객체들에 대한 1회 이상의 시뮬레이션을 병렬적으로 내지는 순차적으로 내지는 병렬적과 순차적을 혼합하여서 수행하는 시뮬레이션을 진행함으로서, 추상화 상위 수준에서부터 추상화 하위 수준으로 점진적 구체화 방식으로 진행되는 추상화 단계별 검증 과정에서 추상화 하위 수준에서 이루어지는 시뮬레이션을 빠르게 하는 과정을 포함하는 검증 방법.
28. 추상화 상위 수준에서 존재하는 모델 내지는 이 모델 내의 1 이상의 설계객체들을 대상으로 하는 1회 이상의 시뮬레이션에서 얻어지는 상기 모델 내지는 이 모델 내의 1 이상의 설계객체들의 s-DCP 내지는 t-DCP를 활용하여서 상기 추상화 상위 수준보다 추상화 수준이 낮은 하위 수준으로 존재하는 모델 내지는 이 모델 내의 1 이상의 설계객체들에 대한 1회 이상의 시뮬레이션을 병렬적으로 내지는 순차적으로 내지는 병렬적과 순차적을 혼합하여서 수행하는 시뮬레이션을 통하여 얻어지는 시뮬레이션 결과를 활용함으로서, 추상화 상위 수준에서부터 추상화 하위 수준으로 점진적 구체화 방식으로 진행되는 추상화 단계별 검증 과정에서 추상화 상위 수준에서 존재하는 상위 모델과 이 상위 모델이 구체화 과정을 통하여 변환되어져서 추상화 하위 수준에서 존재하게 되는 하위 모델과의 일관성 내지는 등가성을 조사하는 과정을 포함하는 검증 방법.
29. 제 27 항 내지는 제 28 항 에 있어서,

    추상화 하위 수준으로 존재하는 모델 내지는 이 모델 내의 1 이상의 설계객체들에 대한 1회 이상의 병렬적 시뮬레이션이 분산처리적병렬수행 내지는 시간분할적병렬수행을 포함하는 시뮬레이션 방법.
30. 추상화 상위수준의 모델을 이용한 추상화 상위수준의 시뮬레이션 결과를 활용하여 추상화 하위수준의 모델을 이용하는 추상화 하위수준의 시뮬레이션의 전체 내지는 일부분을 분산처리적병렬수행 내지는 시간분할적병렬수행 방식으로 진행함으로서 추상화 하위수준의 시뮬레이션 결과를 얻고, 상기 추상화 상위수준의 시뮬레이션 결과와 상기 추상화 하위수준의 시뮬레이션 결과를 비교하여 추상화 상위수준 모델과 추상화 하위수준 모델 간에 모델 일관성이 있음을 판단하거나 내지는 추상화 상위수준 모델과 추상화 하위수준 모델 사이에 존재하는 모델 불일관성의 원인을 파 악하고 이 모델 불일관성의 원인을 제거함으로서 상기 시뮬레이션에서 사용된 입력 조건하에서 상기 추상화 상위수준 모델과 추상화 하위수준 모델 간에 모델 일관성을 유지하도록 하는 검증 방법.
31. 설계 검증을 위하여 특정 게이트수준 모델을 대상으로 하는 게이트수준 타이밍 시뮬레이션에 있어서,

    상기 게이트수준 타이밍 시뮬레이션을 위하여 앞단 시뮬레이션 단계와 후단 시뮬레이션 단계를 수행하며, 상기 앞단 시뮬레이션을 상기 특정 게이트수준 모델보다 추상화수준이 높은 상이한추상수준 동일모델로 수행하면서 상기 후단 시뮬레이션을 분산병렬 게이트수준 타이밍 시뮬레이션으로 수행하는데 필요한 동적정보를 상기 앞단 시뮬레이션 과정에서 자동적으로 수집하는 단계와, 상기 수집된 동적정보로부터 분산병렬 시뮬레이션의 각 로컬시뮬레이션의 예상입력과 예상출력을 구하는 단계와, 이 예상입력과 예상출력을 로컬시뮬레이션에 이용함으로서 상기 특정 게이트수준 모델 전체를 대상으로 하는 상기 후단 시뮬레이션을 통신 오버헤드 내지는 동기 오버헤드를 최소화한 분산병렬 게이트수준 타이밍 시뮬레이션으로 수행하는 단계를 포함하는 검증 방법.
32. 설계 검증을 위하여 특정 RTL 모델을 대상으로 하는 RTL 시뮬레이션에 있어서,

    상기 RTL 시뮬레이션을 위하여 앞단 시뮬레이션 단계와 후단 시뮬레이션 단계를 수행하며, 상기 앞단 시뮬레이션을 상기 특정 RTL 모델보다 추상화수준이 높은 상이 한추상수준 동일모델로 수행하면서 상기 후단 시뮬레이션을 분산병렬 RTL 시뮬레이션으로 수행하는데 필요한 동적정보를 상기 앞단 시뮬레이션 과정에서 자동적으로 수집하는 단계와, 상기 앞단 시뮬레이션에서 수집된 동적정보를 s-DCP 정확도증강 과정을 통하여 정확도가 향상된 동적정보로 변환하는 단계로서 상기 특정 RTL 모델에 존재하는 2 이상의 설계객체들을 대상으로 상기 앞단 시뮬레이션에서 수집된 동적정보를 입력정보로 이용하여서 수행하는 2 이상의 RTL 시뮬레이션들 각각을 독립적으로 진행함으로서 정확도가 향상된 동적정보를 얻는 단계와, 상기 수집된 동적정보로부터 분산병렬 시뮬레이션의 각 로컬시뮬레이션의 예상입력과 예상출력을 구하는 단계와, 이 예상입력과 예상출력을 로컬시뮬레이션에 이용함으로서 상기 특정 RTL 모델 전체를 대상으로 하는 상기 후단 시뮬레이션을 통신 오버헤드 내지는 동기 오버헤드를 최소화한 분산병렬 RTL 시뮬레이션으로 수행하는 단계를 포함하는 검증 방법.
33. 설계 검증을 위하여 특정 RTL 모델을 대상으로 하는 RTL 시뮬레이션에 있어서,

    상기 RTL 시뮬레이션을 위하여 앞단 시뮬레이션 단계와 후단 시뮬레이션 단계를 수행하며, 상기 앞단 시뮬레이션을 상기 특정 RTL 모델보다 추상화수준이 높은 상이한추상수준 동일모델로 수행하면서 상기 후단 시뮬레이션을 분산병렬 RTL 시뮬레이션으로 수행하는데 필요한 동적정보를 상기 앞단 시뮬레이션 과정에서 자동적으로 수집하는 단계와, 상기 수집된 동적정보로부터 분산병렬 시뮬레이션의 각 로컬시뮬레이션의 예상입력과 예상출력을 구하는 단계와, 이 예상입력과 예상출력을 로컬시 뮬레이션에 이용함으로서 상기 특정 RTL 모델 전체를 대상으로 하는 상기 후단 시뮬레이션을 통신 오버헤드 내지는 동기 오버헤드를 최소화한 분산병렬 RTL 시뮬레이션으로 수행하는 단계를 포함하는 검증 방법.
34. 설계 검증을 위하여 특정 트란젝션 모델을 대상으로 하는 특정 트란젝션수준 시뮬레이션에 있어서,

    상기 특정 트란젝션수준 시뮬레이션을 위하여 앞단 시뮬레이션 단계와 후단 시뮬레이션 단계를 수행하며, 상기 앞단 시뮬레이션을 상기 특정 트란젝션 모델보다 추상화수준이 높은 상이한추상수준 동일모델로 수행하면서 상기 후단 시뮬레이션을 분산병렬 트란젝션수준 시뮬레이션으로 수행하는데 필요한 동적정보를 상기 앞단 시뮬레이션 과정에서 자동적으로 수집하는 단계와, 상기 앞단 시뮬레이션에서 수집된 동적정보를 s-DCP 정확도증강 과정을 통하여 정확도가 향상된 동적정보로 변환하는 단계로서 상기 특정 트란젝션 모델에 존재하는 2 이상의 설계객체들을 대상으로 상기 앞단 시뮬레이션에서 수집된 동적정보를 입력정보로 이용하여서 수행하는 2 이상의 트란젝션수준 시뮬레이션들 각각을 독립적으로 진행함으로서 정확도가 향상된 동적정보를 얻는 단계와, 상기 정확도가 향상된 동적정보에서부터 구해지는 분산병렬 시뮬레이션의 각 로컬시뮬레이션의 예상입력과 예상출력을 이용하여 상기 특정 트란젝션 모델 전체를 대상으로 하는 상기 후단 시뮬레이션을 통신 오버헤드 내지는 동기 오버헤드를 최소화한 분산병렬 트란젝션수준 시뮬레이션으로 수행하는 단계를 포함하는 검증 방법.
35. 설계 검증을 위하여 특정 트란젝션 모델을 대상으로 하는 특정 트란젝션수준 시뮬레이션에 있어서,

    상기 특정 트란젝션수준 시뮬레이션을 위하여 앞단 시뮬레이션 단계와 후단 시뮬레이션 단계를 수행하며, 상기 앞단 시뮬레이션을 상기 특정 트란젝션 모델보다 추상화수준이 높은 상이한추상수준 동일모델로 수행하면서 상기 후단 시뮬레이션을 분산병렬 트란젝션수준 시뮬레이션으로 수행하는데 필요한 동적정보를 상기 앞단 시뮬레이션 과정에서 자동적으로 수집하는 단계와, 상기 수집된 동적정보로부터 분산병렬 시뮬레이션의 각 로컬시뮬레이션의 예상입력과 예상출력을 구하는 단계와, 이 예상입력과 예상출력을 로컬시뮬레이션에 이용함으로서 상기 특정 트란젝션 모델 전체를 대상으로 하는 상기 후단 시뮬레이션을 통신 오버헤드 내지는 동기 오버헤드를 최소화한 분산병렬 트란젝션수준 시뮬레이션으로 수행하는 단계를 포함하는 검증 방법.
36. 제 3 항 내지는 제 4 항에 있어서,

    상기 후단 시뮬레이션이 분산처리적병렬수행/단일수행 혼용방식인 시뮬레이션 방법.
37. 제 3 항 내지는 제 4 항 내지는 제 13 항에 있어서,

    상기 후단 시뮬레이션이 분산처리적병렬수행/단일수행 혼용방식인 시뮬레이션 방법 이며 상기 분산처리적병렬수행/단일수행 혼용방식의 후단 시뮬레이션에서의 분산처리적병렬수행이 상기 앞단 시뮬레이션에서 수집된 s-DCP를 이용하거나 내지는 정확도를 증강시킨 s-DCP를 이용하여서 분산처리적병렬수행으로 진행하면서 이 분산처리적병렬수행 과정에서 t-DCP를 수집하고, 이 수집된 t-DCP를 이용하거나 내지는 정확도를 증강시킨 t-DCP를 이용하여서 상기 분산처리적병렬수행/단일수행 혼용방식의 후단 시뮬레이션에서의 단일수행이 진행되는 시뮬레이션 방법.
38. 설계 검증을 위하여 특정 추상화 수준의 모델을 대상으로 하는 시뮬레이션에 있어서 상기 시뮬레이션의 전체 시간구간에서의 특정 시뮬레이션 구간을 분산병렬 시뮬레이션으로 수행하며 상기 분산병렬 시뮬레이션에서의 1 이상의 로컬시뮬레이션이 시뮬레이션 수행의 예상입력과 예상출력을 이용하는 시뮬레이션에 있어서,

    상기 분산병렬 시뮬레이션 수행이 상기 1 이상의 로컬시뮬레이션 수행을 다른 로컬시뮬레이션들과의 통신과 동기화를 생략하고 상기 예상입력으로 독립적으로 진행할 수 있는지를 판단하는 단계와, 상기 1 이상의 로컬시뮬레이션 수행에 의하여 얻어지는 실제출력과 상기 예상출력이 일치하는지를 판단하는 단계와, 분산병렬 시뮬레이션의 수행에서 단일 시뮬레이션으로의 전환을 판단하는 단계를 포함하는 시뮬레이션 방법.
39. 설계 검증을 위하여 특정 추상화 수준의 모델을 대상으로 하는 시뮬레이션에 있어서 상기 시뮬레이션 전체 시간구간에서의 특정 시뮬레이션 구간 내지는 전체 시뮬 레이션 시간구간을 분산병렬 시뮬레이션으로 수행하며 상기 분산병렬 시뮬레이션에서의 1 이상의 로컬시뮬레이션이 시뮬레이션 수행의 예상입력과 예상출력을 이용하는 시뮬레이션에 있어서,

    상기 분산병렬 시뮬레이션 수행이 상기 1 이상의 로컬시뮬레이션 수행을 다른 로컬시뮬레이션들과의 통신과 동기화를 생략하고 상기 예상입력으로 독립적으로 진행할 수 있는지를 판단하는 단계와, 상기 1 이상의 로컬시뮬레이션 수행에 의하여 얻어지는 실제출력과 상기 예상출력이 일치하는지를 판단하는 단계를 포함하는 시뮬레이션 방법.
40. 제 19 항 내지는 제 20 항 내지는 제 38 항 내지는 제 39 항 내지는 제 42 항 내지는 제 43 항 내지는 제 47 항 내지는 제 48 항 내지는 제 54 항 내지는 제 55 항에 있어서,

    현재 수행하고자 하는 시뮬레이션에 시간적으로 앞서서 이루어진 1회 이상의 별도의 시뮬레이션 과정에서 수집된 동적정보로부터 상기 예상입력 내지는 예상출력을 구하는 시뮬레이션 방법.
41. 제 19 항 내지는 제 20 항 내지는 제 38 항 내지는 제 39 항 내지는 제 42 항 내지는 제 43 항 내지는 제 47 항 내지는 제 48 항 내지는 제 54 항 내지는 제 55 항에 있어서,

    현재 수행하고자 하는 시뮬레이션에 시간적으로 앞서서 이루어진 1회 이상의 별도 의 시뮬레이션 과정에서 수집된 시뮬레이션 대상이 되는 모델 내의 1 이상의 설계객체들의 입력정보와 출력정보로부터 상기 예상입력 내지는 예상출력을 구하는 시뮬레이션 방법
42. 설계 검증을 위하여 특정 추상화 수준의 모델을 대상으로 하는 시뮬레이션에 있어서 상기 시뮬레이션의 전체 시간구간에서의 특정 시뮬레이션 구간을 대상으로 진행되는 분산병렬 시뮬레이션에서의 1 이상의 로컬시뮬레이션에서 시뮬레이션 수행의 예상입력과 예상출력을 이용하는 시뮬레이션에 있어서,

    상기 분산병렬 시뮬레이션 수행이 상기 1 이상의 로컬시뮬레이션 수행을 다른 로컬시뮬레이션들과의 통신과 동기화를 생략하고 상기 예상입력으로 독립적으로 진행할 수 있는지를 판단하는 단계와, 상기 1 이상의 로컬시뮬레이션 수행에 의하여 얻어지는 실제출력과 상기 예상출력이 일치하는지를 판단하는 단계와, 분산병렬 시뮬레이션의 수행에서 단일 시뮬레이션으로의 전환을 판단하는 단계를 포함하는 시뮬레이션 방법.
43. 설계 검증을 위하여 특정 추상화 수준의 모델을 대상으로 하는 시뮬레이션에 있어서 상기 시뮬레이션 전체 시간구간에서의 특정 시뮬레이션 구간 내지는 전체 시뮬레이션 시간구간을 대상으로 진행되는 분산병렬 시뮬레이션에서의 1 이상의 로컬시뮬레이션에서 시뮬레이션 수행의 예상입력과 예상출력을 이용하는 시뮬레이션에 있어서,

    상기 분산병렬 시뮬레이션 수행이 상기 1 이상의 로컬시뮬레이션 수행을 다른 로컬시뮬레이션들과의 통신과 동기화를 생략하고 상기 예상입력으로 독립적으로 진행할 수 있는지를 판단하는 단계와, 상기 1 이상의 로컬시뮬레이션 수행에 의하여 얻어지는 실제출력과 상기 예상출력이 일치하는지를 판단하는 단계를 포함하는 시뮬레이션 방법.
44. 제 20 항 내지는 제 21 항 내지는 제 48 항 내지는 제 49 항 내지는 제 52 항에 있어서,

    상기 1 이상의 이전 시뮬레이션 수행과정이 병렬 시뮬레이션이거나 병렬 시뮬레이션을 포함하는 시뮬레이션 방법.
45. 제 3 항 내지는 제 4 항에 있어서,

    상기 동적정보가 모델 내에 존재하는 1 이상의 설계객체의 입력정보를 포함하는 시뮬레이션 방법.
46. 제 3 항 내지는 제 4 항에 있어서,

    상기 동적정보가 모델 내에 존재하는 1 이상의 설계객체의 출력정보를 포함하는 시뮬레이션 방법.
47. 설계 검증을 위하여 특정 추상화 수준의 모델을 대상으로 하는 분산병렬 시뮬레이 션에 있어서 상기 분산병렬 시뮬레이션의 1 이상의 로컬시뮬레이션이 시뮬레이션 수행의 예상입력과 예상출력을 이용하는 분산병렬 시뮬레이션에 있어서,

    상기 분산병렬 시뮬레이션 수행이 상기 1 이상의 로컬시뮬레이션 수행을 다른 로컬시뮬레이션들과의 통신과 동기화를 생략하고 상기 예상입력으로 독립적으로 진행할 수 있는지를 판단하는 단계와, 상기 1 이상의 로컬시뮬레이션 수행에 의하여 얻어지는 실제출력과 상기 예상출력이 일치하는지를 판단하는 단계와, 예상입출력이용-런 방식의 수행에서 실제입출력이용-런 방식으로의 전환을 판단하는 단계와, 실제입출력이용-런 방식의 수행에서 예상입출력이용-런 방식으로의 전환을 판단하는 단계를 포함하는 분산병렬 시뮬레이션 방법.
48. 설계 검증을 위하여 특정 추상화 수준의 모델을 대상으로 하는 분산병렬 시뮬레이션에 있어서 상기 분산병렬 시뮬레이션에서의 1 이상의 로컬시뮬레이션이 분산병렬 시뮬레이션 수행에 앞서서 상기 특정 추상화 수준의 모델 내지는 상이한추상수준 동일모델을 대상으로 하여서 수행된 1 이상의 이전 시뮬레이션 수행과정에서 얻어진 동적정보에서부터 구해지는 상기 1 이상의 로컬시뮬레이션 수행의 예상입력과 예상출력을 이용하는 분산병렬 시뮬레이션에 있어서,

    상기 분산병렬 시뮬레이션 수행이 상기 1 이상의 로컬시뮬레이션 수행을 다른 로컬시뮬레이션들과의 통신과 동기화를 생략하고 상기 예상입력으로 독립적으로 진행할 수 있는지를 판단하는 단계와, 상기 1 이상의 로컬시뮬레이션 수행에 의하여 얻어지는 실제출력과 상기 예상출력이 일치하는지를 판단하는 단계와, 예상입출력이용- 런 방식의 수행에서 실제입출력이용-런 방식으로의 전환을 판단하는 단계와, 실제입출력이용-런 방식의 수행에서 예상입출력이용-런 방식으로의 전환을 판단하는 단계를 포함하는 분산병렬 시뮬레이션 방법.
49. 설계 검증을 위하여 특정 추상화 수준의 모델을 대상으로 하는 시뮬레이션에 있어서,

    상기 시뮬레이션이 분산병렬 시뮬레이션 과정을 포함하여 1 이상의 특정 시뮬레이션 시간구간을 상기 분산병렬 시뮬레이션으로 수행하고, 상기 분산병렬 시뮬레이션 과정에서 1 이상의 로컬시뮬레이션이 상기 시뮬레이션 수행에 앞서서 상기 특정 추상화 수준의 모델 내지는 상이한추상수준 동일모델을 대상으로 하여서 수행된 1 이상의 이전 시뮬레이션 수행과정에서 얻어진 동적정보를 이용함으로서 상기 분산병렬 시뮬레이션의 수행속도를 높이는 시뮬레이션 방법 .
50. 분산처리적병렬수행 방식의 시뮬레이션 내지는 시간분할적병렬수행 방식의 시뮬레이션에서 이용되는 동적정보의 정확도증강 과정에 시간맞춤이 포함된 시뮬레이션 방법.
51. 제 20 항 내지는 제 21 항 내지는 제 48 항 내지는 제 49 항에 있어서,

    상기 이전 시뮬레이션 수행과정과 상기 현 시뮬레이션 수행과정 중간에 설계검증 대상이 되는 특정 추상화 수준의 모델에 존재하는 1 이상의 설계객체가 수정되어진 시뮬레이션 방법 내지는 검증 방법.
52. 설계 검증을 위하여 특정 추상화 수준의 모델을 대상으로 하는 시뮬레이션에 있어서,

    상기 시뮬레이션의 전체 시뮬레이션 시간구간 내지는 1 이상의 특정 시뮬레이션 시간구간을 분산병렬 시뮬레이션 방식으로 수행하고, 상기 분산병렬 시뮬레이션 과정에서의 1 이상의 로컬시뮬레이션이 상기 시뮬레이션 수행에 앞서서 상기 특정 추상화 수준의 모델 내지는 상이한추상수준 동일모델을 대상으로 하여서 수행된 1 이상의 이전 시뮬레이션 수행과정에서 얻어진 동적정보에서 구해지는 상기 분산병렬 시뮬레이션 과정에서의 1 이상의 로컬시뮬레이션의 예상입력과 예상출력을 이용하거나 내지는 예상입력을 이용하거나 내지는 예상출력을 이용하는 과정을 포함함으로서 상기 분산병렬 시뮬레이션에서의 동기 오버헤드 내지는 통신 오버헤드를 최소화시키는 시뮬레이션 방법.
53. 제 4 항 내지는 제 18 항 내지는 제 32 항 내지는 제 34 항에 있어서,

    상기 정확도증강 과정에 트란젝션화를 통한 s-DCP 정확도증강 과정이 포함된 시뮬레이션 방법.
54. 설계 검증을 위하여 특정 추상화 수준의 모델을 대상으로 하는 시뮬레이션에 있어서 상기 시뮬레이션 전체 시간구간 내지는 전체 시간구간에서의 특정 시뮬레이션 구간을 대상으로 진행되는 분산병렬 시뮬레이션에서의 1 이상의 로컬시뮬레이션에서 시뮬레이션 수행의 예상입력을 이용하는 시뮬레이션에 있어서,

    상기 분산병렬 시뮬레이션 수행이 상기 1 이상의 로컬시뮬레이션 수행을 다른 로컬시뮬레이션들과의 통신과 동기화를 생략하고 상기 예상입력으로 독립적으로 진행할 수 있는지를 판단하는 단계를 포함하는 시뮬레이션 방법.
55. 설계 검증을 위하여 특정 추상화 수준의 모델을 대상으로 하는 시뮬레이션에 있어서 상기 시뮬레이션이 2 이상의 시뮬레이션 프로세스 내지는 2 이상의 시뮬레이션 쓰레드로 구성되어서 상기 시뮬레이션 프로세스 내지는 시뮬레이션 쓰레드 수행시에 시뮬레이션 수행의 예상입력을 이용하는 시뮬레이션에 있어서,

    특정 시뮬레이션 프로세스 수행 내지는 시뮬레이션 쓰레드 수행이 다른 시뮬레이션 프로세스 내지는 시뮬레이션 쓰레드와의 프로세스간통신과 프로세스간동기화를 생략하고 상기 예상입력으로 독립적으로 진행할 수 있는지를 판단하는 단계를 포함하는 시뮬레이션 방법.
56. 제 19 항 내지는 제 20 항 내지는 제 38 항 내지는 제 39 항 내지는 제 42 항 내지는 제 43 항 내지는 제 47 항 내지는 제 48 항 내지는 제 54 항 내지는 제 55 항에 있어서,

    상기 예상입력 내지는 예상출력을 구하기 위하여 현재 수행하고자 하는 시뮬레이션에 시간적으로 앞서서 이루어진 1회 이상의 별도의 시뮬레이션 과정에서 수집된 동 적정보를 이용하는 시뮬레이션 방법.
57. 제 19 항 내지는 제 20 항 내지는 제 38 항 내지는 제 39 항 내지는 제 42 항 내지는 제 43 항 내지는 제 47 항 내지는 제 48 항 내지는 제 54 항 내지는 제 55 항에 있어서,

    상기 예상입력 내지는 예상출력을 구하기 위하여 현재 수행하고자 하는 시뮬레이션에 시간적으로 앞서서 이루어진 1회 이상의 별도의 시뮬레이션 과정에서 수집된 시뮬레이션 대상이 되는 모델내의 1 이상의 설계객체들의 입력정보 내지는 출력정보 내지는 입출력정보를 이용하는 시뮬레이션 방법
58. 제 19 항 내지는 제 20 항 내지는 제 38 항 내지는 제 39 항 내지는 제 42 항 내지는 제 43 항 내지는 제 47 항 내지는 제 48 항 내지는 제 54 항 내지는 제 55 항에 있어서,

    현재 수행하고자 하는 시뮬레이션에 시간적으로 앞서서 이루어진 1회 이상의 별도의 시뮬레이션 과정에서 수집된 시뮬레이션 대상이 되는 모델 내의 1 이상의 설계객체들의 입력정보와 출력정보로부터 내지는 시뮬레이션 대상이 되는 모델의 상이한추상수준 동일모델 내의 1 이상의 설계객체들의 입력정보와 출력정보로부터 상기 예상입력과 예상출력 내지는 예상입력 내지는 예상출력을 구하는 시뮬레이션 방법
59. 제 19 항 내지는 제 20 항 내지는 제 38 항 내지는 제 39 항 내지는 제 42 항 내지 는 제 43 항 내지는 제 47 항 내지는 제 48 항 내지는 제 54 항 내지는 제 55 항에 있어서,

    상기 예상입력 내지는 예상출력을 구하기 위하여 현재 수행하고자 하는 시뮬레이션에 시간적으로 앞서서 이루어진 1회 이상의 별도의 시뮬레이션 과정에서 수집된 시뮬레이션 대상이 되는 모델 내의 1 이상의 설계객체들의 입력정보 내지는 출력정보 내지는 입출력정보를 내지는 시뮬레이션 대상이 되는 모델의 상이한추상수준 동일모델 내의 1 이상의 설계객체들의 입력정보 내지는 출력정보 내지는 입출력정보를 이용하는 시뮬레이션 방법.
60. 제 19 항 내지는 제 20 항 내지는 제 21 항 내지는 제 38 항 내지는 제 39 항 내지는 제 42 항 내지는 제 43 항 내지는 제 47 항 내지는 제 48 항 내지는 제 49 항 내지는 제 52 항 내지는 제 54 항에 있어서

    상기 1 이상의 로컬시뮬레이션 중의 1 이상의 특정 로컬시뮬레이션이 하드웨어기반검증플랫폼 상에서 수행되는 시뮬레이션 방법.
61. 설계 검증을 위한 시뮬레이션에 있어서,

    상기 시뮬레이션이 분산처리적병렬수행 방식의 시뮬레이션을 포함하는 시뮬레이션 방법.
62. 제 19 항 내지는 제 20 항 내지는 제 38 항 내지는 제 39 항 내지는 제 42 항 내지 는 제 43 항 내지는 제 47 항 내지는 제 48 항 내지는 제 54 항 내지는 제 55 항에 있어서

    상기 판단하는 과정이 로컬시뮬레이션의 진행 도중에 이루어지는 시뮬레이션 방법.
63. 설계 검증을 위하여 특정 추상화 수준의 모델을 대상으로 하는 시뮬레이션 방법에 있어서,

    상기 시뮬레이션 방법이 분산처리적병렬수행 방식의 시뮬레이션 방법이거나, 내지는 시간분할적병렬수행 방식의 시뮬레이션 방법이거나, 내지는 분산처리적병렬수행 혹은 시간분할적병렬수행을 포함하는 시뮬레이션 방법.
64. 설계 검증을 위하여 특정 추상화 수준의 모델을 대상으로 하는 시뮬레이션 방법에 있어서,

    상기 시뮬레이션 방법이 인크리멘탈 시뮬레이션을 활용한 분산처리적병렬시뮬레이션이거나, 내지는 인크리멘탈 시뮬레이션을 활용한 분산처리적병렬수행 방식을 포함하는 시뮬레이션 방법.
65. 분산처리적병렬시뮬레이션이 동적배움을 이용한 s-DCP 정확도증강 과정 내지는 트란젝션화를 통한 s-DCP 정확도증강 과정을 포함하는 시뮬레이션 방법.
66. 시간적으로 앞서서 수행된 시뮬레이션에서 수집된 동적정보를 이용하는 분산처리적 병렬시뮬레이션이 동적배움을 이용한 s-DCP 정확도증강 과정 내지는 트란젝션화를 통한 s-DCP 정확도증강 과정을 포함하는 시뮬레이션 방법.

Images