KR20060066634A - 검증 성능과 검증 효율성을 높이는 동적검증 기법 방식의검증 장치 및 이를 이용한 검증 방법론 - Google Patents

Abstract

본 발명의 목적은 초대규모급 디지털 시스템 설계에 대한 검증을 위한 시뮬레이션의 성능 및 효율성을 크게 향상시키는 시뮬레이션 기반의 설계 검증 장치 및 이를 이용한 설계 검증 방법을 제공함에 있다. 구체적으로는, 본 발명에서 언급되는 기술은 설계된 수백만 게이트급 이상의 디지탈 시스템을 시뮬레이션과, 필요시에는 이와 더불어서 정식검증, 시뮬레이션 가속, 하드웨어 에뮬레이션, 프로토타이핑들까지도 같이 이용하여서 검증하고자 하는 경우에도 검증의 성능과 효율성을 증가시키는 검증 장치 및 이를 이용한 검증 방법에 관한 것이다.

본 발명에서는 임의의 컴퓨터에서 수행되어지는 본 발명의 검증 소프트웨어로 하여금 설계 코드에 부가적인 코드나 부가적인 회로를 추가하여 1회 이상의 시뮬레이션을 수행하게 한다. 시뮬레이션 수행은 앞단 시뮬레이션과 후단 시뮬레이션으로 나누어지며, 앞단 시뮬이션의 결과를 효과적으로 이용하는 후단 시뮬레이션은 1 이상의 컴퓨터에서 수행되는 1 회 이상의 시뮬레이션을 1 이상의 시뮬레이터를 이용하여 순차적 수행을 가능하게 할 뿐만 아니라, 네트워크 상에서 연결된 2 이상의 컴퓨터에서 돌아가는 2 이상의 시뮬레이터를 이용하여 상호 완전 독립적인 병렬적 수행도 가능하게 함으로서 전체 검증 시간과 검증 비용의 대폭적인 단축을 가능하게 하고, 검증의 효율성을 크게 높일 수 있게 한다.

Description

검증 성능과 검증 효율성을 높이는 동적검증 기법 방식의 검증 장치 및 이를 이용한 검증 방법론{Dynamic-Verification-Based Verification Apparatus Achieving High Verification Performance and Verification Efficiency, and the Verification Methodology Using the Same}

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

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

도3 은 본 발명에서 제안하는 방법으로 시뮬레이션을 수행하는 과정을 개략적으로 도시한 도면.

도4 는 본 발명에서 제안하는 앞단 시뮬레이션 단계인 1차 시뮬레이션과 후단 시뮬레이션 단계인 1차 이후의 시뮬레이션을 통하여 설계 오류를 발견하고 수정하는 과정을 개략적으로 도시한 도면.

도5(a) 은 도1 내지는 도2 와 같은 장치를 이용한 설계 검증을 수행하는 과정을 개략적으로 도시한 순서도를 도시한 도면.

도5(b) 는 도1 내지는 도2 와 같은 장치를 이용한 설계 검증을 수행하는 또 다른 과정을 개략적으로 도시한 순서도를 도시한 도면.

도6(a) 는 도2 와 같은 장치를 이용한 설계 검증에서 후단 시뮬레이션 단계 인 1차 이후의 시뮬레이션을 병렬적으로 수행하는 과정 의 일례를 개략적으로 도시한 도면.

도6(b) 는 도2 와 같은 장치를 이용한 설계 검증에서 후단 시뮬레이션 단계인 1차 이후의 시뮬레이션을 병렬적으로 수행하는 또 다른 과정 의 일례를 개략적으로 도시한 도면.

도6(c) 는 도2 와 같은 장치를 이용한 설계 검증에서 후단 시뮬레이션 단계인 1차 이후의 시뮬레이션을 병렬적으로 수행하는 또 다른 과정 의 일례를 개략적으로 도시한 도면.

도6(d) 는 도2 와 같은 장치를 이용한 설계 검증에서 후단 시뮬레이션 단계인 1차 이후의 시뮬레이션을 병렬적으로 수행하는 또 다른 과정 의 일례를 개략적으로 도시한 도면

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

도 8 은 컴퓨터에서 운영되는 본 발명의 검증 소프트웨어와 시뮬레이터를 갖는 컴퓨터와 하드웨어기반검증플랫폼으로 구성된 본 발명에 관한 설계 검증 장치의 일예를 개략적으로 도시한 도면.

도 9는 컴퓨터에서 운영되는 본 발명의 검증 소프트웨어와 시뮬레이터를 갖는 2 이상의 컴퓨터들과 하드웨어기반검증플랫폼과 이들 컴퓨터들을 연결하는 컴퓨터 네트워크로 구성된 본 발명에 관한 설계 검증 장치의 또 다른 일 예를 개략적으로 도시한 도면.

도 10은 컴퓨터에서 운영되는 본 발명의 검증 소프트웨어와 이 검증 소프트웨어가 운영되는 컴퓨터와 하드웨어기반검증플랫폼으로 구성된 본 발명에 관한 설계 검증 장치의 또 다른 일 예를 개략적으로 도시한 도면.

도 11 은 도8 을 이용한 검증결과 재활용의 일 실시 예를 설명하는 흐름도.

도 12 는 도1 을 이용한 시뮬레이션결과 재활용의 일 실시 예를 설명하는 흐름도.

도 13 은 임의의 검증플랫폼을 사용하여 설계 검증을 수행하는 과정에서 설계 객체 변정 전에 수행된 검증결과를 재활용을 하여 설계객체 변경 후에 수행되는 검증을 신속하게 수행하는 과정의 일 실시 예를 개략적으로 도시한 도면.

도 14는 임의의 하드웨어기반검증플랫폼을 사용하여 설계 검증을 수행하는 과정에서 설계객체 변경 전에 수행된 검증결과를 재활용을 하여 설계객체 변경 후에 수행되는 검증을 신속하게 수행하는 과정의 일 실시 예를 개략적으로 도시한 도면.

도 15는 시뮬레이터를 사용하여 설계 검증을 수행하는 과정에서 설계객체 변경 전에 수행된 시뮬레이션결과를 재활용을 하여 설계객체 변경 후에 수행되는 시뮬레이션를 신속하게 수행하는 과정의 일 실시 예를 개략적으로 도시한 도면.

도16은 앞단 시뮬레이션 단계인 1차 시뮬레이션에서의 상태 저장을 시뮬레이션의 일정 구간에 걸쳐서 이루어지는 경우와 후단 시뮬레이션 단계인 1차 이후의 시뮬레이션에서의 상태 재설정을 시뮬레이션의 일정 구간에 걸쳐서 이루어지 경우의 일 예를 도시한 도면.

도17은 앞단 시뮬레이션 단계인 1차 시뮬레이션의 진행 도중에서 후단 시뮬레이션 단계인 1 이상의 1차 이후의 시뮬레이션을 시작하여서 진행하는 일 예를 도시한 도면.

＜도면의 주요부분에 대한 부호의 설명＞

12 : 테스트벤치 설계객체 14 : DUV 설계객체

16 : 설계블럭 설계객체 18 : 재생용 입력정보

20 : 변경된 설계객체 22 : 설계 변경 전 수집된 동적정보의 일부분

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

28 : 프로토타이핑시스템의 시스템소프트웨어 컴퍼넌트

29 : 시뮬레이션가속기의 시스템소프트웨어 컴퍼넌트

30 : 하드웨어에뮬레이터의 시스템소프트웨어 컴퍼넌트

31 : 검증 소프트웨어에서 설계 코드나 합성으로 생성된 게이트수준의 네트리스트에 추가 코드나 추가 회로를 자동적으로 부가하고 검증 준비를 진행하는 소프트웨어모듈

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

35 : 컴퓨터

36 : 하드웨어에뮬레이터 플랫폼의 하드웨어 컴퍼넌트

37 : 시뮬레이션가속기 플랫폼의 하드웨어 컴퍼넌트

38 : 프로토타이핑시스템 플랫폼의 하드웨어 컴퍼넌트

42 : 모델검사기/특성검사기

44 : 검증 소프트웨어에서 검증 실행 도중에 1 이상의 컴퓨터간에 파일이나 데이터 전송을 가능하게 하고, 1차 검증 실행을 진행하고 1차 이후의 검증 실행을 위한 준비를 진행하고 1차 이후의 검증 실행을 진행시키는 소프트웨어모듈

본 발명은 설계된 수백만 게이트급 이상의 디지털 시스템의 설계를 검증하는 기술에 관한 것으로, 설계된 수백만 게이트급 이상의 디지털 시스템을 시뮬레이션을 통하여 검증하고자 하는 경우에 시뮬레이션을 이용한 검증의 성능과 효율성을 증가시키는 검증 장치 및 이를 이용한 검증 방법에 관한 것이다.

최근에 집적회로의 설계 및 반도체 공정기술이 급격하게 발달함에 따라 디지털 회로 내지는 디지털 시스템 설계의 규모가 최소 수백만 게이트급에서 수천만 게이트급까지 커짐은 물론 그 구성이 극히 복잡해지고 있는 추세이고, 이와 같은 추세는 계속적으로 확대되고 있는 추세로 가까운 미래에 일억 게이트급 이상의 설계도 예상되고 있다. 그러나, 시장에서의 경쟁은 더욱 더 치열해지므로 빠른 시간 내에 우수한 제품을 개발하여야만 하는데 최근의 칩 설계에서 설계 검증은 전체 설계 시간에서 최대 70％까지의 시간을 차지하게 됨으로서, 빠른 시간 내에 자동화된 방법으로 설계된 회로를 효율적으로 설계 검증하기 위한 효과적인 방법의 필요성이 더욱 커지고 있다. 디지털 시스템을 칩으로 설계하는 경우에는 설계하는 대상이 두 가지가 있는데 그 하나는 DUV(Design Under Verification)이고, 또 다른 하나는 테 스트벤치(testbench, 앞으로는 이를 TB로 약칭함)이다. DUV는 궁극적으로 반도체 제조 공정을 거쳐서 칩으로 만들어지는 설계 대상이고, 테스트벤치는 구현된 해당 칩이 장착되어서 동작하는 주변상황을 모델링한 것으로서 DUV의 시뮬레이션에 사용된다. DUV를 시뮬레이션을 통하여 검증하고자 하는 경우에 테스트벤치가 DUV에 입력을 인가하고 인가된 입력으로 DUV에서 출력되는 결과를 받아들여서 처리하는 것이 일반적이다.

지금까지는 설계된 디지털 회로를 설계 검증하기 위하여서 하드웨어기술언어(Hardware Description Language, 앞으로 이를 HDL로 약칭함)나 시스템 기술 언어(System Description Language, 앞으로 이를 SDL로 약칭함)와 필요에 따라서는 하드웨어검증언어(Hardware Verification Language, 앞으로 이를 HVL로 약칭함)까지를 사용하거나, 또는 이들을 복합적으로 사용하고 있다. 설계 초기에는 소프트웨어적 접근법인 HDL 시뮬레이터들(예로, Verilog 시뮬레이터, VHDL 시뮬레이터, SystemVerilog 시뮬레이터 등)나 SDL 시뮬레이터(예로, SystemC 시뮬레이터, HW/SW co-simulator 등)이 주로 사용되어지고 있는데, 경우에 따라서는 이들과 더불어서 HVL 시뮬레이터들(예로, Vera 시뮬레이터, e 시뮬레이터 등)도 같이 사용되고 있다. 이와 같은 시뮬레이터는 설계 검증 대상회로와 테스트벤치를 소프트웨어적으로 모델링한 순차적인 인스트럭션 시퀀스로 구성된 소프트웨어 코드를 컴퓨터 상에서 순차적으로 수행하여야 함으로 상기 수백만 게이트급 이상의 설계에 대해서는 시뮬레이션 성능의 저하가 설계대상의 크기에 비례하여 발생하는 것이 문제가 되고 있다. 일 예로, 1000만 게이트급 이상의 설계를 HDL 시뮬레이터나 SDL 시뮬레이터로 시뮬레이션하는 경우에 현존하는 제일 빠른 프로세서를 장착한 컴퓨터에서 해당 HDL 시뮬레이터로 설계를 시뮬레이션하는 경우에 시뮬레이션 속도는 레지스터전송수준(Register Transfer Level, 앞으로 이를 RTL로 약칭함)으로 하는 경우에 10-100 cycles/sec를 넘기기 어려우며, 게이트 수준에서 시뮬레이션을 진행하면 1-10 cycles/sec를 넘기기가 어려운 것이 매우 일반적이다. 그러나 해당 설계를 검증하고자 필요한 시뮬레이션 사이클은 최소 수백만 사이클에서부터 최대 수십억 사이클이 필요함으로 전체 시뮬레이션 시간은 상상을 초월하게 오래 걸리게 된다.

이와 같은 장시간의 검증 시간을 단축하기 위하여 현재에 사용되는 기술들은 다음과 같은 것들이 있다. 첫째는 하드웨어 기반의 검증 시스템(예로, 시뮬레이션가속기, 하드웨어 에뮬레이터, FPGA 프로토타이핑 시스템 등)을 사용하거나, 둘째는 1 이상의 컴퓨터(예로, 100대의 워크스테이션)들 각각에 HDL 시뮬레이터를 인스톨하고 이를 고속의 네트워크를 통하여 연결한 시뮬레이션팜(simulation farm)을 사용하는 것이다. 그러나 하드웨어 기반의 검증 시스템을 사용하는 것은 설계 초기에는 적용이 불가능하고, 합성(synthesis)이나 컴파일 과정이 HDL 시뮬레이터를 사용하는 것보다 훨씬 오래 걸리며, 사용하기가 HDL 시뮬레이터에 비하여 매우 어렵고, 시스템의 구입 비용과 유지/보수 비용이 매우 클 뿐만 아니라, 무엇보다도 설계자나 검증 엔지니어들이 HDL 시뮬레이터에 대한 선호도가 이들 하드웨어 기반의 검증 시스템에 비하여 매우 높고, HDL 시뮬레이터로는 아무 문제가 없이 수행이 되는 설계 코드들이 하드웨어 기반의 검증 시스템에서는 수행되지 않는 경우가 많아서 이들 하드웨어 기반의 검증 시스템들은 제한적인 상황과 제한적인 사용자들에서 만 사용되고 있는 문제점이 있다. 또한 시뮬레이션팜을 이용하여 시뮬레이션의 성능을 향상시키는 것은 시뮬레이션을 위한 설계 코드나 테스트벤치가 2이상의 경우에만 가능할 뿐만 아니라, 테스트벤치들이 여러 개인 경우라고 하더라도 이들 중에서 제일 수행시간을 요하는 테스트벤치에 의하여 전체 시뮬레이션 시간이 결정되는 문제점(예를 든다면 특정 테스트벤치에 의한 시뮬레이션 시간이 일주일을 요하는 경우에는 시뮬레이션팜(simulation farm)을 이용하더라도 일주일의 시뮬레이션 시간은 더 이상 단축이 안됨)이 있다. 이와 같은 상황은 SDL 시뮬레이터를 사용하는 경우도 마찬가지이고, HVL 시뮬레이터를 사용하는 경우도 마찬가지이다. 특히, 최근에는 테스트벤치의 복잡도가 매우 증가하고 테스트벤치 내에 다양한 컴퍼넌트들(예로, 랜덤 입력스티뮬러스 발생기, 모니터, 검사기, 커버리지분석기, 응답검사기 등)이 존재함으로서 상위수준에서 추상화되어져 구술된 테스트벤치의 오버헤드가 매우 커짐으로 이것 또한 시뮬레이션의 수행 속도를 떨어뜨리는 주요 요소 중의 하나로 작용하고 있다. 이와 같은 다양한 테스트벤치 혹은 경우에 따라서는 DUV 내의 컴퍼넌트들은 최근의 발전된 검증(advanced verification) 기법에서 검증의 정량화와 자동화를 위하여 사용되는 테스트벤치 자동화(testbench automation), 커버리지지향 검증(coverage-driven verification), 주장기반 검증(assertion-based verification) 등에서 반드시 필요한 것들이지만 앞서서 지적한대로 이들의 사용은 시뮬레이션의 속도를 더욱 떨어뜨리는 부정적인 부수효과를 초래하게 된다. 상황을 더욱 악화시키게 되는 것은 이와 같은 발전된 검증 기법을 통하여서는 버그의 존재 여부만을 알 수 있거나, 기껏해야 버그가 존재하는 대략적인 위치만을 예측하는 것 만이 가능하고, 버그가 정확하게 어디에 존재하고 있는지를 알아내는 것은 극히 어렵다는 것이다. 버그가 정확하게 어디에 존재하는지를 알아내고 이를 제거하는 것은 지능을 소유한 설계자나 검증엔지니어들의 몫이며, 이들 위해서는 시뮬레이션 과정에서 DUV에 그리고 경우에 따라서는 TB에 존재하는 시그널들이나 변수들의 값들을 탐침(probing)하여 저장하고, 이를 설계자나 검증엔지니어들이 확인하는 과정이 반드시 필요하게 된다. 그러나, 이와 같은 두가지 상황들이 합쳐지면서 시뮬레이션의 속도 저하는 더욱 크게 나타나게 된다. 더욱이 별도의 HVL을 사용하여서 테스트벤치를 구술하게 되면 일반적으로 HDL 시뮬레이터들의 API(Application Program Interface)인 VPI/PLI/FLI 등을 반드시 사용하여야 하는데 이것의 사용도 시뮬레이션의 수행 속도를 떨어뜨리는 주요 요소 중의 또 다른 하나로 작용하고 있다. 뿐만 아니라, 지금까지의 설계는 레지스터전송수준(Register Transfer Level, 앞으로는 이를 RTL로 약칭함)에서의 설계에서 합성 기술을 사용하여서 네트리스트를 자동 생성하는 설계 방법이 주류를 이루고 있다. 한편에서는 설계 복잡도의 증가를 해결하고자 RTL 수준보다도 높은 단계인 행위수준(behavioral level)내지는 시스템레벨수준에서 DUV와 TB 모두를 구술하여서 RTL 구조를 자동 생성하고 최종적으로 네트리스트도 자동 생성하고자 하는 시도들이 있다. 그러나, 이와 같은 새로운 방법이 보편화될 수 있을지는 매우 불투명한 상황인데, 이유로는 대부분의 하드웨어 설계자들은 RTL 수준에서의 설계에 매우 익숙해져 있기 때문이며, RTL 수준보다 상위 수준에서 구술된 설계의 합성 결과가 일반적 상황에서는 RTL에서 구술되어 합성된 결과에 비하여 동작속도/면적 등에서 많이 뒤떨어지기 때문이다. 그러나 최 근의 수천만 게이트급의 설계는 대부분 내부에 1개 이상의 프로세서를 내장하고 있는 SOC(System On a Chip) 설계인데, 이와 같은 SOC들은 내장된 프로세서를 구동하는 대용량의 소프트웨어를 내장하고 있어서 SOC 설계에서는 이와 같은 내장 소프트웨어의 개발이 하드웨어의 개발과 동시적으로 진행되어질 수 있는 하드웨어/소프트웨어 동시설계(co-design) 및 동시검증(co-verification)이 필수적이다. 그러나 하드웨어 설계자들이 절대적으로 선호하는 RTL 수준에서 구술된 DUV의 수행속도는 앞서서 언급된 것과 같이 수행 속도가 너무 느림으로 내장 소프트웨어를 개발하기 위한 플랫폼으로는 사용할 수가 없는 반면에, 소프트웨어 개발자들은 개발하고자 하는 내장 소프트웨어들이 신속하게 수행될 수 있는 플랫폼을 하드웨어 설계가 진행되고 있는 시점에 이미 필요로 하고 있는 문제점이 있다.

현재 제일 많이 사용되어지고 있는 시뮬레이션은 이벤트-구동(event-driven) 시뮬레이션이다. 이벤트(event)란 이진비트의 경우에는 신호값 변화가 일어나는 변이를 말하는데, 예를 든다면 0에서 1로(0-＞1) 혹은 1에서 0으로(1-＞0) 혹은 X(Unknown)에서 0으로(X-＞0) 혹은 Z(Hi-impedance)에서 1로(Z-＞1) 등을 이야기할 수 있으며, 이와 같이 신호값 변화, 즉 이벤트가 없는 것을 안정값(stable value, 예로 0 혹은 1 혹은 X 혹은 Z)이라고 칭하기로 한다. 시뮬레이션은 이 외에 사이클-기반(cycle-based) 시뮬레이션, 트란젝션-기반(transaction-based) 시뮬레이션 등이 있다. 현재 레지스터전송수준에서의 칩 설계에서 사용되는 HDL 시뮬레이터들(Cadence NC-Verilog/NC-VHDL, Synopsys VCS/VCS-MX, Mentor Graphic ModelSim, Aldec Active-HDL/Riviera 등) 내지는 SystemC simulator는 모두 이벤트-구동 방식 의 시뮬레이터들이다. 사이클-기반의 시뮬레이터로는 대표적으로 Synopsys의 Scirocco와 초기의 SystemC simulator가 있는데, 사이클-기반의 시뮬레이션에서는 조합회로부를 모델링한 HDL 코드나 게이트수준의 네트리스트의 모든 부분에서는 지면시간을 0으로 가정하고, DUV의 동작이 플립플롭 내지는 래치의 플립플롭이나 래치의 출력을 활성화시키는 클럭 에지(active clock edge)(예로, rising-edge sensitive 플립플롭이나 positive-level sensitive 래치의 경우에는 클럭의 rising-edge, falling-edge sensitive 플립플롭이나 negative-level sensitive 래치의 경우에는 클럭의 falling-edge)에만 동기화되어서 이루어지도록(즉, 사이클-기반의 시뮬레이션에서는 DUV에서 구술되어져 행위수준이나 소자로서 존재하게 되는 모든 플립플롭들이나 래치들의 출력 Q 값들만이 사이클 단위로서만 중요하며, 따라서 HDL 소스 코드에 구술된 모든 지연시간들과는 상관없이 플립플롭이나 래치의 Q 출력이 변화 가능한 시점은 해당 클럭의 활성 에지와 시간차 없이 정확하게 일치됨) 시뮬레이션 되어진다. 이벤트-구동 시뮬레이터를 사용하는 경우에도, HDL 설계코드에 존재하는 모든 지연시간 구문들(예로, Verilog 코드에서는 # 구문, 내지는 VHDL 코드에서는 AFTER delay 구문 또는 TRANSPORT (signa-expression) AFTER delay 구문 등)을 무시하거나, 이들 지연시간 구문들을 제거하고 시뮬레이션을 한다면 시뮬레이션 결과는 사이클-기반 시뮬레이션 결과와 같게 되는데, 이벤트-구동 시뮬레이터를 이와 같은 방식으로 동작시키는 것을 사이클-기반 모드(cycle-based mode)로 동작시킨다고 정의한다. 추상화(abstraction)된 기준에서 본다면 이벤트-구동이 사이클-기반 보다는 덜 추상화된 것이고 사이클-기반이 트란젝션-기반 보다 는 덜 추상화된 것이다. 사이클-기반 시뮬레이션은 이벤트-구동 시뮬레이션보다 대략 10-100배 정도 빠르지만 이벤트-구동 시뮬레이션에 비하여 제약성이 많아서 현재에는 하드웨어 검증에는 거의 사용되지 못하고 소프트웨어 검증의 가상 플랫폼(virtual platform)으로만 사용되고 있는 실정이다. 즉, 사이클-기반 시뮬레이션을 이용하게 되면 이벤트-구동 시뮬레이션에 비하여 훨씬 빠르게 시뮬레이션을 수행하는 것이 가능하지만, 극히 제한적인 상황에서만 이용가능하고 이의 시뮬레이션 결과도 전적으로 신뢰할 수 없음으로, 현재 HDL을 이용하는 하드웨어 설계자들로부터는 사이클-기반 시뮬레이션은 철저히 외면 되어지고 있으며 하드웨어 설계자들의 대부분은 이벤트-구동 시뮬레이션을 절대적으로 선호하고 있는 실정이다. 또한 현재 이벤트-구동 시뮬레이션, 사이클-기반 시뮬레이션, 트란젝션-기반 시뮬레이션 등은 각기 독립적으로만 사용되고 있는 상황이다. 결과적으로, 이와 같은 상황들은 전체 검증의 효율성과 성능을 제약하는 요소가 되고 있다.

또한, 시뮬레이션 내지는 시뮬레이션가속 내지는 에뮬레이션 등과 같은 동적기반 방식의 검증에서 검증 실행이 완료된 후에는 이 검증 실행의 결과를 분석하고 이의 결과에 따라서 설계오류를 찾아서 제거하는 디버깅 과정이 필요한데 (이와 같은 검증 실행 -＞ 검증 결과 분석 -＞ 디버깅(디버깅은 설계 오류의 존재 유무에 따라서 선택적으로 진행됨)의 3 단계를 하나로 묶어서 이를 완전검증과정이라 칭하고, 한번의 완전검증과정에 소요되는 시간을 턴어라운드시간(turn around time)이라고 칭함), 검증 전체 과정은 이와 같은 완전검증과정을 1회 이상, 통상적으로는 최소 수차례 내지는 수십차례 내지는 최대 수백차례 이상 반복적으로 수행하는 과 정이라고 생각할 수 있다. 따라서 검증 전체 시간을 단축시키기 위해서는 이와 같은 검증 전체 과정에 존재하는 상기 복수 회수의 완전검증과정들 각각에 소요되는 시간을 단축시키는 것, 즉 턴어라운드시간을 단축시키는 것이 절대적으로 필요하다. 그러나, 현재의 검증 방법들에서는 이와 같은 3 단계의 각 단계는 앞 단계가 완전히 종료된 후에 진행됨으로서 검증 실행 시간이 매우 길면 결과적으로 하나의 완전검증과정에 소요되는 시간, 즉 턴어라운드시간도 같이 크게 늘어나게 되고 이로 인하여 전체 검증 시간도 크게 늘어나게 된다. 뿐만 아니라, 시뮬레이션 실행 결과를 가지고 검증 결과 분석 과정에서 디버깅이 필요한지 아니면 불필요한지를 판단하여야 하는데 이 또한 현재의 검증 방법들에서는 자동화된 방식을 사용하지 않음으로 해서 많은 시간이 소요되는 과정이기 때문에 완전검증과정에 소요되는 시간이 이로 인하여서도 늘어나게 된다.

따라서, 본 발명의 목적은 초대규모급 디지털 시스템 설계에 대한 검증을 위하여 시뮬레이터(Cadence NC-Verilog/NC-VHDL, Synopsys VCS/VCS-MX, Mentor Graphic ModelSim, Aldec Active-HDL/Riviera, SystemC simulator 등)를 이용한 시뮬레이션의 성능 및 효율성을 크게 향상시키는 시뮬레이션 기반의 설계 검증 장치 및 이를 이용한 설계 검증 방법을 제공함에 있다. 특히 시뮬레이션을 수행한 후에 설계 오류에 대한 디버깅을 수행하기 위하여 설계 코드에 존재하는 시그널들이나 변수들에 대한 가시도(visibility)가 요구되는데, 문제는 설계 오류의 정확한 위치를 알아내기 위해서 시뮬레이션 수행 전에 구체적으로 어느 특정 시그널들이나 변 수들에 대한 가시성이 어느 시뮬레이션 구간에서 필요한지를 예측하기 어렵다는 것이다. 따라서 시뮬레이션을 수행할 때에 처음부터 설계 코드에 존재하는 모든 시그널들과 변수들에 대하여 탐침이 가능하게 이들 모두를 덤프(dump) 대상으로 선정한 다음에 시뮬레이션을 수행한다. 그러나 설계 코드에 존재하는 모든 시그널들과 변수들을 덤프하면서 시뮬레이션을 수행하는 경우에는, 덤프를 전혀 하지 않고 시뮬레이션을 수행하는 것과 비교하여 시뮬레이션 수행시간이 대략 2배에서 많게는 10배 이상 길어지게 된다. 뿐만 아니라, 최근에는 주장(assertion)을 이용하여 기존의 덤프 방법보다도 더욱 지능적인 가시도 확보 방법들도 많이 사용되어지고 있는데, 이와 같은 주장구문(assertion statement)을 이용하는 경우에도 많은 수의 주장구문들에 대한 추가적인 처리시간이 필요하게 됨으로서 덤프 방법과 같이 시뮬레이션 시간을 크게 증가시키게 된다. 뿐만 아니라, 최근에는 전력소비량 등과 같은 설계 코드에 대한 분석을 위하여서도 RTL 설계 코드 내지는 게이트-수준 네트리스트에 존재하는 1 이상의 시그널들이나 변수들에 대한 모니터링(예로, 다이나믹 파워분석을 위한 스위칭 동작(switching activity)의 조사를 위한 모니터링)이 시뮬레이션 과정에서 요구되는데 이와 같은 모니터링도 주장구문과 동일하게 시뮬레이션 시에서 가시도가 확보되어져야 하며, 이 또한 시뮬레이션 시간을 크게 증가시키게 된다. 본 발명에서는 위에서 언급된 디버깅을 위한 탐침 뿐만 아니라, 주장기법을 위해서나 여타 다른 목적들을 위한 설계 코드에 대한 다양한 모니터링 모두를 시뮬레이션 시에 설계 코드에 대한 가시도를 확보하는 일들로서 보기로 한다. 따라서 본 발명에서는 설계 코드에서 버그의 위치를 정확히 파악하거나 설계 코드에 대 한 분석을 수행하기 위하여 설계 코드에 존재하는 모든 시그널들과 변수들 내지는 1 이상의 특정 시그널들이나 변수들에 대하여 시뮬레이션 처음부터 덤프 내지는 모니터링을 수행하는 기존의 방법 내지는 주장을 시뮬레이션에 통상적으로 이용하는 방법에서의 시뮬레이션 시간 증가가 초래되는 것과는 다르게 시뮬레이션 수행시간을 크게 늘리지 않고서, 혹은 기존의 방법과 비교하여 시뮬레이션 수행시간을 크게 단축하면서도 설계 코드에서 버그의 위치를 찾을 수 있도록 하거나 RTL 설계 코드 내지는 게이트-수준의 네트리스트에 대한 다양한 분석(예로 최대 전력소비량 분석, 평균 전력소비량 분석 등)을 신속하게 수행하게 하는 방법과 이를 위한 검증 장치를 제공함을 목적으로 한다.

본 발명의 또 다른 목적으로는, 발전된 검증 기법에서 사용되는 테스트벤치 자동화, 커버리지지향 검증, 주장기반 검증 등을 사용하면서도, 동시에 DUV에 대한 높은 가시도를 신속하게 확보하는 자동화된 방법과 이를 위한 검증 장치를 제공하는 것이다.

본 발명의 또 다른 목적으로는, 하향식으로 진행되는 설계 과정에 있어서 추상화 단계의 상위 수준에서 수행된 시뮬레이션 결과를 추상화 단계의 하위 수준에서 수행되는 시뮬레이션에 이용함으로서 DUV에 대한 높은 가시도를 신속하게 확보하는 동시에 하위 수준에서 수행되는 시뮬레이션을 병렬화시키거나 하위 수준에서 수행되는 시뮬레이션 시간 구간을 상위 수준에서 수행되는 시뮬레이션 시간 구간과 비교하여서 단축시킬 수 있음(예로, 상위 수준에서의 시뮬레이션은 시뮬레이션 시간 0 - 100,000,000 나노초까지 시뮬레이션 하지만, 하위 수준에서의 시뮬레이션은 시뮬레이션 시간 80,000,000 - 85,000,000 나노초까지 시뮬레이션)으로 해서 전체 시뮬레이션 시간을 크게 단축할 수 있도록 하는 자동화된 방법과, 이를 위한 검증 장치를 제공함으로서 하드웨어 검증 내지는 소프트웨어 검증 내지는 하드웨어/소프트웨어 동시 검증을 효과적으로 가능하게 하는 것이다. 설계 과정에서의 추상화 수준의 사례들을 설명한다면, 행위수준(behavioral-level)은 레지스터전송수준보다 추상화 수준이 높으며, 레지스터전송수준은 게이트수준보다 추상화 수준이 높다고 이야기한다. 또한, DUV를 볼때 DUV의 하위블럭들이 다수가 존재하는 경우에, 특정 DUV의 구술사례 X가 1 이상의 특정 하위블럭의 추상화 수준이 같은 DUV에 대하여 구술방법이 다르도록 구술된 사례 Y에서 존재하는 해당 특정 하위블럭의 추상화 수준보다 높고 다른 여타의 모든 하위블럭들에서는 추상화 수준이 낮지 않다면 DUV 전체로서도 X의 추상화 수준이 Y 보다 높다고 정의한다. 구체적으로 예를 든다면, DUV의 하위 계층에 설계블럭들 B0, B1, B2, B3가 존재하며 DUV_1은 B0, B1, B2, B3가 모두 행위수준으로 구술되어 있다고 하고, DUV_2는 B0, B1, B2는 행위수준으로 구술되어 있는 반면에 B3는 레지스터전송수준으로 구술되어 있다고 하고, DUV_3은 B0, B1, B2, B3가 모두 레지스터전송수준으로 구술되어 있다고 하고, DUV_4는 B0, B1, B2는 레지스터전송수준으로 구술되어 있는 반면에 B3는 게이트수준으로 구술되어 있다고 하고, DUV_5는 B0, B1, B2, B3 모두가 게이트수준으로 구술되어 있다면, DUV_1의 추상화 수준이 제일 높고, 그 다음으로 DUV_2의 추상화 수준이 높으며, 그 다음으로는 DUV_3의 추상화 수준이 높고, 그 다음으로 DUV_4의 추상화 수준이 높고, DUV_5의 추상화 수준이 제일 낮다 (즉, DUV_1의 추상화 수준이 DUV_2의 추상화 수준보다 상위에 있다고 하고, DUV_2의 추상화 수준이 DUV_3의 추상화 수준보다 상위에 있다고 하고, DUV_3의 추상화 수준이 DUV_4의 추상화 수준보다 상위에 있다고 하고, DUV_4의 추상화 수준이 DUV_5의 추상화 수준보다 상위에 있다고 한다). 또 다른 추상화 수준은 게이트수준에서 상이한 지연시간 모델을 사용하는 경우에 존재하게 된다. 즉 같은 게이트수준이라고 하더라도 더 정확한 지연시간 모델을 사용한 것이 덜 정확한 지연시간 모델을 사용한 것보다 추상화 수준이 낮다고 이야기한다. 따라서 같은 게이트수준의 네트리스트를 사용하더라도 SDF(Standard Delay Format)를 사용한 DUV_a와 단위지면시간 모델(unit-delay model)을 사용한 DUV_b와 제로지연시간 모델(zero-delay model)을 사용한 DUV_c가 있을때에, DUV_c의 추상화 수준이 DUV_b의 추상화 수준보다 높다고 하고, DUV_b의 추상화 수준이 DUV_a의 추상화 수준보다 높다고 정의한다.

본 발명의 또 다른 목적으로는, 상위 단계에서 하위 단계에서 진행되는 설계 과정에 따라서 검증도 상위 단계에서 하위 단계로 진행되는 과정에서 상위 단계의 검증 결과를 하위 단계의 검증 결과에 자동화된 방식으로 사용하게 하고, 상위 단계의 검증 결과를 활용하여 하위 단계의 검증을 순차적 내지는 병렬적으로 신속하게 수행될 수 있게 할 뿐만 아니라, 필요에 따라서는 상위 단계의 검증 결과를 레퍼런스(reference)로 하여서 하위 단계의 검증을 효율적으로 수행할 수 있도록 함으로서 여러 추상화 단계들에 걸쳐서 존재하고 있는 전체적인 검증의 속도 향상과 효율성 향상을 가능하게 하는 것이다.

본 발명의 또 다른 목적으로는, 상위 단계에서 하위 단계에서 진행되는 설계 과정에 따라서 검증도 상위 단계에서 하위 단계로 진행되는 과정에서 상위 단계의 검증 결과를 하위 단계의 검증 결과에 자동화된 방식으로 사용하게 하고, 상위 단계의 검증 결과를 활용하여 하위 단계의 검증을 순차적 내지는 병렬적으로 신속하게 수행될 수 있게 할 뿐만 아니라, 필요에 따라서는 하위 단계의 검증 결과를 레퍼런스로 하여서 상위 단계의 검증을 효율적으로 수행할 수 있도록 함으로서 여러 추상화 단계들에 걸쳐서 존재하고 있는 전체적인 검증의 속도 향상과 효율성 향상을 가능하게 하는 것이다.

본 발명의 또 다른 목적으로는, 상위 단계에서 하위 단계에서 진행되는 설계 과정에 따라서 검증도 상위 단계에서 하위 단계로 진행되는 과정에서 각 단계에 제일 적합한 방식의 시뮬레이션을 트란젝션-기반 시뮬레이션, 사이클-기반 시뮬레이션, 이벤트-구동 시뮬레이션 중에서 최적하게 선정하여 사용하게 하고, 특정 추상화 단계의 검증 결과를 다른 추상화 단계의 검증 결과에 자동화된 방식으로 사용하게 하여서 상기 다른 추상화 단계에서의 검증을 신속하게 수행될 수 있게 하여서 전체적인 검증의 속도 향상과 효율성 향상을 가능하게 하는 것이다.

본 발명의 또 다른 목적은 시뮬레이션과 더불어서 정식검증, 시뮬레이션 가속, 하드웨어 에뮬레이션, 프로토타이핑 중에 1 이상을 시뮬레이션과 같이 사용하여서 설계 검증을 수행하게 함으로서 전체 검증의 성능과 효율성을 증가시키는 가능하게 하는 것이다.

본 발명의 또 다른 목적은 특정 시뮬레이션의 실행을 시작하고 이를 진행하여 종료할 때까지의 시뮬레이션 실행 시간이 매우 긴 경우에 있어서, 시뮬레이션의 종료 시점까지 기다리지 않고서 시뮬레이션의 진행 도중에서 시뮬레이션의 부분 실행결과를 자동화된 방법으로 획득할 수 있도록 함으로서 턴어라운드시간의 대폭적인 단축을 통한 효율적 검증 및 디버깅을 가능하게 하는 것이다. 특히 상위 수준에서 수행되는 검증결과를 레퍼런스로 활용할 수 있도록 하는 것과 빠른 턴어라운드시간을 가능하게 하는 하위 수준에서의 시뮬레이션을 병행하여서, 하위 수준에서 수행되는 긴 시간의 시뮬레이션(예로 SDF를 이용한 게이트수준의 타이밍시뮬레이션)을 진행하는 과정에서 시뮬레이션의 종료를 기다리지 않고서 시뮬레이션의 시작 이후에 최대한 빠른 시간 내에 시뮬레이션의 올바름에 대한 점검 내지는 시뮬레이션 결과의 분석을 특정 시뮬레이션 시간대 별로 자동화된 방법으로 진행할 수 있도록 하고, 필요 시에(디자인에 존재하는 버그로 인하여 시뮬레이션 결과가 의도한대로 되지 않은 경우에) 시뮬레이션이 종료되지 않은 시점에도 현재까지 발견된 오류 내지는 이상 징후에 대한 즉각적인 디버깅을 시작할 수 있도록 하는 것이다.

본 발명의 또 다른 목적으로는, DUV에 대한 스위칭 활동(switching activity) 분석이나 동적 전력(dynamic power) 분석과 같은 시뮬레이션-기반의 분석을 정확하게 수행하기 위하여 게이트수준의 네트리스트와 배치/배선에서 추출된 타이밍 정보를 이용하여서 지연시간이 고려된 정확한 타이밍 시뮬레이션을 일정 시뮬레이션 구간에서 수행하여야 하거나, 혹은 RTL 수준의 설계코드를 이용하여서 함수적 시뮬레이션을 일정 시뮬레이션 구간 내지는 시뮬레이션 전체 구간에서 수행하여야 하는 경우에 상기 특정 추상화 수준에서의 시뮬레이션을 이와 같은 일정 시뮬레이션 구간에서만 신속하게 수행시킬 수 있게 하거나 병렬적인 수행으로 전체 구 간에 대한 시뮬레이션을 신속하게 수행하게 함으로서 상기 시뮬레이션-기반의 분석을 신속하면서도 정확하게 수행될 수 있게 하는 것이다.

본 발명의 또 다른 목적으로는, DUV에 대한 스위칭 활동(switching activity) 분석이나 동적 전력(dynamic power) 분석과 같은 시뮬레이션-기반의 분석을 정확하게 수행하기 위하여 게이트수준의 네트리스트와 배치/배선에서 추출된 타이밍 정보를 이용하여서 지연시간이 고려된 정확한 타이밍 시뮬레이션을 DUV내의 1 이상의 특정 설계객체에 대하여 수행하여야 하거나, 혹은 RTL 수준의 설계코드를 이용하여서 함수적 시뮬레이션을 DUV내의 1 이상의 특정 설계객체에 대하여 수행하여야 하는 경우에 상기 특정 추상화 수준에서의 시뮬레이션을 이와 같은 1 이상의 특정 설계객체에 대해서만 신속하게 수행시킬 수 있게 하거나 병렬적인 수행으로 2 이상의 특정 설계객체들에 대한 시뮬레이션을 신속하게 수행하게 함으로서 상기 시뮬레이션-기반의 분석을 신속하면서도 정확하게 수행될 수 있게 하는 것이다.

본 발명의 또 다른 목적으로는, 설계 복잡도가 큰 DUV를 효과적으로 검증하는 방법으로서 DUV 내지는 DUV 내의 1 이상의 설계객체들에 대한 추상화 수준을 높임으로서 검증 실행의 속도(예로 시뮬레이션의 실행 속도)를 높이는 경우에 부정적인 반대 급부로서 검증 실행의 결과도 높아진 추상화 수준에 맞추어지게 됨으로서 정확도의 희생이 필요(예로 이벤트-기반의 시뮬레이션 대신에 사이클-기반의 시뮬레이션을 수행하는 경우에 시뮬레이션의 속도는 최대 10배 이상 증가하지만, 비동기적 동작상황 등에 대한 정확한 결과를 얻는 것은 불가능함)하게 되는데, 이와 같은 경우에도 추상화에 의한 검증 실행의 속도를 높이는 것과 동시에 검증 결과의 정확도는 상기 추상화 수준보다 높은 수준에서 얻을 수 있는 검증 방법(예로, 사이클-기반의 시뮬레이션에 의한 시뮬레이션 속도 향상을 얻는 동시에, 시뮬레이션의 결과는 이벤트-구동 시뮬레이션의 정확도를 얻는 시뮬레이션 방법)을 제공하는 것이다.

상기 목적들을 달성하기 위하여, 본 발명에 따른 설계 검증 장치는 검증 소프트웨어와 1 이상의 검증플랫폼(예로, 1 이상의 임의의 HDL 시뮬레이터로 구체적으로는 Cadence NC-Verilog/NC-VHDL, Synopsys VCS/VCS-MX, Mentor Graphic ModelSim, Aldec Active-HDL/Riviera 등)이 인스톨된 1 이상의 컴퓨터로 구성된다. 검증 소프트웨어는 컴퓨터에서 실행되며, 만일 상기 설계 검증 장치에 2 이상의 컴퓨터들이 있는 경우에는 이들 2 이상의 컴퓨터는 네트워크(예로, 기가비트-이더넷과 같은 LAN(Local Area Network), 내지는 인터넷과 같은 WAN(Wide Area Network) 등. 앞으로 본 명세서에서는 이와 같은 LAN이나 WAN 등을 컴퓨터 네트워크 내지는 줄여서 네트워크로 통칭함)로 연결되어 컴퓨터들 간에 파일들의 이동을 네트워크를 통하여 가능하게 한다. 상기 1 이상의 검증플랫폼은 시뮬레이터 내지는 시뮬레이션가속기 내지는 모델검사기(model checker)/특성검사기(property checker)와 같은 정식검증기(formal verification tool) 내지는 하드웨어에뮬레이터 내지는 프로토타이핑 시스템(예로 FPGA 프로토타이핑보드)이 될 수 있지만, 특별한 언급이 없는 한 검증플랫폼을 시뮬레이터로 한정하여서 설명하기로 한다. 또한 검증 플랫폼으로는 시뮬레이터 내지는 모델검사기/특성검사기와 같은 정식검증기 내지는 시뮬레이 션가속기(Tharas사의 Hammer 시리즈, Pittsburgh Simulation사의 V-500, Cadence사의 Excite 시리즈등) 내지는 하드웨어에뮬레이터(Cadence사의 Palladium/Extreme 시리즈, Mentor Graphic사의 V-Station/Celaro 시리즈 등으로 최근의 하드웨어에뮬레이터는 모두 시뮬레이션가속 기능을 내장함) 내지는 프로토타이핑 시스템(EVE사의 ZeBu 시리즈, Aptix사의 SystemExplorer/Pathfinder 시리즈, S2C사의 IP porter 시리즈, Alatek 사의 HES 시리즈, Dynalith사의 iProve 시리즈 등)이 있는데, 여기서 시뮬레이터 내지는 모델검사기/특성검사기와 같은 정식검증기를 소프트웨어-방식 검증플랫폼이라 통칭하고 시뮬레이션가속기 내지는 하드웨어에뮬레이터 내지는 프로토타이핑 시스템을 하드웨어-기반 검증플랫폼이라 통칭한다.

상기 1 이상의 검증플랫폼이 시뮬레이터(예로 HDL 시뮬레이터)인 경우에는, 이들 시뮬레이터는 이벤트-구동 시뮬레이터로만 구성될 수도 있고, 혹은 이벤트-구동 시뮬레이터와 사이클-기반 시뮬레이터로 같이 구성될 수도 있고, 혹은 사이클-기반 시뮬레이터로만 구성될 수도 있고, 혹은 사이클-기반 시뮬레이터와 트란젝션-기반 시뮬레이터로 같이 구성될 수도 있고, 혹은 이벤트-구동 시뮬레이터와 사이클-기반 시뮬레이터와 트란젝션-기반 시뮬레이터로 같이 구성될 수도 있다.

본 발명에서 제안되는 검증 장치와 검증 방법은 검증 플랫폼이 시뮬레이터인 경우에는 하드웨어 설계 코드 자체를 검증하는 함수적 검증(functional verification)에 사용될 수 있을 뿐만 아니라, 설계 코드를 합성한 게이트수준의 네트리스트를 이용한 게이트수준의 검증에서도 사용될 수 있고, 또는 배치(placement) 및 배선(routing)이 되고 추출된 타이밍정보를(예로, SDF 형식으로 추 출된 타이밍정보를) 게이트수준의 네트리스트에 첨부시켜(back-annotated) 수행하는 타이밍 검증에서도 사용될 수 있다. 뿐만 아니라, 함수적 검증에서도 레지스터전송수준(Register Transfer Level, 앞으로 이를 RTL로 약칭함)에서 뿐만 아니라, 이보다 상위 수준인 행위수준(behavioral level)이나 트란젝션수준(transaction level)에서도 적용할 수 있다. 뿐만 아니라, 이들 여러 수준들에서의 검증들을 통합화하여 진행되는 혼용 수준에서의 검증에서도 적용 되어질 수 있다.

상기 본 발명에서의 검증 소프트웨어는 설계 코드를 읽어 들인 후에 설계 코드에다 추가적으로 부가 코드나 부가 회로를 자동화된 방식으로 부가한다. 부가 코드나 부가 회로는 기본적으로 추가되어지는 HDL 코드 내지는 SDL 코드 내지는 HVL 코드 내지는 C/C++ 코드 내지는 시뮬레이션 명령어 내지는 이들의 조합들로서, 시뮬레이션을 수행하는 과정에서의 시뮬레이션 시간 상에서 일정 간격이나 혹은 1 이상의 특정 시뮬레이션 시점들이나 시뮬레이션 구간(여기에서 구간의 의미는 1 이상의 시뮬레이션 시점들이 모인 복수개의 시뮬레이션 시점들을 나타내는 시간 구간의 의미이나, 앞으로는 편의상 구간으로 약칭함)들에서 시뮬레이션의 상태나, 가시도가 필요한 DUV에서의 1 이상의 설계객체(추후에 설명됨)들의 상태와 경우에 따라서는 TB의 상태까지를 저장하는 역할을 수행하고, 또한 추후에 사용자의 요구에 따라서 저장된 시뮬레이션의 상태나, 저장된 상기 가시도가 필요한 DUV에서의 1 이상의 설계객체들의 상태로부터 내지는 저장된 상기 가시도가 필요한 DUV에서의 1 이상의 설계객체들의 상태와 TB의 상태로부터 다시 시뮬레이션을 재개하게 한다. 가시도가 필요한 DUV에서의 1 이상의 설계객체들의 상태는 저장하지만, TB의 상태를 저장하 지 않는 경우에는 이 대신에 시뮬레이션 전 구간에 걸쳐서 최소한 상기 가시도가 필요한 DUV에서의 1 이상의 설계객체들의 모든 입력 값들과 입력모드시의 모든 입출력 값들을 이 입력들에서나 입출력들에서 매 이벤트 발생시마다 내지는 매 사이클마다 내지는 매 트란젝션마다 저장하는 것이 필요하다. 시뮬레이션의 상태(state of simulation)란 시뮬레이터라는 소프트웨어 프로그램이 수행되는 과정에서의 특정 시뮬레이션 시점에서 시뮬레이터의 모든 정적 정보와 동적 정보를 일컫는 말이다. 이는 멀티프로그래밍 환경에서 임의의 프로그램(혹은 프로세스 내지는 쓰레드)이 잠시 수행을 멈추는 상태(wait)로 갔다가 나중에 다시 재개(resume)하기 위해서 저장이 되어져야 하는 프로그램의 상태 정보와 유사하다. 설계객체의 상태(state of design object)란 설계객체에 존재하는 변수나 시그널들의 특정 시뮬레이션 시점이나 특정 구간에서의 값들을 일컫는 말로서, 특정 설계객체의 상태 정보는 완전상태 정보와 불완전상태 정보로 나눌 수 있고 최소상태 정보는 불완전상태 정보의 특별한 경우이다. 특정 설계객체의 완전상태란 해당 설계객체에 존재하는 모든 변수나 시그널들의 특정 시뮬레이션 시점이나 특정 구간에서의 값들을 일컫는 말이고 설계객체의 불완전상태란 해당 설계객체에 존재하는 1 이상의 임의의 변수나 시그널들의 특정 시뮬레이션 시점이나 특정 구간에서의 값들을 일컫는 말이다. 또한 설계객체의 최소상태란 해당 설계객체에 존재하는 모든 변수나 시그널들 중에서 기억소자(기억소자란 플립플롭 혹은 래치 혹은 메모리셀을 말함)의 출력 이름이 되는 변수나 시그널들만의 값들과 조합궤환루프(combinational feed-back)가 상기 가시도가 필요한 DUV에서의 1 이상의 설계객체들에 존재하는 경우에는 궤환루프 경로상 의 이름이 되는 변수나 시그널들만의 값을 모두 합친 것을 일컫는 말이다. TB의 상태란 TB에 존재하는 변수나 시그널들의 특정 시뮬레이션 시점이나 특정 구간에서의 값들을 일컫는 말이다. 또한 이와 같은 저장된 시뮬레이션의 상태나, 저장된 가시도가 필요한 DUV에서의 1 이상의 설계객체들의 상태와 경우에 따라서는 TB의 상태로부터(가시도가 필요한 DUV에서의 1 이상의 설계객체들의 상태는 저장하지만, TB의 상태를 저장하지 않는 경우에는 TB의 상태 대신에 시뮬레이션 전 구간에 걸쳐서 최소한 상기 가시도가 필요한 DUV에서의 1 이상의 설계객체들의 모든 입력 값들과 입력모드시의 모든 입출력 값들을 이 입력들에서나 입출력들에서 매 이벤트 발생시마다 내지는 매 사이클마다 내지는 매 트란젝션마다 저장된 것과 상기 저장된 가시도가 필요한 DUV에서의 1 이상의 설계객체들의 상태를 이용하여서) 다시 시뮬레이션을 재개하는 경우에는 사용자의 의도에 따라서 설계 코드에 존재하는 모든 시그널들과 변수들에 대한 탐침을 수행하기 위한 덤프를 병행하거나 혹은 설계 코드에 존재하는 특정 시그널들이나 변수들에 대한 탐침을 수행하기 위한 덤프를 병행한다. 시뮬레이터로 HDL 시뮬레이터(예로, Verilog 시뮬레이터나 VHDL 시뮬레이터나 SystemVerilog 시뮬레이터 등)를 사용하는 경우에 시뮬레이션의 상태를 저장하는 방법의 한 예로서 HDL 시뮬레이터의 save(NC-Verilog, Verilog-XL, VCS의 경우)나 혹은 checkpoint(ModelSim의 경우)라는 명령을 사용하고, 저장된 특정 시뮬레이션 상태로부터 시뮬레이션을 특정 시간에서부터 재개하는 방법의 한 예로서 HDL 시뮬레이터의 restore(ModelSim) 혹은 restart(NC-Verilog, Verilog-XL, VCS)와 같은 명령을 사용할 수 있다. 또한 1 이상의 특정 설계객체의 저장된 상태를 특정 시뮬 레이션 시작 시에 해당 상기 1 이상의 특정 설계객체의 초기 상태(initial state로 시뮬레이션이 시작하게 되면 해당 설계객체의 상태 정보를 해당 초기 상태로 설정되어서 진행됨)로서 사용하여서 시뮬레이션을 하기 위해서는 상기 1 이상의 특정 설계객체내에 존재하는 해당 변수들이나 시그널들이 상기 저장된 상태의 값들을 가지고 시뮬레이션을 시작할 수 있도록 하면 된다. 이를 위해서는 시뮬레이터에서 제공하는 다양한 제어능력(controllability) 방법들을 사용할 수 있는데, Verilog의 경우에 일 예들을 든다면 시뮬레이터의 XMR(Cross Module Reference)을 이용하면서 force/release 시스템테스크를 이용하거나, 혹은 force/release 내지는 assign/deassign procedural continous assignment statement를 사용하거나, 혹은 원 HDL 코드의 1 이상의 해당 모듈들에 initial statement를 추가 함과 동시에 메모리를 모델링 하기 위하여 REG type의 ARRAY가 선언되어져 있는 경우에는 시스템 테스트 ＄readmemb 내지는 ＄readmemh을 사용하면서, 필요시에 추가적인 PLI/VPI(VHDL의 경우에는 FLI)와 같은 HDL의 시스템 테스크나 함수들 혹은 HDL에서 정의된 다양한 assignment문 등을 사용할 수 있다. 따라서, 본 검증 장치의 검증소프트웨어를 통하여서 상기의 부가코드나 부가 회로가 원 설계 코드에 부가되어져서 이와 같은 기능 들을 자동적으로 수행할 수 있도록 한다. 이와 같은 시뮬레이션 방법이 검증의 성능 향상 및 효율성을 증대시킬 수 있는 이유는 다음과 같다. 이미 언급된 대로 시뮬레이션을 통하여 검증을 수행하는 과정에서는 설계 오류를 발견하고 이를 수행하는 과정에서 반드시 설계 코드에 존재하는 특정 시그널들이나 변수들의 값들을 특정 시간대에서 알 수 있도록 하는 탐침(probing)하는 과정 등의 가 시도를 얻는 과정이 항상 필요하다. 그러나 문제는 이와 같은 설계 코드에서 설계 오류를 발견하고 이를 수정하기 위해서 탐침이 필요한 특정 시그널들이나 변수들이 어떤 것인지를 시뮬레이션 수행 전에 정확히 예측할 수가 없을 뿐만 아니라, 이들 탐침 대상의 탐침 시점이 언제 필요한지도 시뮬레이션 수행 전에 정확히 예측할 수가 없다. 따라서 시뮬레이션을 1차 적으로 수행하여 얻어지는 시뮬레이션 결과를 바탕으로 설계 오류의 위치를 파악하기 위하여 필요한 특정 시뮬레이션 시점에서의 특정 시그널들이나 변수들을 탐침 대상으로 선정한 후에 2차 시뮬레이션을 시뮬레이션 시간 0에서부터 1차 시뮬레이션 종료시점까지 진행하면서 탐침 대상이 된 시그널들이나 변수들을 특정 시간대에서 덤프를 수행하게 된다. 이와 같이 2차 시뮬레이션 과정에서도 설계 오류의 위치를 파악하지 못하면, 새로운 시그널들이나 변수들을 탐침 대상으로 선정하고 시뮬레이션을 다시 시뮬레이션 시간 0에서부터 반복하게 되며, 이와 같은 과정을 설계 오류의 위치가 발견되기까지 수 차례 반복하는 과정이 필요하다. 그러나 이와 같은 반복적인 시뮬레이션을 시뮬레이션 시간 0에서부터 2회 이상 반복하게 됨으로서 전체 검증 시간은 크게 늘어나게 된다. 만일 이와 같은 반복적인 시뮬레이션을 피하고자 하는 경우에는 제일 처음 수행하는 시뮬레이션 수행 시에 설계 코드에 존재하는 모든 시그널들과 변수들을 탐침 대상으로 설정하고 시뮬레이션 전 과정에 걸쳐서 이들을 덤프하면서 진행하여야 한다. 그러나 이와 같이 설계 코드에 존재하는 모든 시그널들과 변수들을 덤프하면서 시뮬레이션을 진행하게 되면 덤프를 진행하지 않고 시뮬레이션을 진행하는 것에 비하여 시뮬레이션 시간이 대략 2배에서부터 최대 10배 이상 증가하게 되어 이 또한 전체 검증 시간을 크게 늘리게 된다. 뿐만 아니라 이와 같이 설계 코드에 존재하는 모든 시그널들과 변수들을 전체 시뮬레이션 구간에 걸쳐서 덤프하게 되면 덤프되는 시뮬레이션 파형(simulation waveform) 데이터의 크기가 수십 기가바이트에서부터 수백 기가바이트 이상 증가하게 된다. 이와 같은 큰 용량의 시뮬레이션 파형 데이터를 저장하기 위해서는 대용량의 하드디스크를 필요로 할 뿐만 아니라, 이와 같이 특정 형식(예로, Verilog의 VCD/extended-VCD 형식 내지는 Novas사의 FSDB 형식 내지는 SHM, VCD+와 같은 특정 시뮬레이터 벤더들의 압축된 파형형식)으로 하드디스크에 저장된 시뮬레이션 파형 데이터를 컴퓨터로 읽어와서 파형분석기(waveform viewer)로 분석하는 과정에서도 매우 긴 시간이 필요하게 되어 이 또한 전체 검증 시간을 증가시키게 된다. 본 특허에서 제안되는 시뮬레이션 방법은 시뮬레이션의 구성을 앞단 시뮬레이션 단계와 후단 시뮬레이션 단계의 두 단계로 나누어서 수행되도록 한다. 앞단 시뮬레이션 단계에서는 1차 시뮬레이션 수행을 설계 코드에 존재하는 모든 시그널들과 변수들을 덤프하지는 않도록 함으로서 시뮬레이션 시간의 증가를 초래하지 않고 신속하게 시뮬레이션을 진행할 수 있게 한다. 이와 같은 1차 시뮬레이션 과정에서 수행되어지는 것은 후단 시뮬레이션 단계인 1차 시뮬레이션 시작 이후의 추가 시뮬레이션들을 기존 방법에서와 같은 시뮬레이션 시간 0에서 수행되지 않고 사용자가 관심이 있는 시뮬레이션 시간대에서 아주 가까운 곳에서부터 시작할 수 있도록 시뮬레이션 일정 간격(예로, 시뮬레이션 시작에서부터 매 100,000 나노초마다, 혹은 매 50,000 시뮬레이션 사이클마다)마다 혹은 원하는 시뮬레이션 시점들 t0, t1, .., tn(예로 t_1는 시뮬레이션 시작후 1,000,000나노초에서, t_2는 시 뮬레이션 시작후 2,000,000나노초에서, t_3는 시뮬레이션 시작후 3,000,000나노초에서, ... t_(n-1)은 시뮬레이션 시작후 99,000,000나노초에서) 내지는 원하는 시뮬레이션 구간들 p_0, p_1, .., p_(n-1)(예로 p_1는 시뮬레이션 시작후 1,000,000나노초에서부터 1,000,004나노초까지, p_2는 시뮬레이션 시작후 2,000,000나노초에서부터 2,000,004나노초까지, p_3는 시뮬레이션 시작후 3,000,000나노초에서부터 3,000,004나노초까지, ... p_(n-1)은 시뮬레이션 시작후 99,000,000나노초에서부터 99,000,004나노초까지)마다 시뮬레이션의 상태나, 혹은 가시도가 필요한 DUV에서의 1 이상의 설계객체들의 상태와 경우에 따라서는 TB의 상태 S0, S1, .., Sn를 저장(가시도가 필요한 DUV에서의 1 이상의 설계객체들의 상태는 저장하지만 TB의 상태를 저장하지 않는 경우에는 TB의 상태 저장 대신에 시뮬레이션 전 구간에 걸쳐서 최소한 상기 가시도가 필요한 DUV에서의 1 이상의 설계객체들의 모든 입력 값들과 입력모드시의 모든 입출력 값들을 이 입력들에서나 입출력들에서 매 이벤트 발생시마다 내지는 매 사이클 마다 내지는 매 트란젝션 마다 저장)시키는 것이다. 이상과 같이 상태정보를 저장하는 시점 내지는 구간을 T_capture라고 표기하기로 한다 (위 첫 번째 예의 경우에는 상태정보를 한 시점에서 저장함으로 T_capture = 0이며, 두 번째 예의 경우에는 상태정보를 저장하는 구간이 4나노초에 걸쳐 있음으로 T_capture = 4나노초임). 이상과 같이 하면 전체 시뮬레이션 시간 영역이 상태 저장 시점이나 구간들을 기준으로 하여서 2 이상의 시뮬레이션 시간 소영역으로 나누어지는데, 이들 각각의 시간 소영역을 슬라이스(slice)라고 칭하기로 한다. 모든 슬라이스들은 동일한 시뮬레이션 시간을 가질 수도 있고, 슬라이스별로 다른 시뮬레이션 시간을 가질 수도 있다. 또한 슬라이스의 시작 시점이 바로 앞에 있는 슬라이스의 종료 시점과 정확하게 일치할 수 도 있거나(즉, 오버랩되어 있지 않은 경우), 바로 앞에 있는 슬라이스의 끝 부분과 일정 정도 만큼 오버랩되어 있을 수도 있다. 이 경우에 슬라이스 들이 오버랩되어 있지 않은 경우를 불중복 슬라이스 상황이라 정의하고, 슬라이스 들이 오버랩되어 있는 경우를 중복 슬라이스 상황이라 정의하며 중복된 시간 영역의 크기를 슬라이스 오버랩 구간이라 정의한다. 예를 든다면 전체 시뮬레이션 시간 영역이 0부터 10,000,000나노초 이며, 이들을 10개의 슬라이스로 나누는 경우에 불중복 슬라이스 상황으로 나누게 된다면 Slice_0 = (0-1,000,000), Slice_1 = (1,000,000-2,000,000), Slice_2 = (2,000,000-3,000,000), Slice_3 = (3,000,000-4,000,000), Slice_4 = (4,000,000-5,000,000), Slice_5 = (5,000,000-6,000,000), Slice_6 = (6,000,000-7,000,000), Slice_7 = (7,000,000-8,000,000), Slice_8 = (8,000,000-9,000,000), Slice_9 = (9,000,000-10,000,000)이다. 또한, 이들을 10개의 슬라이스로 나누는 경우에 중복 슬라이스 상황으로 나누고, 슬라이스 오버랩구간이 10나노초라 가정하면 Slice_0 = (0-1,000,000), Slice_1 = (999,990-2,000,000), Slice_2 = (1,999,990-3,000,000), Slice_3 = (2,999,990-4,000,000), Slice_4 = (3,999,990-5,000,000), Slice_5 = (4,999,990-6,000,010), Slice_6 = (5,999,990-7,000,010), Slice_7 = (6,999,990-8,000,000), Slice_8 = (7,999,990-9,000,000), Slice_9 = (8,999,990-10,000,000)이다. 1 이상의 특정 시뮬레이션 시점이나 구간에서 설계객체 들의 상태나 입력/출력/입출력에서의 값들의 저장은 시뮬레이터의 각종 시스템 테스크 내지는 함수들(예로, 시스템 테스크인 ＄ dumpvars 내지는 ＄dumpport 내지는 ＄dumpall 내지는 ＄writememb 내지는 ＄writememh 내지는 PLI 함수호출 내지는 ＄fopen 등) 등을 통하여 수행되어진다. 1 이상의 특정 시뮬레이션 구간(일 예로 시뮬레이션 시점 1,000,000나노초부터 1,000,002나노초까지)에서 1 이상의 설계객체 들의 상태의 저장이나 입력/출력/입출력에서의 값들의 저장도 시뮬레이터의 각종 시스템 테스트 내지는 함수들(예로, 시스템 테스크인 ＄dumpvars 내지는 ＄dumpport 내지는 ＄dumpall 내지는 ＄writememb 내지는 ＄writememh 내지는 PLI 함수호출 내지는 ＄fopen 등) 등을 상기 1 이상의 특정 시뮬레이션 구간에 대하여 연속적으로 적용함으로 이루어지게 진다. 이를 위한 구체적인 방법의 일 예로는, 1 이상의 설계객체들의 상태의 저장은 ＄dumpvars 시스템 테스크 내지는 ＄dumpall을 사용하여서 설계객체내의 시그널이나 변수들(예로 Verilog를 사용한 경우에는 REG 타입 내지는 wire 타입으로 선언된 것들)의 값을 저장하고, 설계체내의 메모리들(예로 Verilog를 사용한 경우에는 REG 타입의 array로 선언된 것들)의 값들은 ＄writememb 내지는 ＄writememh을 사용하고, 1 이상의 설계 객체들의 입력/입출력 내지는 입력/입출력/출력들에서의 값들의 저장은 PLI 함수인 acc_fetch_direction, acc_fetch_defname, acc_fetch_size, acc_fetch_name, acc_fetch_value, acc_handle_by_name, acc_next_port, acc_vcl_add, acc_fetch_location, acc_vcl_add, acc_initialize, tf_getlongsimtime, tf_error, tf_nump, tf_igettimeunit, tf_igettimeprecision, tf_getp, tf_getcstringp 등을 함께 사용하여서 할 수 있다. 이는, HDL 시뮬레이션 이나 SDL 시뮬레이션 이나 HVL 시뮬레이션은 이산 시간(discrete time) 상에서 시 뮬레이션이 진행되는 것임으로 특정 시뮬레이션 구간 하나 pi는 1 이상 유한수(finite number)의 시뮬레이션 시점들 {ti_0, ti_1, ti_2, ..., ti_n-1}로 구성되어 있기 때문이다. 이와 같이 1 이상의 시뮬레이션 시점들이나 일정한 시뮬레이션 구간들에서 시뮬레이션의 상태나, 가시도가 필요한 DUV에서의 1 이상의 설계객체들의 상태와 경우에 따라서는 TB의 상태를 저장(가시도가 필요한 DUV에서의 1 이상의 설계객체들의 상태는 저장하지만, TB의 상태를 저장하지 않는 경우에는 TB의 상태 저장 대신에 시뮬레이션 전 구간에 걸쳐서 최소한 상기 가시도가 필요한 DUV에서의 1 이상의 설계객체들의 모든 입력 값들과 입력모드시의 모든 입출력 값들을 이 입력들에서나 입출력들에서 매 이벤트 발생시마다 내지는 매 사이클마다 내지는 매 트란젝션마다 저장)하게 되면, 이후부터는 재 시뮬레이션을 시뮬레이션 시간 0에서뿐만 아니라 이 각 시뮬레이션 시점들 t0, t1, ..., tn의 하나에서 내지는 각 시뮬레이션 구간들 p_0, p_1, ..., p_n들 중의 특정 구간 p_i내에 존재하는 임의의 시점들이나 구간들에서 부터도 가능하게 된다. 이를 위해서는 후단 시뮬레이션 단계인 1차 시뮬레이션 시작 이후에 수행되는 1회 이상의 시뮬레이션들 각각의 시뮬레이션에 대하여서 시뮬레이션의 맨 처음에 1 이상의 설계객체의 상태를 앞단 시뮬레이션 단계인 1차 시뮬레이션에서 저장된 1 이상의 설계객체의 상태들 각각으로 복원시키고서 시뮬레이션을 진행하는 것이 필요하다. 이와 같은 설계객체의 상태복원을 위해서는 시뮬레이터에서 제공되는 다양한 제어기능을 사용할 수 있다. 즉, Verilog 시뮬레이터의 경우에는 시뮬레이터의 XMR(Cross Module Reference)을 이용하면서 force/release 시스템테스크를 이용하거나, 혹은 force/release 내지는 assign/deassign procedural continous assignment statement를 사용하거나, 혹은 원 HDL 코드의 1 이상의 해당 모듈들에 initial statement를 추가 함과 동시에 메모리를 모델링 하기 위하여 REG type의 ARRAY가 선언되어져 있는 경우에는 ＄readmemb 내지는 ＄readmemh을 사용하면서, 필요시에 추가적인 PLI/VPI(VHDL 시뮬레이터의 경우에는 FLI)와 같은 시뮬레이터의 시스템 테스크나 함수들 혹은 HDL에서 정의된 다양한 assignment문 등을 사용할 수 있다. 이를 위한 구체적인 방법의 일 예로는, 1 이상의 설계객체들의 상태를 설정/복원시키는 경우에 force/release를 사용하여서 설계객체내의 시그널이나 변수들(예로 Verilog를 사용한 경우에는 REG 타입 내지는 wire 타입으로 선언된 것들)의 값을 설정/복원하고, 설계체내의 메모리들(예로 Verilog를 사용한 경우에는 REG 타입의 array로 선언된 것들)의 값들은 ＄readmemb 내지는 ＄readmemh을 사용하여서 설정/복원하고, 1 이상의 설계 객체들의 입력/입출력에 대한 값들의 인가는 HDL의 시스템테스크인 ＄fopen과 ＄readmemb 내지는 ＄readmemh을 사용하여서 할 수 있다. 설계객체의 상태를 특정 시뮬레이션 시점 t_i에 모두 설정/복원시키는 경우에는 t_i 시점에서 force를 한 후에 이어서 델타지연시간(델타지연시간은 실제적 크기의 지연시간치가 아닌, 이벤트 순서만을 결정해주는 가상의 매우 작은 지연시간임)을 가지고(즉 t_i + 델타지연시간) release를 할 수도 있고, 혹은 설계객체의 상태를 특정 시뮬레이션 구간 p_i에서 동시에 설정/복원시키는 경우에는 p_i의 시작시점에서 force를 한 후에 p_i의 끝시점에 release를 할 수도 있고(예로 p_i가 시뮬레이션 시작후 1,000,000나노초에서부터 1,000,004나노초까지이면 상태 정보를 갖는 모든 변수나 시그널들을 1,000,000나노초에서 force하고 1,000,004나노초에서 release함), 혹은 설계객체의 상태를 특정 시뮬레이션 구간 p_i에서 상태 정보를 갖는 모든 변수나 시그널들을 일정한 순서대로 설정/복원시키는 경우에는 구간 p_i 사이에서 일정한 순서에 의하여 변수나 시그널들을 force를 한 후에 release를 할 수도 있다(예로 p_i가 시뮬레이션 시작후 1,000,000나노초에서부터 1,000,004나노초까지이고, 상태 정보를 갖는 모든 변수나 시그널들이 v1, v2, v3, v4, v5 인 경우에 v1과 v2는 1,000,000나노초에서 force후에 1,000,000+델타지연시간 후에 release, v3는 1,000,001나노초에서 force후에 1,000,001+델타지연시간 후에 release, v4는 1,000,002나노초에서 force후에 1,000,002+델타지연시간 후에 release, v5는 1,000,004나노초에서 force후에 1,000,004+델타지연시간 후에 release).

위에서 언급한 후단 시뮬레이션에서 1 이상의 설계객체들에 대한 상태 설정/복원을 수행하는 경우에 상기 1 이상의 설계객체들의 설계 규모가 천만 게이트급을 넘어가는 경우에는 상기의 상태 설정/복원을 최소상태에 대하여 상태 설정/복원을 수행하는 것이 효과적이며 현실적이다. 이와 같은 경우에 상태 설정/복원의 시점을 결정하는 구체적 방법들 중의 하나를 구체적으로 설명하면 다음과 같다. 우선, 앞단 시뮬레이션에서 사용된 1 이상의 설계객체들로부터 최소상태를 결정하는 모든 시그널 및 변수(즉, 플립플롭의 출력 내지는 래치의 출력 내지는 메모리셀의 출력에 대응되는 시그널 및 변수)들을 조사하고, 이들 각각의 값들을 변화시킬 수 있는 드라이버 시그널 내지는 변수들도 조사한다 (예로 D 플립플롭의 행위를 플립플롭의 출력 시그널 QOUT과 입력 시그널 CLOCK과 또 다른 입력 시그널 DIN으로 모델링한 경우에, QOUT의 드라이버 시그널은 CLOCK과 DIN). 다음으로는, 드라이버 시그널들 중에서 필수 드라이버 시그널들을 조사하는데, 필수 드라이버 시그널들이란 이 소자의 모델링 시에 올바른 모델링을 위하여 시뮬레이션의 sensitivity list에 반드시 포함되어져야 하는 드라이버 시그널들을 말한다 (예로 위 D 플립플롭의 드라이버 시그널들 CLOCK와 DIN 중에서는 CLOCK만이 필수 드라이버 시그널임). 이상과 같이 최소상태를 결정하는 모든 시그널과 변수들 각각에 대한 필수 드라이버 시그널들이나 변수들이 인과관계(cause-effect relation) 각각 R(S_i) = (S_i ＜= #d (CD_1, CD_2, ..., CD_n))으로 표시하고, 최소상태를 구성하는 모든 시그널과 변수들의 이와 같은 인과관계 모두를 합친 것을 MS = { R(S_1), R(S_2), ..., R(S_k) }라고 표시한다. 또한 일반적으로 설계코드에 구술되어진 R(S_i)의 모델링에서 지연시간도 모델링을 하는 것이 일반적인데, 이 지연시간을 R(S_i) = (S_i ＜= #d (CD_1, CD_2, ..., CD_n))에서 d로 표시한다 (예로 위 D 플립플롭의 경우에 클럭에 라이징에지가 있고 이 라이징에지 시점부터 1ns 후에 QOUT이 변하는 경우로 구술되어져 있다면, d는 1ns이고 R(DOUT) = #1 (DOUT ＜= (CLOCK))임). 이상과 같은 각 인과관계는 최소상태를 구성하는 각 시그널이나 변수에 대하여 d로 표시되는 시간개념이 고려된 (결과 ＜= #d (원인들))의 정보를 가지고 있게 된다. 이와 같은 경우에 후단 시뮬레이션에서의 특정 슬라이스를 위한 특정 최소상태 설정/복원의 시점들로서 결정되는 T_f와 T_r의 시점(T_f는 force하는 시점, T_r은 release하는 시점)이 T_f와 T_r 사이에 MS에 존재하는 모든 R(S_i) (i=1, 2, ..., k)들 각각에서 존재하는 (결과 ＜= #d (원인들))에서의 "원인들이 발생하는 시점들"과 "결과가 나 타나는 시점"이 모두 포함되도록 설정 되든지 (이를 설정시점 방법 1로 지칭함), 혹은 T_r의 시점이 MS에 존재하는 모든 R(S_i)들 각각에 존재하는 (결과 ＜= #d (원인들))_i에서의 "원인들이 발생하는 시점들(i)"과 "결과가 나타나는 시점(i)" (i=1, 2, ..., k)의 사이에 일절 존재하지 않도록 설정 되어져야 한다 (이를 설정시점 방법2로 지칭함). 설정시점 방법 1의 경우에, force가 되는 최소 상태 값들은 상기 "원인들이 발생하는 시점들" 모두에서 시간적으로 제일 앞서있는 원인발생 시점에서부터 상기 "결과가 나타나는 시점" 모두에서 시간적으로 제일 위에 있는 결과발생 시점까지의 일정 구간에서의 모든 최소 상태 값들이다 (따라서 force되는 최소 상태 값은 상기 force와 release되는 구간에서 계속적으로 변이가 될 수 있음). 설정시점 방법 2의 경우에, force를 위한 최소 상태 값은 상기 T_r 시점에서의 최소 상태 값(이를 S_min(T_r)으로 표기함)이며, S_min(T_r)을 force하는 시점은 시뮬레이션 시간 0에서부터 T_r 시점 사이에 존재하는 임의의 시점이 될 수 있으나, 가장 일반적으로는 시뮬레이션 시간 0에서부터 S_min(T_r)을 force하고 T_r 시점에서 release하거나, T_r 시점보다 상당히 시간적으로 앞선 시점 (예로 T_r 시점보다 1-10 사용자클럭 주기 앞선 시점. 여기서 사용자클럭이 1 이상인 경우에는 사용자클럭 중에서 제일 느린 클럭을 선택)에서 force하고 T_r 시점에서 release하게 된다 (따라서 force되는 최소 상태 값은 release될 때까지 변이가 없음). 위에서 언급된 설정시점 방법 1과 설정시점 방법2 모두에서의 공통점은 T_r의 시점이 MS에 있는 개개의 R(S_i) (i=1, 2, ..., k)에 존재하는 (결과 ＜= #d (원인들))_i에서의 "원인들이 발생하는 시점들(i)"과 "결과가 나타나는 시점(i)" (i=1, 2, ..., k)에서 존재하는 인과관계시간구간들의 어떤 특정 인과관계시간구간 사이에도 위치하지 않는다는 것인데, 이와 같이 T_r의 시점을 설정하는 것을 인과관계보장가능 시점설정(cause-effect preserving time set-up)이라고 약칭하고, 앞으로는 이와 같은 약칭명을 사용하기로 한다.

앞단 시뮬레이션 단계인 1차 시뮬레이션을 통하여 설계 코드(설계 코드란 DUV 내지는 TB를 구술한 코드)에 존재하는 시그널들이나 변수들 중에서 설계 오류의 위치를 찾기 위하여 탐침이 필요한 특정 시그널들이나 변수들을 선정(필요한 경우에는 설계 코드에 존재하는 모든 시그널들과 변수들을 선정)하고 이들 탐침 대상에 대한 탐침이 어느 시뮬레이션 시간대에서 필요한 가를 파악한 다음(파악하는 방법의 예로는 로깅을 하거나 주장기법(assertion technique)을 사용하는 것임)에, 후단 시뮬레이션 단계에서 수행되는 1차 시뮬레이션 시작 이후에 수행되는 시뮬레이션들에서는 앞단 시뮬레이션 단계인 1차 시뮬레이션에서 저장된 1 이상의 시뮬레이션 상태나, 저장된 가시도가 필요한 DUV에서의 1 이상의 설계객체들의 상태 저장과 경우에 따라서는 TB의 상태들에서 이 저장(가시도가 필요한 DUV에서의 1 이상의 설계객체들의 상태는 저장하지만, TB의 상태를 저장하지 않는 경우에는 TB의 상태 저장 대신에 시뮬레이션 전 구간에 걸쳐서 최소한 상기 가시도가 필요한 DUV에서의 1 이상의 설계객체들의 모든 입력 값들과 입력모드시의 모든 입출력 값들을 이 입력들에서나 입출력들에서 매 이벤트 발생시마다 내지는 매 사이클마다 내지는 매 트란젝션마다 저장)이 일어난 시뮬레이션 시간이 탐침이 필요한 시뮬레이션 시간대 (ts,te)의 시작시점 ts에서 시뮬레이션 시간적으로 앞서면서(시뮬레이션 시간 10,000 나노초와 20,000 나노초가 있는 경우에, 10,000 나노초는 20,000 나노초에 비하여 시간적으로 앞서 있다고 하고, 20,000 나노초는 10,000 나노초에 비하여 시간적으로 뒤에 있다고 함) 제일 가까운 곳에 있는 시간대로 시뮬레이션 시간을 재설정하기 위하여 해당 시점의 시뮬레이션 상태 내지는 가시도가 필요한 DUV에서의 1 이상의 설계객체들의 저장된 상태와 TB의 상태까지 저장된 경우는 TB의 저장된 상태까지를 갖는 상태 Si로 시뮬레이션의 상태나 가시도가 필요한 DUV에서의 1 이상의 설계객체들의 상태와 TB의 상태까지 저장된 경우는 TB의 저장된 상태 각각으로 상기 1 이상의 설계객체들과 TB의 상태를 설정(TB의 상태를 저장하지 않은 경우에는 상기 가시도가 필요한 DUV에서의 1 이상의 설계객체들의 상태만을 이용함)하고 시뮬레이션 시간 ti에서부터 te까지 시뮬레이션을 수행하면서 해당 탐침 대상에 대한 탐침을 진행하고, 필요시에는 Si보다 시간적으로 앞선 시뮬레이션 상태나 가시도가 필요한 DUV에서의 1 이상의 설계객체들의 저장된 상태와 경우에 따라서는 저장된 TB의 상태들 Si-1, Si-2, .., Si-n 각각으로 시뮬레이션의 상태나 가시도가 필요한 DUV에서의 1 이상의 설계객체들의 상태와 TB의 상태까지 저장된 경우는 TB의 저장된 상태 각각으로 상기 1 이상의 설계객체들과 TB의 상태를 순차적을 설정(TB의 상태를 저장하지 않은 경우에는 상기 가시도가 필요한 DUV에서의 1 이상의 설계객체들의 상태만을 이용함)하면서 각각의 시뮬레이션 시간 ti-1, ti-2, .., ti-n에서부터 ti, ti-1, .., ti-n+1까지 순서적으로 추가적인 n번의 시뮬레이션을 순차적으로 설계 코드에서 설계 오류의 위치와 원인이 밝혀 질 때까지 진행한다. 따라서 이와 같은 과정을 통하여 설계에 대한 디버깅을 신속하게 할 수 있는데, 이 와 같은 과정은 기존의 시뮬레이션 기반의 검증 방법들에 비하여 검증 시간을 크게 단축시켜 줄 수 있음으로 매우 효율적인 검증 방법이 된다. 이와 같은 시뮬레이션 방법을 A 시뮬레이션 방법이라고 칭한다.

또 다른 방법으로서는 설계 코드에서 DUV나 테스트벤치에 존재하는 계층 구조를 이용한 분할 및 정복(divide ＆ conquer) 방법을 사용할 수 있다. 이 경우에는 검증 소프트웨어가 설계 코드를 읽어 들여서 DUV와 테스트벤치에 대하여 분할을 수행하여 설계 코드를 2 이상의 설계블록들로(M개의 설계블록들로 분할되었다고 가정) 나누고, 이 설계블록 각각에 존재하는 모든 입력과 입출력들을 탐침 대상으로 선정한 후에 이들 탐침 대상들이 앞단 시뮬레이션 단계인 1차 시뮬레이션 과정에서 덤프되어질 수 있도록 설계 코드에 부가 코드나 부가 회로를 부가한다. 여기서 설계블럭(design block)들이란 크게 DUV 뿐만 아니라 테스트벤치 모두를 포함한다. 뿐만 아니라, 이들 DUV와 테스트벤치는 일반적으로 계층적인 구조로 내부에 다양한 1 이상의 하위모듈들을 가지고 있는데, 이들 하위모듈 각각도 설계블럭이라고 할 수 있다. 이와 같은 설계블럭들이나 DUV, 그리고 테스트벤치 각각이나 이들의 조합들을 모두 설계객체(design object)들이라고 할 수 있다. 따라서 DUV 전체가 하나로서 설계객체가 될 수 있을 뿐만 아니라, DUV 내부에 존재하는 특정 설계블럭 하나도 설계객체가 될 수도 있고, 2 이상의 설계블럭들이 모여서 하나의 설계객체가 될 수도 있다. 앞단 시뮬레이션 단계인 1차 시뮬레이션을 수행하면서 각 설계블록들의 모든 입력과 입출력들을 덤프하여 파일 형태로 저장한 후에, 이를 본 발명의 검증 소프트웨어를 이용하여 해당 설계블록들에 대한 M개의 테스트벤치들로 변환하 여 해당 설계블록의 설계 코드와 같이 해당 테스트벤치를 같이 시뮬레이션 컴파일을 수행하여 M개의 설계블록들에 대응되는 M개의 시뮬레이션 실행파일을 생성한다. 이와 같이 각 설계블록별로 새로운 테스트벤치를 생성하여 시뮬레이션 컴파일을 수행하여 별도의 시뮬레이션 실행파일을 생성하게 되는 것에 비하여, 해당 설계블록들의 모든 입력들과 입출력들을 탐침된 파일(예로, VCD/extendted VCD 파일 내지는 FSDB 파일)을 테스트벤치화 하지 않고 직접 이용하게 되면 변환 시간과 시뮬레이션 컴파일 시간을 절약할 수 있지만 해당 설계블록을 추후에 시뮬레이션 하는 경우에 필요한 입력값들을 상기 탐침된 파일에서 읽어서 인가해주기 위하여서는 API(Application Program Interface)를 사용하는 것(Verilog에서는 VPI/PLI, VHDL에서는 FLI 등)이 필요하다. 그러나 이와 같은 API를 사용하여 별도의 코드를 시뮬레이터에 연동시키게 되면 API 오버헤드로 인하여 시뮬레이션의 속도가 저하됨으로 득보다 실이 많을 수 있으나 이는 사례마다 달라진다. 또한, 최근에 사용되는 특정 시뮬레이터(예로, Synopsys의 VCS 7.0이상)에서는 API를 사용하지 않고 외부 코드모듈(예로, C, C++ 코드)를 시뮬레이터에 연동시키는 것이 가능하기도 한데, 이와 같은 경우에는 직접 앞단 시뮬레이션 단계인 1차 시뮬레이션에서 덤프를 통하여 얻어진 탐침 파일을 직접 이용하여 시뮬레이션 컴파일을 수행하여 M개의 시뮬레이션 실행 파일을 생성하는 것도 가능하다. 이 후에 설계 오류에 대한 위치를 파악하기 위하여 추가적인 시그널들이나 변수들에 대한 탐침이 필요한 경우에는 상기 M개의 시뮬레이션 실행파일들 중에서 해당 시그널들이나 변수들이 존재하는 해당 설계블록과 상기 1차 시뮬레이션 후에 생성된 덤프 파일이나 테스트벤치로써 시뮬레이션 컴파일하여 얻어진 특정 시뮬레이션 실행파일을 이용한 추가적인 시뮬레이션을 하게 된다. 이와 같은 추가적인 시뮬레이션에서는 해당 설계블록들에 존재하는 모든 시그널들이나 변수들에 대한 탐침을 수행하면서 시뮬레이션을 진행하거나, 또는 관심대상이 되는 특정 시그널들이나 변수들에 대한 탐침을 수행하면서 시뮬레이션을 진행한다. 만일, 탐침이 필요한 특정 시그널들이나 변수들이 2 이상의 설계블록들에 분산되어져서 존재하는 경우에는 이들 설계블록들에 대하여 상기 설계블록이 하나인 과정과 동일한 과정들을 순서적으로 반복하여 수행하여 각 과정에서 얻어진 탐침 결과들을 통합하면 된다. 이와 같이 원래의 DUV와 원래의 복잡한 테스트벤치 전체를 시뮬레이션하지 않고서 특정 설계블록들과 덤프 파일이나 새롭게 생성된 테스트벤치만을 이용한 시뮬레이션을 수행하게 되면 시뮬레이션 속도를 크게 증가시킬 수 있다. 이와 같은 시뮬레이션 방법은 B 시뮬레이션 방법이라 칭한다. 또한 B 시뮬레이션 방법에서 앞단 시뮬레이션 단계인 1차 시뮬레이션에서 VPI/PLI/FLI 등을 사용하여서 시뮬레이션을 진행하면서 VCD 내지는 FSDB를 생성하는 대신에 집적 1 이상의 테스트벤치 파일을 생성시키는 것도 가능한데, 이와 같은 경우에는 1차 시뮬레이션 후에 VCD 내지는 FSDB를 테스트벤치로 변환시키는 과정을 생략 가능하다.

이와 같은 두 가지 방법들은 기존의 시뮬레이션 방법들에 비하여 설계객체들에 대한 높은 가시도를 제공하면서도 시뮬레이션의 속도를 크게 저하시키지 않을 뿐 만 아니라, 앞단 시뮬레이션과 후단 시뮬레이션을 다른 추상화된 수준들에서 수행하게 되면 별도의 특별한 하드웨어 기반의 검증 플랫폼들(예로, 하드웨어 에뮬레 이터 또는 FPGA 프로토타이핑 플랫폼 등)을 사용하지 않고서 시뮬레이션의 속도를 크게 향상시키는 것도 가능하다 (자세한 내용은 아래에서 설명됨). 물론 상기 두 가지 방법들인 A 시뮬레이션 방법과 B 시뮬레이션 방법을 병행한 검증 방법도 가능하다. 그러나 위에서 언급된 A 시뮬레이션 방법과 B 시뮬레이션 방법의 경우에 다음과 같은 문제점들이 있을 수 있다. 우선 A 시뮬레이션 방법의 경우에 후단 시뮬레이션 단계인 2차 이후의 시뮬레이션에서 시뮬레이션 하고자 하는 시간대 (ts, te)가 매우 긴 경우에 ti, ti-1, ti-2, .., ti-n시점 내지는 Pi, Pi-1, Pi-2, .., Pi-n 구간에서의 총 n+1 횟수의 시뮬레이션을 순차적으로 수행하여야 함으로서 원래 시뮬레이션 방식보다는 검증 시간을 단축할 수 있지만 그래도 많은 검증 시간이 A 시뮬레이션 방법에 필요하게 된다. 또한 B 시뮬레이션 방법의 경우에도 2차 이후의 시뮬레이션에서 시뮬레이션 하여야 하는 설계블록들의 숫자가 큰 경우에는 이들을 순차적으로 수행하여야 함으로서 원래 시뮬레이션 방식보다는 검증 시간을 단축할 수 있지만 그래도 많은 검증 시간이 B 시뮬레이션 방법에도 필요하게 된다. 그러나, 시뮬레이터가 2 이상이고 이들 시뮬레이터들이 수행되는 복수개의 컴퓨터들(예로, X개의 시뮬레이터가 X개의 컴퓨터에 인스톨되어져 있음)이 네트워크(예로 이더넷, 기가비트-이더넷, SCI, 인피니밴드 등)으로 연결되어져 있는 경우에는 이와 같은 A 시뮬레이션 방법이나 B 시뮬레이션 방법에서 수행되는 후단 시뮬레이션 단계인 1차 시뮬레이션 시작 이후에 수행되는 추가 시뮬레이션들을 동시에 병렬적으로 수행하는 것이 가능하다. 이와 같은 병렬적 시뮬레이션은 이 병렬적으로 수행되어져야 하는 각 시뮬레이션들이 완전히 독립적으로 수행하는 것이 가능함으로서 후 단 시뮬레이션 단계인 1차 시뮬레이션 시작 이후에 수행되는 추가 시뮬레이션의 수행을 획기적으로 빠르게 수행하는 것이 가능하다. 그런데 A 시뮬레이션 방법에서의 병렬적 수행은 시간적으로 병렬성(즉 슬라이스별로 독립적으로 실행하여서 병렬성)을 얻는 것임으로 시간적 병렬수행(temporally parallel execution)이라고 칭하고 (시간적 병렬수행은 2개 이상의 시뮬레이터를 이용하여 2개 이상의 슬라이스에 대한 시뮬레이션을 동시에 수행하게만 되면, 최대한으로 병렬도 - 최대한의 병렬도는 슬라이스가 N개인 경우에 N개의 시뮬레이터를 사용하는 경우에 달성 - 와는 상관없이 시간적 병렬수행이라 정의함), B 시뮬레이션 방법에서의 병렬적 수행은 공간적으로 병렬성을 얻는 것임으로 공간적 병렬수행(spatially parallel execution)이라 칭하기로 한다.

앞단 시뮬레이션 단계인 1차 시뮬레이션의 목적과 후단 시뮬레이션 단계인 1차 시뮬레이션 시작 이후에 수행되는 시뮬레이션의 목적을 비교하여 보면, 1차 시뮬레이션 시작 이후에 수행되는 시뮬레이션을 통하여 DUV와 경우에 따라서는 TB까지에 대한 가시도를 얻는 것이 필요함으로 후단 시뮬레이션 단계인 1차 시뮬레이션 시작 이후에 수행되는 시뮬레이션에서 많은 수행시간이 필요함을 알 수가 있는데, 본 특허의 방법을 이를 상기의 시간 병렬과 공간 병렬 방법에 의하여 크게 줄일 수 있다. 하지만, 전체적인 시뮬레이션의 속도 향상을 위해서는 앞단 시뮬레이션 단계인 1차 시뮬레이션까지도 가능한 최대한도로 빠르게 수행하면서도, 후단 시뮬레이션 단계인 1차 시뮬레이션 시작 이후에 수행되는 1회 이상의 시뮬레이션들을 후단 시뮬레이션의 목적에 맞도록 정확하고 올바르게 수행하는데 필요한 정확한 정보를 수집하여서 후단 시뮬레이션 단계에 전달하는 것도 매우 중요하다. 이를 위하여서는 여러 가지 방법들을 생각할 수 있다. 그 중에서 첫째 방법은 앞단 시뮬레이션 단계인 1차 시뮬레이션도 2 이상의 컴퓨터에서 돌아가는 2 이상의 시뮬레이터들을 사용하여서 병렬적으로 수행하는 것이다. 이와 같은 앞단 시뮬레이션 단계인 1차 시뮬레이션에서의 병렬 수행은 각 시뮬레이터가 독립적으로 수행되는 것이 아니고 서로 연동되면서 수행하여야 함으로 많은 통신 오버헤드와 동기화 오버헤드가 발생할 가능성을 배제할 수 없다. 둘째 방법은 앞단 시뮬레이션 단계인 1차의 시뮬레이션을 빠른 시뮬레이션이 수행될 수 있도록 원래의 설계 코드 대신에 원래 설계 코드와 함수적으로 등가이나 다른 구문 형식으로 변환된 설계 코드를 사용하여서 시뮬레이션하는 것이다. 이는 원 설계 코드에서 시뮬레이션의 수행을 오래 걸리게 하는 구문이 포함되어 있는 경우에 이 구문과 함수적으로 등가이며 시뮬레이션의 수행을 빠르게 하는 다른 구문으로 변환시키는 것이다. 구체적인 예를 든다면, 원 설계 코드의 루프(loop)문들을 펼침으로(un-rolling) 루프문을 제거하거나 감지리스트(sensitivity list)에서 불필요한 리스트들을 제거하거나, 경우에 따라서는 지연관련 구문을 제거 내지는 무시하거나, Verilog에서 procedural block들을 합쳐서 최소한의 procedural block들을 가지도록 하거나, VHDL에서는 process들을 합쳐서 최소한의 process들을 가지도록 하거나, Verilog에서는 continuous assignment들을 procedural block으로 바꾸고 원 코드와는 다른 감지리스트를 사용하여 원 설계코드로 시뮬레이션 하는 것보다 적게 평가(evaluation)되게 하거나, VHDL에서 concurrent assignment들을 process로 바꾸고 원 코드와는 다른 감지리스트를 사용 하여 원 설계코드로 시뮬레이션 하는 것보다 적게 평가되게 하거나, Verilog에서 continuous assignment를 procedural block으로 바꾸고 감지리스트를 사용하여 원 설계코드로 시뮬레이션 하는 것보다는 적게 평가되게 하거나, Verilog에서 continuous assignment를 procedural block으로 바꾸고 감지리스트를 사용하여 원 설계코드로 시뮬레이션 하는 것보다는 적게 평가되게 하거나, 감지리스트를 조정하여서 해당 always 블록이나 process들이 원 설계코드로 시뮬레이션 하는 것보다는 적게 평가되게 하거나, 원 설계코드에 존재하는 변수들이나 시그널들 중에서 앞단 시뮬레이션 단계인 1차 시뮬레이션에서 필요한 변수들과 시그널들만을 남기고 다른 변수들이나 시그널들을 제거하는 것 등이다. 또한 이와 같은 과정에서 빠른 논리변환(logic translation)이나 빠른 논리합성(logic synthesis) 과정을 통하여 설계 코드 전체나 부분적으로 일시적 내지는 영구적으로 구조적으로 변환(structural transformation)시키는 것도 가능하다. 뿐만 아니라, 변환된 설계 코드의 일부분은 시뮬레이션의 효율성을 위하여 이진결정다이아그램(BDD: Binary Decision Diagram, 앞으로 BDD로 칭함) 내지는 다진결정다이아그램(MDD: Multi-valued Decision Diagram, 앞으로 MDD로 칭함)로 표현되어져서 시뮬레이션될 수 있다. 이와 같은 변환 과정은 본 특허에서의 검증 장치의 검증 소프트웨어를 이용하여 자동적으로 수행될 수 있다. 셋째 방법은 앞단 시뮬레이션 단계인 1차 시뮬레이션에서는 후단 시뮬레이션 단계에서 사용하는 것보다 추상화 단계를 높여서 시뮬레이션을 수행하고, 후단 시뮬레이션 단계에서 상기 높은 추상화 단계에서 수행된 시뮬레이션 결과를 활용하여서 1차 시뮬레이션 시작 이후에 수행되는 시뮬레이션을 신속하게 수행하는 것이다. 구체적인 예를 든다면, 후단 시뮬레이션 단계인 1차 시뮬레이션 시작 이후에 수행되는 시뮬레이션을 이벤트-구동 시뮬레이터를 사용하는 경우에 앞단 시뮬레이션 단계인 1차 시뮬레이션에서는 이벤트-구동(event-driven) 시뮬레이터를 사용하는 대신에 수행속도 면에서 이벤트-구동 시뮬레이터보다 대략 10-100배 정도가 빠른 사이클-기반(cycle-based) 시뮬레이터를 사용하는 것이다. 셋째 방법을 위해서 Verilog나 VHDL로 코딩된 설계 코드를 자동화된 방법(예로, HDL2SystemC 변환툴을 사용하여서 자동 변환)이나 수동으로 SystemC 코드로 변환시켜서 HDL 시뮬레이터 대신에 SystemC 시뮬레이터를 사용할 수 있다. 일반적으로 SystemC 시뮬레이터는 이벤트스케줄러가 매우 경량임으로 Verilog 시뮬레이터나 VHDL 시뮬레이터와 비교하여 빠르게 수행하는 것이 가능하다. 넷째 방법은 앞단 시뮬레이션 단계인 1차 시뮬레이션의 진행을 위하여 지연시간_모드(delay_mode)를 제로지연시간(zero delay) 모델이나 혹은 일정한 제일 작은 단위의 지연시간모델(예로 단위지연시간 모델)을 사용하여 진행하도록 설정하는 것이다. 이를 위해서 시뮬레이터의 컴파일러 디렉티브에 'delay_mode_zero내지는 'delay_mode_unit로 선언하여 컴파일할 수 있을 뿐만 아니라 시뮬레이션 커멘드라인 옵션으로서 +delay_mode_zero 내지는 'delay_mode_unit로 지정하여 시뮬레이션할 수 있다. 넷째 방법은 둘째와 셋째 방법과 같이 병행되어져서 사용되어질 수 있다. 다섯째 방법은 몇몇 HDL 시뮬레이터에서 제공 중인 시뮬레이터의 최적화 옵션기술(예로 시놉시스 VCS의 Radiant Technology)을 적용한 시뮬레이션으로 앞단 시뮬레이션인 1차 시뮬레이션을 진행하는 것이다. 다섯째 방법은 앞단 시뮬레이션인 1차 시뮬레이션의 일정 시뮬레이션 구간을 제외한 전체 구간 내지는 전체 시뮬레이션 구간을 이진상태 시뮬레이션(two-state simulation) 방식으로 진행하는 것이다. 둘째와 셋째 방법의 경우에는 앞단 시뮬레이션 단계인 1차 시뮬레이션을 SystemC 시뮬레이터나 사이클-기반(cycle-based) 시뮬레이터로써 수행하면서 시뮬레이션의 상태를 주기적 간격이나 1 이상의 특정 시뮬레이션 시점들에서 1회 이상 저장하는 대신에, 가시도가 필요한 DUV에서의 1 이상의 설계객체들의 상태 저장과, 경우에 따라서는 TB의 상태까지를 주기적 간격이나 1회 이상의 특정 시뮬레이션 시점들이나 특정 시뮬레이션 구간들에서 1회 이상 저장하고(가시도가 필요한 DUV에서의 1 이상의 설계객체들의 상태는 저장하지만, TB의 상태를 저장하지 않는 경우에는 TB의 상태 저장 대신에 시뮬레이션 전 구간에 걸쳐서 상기 가시도가 필요한 DUV에서의 1 이상의 설계객체들의 모든 입력 값들과 입력모드시의 모든 입출력 값들을 이 입력들에서나 입출력들에서 매 이벤트 발생시마다 내지는 매 사이클마다 내지는 매 트란젝션마다 저장하고), 후단 시뮬레이션 단계인 1차 시뮬레이션 시작 이후에 수행되는 1회 이상의 시뮬레이션을 2 이상의 컴퓨터 상에서 돌아가는 2 이상의 HDL 시뮬레이터를 사용하고 병렬적으로 수행하게 된다. 이를 위해서 상기 후단 시뮬레이션 단계인 1차 시뮬레이션 시작 이후에 수행되는 1회 이상의 시뮬레이션 각각을 상기 앞단 시뮬레이션 단계인 1차 시뮬레이션수행 과정에서 1회 이상의 시뮬레이션 시점들이나 시뮬레이션 구간들에서 저장된 1 이상의 설계 코드 상태 정보들 각각으로 초기 상태를 다르게 설정하여서 수행한다. 후단 시뮬레이션 단계에서의 1차 시뮬레이션 시작 이후에 수행되는 시뮬레이터에 사용되는 테스트벤치는 앞단 시뮬레이션 단계에서의 1차 시뮬레이션에서 사용한 테스트벤치(예로, SystemC로 구술된 테스트벤치)를 그대로 사용할 수 있을 뿐만 아니라, 둘째와 셋째 방법에서는 1차 시뮬레이션에서 사용되는 시뮬레이터와 1차 시뮬레이션 시작 이후 수행되는 시뮬레이션에서 사용되는 시뮬레이터가 서로 상이함으로 시뮬레이션 상태를 이용하는 것이 불가능함으로 1차 시뮬레이션과정에서 저장한 가시도가 필요한 DUV에서의 1 이상의 설계객체들의 상태 정보를 이용하여야 함과 더불어서 1차 시뮬레이션 과정에서 TB의 상태를 저장하지 않은 경우에는 가시도가 필요한 DUV에서의 1 이상의 설계객체들의 입력값과 입력 모드에서의 입출력값들도 1차 시뮬레이션전 과정에 걸쳐서 매 이벤트 발생마다 내지는 매 사이클마다내지는 매 트란젝션마다 지속적으로 탐침하여 저장하고(예로, VCD dump나 FSDB dump를 함), 이를 테스트벤치로 변환해서 후단 시뮬레이션 단계인 1차 시뮬레이션 시작 이후에 수행되는 시뮬레이션에서 사용할 수도 있다. 이와 같이 원래의 테스트벤치를 사용하지 않고 앞단 시뮬레이션 단계인 1차 시뮬레이션에서 생성된 테스트벤치를 사용하게 되면, 테스트벤치의 파일 사이즈가 커짐으로 컴파일 시간은 늘어날 수 있음으로 이 패턴을 파일 형태로 저장하여서 테스트벤치에서 이 파일을 억세스하여 읽어들이게 되면 테스트벤치의 구성이 단순 패턴기반 형태가 됨으로 원래의 복잡한 테스트벤치가 시뮬레이션 런타임 시에 소비하는 시뮬레이션 시간에서 테스트벤치가 차지하는 시간을 단축할 수 있는 장점이 있다.

뿐만 아니라, 위에서 언급한 기법은 RTL 설계 코드를 이용하여 RTL에서 시뮬레이션한 결과를 RTL 설계 코드를 합성하여서 게이트-네트리스트를 생성하고, 필요시에는 배치 및 배선 결과에 의한 지연시간 정보까지를 가져와서 수행되는 게이트 수준에서의 시뮬레이션 결과에 이용함으로서 게이트수준에서의 시뮬레이션 시에서의 디버깅을 매우 효과적으로 하는 것에 이용할 수 있다. 즉, 앞단 시뮬레이션 단계인 1차 시뮬레이션을 RTL 설계 코드를 이용하여 RTL에서 이벤트-구동(event-driven) 방식 내지는 사이클-기반(cycle-based) 방식 시뮬레이션하면서 설계 코드에 대한 상태 정보를 1 이상의 특정 시뮬레이션 시점들이나 시뮬레이션 구간들에서 저장하고, 후단 시뮬레이션 단계인 1차 시뮬레이션 시작 이후에 수행되는 1회 이상의 시뮬레이션은 게이트수준에서의 시뮬레이션을 상기 RTL 시뮬레이션에서 상기 1 이상의 특정 시뮬레이션 시점들이나 시뮬레이션 구간들에서 저장된 1 이상의 상태 정보들 각각을 이용함으로서 1 이상의 게이트수준에서의 시뮬레이션들을 병렬적으로 수행하는 것도 가능하다. 상기 게이트수준에서의 시뮬레이션은 SDF(Standard Delay Format) 등을 이용하여서 타이밍 시뮬레이션도 가능하고, 타이밍 정보를 이용하지 않는 게이트수준의 함수적 시뮬레이션도 가능하다. 위에서 설명된 것과 같이, 앞단 시뮬레이션 단계인 1차 시뮬레이션을 후단 시뮬레이션 단계인 1차 시뮬레이션 시작 이후에 수행되는 시뮬레이션 보다 좀 더 추상화된 수준에서 수행하면서 가시도가 필요한 DUV에서의 1 이상의 설계객체들에 대한 동적정보(예로, 설계검증대상의 최소상태 정보와 필요시에는 입력정보도 포함, 혹은 설계검증대상의 완전상태 정보)를 수집하고, 상기 후단 시뮬레이션 단계인 1차 시뮬레이션 시작 이후에 수행되는 시뮬레이션에서 상기 수집된 동적정보를 이용하는 경우에 앞단 시뮬레이션의 결과와 후단 시뮬레이션이 결과가 모두 일치하게 된다면, 결론적으로는 시뮬레이션을 두 단계로 나누어서 추상화가 더 된 수준에서의 앞단 시뮬레이션(예로 RTL 수준에서의 사이클-기반 시뮬레이션)과 추상화가 덜 된 수준에서의 후단 시뮬레이션(예로 RTL 수준에서의 이벤트-구동 시뮬레이션)을 이용하여서 단일 추상화 수준에서만의 반복적인 시뮬레이션을 수행하는 기존 방법(예로 단계 구별이 없는 RTL 수준에서의 이벤트-구동 시뮬레이션만을 수행한 방식)을 통한 시뮬레이션보다 매우 빠르게 수행한 것(시뮬레이션의 속도의 대폭적 향상)이 됨으로 매우 효과적이게 된다. 이를 위해서는, 추상화가 높은 수준에서의 설계의 상태정보와 추상화가 낮은 수준에서의 설계의 상태정보를 정확하게 매핑(mapping, 앞으로 매핑이라 함은 이와 같은 과정을 의미함)시킬 수 있어야 한다 (예를 든다면, RTL 수준의 설계에 존재하는 시그널 myreg[3], myreg[2], myreg[1], myreg[0]과 같은 4-비트 벡터가 합성되어져서 게이트 수준에서의 네트리스트에서는 각각 비트별로 myreg_3, myreg_2, myreg_1, myreg_0의 시그널로 존재한다고 가정하면 RTL 수준에서의 myreg[3]과 게이트 수준의 myreg_3, RTL 수준에서의 myreg[2]과 게이트 수준의 myreg_2, RTL 수준에서의 myreg[1]과 게이트 수준의 myreg_1, RTL 수준에서의 myreg[0]과 게이트 수준의 myreg_0을 대응시켜서, 앞단 시뮬레이션의 결과로서 얻어지는 1 이상의 슬라이스 시작 시점이나 슬라이스 시작 구간에서의 RTL 수준의 myreg[3], myreg[2], myreg[1], myreg[0]의 값들을 게이트 수준의 설계를 대상으로 하는 후단 시뮬레이션의 해당 슬라이스의 시작 시점이나 슬라이스 시작 구간에서 게이트 수준의 myreg_3, myreg_2, myreg_1, myreg_0의 값들로 설정하는 매핑을 수행하여야 한다). 뿐만 아니라 이와 같은 매핑 과정에서는 계층 구조도 다른 추상화 수준들의 설계에서 다를 수 있음으로 이 또한 매핑 과정에서 고려하여야 한다 (예 를 든다면, RTL 수준의 설계 코드에 존재하는 계층 구조와 이 RTL 수준의 설계 코드가 합성되어져서 생성되는 게이트 수준의 설계 코드에 존재하는 계층 구조는 다를 수 있음으로, 매핑 과정에서 이 또한 고려하여야 한다). 그런데, 논리합성 과정에서는 RTL 수준에서 존재하는 시그널들 중에서 모든 설계블럭들의 포트명들과 내부신호선들 중에서 플립플롭 내지는 래치 내지는 메모리 출력들에 해당하는 시그널들은 최적화 과정에서 제거되지 않는 것이 일반적이고, 합성되어진 게이트 수준에서의 해당 시그널명들도 RTL 수준의 설계 코드에 존재하는 원 시그널명들을 그대로 사용하거나, 바꾸는 경우에도 일정한 규칙하에서 최소한의 변경(예로, 위 예를 든다면 RTL에서 벡터 시그널들이 게이트 수준에서는 각 비트별로 존재하며, 변경되는 규칙은 mtyreg[n]이 myreg_n으로 변경되고 변경된 시그널명에 RTL 수준에서 존재하는 계층구조 정보도 포함되어 있음) 만을 함으로, RTL 수준의 원 설계 코드를 파싱하고 이를 일레보레이션과정(논리합성에서 최적화에 앞서서 이루어지는 전처리 과정으로, 예를 든다면 Verific Design Automation, Inc. 사의 Verilog/VHDL Parser ＆ Elaborator 제품이 이와 같은 기능을 제공함)을 진행하여서 원 설계 코드에 존재하는 시그널들 중에서 어떤 시그널들 집합 S_seq이 플립플롭 내지는 래치 내지는 메모리의 출력에 해당되는지를 알아내고, 논리합성으로 생성된 게이트 수준의 네트리스트도 파싱하여 S_seq 내에 존재하는 시그널명들이 게이트 수준에서 어떻게 표현되는지를 알아낼 수 있다. 이와 같은 과정은 정식검증(formal verification) 기법 중에서 현재 가장 널리 사용 중인 조합적 등가검사기(combinational equivalence checker)에서도 필요한 과정으로, 이를 위한 다양한 방법들은 이미 널 리 알려져 있다. 뿐만 아니라, Synopsys 사의 SAIF(Switching Activity Interchange Format)에(논리합성에 의하여 생성되는 forward SAIF) 논리합성 전과 후에 최적화 과정에서 없어지지 않고 RTL 수준과 게이트 수준 모두에 존재하는 시그널명들간의 매핑에 대한 완전한 정보가 존재함으로, 이 SAIF 파일을 읽어서도 정확한 매핑을 수행할 수 있다. 이와 같은 RTL 수준과 게이트 수준간의 매핑 과정은 상기에서 언급된 규칙 등을 이용하여서 본 특허에서 언급된 검증 장치의 구성 요소인 검증 소프트웨어에 의하여 자동적으로 수행될 수 있다. 뿐만 아니라, 후단 시뮬레이션에서 사용되는 1 이상의 설계객체가 Verilog로 구술되어 있으며, 1 이상의 순차 UDP(sequential User Defined Primitive)(예로 플립플롭 내지는 래치를 모델링한 UDP)를 사용한 경우에는 모든 사용된 순차 UDP들을 함수적으로 등가인 Verilog의 module들(이 module에서는 순차 UDP를 사용하지 않고 이를 행위수준으로 모델링함)로 변환시키는 과정이 시뮬레이션에 앞서서 진행되는데 이와 같은 과정은 본 특허에서 제안된 방법을 위한 준비과정(set-up)에서 진행되는 것이 일반적이다. 이와 같은 변환 과정은 일회성으로 진행되어지면 됨으로 수작업으로 진행되어지는 것도 가능할 뿐만 아니라, 본 특허에서 언급된 검증 장치의 구성 요소인 검증 소프트웨어에 의하여 자동적으로 수행될 수 있다. 이와 같은 변환 과정이 자동적으로 수행되는 경우에는, 검증 소프트웨어 내에 Verilog 파서(parser)와 일레보레이터(elaborator) 모듈을 내장하여야 하는데, 이와 같은 Verilog 파서와 일레보레이터 모듈을 구성하는 구체적 예로서는 Verific Design Automation사의 Verilog Parser/Elaborator를 사용함으로 가능하다.

또한 이와 같은 매핑이 RTL 수준와 RTL 수준보다 추상화 수준이 높은 상위수준 사이에서 필요한 경우에, 만일 RTL 수준보다 추상화 수준이 높은 상위수준 설계코드에서 합성 기술(아키텍춰 합성 기술 내지는 상위수준 합성 기술 내지는 행위수준 합성 기술 등)을 통하여서 RTL 수준의 설계를 자동 생성 시키는 경우나 반대로 RTL 수준 코드에서 RTL 수준보다 높은 추상화 수준의 설계를 자동 생성 시키는 경우에도 앞서서 언급한 것과 유사한 방법을 적용할 수 있고, 본 특허에서 언급된 검증 장치의 구성 요소인 검증 소프트웨어에 의하여 자동적으로 수행될 수 있다. 만일, 합성 기술 내지는 자동 전환 기술이 적용되지 않고 수작업으로 생성된 상황에서는 이와 같은 매핑 정보에 관련된 파일(예로, 앞서 설명된 forward SAIF 파일에 있는 정보와 유사한 정보)은 수작업으로 생성하여 이를 본 특허에서 언급된 검증 장치의 구성 요소인 검증 소프트웨어를 통하여 읽어냄으로서 매핑 관계를 파악하는 것도 가능하다.

뿐만 아니라 앞에서 바로 언급한 후단 시뮬레이션의 결과와 앞단 시뮬레이션이 결과가 모두 일치하게 되는 경우의 시뮬레이션의 속도의 대폭적 향상 이외에, 후단 시뮬레이션의 결과와 앞단 시뮬레이션이 결과가 모두 일치하지 않게 되는 경우라도 다음과 같은 또 다른 매우 중요한 장점이 있다. 현재의 설계 방법은 하향식 설계기법(top-down design methodology)을 많이 이용하는데, 이와 같은 하향식 설계에서 상위에서 하위로(예로, 행위단계에서 레지스터전송수준을 거쳐서 게이트수준으로) 내려오면서 설계가 진행되어오는 것에 맞추어서 검증도 상위에서 하위로(예로, 행위단계에서 레지스터전송수준을 거쳐서 게이트수준으로) 내려오면서 수행 되어야 한다. 따라서, 위에서 언급된 방법은 상위 단계에서 얻어진 시뮬레이션 결과를 이 보다 하위 단계(예로, 행위수준에서의 시뮬레이션 결과를 이 보다 하위 단계인 레지스터전송수준에서, 또는 레지스터전송수준에서의 시뮬레이션결과를 이 보다 하위 단계인 게이트수준)에서 수행되는 시뮬레이션에 적용할 수 있도록 함으로서 하향식 설계의 전과정에서 설계의 일관성을 검증 과정에서 체계적이며 효율적으로 점검할 수 있게 하는 매우 중요한 추가적인 장점이 있다. 이와 같은 시뮬레이션 방법은 새로운 검증 방법론(verification methodology)이라고 할 수 있는데, 추상화가 더 된 설계코드를 이용한 검증 결과를 추상화가 될 된 설계코드를 이용한 검증에 사용함으로서 전체 검증 시간과 디버깅 시간을 크게 줄일 수 있을 뿐만 아니라, 전체 검증 시간과 전체 설계시간까지도 크게 줄일 수 있는 새로운 방법이다. 이는 설계 구현 단계(implementation phase)에서 Magma Design Automation 사가 물리적 합성(physical synthesis)에서 사용하여서 큰 성공을 거둔 기술인 이득-기반의 합성(GBS: Gain-based Synthesis) 기술에서 얻을 수 있는 장점과 유사한 장점을 검증 과정에서 얻을 수 있게 한다. 즉 현재 반도체 설계 과정에서의 최대 문제점은 추상화를 통하여서 대규모의 설계를 효율적으로 할 수 있게 된 장점의 부정적인 부수효과로서 설계 과정이 진행되면서 앞 단계에서 예측된 결과와는 다른 결과가 후 단계에서 나타나게 되고, 이는 설계 과정에서 과도한 설계 및 검증 반복(design ＆ verification iteration)을 초래한다는 것이다. 그런데 본 특허에서의 방법과 GBS 방법은 상위단계에서 하위단계로 진행되면서 변화가 되는 상황에 최대한도의 일관성을 제공함으로서 모두 이와 같은 과도한 반복을 최대한 방지시킬 수 있는 방법이 라는 공통점이 있다. 차이점으로는 두 기술이 하나는 검증 관련 기술이고 하나는 구현 기술이라는 것과, 또 다른 개념적 차이는 GBS에서는 추상화 단계에서 하위 수준의 정보(타이밍 정보)에 맞추어지도록 상위 수준에서부터 이에 맞추어 나가는 것인 반면에, 본 특허에서 검증에서 적용하는 기술은 대부분의 경우에 해당하는 정상적 상황에서는 이와는 정반대로 추상화 단계에서 정해진 상위 수준의 검증 정보에 맞추어지도록 하위 수준에서 검증 및 디버깅을 진행하는 것이라 할 수 있다. 즉, 상위 수준의 검증 결과가 하위 수준 검증에서의 레퍼런스 역할(또는 골든 역할)을 수행함으로서 전체 검증 및 설계 과정을 신속하게 수행할 수 있게 된다. 이와 같은2 이상의 추상화 수준들에서의 시뮬레이션 결과들을 통합하여서 상위 수준에서의 시뮬레이션 결과를 하위 수준에서의 시뮬레이션에 이용할 수 있게 하는 것은 많은 장점들이 있다. 상위 수준에서의 시뮬레이션이 되는 대상이 DUV 전체가 되는 것이 성능 면에서 제일 바람직하지만, 설계 재사용(design reuse) 등과 같은 이유 등에서 DUV의 1 이상의 특정 설계객체들만이 상위 수준으로 구술된 설계에 대해서도 위와 같은 개념은 그대로 적용되어질 수 있다. 예로, DUV 내에 5개의 설계블록 B0, B1, B2, B3, B4가 존재하고 B0와 B1은 이벤트-구동 Verilog RTL 코드로 구술되어 있고 B2, B3, B4는 사이클-기반 SystemC 코드로 구술되어 있는 경우에는 B0과 B1에 대한 이벤트-구동 방식의 시뮬레이션이 B2와 B3와 B4에 대한 사이클-기반의 시뮬레이션과 연동되어져서, DUV 부분적으로는 상위 수준에서 시뮬레이션이 수행됨으로 시뮬레이션의 속도를 높이는 것도 가능하다. 일반적으로 추상화가 더 된 상위수준에서의 시뮬레이션 결과는 추상화가 덜 된 하위수준에서 DUV가 모델링되어져서 모 의 동작하는 많은 경우들의 특정한 경우라고 생각할 수 있다. 따라서 이와 같은 특정한 경우에도 DUV는 반드시 올바른 동작을 보장하여야 하며 (즉, 설계가 강인한 설계(robust design)이려면 추상화 수준이 다른 후단 시뮬레이션의 결과와 앞단 시뮬레이션이 결과가 일치하도록 동작하여야 하며), 이와 같은 사실에서부터 상위수준에서의 시뮬레이션 결과는 대부분의 경우에 매우 유용한 레퍼런스의 역할을 수행할 수 있게 됨을 알 수 있다. 따라서 위에서 자세하게 설명된 본 발명에서 제안하는 추상화 수준이 다른 두 단계에서의2회 이상의 시뮬레이션 방법과 이 시뮬레이션 결과들의 일치성 조사를 통한 설계에 대한 설계오류 디버깅 방법은 매우 효율적인 새로운 검증 수행 방법임을 알 수가 있다. 뿐만 아니라 위에서 설명된 것과 유사하게, 2 이상의 추상화 수준들에서의 시뮬레이션 결과들을 통합하여서 하위 수준에서의 시뮬레이션 결과를 상위 수준에서의 시뮬레이션의 이용할 수 있게 하는 것도 가능하다.

상기에서 설명된 검증 장치 및 검증 기법은 검증플랫폼으로 시뮬레이터 이외에 1 이상의 시뮬레이션가속기 내지는 하드웨어에뮬레이터 내지는 프로토타이핑시스템 내지는 모델검사기/특성검사기와 같은 정식검증기 등을 사용하는 경우에도 적용할 수 있다. 즉 앞단 검증 단계인 1차 검증 실행을 1 이상의 시뮬레이터 내지는 시뮬레이션가속기 내지는 하드웨어에뮬레이터 내지는 프로토타이핑시스템 내지는 모델검사기/특성검사기와 같은 정식검증기를 독립적 내지는 복합적으로 사용하여서 수행하면서 후단 검증 단계인 1차 시뮬레이션 시작 이후에 수행되는 검증 실행을 1 이상의 시뮬레이터 내지는 시뮬레이션가속기 내지는 하드웨어에뮬레이터 내지는 프 로토타이핑시스템 내지는 모델검사기/특성검사기와 같은 정식검증기를 병렬적 내지는 순차적으로 실행하는 것에 필요한 최소한의 정보(예로 검증 대상이 되는 DUV의 1 이상의 설계객체들에 대한 1 이상의 검증 시점들이나 구간들에서의 상태 정보와, 필요시에는 추가적으로 상기 DUV의 1 이상의 설계객체들의 모든 입력값과 입력모드에서의 입출력값에 대한 검증구간에 걸친 정보)를 수집하면서실행하고, 이와 같이 수집된 정보를 이용하여서 후단 검증 단계인 1차 시뮬레이션 시작 이후에 수행되는 검증 실행을 1 이상의 시뮬레이터 내지는 시뮬레이션가속기 내지는 하드웨어에뮬레이터 내지는 프로토타이핑시스템 내지는 모델검사기/특성검사기와 같은 정식검증기를 병렬적 내지는 순차적으로 실행함으로서 전체적인 검증의 성능과 효율성을 높이는 것도 가능하다. 이와 같은 하드웨어-기반 검증 플랫폼은 대부분 하드웨어-기반 검증 플랫폼에 구현되는 1 이상의 설계객체들에 대한 상태정보(예로, 최소 상태정보, 내지는 최소 상태정보와 입력정보 등)를 검증 실행 과정 중에 1 이상의 검증시점들에서 읽어낼 수 있는 기능을 가지고 있을 뿐만 아니라, 이와 같은 기능을 가지고 있지 않은 특정 하드웨어-기반 검증 플랫폼의 경우에도 미국특허 US6,701,491에서 제시된 탐침 방법이나 Xilinx사의 FPGA가 보유하고 있는 기능인 readback 기능을 사용함으로서 동일한 기능을 가질 수 있다.

뿐만 아니라, 위에서 언급된 앞단 검증 단계와 후단 검증 단계의 2단계 검증 실행 방법을 통하게 되면 검증 대상이 되는 DUV의 1 이상의 설계객체들에 대한 검증 수행 과정에서의 동적정보(예로, 시뮬레이션 과정에서 DUV와 TB에서 덤프된 VCD나 FSDB)를 매우 신속하게 획득하는 것이 가능하다. 이와 같은 과정을 통하여서 특 정검증실행 과정 Vt 에서 얻어진 동적정보는 이 후에 실행되는(예로 코드 수정이 이루어지고 난 후에 코드 수정이 원하는대로 이루어졌는지를 확인하고자 실행되는) 또 다른 검증실행 과정 Vt+j에서 부분적으로 내지는 전체적으로 재활용되어서 Vt+j의 검증 실행 과정을 빠르게 진행할 수도 있게 한다. 이와 같은 디버깅 과정에서 설계오류가 올바르게 제거되었는지를 위한 확인 검증 단계에서의 신속한 수행방식을 점진적 검증(incremental verification) 방식이라고 하는데, 구체적으로 이와 같이 동적정보가 재활용(reuse of dynamic information)될 수 있는 경우는 2가지 경우로 나눌 수 있다.

첫 번째는, 특정 설계객체에 설계오류가 존재하여 해당 설계객체의 내용이 디버깅 과정을 거쳐서 수정이 된 경우에 리그레션 테스트 과정이 필요하게 되는데 이와 같은 경우에 재활용을 하는 것과, 설계객체에 대한 수정이 이루어진 후에 수정이 원 의도대로 되었는지를 확인하는 경우에 재활용을 하는 것이다. 이 경우에는 리그레션 테스트의 진행에 있어서 특정 테스트 시나리오를 실행하는 경우나 원 의도대로 수정이 되었는지를 확인하기 위한 실행과정에서 설계객체(DUV와 TB 모두를 포함) 전체를 대상으로 하여 검증을 진행하지 않고, 전체 검증시간의 1 이상의 일정 시간 영역에서는(예로 검증시간 0에서부터 일정 검증시간 tm까지는) 오직 설계 수정이 된 1 이상의 설계객체들 DO(mod)만을 대상으로 하는 검증을 진행함으로서 빠른 속도로 검증 실행이 진행될 수 있도록 하고, 이 이외의 시간 영역에서는(예로 검증시간 tm이후부터는) 설계객체 전체(DUV와 TB 모두)에 대하여 검증을 진행하도록 한다. 이와 같은 방법을 위해서 핵심적인 사항은 설계 수정이 된 1 이상의 설계 객체들만을 대상으로 하는 검증 실행을 진행하여도 무방한 1 이상의 일정 시간 영역을 전체 검증시간영역에서 구분할 수 있어야 한다. 이는 설계 수정이전에 수행되는 검증실행 과정에서 특정 1 이상의 설계객체들에 대하여 동적정보를 수집하여 이를 설계 수정이후에 수행되는 검증실행 과정에서 설계 수정이 이루어진 설계객체들에서 생성되는 동적정보들과 검증실행 과정에서 실시간으로 비교하여 처리함으로서 가능하게 된다. 또한 오직 설계 수정이 된 1 이상의 설계객체들 DO(mod)를 적절하게 선정하는 것이 필요한데, 설계변경 후에 시뮬레이터를 이용한 검증 실행을 하는 경우에는 시뮬레이션의 속도를 크게 높이기 위해서 DO(mod)범위(즉 DO(mod)의 크기)를 최소화시키는 것이 매우 중요하고, 설계변경 후에 하드웨어기반검증플랫폼(예로 시뮬레이션가속기)를 이용한 검증 실행을 하는 경우에는 통상 하드웨어기반검증플랫폼의 실행속도는 하드웨어기반검증플랫폼 상에서 수행되는 설계객체의 크기 내지는 복합도와 무관함으로 DO(mod)범위를 최소화할 필요는 없다 (예로 시뮬레이션가속의 경우에는 DUV 내부에 존재하는 하위 설계객체의 하나를 수정한 경우에는 DO(mod)를 DUV로 지정하는 것도 가능하지만, 시뮬레이션의 경우에는 DO(mod)는 상기 수정된 하위 설계객체 하나로 지정하는 것이 중요함).

구체적인 방법의 일 예를 설명하면 다음과 같다 (이를 체크포인트기반 방법이라 칭함). 리그레션 테스트 진행 과정의 각 테스트 시나리오 실행에서 검증시간 0에서부터 설계 수정이 이루어진 설계객체들의 출력과 출력모드시의 양방향 입출력의 값들 Vi(post_o)을 설계 수정 이전의 동일 설계객체들의 출력과 출력모드시의 양방향 입출력의 값들 Vi(pre_o)과 검증실행 과정에서 실시간으로 비교하여 이들 두 값들이 동일한 경우까지는 상기 설계 수정이 이루어진 설계객체들만을 설계 수정 이전의 검증 실행에서 구하여 특정 형태(예로 TB화된 형태, 내지는 VCD 형태, 내지는 이진 파일 형태)로 저장시킨 재생용 입력정보 내지는 재생용 입출력정보 중에서 재생용 입력정보만을 입력스티뮬러스로 사용해서 매우 빠르게 검증과정을 실행하고, 상기 두 값들 Vi(post_o)와 Vi(pre_o)이 달라지는 시점(앞으로는 이를 tm으로 약칭함)에서부터 설계 수정이 이루어진 설계객체들과 설계 수정이 이루어지지 않은 나머지 설계객체들 모두를 합하여서 검증을 계속 진행하게 되면 전체의 검증 시간을 줄이면서도 바르고 정확한 검증을 수행하는 것이 가능하다. 그런데, 이와 같이 상기 두 값들이 달라지는 시점 tm에서 설계 수정이 이루어진 설계객체들과 설계 수정이 이루어지지 않은 나머지 설계객체들을 합하는 과정에서, 설계 수정이 이루어지지 않은 나머지 설계객체들의 동적정보를 설계수정이 이루어진 설계객체들의 동적정보와 같은 검증시간대로 정확히 맞추어 주는 것이 필수적이다. 이를 위한 한 가지 효과적인 방법은 설계 수정 이전에 수행된 설계검증 과정에서 설계객체들에 대하여 일정 검증시간 간격 내지는 일정 검증구간 간격으로 동적정보를 1회 이상 저장(예로 총 20회 저장)시키게 하고, 이와 같이 저장된 동적정보를 이용하면 가능하다. 지금부터는 각 검증플랫폼을 사용하는 경우에 대하여 위에서 언급된 동적정보 저장 방법을 구체적으로 설명한다.

시뮬레이터를 검증플랫폼으로 사용하는 경우에는 두 가지 방법이 있는데 첫 번째 방법은 설계객체의 수정 이전에 수행된 시뮬레이션의 상태 정보를 1회 이상 저장하고, 이를 추후에 이용하는 것이다. 이것은 시뮬레이션의 상태 정보에는 해당 시뮬레이터에 의하여 실행되는 모든 설계객체들에 대한 완벽한 동적정보를 포함하고 있기 때문이다. 시뮬레이션의 상태 정보를 저장하는 방법은 여러 가지가 있을 수 있는데, 그들 중에서 제일 편리한 방법으로는 시뮬레이터에서 제공하는 시뮬레이션 상태 저장 명령(예로 HDL 시뮬레이터에서의 save 명령 내지는 checkpoint 명령)을 사용하면 되고, 임의의 프로그램의 경우에는 스냅셧(snapshot) 기능을 사용하면 된다. 두 번째 방법은 설계객체 수정 이전에 수행되는 검증 실행(예로, 시뮬레이션 혹은 시뮬레이션가속 수행) 과정에서 설계객체의 상태 정보를 1회 이상 저장하고, 이를 추후에 이용하는 것이다. 이 방법은 특히 하드웨어기반검증플랫폼을 사용하는 경우에 효과적인데, 이유는 하드웨어기반검증플랫폼은 스냅셧/재출발 기능을 제공하는 시뮬레이터와는 달리 검증플랫폼의 상태 정보를 저장하는 방법이 제공되지 않기 때문이다. 그러나, 두 번째 방법은 하드웨어기반검증플랫폼을 이용하는 경우뿐만 아니라, 시뮬레이터를 이용하는 경우에도 적용될 수 있는 방법이지만, 여기서는 하드웨어기반검증플랫폼을 사용하는 경우를 예로 하여 설명하기로 한다. 하드웨어기반검증플랫폼을 검증플랫폼으로 사용하는 경우에는 시뮬레이션가속기를 가정하여 설명한다. 나머지 하드웨어기반검증플랫폼의 경우에도 시뮬레이션가속기와 유사한 방법을 사용하면 됨으로 구체적인 설명은 생략하기로 한다. 시뮬레이션가속기를 이용한 시뮬레이션가속을 통한 검증 실행에서는 시뮬레이션가속기에 구현된 설계객체들에 대해서는 설계객체들 각각의 상태 정보를 1회 이상 저장하고 설계 수정이 이루어진 설계객체들을 제외한 나머지 설계객체들에 대하여서 이들 저장된 상태 정보를 복원과정을 통하여 설계 수정 후의 검증실행에 이용하는 것을 생각할 수 있다. 시뮬레이션가속기와 병행하여서 HDL/SDL/HVL 시뮬레이터가 같이 사용되는 경우(예로 HDL 시뮬레이터나 HVL 시뮬레이터에서 TB가 수행되는 경우)에는 상기 HDL/SDL/HVL 시뮬레이터 상에서 수행되는 설계객체들에 대해서는 설계 수정 전에 수행되는 시뮬레이션의 상태정보를 1회 이상 저장하거나 시뮬레이션 수행 과정에서 설계객체들의 상태 정보를 1회 이상 저장하고 이를 추후에 복원 과정을 통하여 이용할 수 있다. 상기 복원 과정은 시뮬레이터의 재출발(restart) 기능(구체적인 예는 시뮬레이터의 restore 명령이나 restart 명령)을 이용하면 된다. 이와 같은 방법이 매우 효율적인 이유는 검증시간 0에서부터 tm부근 내지는 tm까지는 검증 실행이 설계 수정이 이루어진 설계객체들 DO{s} 에 대해서만 설계 수정 이전의 검증 실행에서 구하여 특정 형태로 저장된 DO{s}에 대한 재생용 입력정보 내지는 재생용 입출력정보 중에서 재생용 입력정보만을 입력스티뮬러스로 사용해서 매우 빠르게 검증과정을 실행할 수 있다는 것이다.

이를 위한 또 다른 방법(이를 저장부분회피 방법이라 칭함)은, 설계 수정이 이루어지지 않은 설계객체들 중에서 일부분만을 같이 수행시키는 것이다. 이 방법은 앞에서 제안된 체크포인트기반 방법보다는 설계 수정 후에 실행되는 검증실행에서 검증시간 0에서부터 tm부근 내지는 tm까지에서 상대적으로 검증실행의 성능저하가 발생되는 단점이 있지만, 특정 설계객체들에 대한 동적정보 저장이 용이하지 않은 경우에 유용한 방법이다. 이 경우에는 설계 수정이 이루어지지 않은 설계객체들 중에서 수행되는 일부분의 범위를 최소화시키는 것이 필요한데, 예를 든다면 TB와 DUV로 이루어진 설계객체에서 설계 수정이 이루어진 경우에 TB만을 설계 수정이 이 루어진 객체와 같이 수행되는 대상으로 선정하고, DUV의 하위 설계객체의 하나가 수정이 된 경우에는 수정된 DUV의 하위 설계객체의 수행과 더불어 TB도검증시간 0에서부터 tm까지 같이 수행한 다음에 tm에서부터는 DUV에서 설계 수정이 안된 설계객체들에 대해서만 설계 수정 전의 검증 실행에서 저장한 상태 정보를 이용하여 설계 수정 후의 검증 실행 과정에서 tm부근에서의 상태 정보로 복귀(restore)하면 된다.

두 번째는, 설계객체에 대한 수정 없이 다른 테스트 시나리오를 이용한 테스트를 진행하는 경우에 이에 앞서서 진행된 테스트 시나리오를 이용한 테스트 결과를 재활용 하는 것이다. 이 경우가 첫 번째 경우와 다른 것은 설계변경이 이루어진 설계객체가 이 경우에는 항상 TB인 반면에, 첫 번째 경우에는 설계변경이 이루어진 설계객체가 DUV이거나 DUV 내에 존재하는 특정한 1 이상의 설계블럭일 수 있다는 것 이외에는 없다 (첫 번째 경우에도 설계변경이 이루어진 설계객체가 TB일 수도 있다). 따라서, 첫 번째 경우에 적용된 방법과 동일한 방법을 두 번째 경우에 적용하여 앞서서 진행된 테스트 시나리오를 이용한 테스트 결과를 재활용 함으로서 다른 테스트 시나리오를 이용한 테스트를 신속하게 진행할 수 있다.

상기 2가지 경우에 설계 수정에 의하여 1 이상의 설계객체가 변경되기 전의 실행결과와 설계객체가 변경된 후의 실행결과가 검증시간 0에서부터 시작하여 처음으로 달라지는 검증시점 tm을 최대한도로 신속하게 찾아내는 것도 매우 중요하다. 이를 위해서는 다음과 같은 방법을 사용하면 매우 효과적이다. 설계객체가 변경되기 전의 검증실행 과정에서 1이상의 시점들이나 구간들에서 1 이상의 설계객체들에 대한 동적정보를 저장(일 예로 상태 정보는 일정 시간간격(예로 10만 시뮬레이션 나노초마다)으로 저장, 재생용 입력정보나 재생용 입출력정보는 매 이벤트 발생시마다 혹은 매 사이클마다 저장)하여서 상태 정보가 저장된 2 이상의 시점들이나 구간들에서 독립적으로 병렬적으로 설계검증 실행을 재현할 수 있게 하고, 1 이상의 설계객체가 수정된 이후에 설계 검증을 수행을 상기 상태 정보가 저장된 2 이상의 시점들이나 구간들에서 독립적으로 병렬적으로 진행하고 수정된 1 이상의 설계객체의 출력과 출력모드시의 입출력 값들이 달라지는 1 이상의 검증 시간들이나 구간들 중에서 검증 시간 0(검증 시간 0은 검증의 시작시점임)에 제일 가까운 검증 시간이 tm이 된다. 이와 같이 tm을 찾는 과정을 병렬적으로 진행하게 되면 tm을 찾는 시간을 tm을 찾는 과정을 순차적으로 진행하는 것에 비하여 크게 단축시키는 것이 가능할 수 있다.

가시도가 assertion을 통하여 확보될 필요가 있는 경우에는 다음과 같은 방법을 사용하여 시뮬레이션 시간을 크게 줄이는 것이 가능하다. 즉, 앞단 시뮬레이션인 1차 시뮬레이션에서는 assertion들을 전부 혹은 최소한도로만 enable(활성화)시키고 시뮬레이터의 상태 정보나 DUV에 대한 상태 정보를 1이상의 시뮬레이션 시간 구간에서 저장히고(필요시 TB에서의 입력정보도 전체 시뮬레이션 전과정에서 저장), 1차 시뮬레이션 시작 이후에 시작되는 후단 시뮬레이션 단계인 1차 이후의 1 이상의 시뮬레이션을 순차적으로 내지는 병렬적으로 진행하는 과정에서 필요한 모든 assertion들을 활성화시켜서 진행한다면 assertion 기반의 시뮬레이션도 매우 신속하게 수행하는 것이 가능하다. 따라서 본 특허에서 가시도 확보라 함은, DUV에 존재하는 1 이상의 시그널들 내지는 변수들을 볼 수 있도록 덤프와 같은 방법을 통한 전통적인 탐침 방법이거나, 내지는 주장기법을 이용하여서 1 이상의 주장구문(assertion statement)을 통한 방법 모두를 통칭하는 것이다.

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

도1 은, 컴퓨터에서 운영되는 본 발명의 검증 소프트웨어와 시뮬레이터를 갖는 컴퓨터로 구성된 본 발명에 관한 설계 검증 장치의 일 예를 개략적으로 도시한 도면이다.

도2 는, 컴퓨터에서 운영되는 본 발명의 검증 소프트웨어와 2 이상의 시뮬레이터를 갖는 2 이상의 컴퓨터들과 이들 컴퓨터들을 연결하는 네트워크로 구성된 본 발명에 관한 설계 검증 장치의 또 다른 일 예를 개략적으로 도시한 도면이다.

도3 은 앞단 시뮬레이션 단계인 1차 시뮬레이션수행 도중에 주기적으로 내지는 1 이상의 특정 시뮬레이션 시점들 내지는 일정 시뮬레이션 구간들에서 시뮬레이션의 상태나, 저장된 가시도가 필요한 DUV에서의 1 이상의 설계객체들의 상태와 경우에 따라서는 TB의 상태를 저장(가시도가 필요한 DUV에서의 1 이상의 설계객체들의 상태는 저장하지만, TB의 상태를 저장하지 않는 경우에는 TB의 상태 저장 대신에 시뮬레이션 전 구간에 걸쳐서 상기 가시도가 필요한 DUV에서의 1 이상의 설계객체들의 모든 입력 값들과 입력모드시의 모든 입출력 값들을 이 입력들에서나 입출력들에서 매 이벤트 발생시마다 내지는 매 사이클마다 내지는 매 트란젝션마다 저장)하고, 후단 시뮬레이션 단계인 2차 시뮬레이션수행에서 1차 시뮬레이션에서 저 장된 총 n+1개의 시뮬레이션 상태나, 저장된 가시도가 필요한 DUV에서의 1 이상의 설계객체들의 상태와 경우에 따라서는 TB의 상태 중에서 특정 상태 Si-1로 시뮬레이션을 설정하여(가시도가 필요한 DUV에서의 1 이상의 설계객체들의 상태는 저장하지만, TB의 상태를 저장하지 않는 경우에는 TB의 상태 대신에 시뮬레이션 전 구간에 걸쳐서 상기 가시도가 필요한 DUV에서의 1 이상의 설계객체들의 모든 입력 값들과 입력모드시의 모든 입출력 값들을 이 입력들에서나 입출력들에서 매 이벤트 발생시마다 내지는 매 사이클마다 내지는 매 트란젝션마다 저장된 것과 상기 저장된 가시도가 필요한 DUV에서의 1 이상의 설계객체들의 상태 Si-1를 이용하여서) ti-1에서부터 ti까지 시뮬레이션을 수행하는 과정을 개략적으로 도시한 것이다.

도4 는 앞단 시뮬레이션 단계인 1차 시뮬레이션수행 도중에 주기적으로 시뮬레이션의 상태나, 저장된 가시도가 필요한 DUV에서의 1 이상의 설계객체들의 상태와 경우에 따라서는 TB의 상태를 저장(가시도가 필요한 DUV에서의 1 이상의 설계객체들의 상태는 저장하지만, TB의 상태를 저장하지 않는 경우에는 TB의 상태 저장 대신에 시뮬레이션 전 구간에 걸쳐서 상기 가시도가 필요한 DUV에서의 1 이상의 설계객체들의 모든 입력 값들과 입력모드시의 모든 입출력 값들을 이 입력들에서나 입출력들에서 매 이벤트 발생시마다 내지는 매 사이클마다 내지는 매 트란젝션마다 저장)하고, 후단 시뮬레이션 단계인 1차 시뮬레이션 시작 이후에 수행되는 시뮬레이션에서 상기 앞단 시뮬레이션 단계인 1차 시뮬레이션에서 저장된 1 이상의 시뮬레이션 상태나, 저장된 가시도가 필요한 DUV에서의 1 이상의 설계객체들의 상태들과 경우에 따라서는 저장된 TB의 상태들에서(가시도가 필요한 DUV에서의 1 이상의 설계객체들의 상태는 저장하지만, TB의 상태를 저장하지 않는 경우에는 가시도가 필요한 DUV에서의 1 이상의 설계객체들의 저장된 상태들에서) 이 저장이 일어난 시뮬레이션 시간이 탐침이 필요한 시뮬레이션 시간대 (ts, te)의 시작시점 ts에서 시뮬레이션 시간적으로 앞서면서 제일 가까운 곳에 있는 시뮬레이션 상태나, 가시도가 필요한 DUV에서의 1 이상의 설계객체들의 저장된 상태와 경우에 따라서는 TB의 저장된 상태 Si (가시도가 필요한 DUV에서의 1 이상의 설계객체들의 상태는 저장하지만, TB의 상태를 저장하지 않는 경우에는 가시도가 필요한 DUV에서의 1 이상의 설계객체들의 저장된 상태 Si)로 시뮬레이션의 상태나, 가시도가 필요한 DUV에서의 1 이상의 설계객체들의 상태와 TB의 상태를 설정하고(가시도가 필요한 DUV에서의 1 이상의 설계객체들의 상태는 저장하지만, TB의 상태를 저장하지 않는 경우에는 가시도가 필요한 DUV에서의 1 이상의 설계객체들의 상태를 설정하고) 시뮬레이션 시간 ti에서부터 te까지 시뮬레이션을 수행하면서 해당 탐침 대상에 대한 탐침을 진행하고, 필요시에는 Si보다 시간적으로 앞선 시뮬레이션 상태나, 가시도가 필요한 DUV에서의 1 이상의 설계객체들의 상태와 경우에 따라서는 TB의 상태들 Si-1, Si-2, .., Si-n각각으로(가시도가 필요한 DUV에서의 1 이상의 설계객체들의 상태는 저장하지만, TB의 상태를 저장하지 않는 경우에는, 가시도가 필요한 DUV에서의 1 이상의 설계객체들의 상태들 Si-1, Si-2, .., Si-n각각으로) 시뮬레이션의 상태나, 가시도가 필요한 DUV에서의 1 이상의 설계객체들의 저장된 상태와 경우에 따라서는 TB의 저장된 상태를(가시도가 필요한 DUV에서의 1 이상의 설계객체들의 상태는 저장하지만, TB의 상태를 저장하지 않는 경우에는, 가시도가 필요한 DUV에서의 1 이 상의 설계객체들의 저장된 상태를) 순차적을 설정하면서 각각의 시뮬레이션 시간 ti-1, ti-2, .., ti-n에서부터 ti, ti-1, .., ti-n+1까지 순서적으로 추가적인 n번의 시뮬레이션을 순차적으로 진행하는 과정을 개략적으로 도시한 것이다.

도5(a) 은 도1내지는 도2와 같은 장치를 이용한 설계 검증을 수행하는 과정을 개략적으로 도시한 순서도이다. 제 100 단계에서, 1차 시뮬레이션 수행 도중에 일정 간격이나 특정 시점들 내지는 일정 구간들에서 시뮬레이션의 상태 내지는 탐침대상이 되는 DUV내의 1 이상의 설계객체의 상태와 TB의 상태 내지는 탐침대상이 되는 DUV내의 1 이상의 설계객체의 상태가 자동적으로 저장되도록 설계 코드에 추가 코드를 부가하고, 제 102 단계로 진행한다. 제 102 단계에서는, 상태 저장 간격이나 1 이상의 저장 시점들이나 저장 구간들을 설정하고 제 104 단계로 진행한다. 제 104 단계에서는, 1차 시뮬레이션 수행과 동시에 상태 정보를 저장하고 제 106 단계로 진행한다. 제 106 단계에서는 탐침이 필요한 시뮬레이션 시간대 (ts, te) 설정하고 제 108 단계로 진행한다. 제 108 단계에서는 1차 시뮬레이션 과정에서 이미 저장된 상태 정보를 이용하여 시뮬레이션을 수행하면서 탐침 실행하고 제 110 단계로 진행한다. 제 110 단계에서는 설계 코드에 존재하는 설계 오류 발견 및 제거되면 제 112 단계로 진행하고, 그렇치 않으면 제 106 단계로 진행한다. 제 112 단계에서 설계 검증완료가 완료된 것이 확인되면 전체 과정을 종료하게 되고, 그렇치 않으면 제 102 단계로 진행한다.

도5(b) 는 도1 내지는 도2와 같은 장치를 이용한 설계 검증을 수행하는 또 다른 과정을 개략적으로 도시한 순서도이다. 제 200 단계에서 설계 코드에 대한 분 할을 수행 2 이상의 설계블럭들을 생성하고, 제 202 단계로 진행한다. 제 202 단계에서는 1차 시뮬레이션 수행 도중에 모든 설계블럭들의 입력과 입출력을 시뮬레이션 전구간에서 탐침하여 저장할 수 있도록 설계 코드에 추가 코드를 추가하고 제 204 단계로 진행한다. 제 204 단계에서는1차 시뮬레이션수행과 동시에 각 설계블럭들의 입력과 입출력에 대한 탐침 정보들을 저장한 후, 해당 설계블럭들과 같이 시뮬레이션 컴파일하여 1 이상의 시뮬레이션 실행 파일 생성하고 제 206 단계로 진행한다. 제 206 단계에서는 추가 탐침이 필요한 시그널들이나 변수들 설정하고 제 208 단계로 진행한다. 제 208 단계에서는 추가 탐침이 필요한 시그널들이나 변수들을 포함하는 1 이상의 설계블럭들을 포함하고 있는 1 이상의 시뮬레이션 이진 파일들을 이용한 시뮬레이션 수행 하며 해당 시그널들이나 변수들에 대한 탐침 수행을 수행하고 제 210 단계로 진행한다. 제 210 단계에서는 설계 코드에 존재하는 설계 오류 발견 및 제거하면 제 212 단계로 진행하고, 그렇치 못하면 제 206 단계로 진행한다. 제 212 단계에서는 설계 검증 완료가 확인되면 전체 과정을 종료하고, 그렇치 못하면 제 204 단계로 진행한다.

도6(a) 는 도2 와 같은 장치를 이용한 설계 검증에서 후단 시뮬레이션 단계인 1차 시뮬레이션 시작 이후에 수행되는 시뮬레이션 과정에서 앞단 시뮬레이션 단계인 1차 시뮬레이션과정에서 저장된 2 이상의 시뮬레이션 상태나, 가시도가 필요한 DUV에서의 1 이상의 설계객체들의 저장된 상태와 TB의 상태까지 저장된 경우에는 TB상태까지를 포함하는 상태(가시도가 필요한 DUV에서의 1 이상의 설계객체들의 상태는 저장하지만, TB의 상태를 저장하지 않는 경우에는, 가시도가 필요한 DUV에 서의 1 이상의 설계객체들의 저장된 상태)들 중에서 2 이상의 시뮬레이션 상태나, 가시도가 필요한 DUV에서의 1 이상의 설계객체들의 저장된 상태와 TB의 상태까지 저장된 경우에는 TB의 상태까지를 포함하는 상태(가시도가 필요한 DUV에서의 1 이상의 설계객체들의 상태는 저장하지만, TB의 상태를 저장하지 않는 경우에는, 가시도가 필요한 DUV에서의 1 이상의 설계객체들의 저장된 상태)로부터 2 이상의 시뮬레이터들을 사용하여 시뮬레이션을 시작할 수 있도록 설정하여 이 2 이상의 시뮬레이션을 병렬적으로 수행하고 이들 시뮬레이션 결과들을 취합하여 사용자에게 제공하는 과정의 일례를 도시한 그림이다.

도6(b) 는 도2 와 같은 장치를 이용한 설계 검증에서 후단 시뮬레이션 단계인 1차 시뮬레이션 시작 이후에 수행되는 시뮬레이션과정에서 앞단 시뮬레이션 단계인 1차 시뮬레이션과정에서 저장된 2 이상의 설계 코드(DUV 전체나 DUV내의 1 이상의 설계객체를 가르키거나, 경우에 따라서는 DUV에 TB를 합친 것을 가르킴)의 상태 정보들 중에서 2 이상의 상태 정보들을 선택하여 이들 2 이상의 설계 코드의 상태 정보들 각각으로 2 이상의 시뮬레이터들에서 병렬적으로 수행되는 설계 코드들 각각의 초기 상태를 설정하여 이 2 이상의 시뮬레이션을 병렬적으로 수행하고 이들 시뮬레이션 결과들을 취합하여 사용자에게 제공하는 과정을 도시한 것인데, 상기 앞단 시뮬레이션 단계인 1차 시뮬레이션을 RTL 시뮬레이션으로 수행하고 상기 후단 시뮬레이션 단계인 1차 시뮬레이션 시작 이후에 수행되는 시뮬레이션을 게이트수준 시뮬레이션으로 수행하는 과정의 일례를 도시한 그림이다.

도6(c) 는 도2 와 같은 장치를 이용한 설계 검증에서 후단 시뮬레이션 단계 인 1차 시뮬레이션 시작 이후에 수행되는 시뮬레이션 과정에서 앞단 시뮬레이션 단계인 1차 시뮬레이션 과정에서 저장된 2 이상의 설계 코드(DUV 전체나 DUV내의 1 이상의 설계객체를 가르키거나, 경우에 따라서는 DUV에 TB를 합친 것을 가르킴)의 상태 정보들 중에서 2 이상의 상태 정보들을 선택하여 이들 2 이상의 설계 코드의 상태 정보들 각각으로 2 이상의 시뮬레이터들에서 병렬적으로 수행되는 설계 코드들 각각의 초기 상태를 설정하여 이 2 이상의 시뮬레이션을 병렬적으로 수행하고 이들 시뮬레이션 결과들을 취합하여 사용자에게 제공하는 과정을 도시한 것인데, 상기 앞단 시뮬레이션 단계인 1차 시뮬레이션을 사이클-기반 시뮬레이션으로 수행하고 상기 후단 시뮬레이션 단계인 1차 시뮬레이션 시작 이후에 수행되는 시뮬레이션을 이벤트-구동 RTL 시뮬레이션으로 수행하는 과정의 일례를 도시한 그림이다.

도2 와 같은 장치를 이용한 설계 검증에서 후단 시뮬레이션 단계인 1차 시뮬이션 시작 이후에 수행되는 시뮬레이션과정에서 앞단 시뮬레이션 단계인 1차 시뮬레이션 과정에서 설계 코드에 존재하는 1 이상의 특정 설계블록들의 입력과 입출력값들을 시뮬레이션 전과정에서 탐침하여 얻어진 2 이상의 덤프 파일들이나 이들을 테스트벤치로 변환된 파일들을 해당 설계블록들과 같이 2 이상의 시뮬레이터들을 이용하여 동시에 시뮬레이션 컴파일하여 2 이상의 시뮬레이션 실행파일들을 생성하여 이를 2 이상의 컴퓨터들에서 병렬적으로 실행시키고 이들 시뮬레이션 결과들을 취합하여 사용자에게 제공할 수 있다. 그러나 이와 같은 방법은 상기 앞단 시뮬레이션 단계인 1차 시뮬레이션 과정에서 설계 코드에 존재하는 1 이상의 특정 설계블록들의 입력과 입출력값들을 시뮬레이션 전과정에서 탐침하게 됨으로 시뮬레이션의 속도가 크게 떨어질 수 있다. 이를 개선하는 방법을 도6(d)로써 설명한다.

도6(d) 는 도2 와 같은 장치를 이용한 설계 검증에서 앞단 시뮬레이션 단계인 1차 시뮬레이션 과정에서 2 이상의 시뮬레이션 시점들이나 시뮬레이션 구간들에서 2 이상의 시뮬레이션 상태나, 저장된 가시도가 필요한 DUV에서의 1 이상의 설계객체들의 상태와 경우에 따라서는 TB의 상태를 저장하고(가시도가 필요한 DUV에서의 1 이상의 설계객체들의 상태는 저장하지만, TB의 상태를 저장하지 않는 경우에는 TB의 상태 저장 대신에 시뮬레이션 전 구간에 걸쳐서 상기 가시도가 필요한 DUV에서의 1 이상의 설계객체들의 모든 입력 값들과 입력모드시의 모든 입출력 값들을 이 입력들에서나 입출력들에서 매 이벤트 마다 내지는 매 사이클 마다 내지는 매 트란젝션 마다 발생시마다 저장하고), 후단 시뮬레이션 단계인 1차 시뮬레이션 시작 이후에 처음으로 수행되는 시뮬레이션에서 2 이상의 컴퓨터에서 수행되는 2 이상의 시뮬레이터를 이용하여 상기 전단 시뮬레이션 단계인 1차 시뮬레이션과정에서 저장된 2 이상의 시뮬레이션 상태나, 가시도가 필요한 DUV에서의 1 이상의 설계객체들의 저장된 상태와 TB 상태까지도 저장된 경우에는 TB 상태까지 합한 상태로부터 시뮬레이션이 병렬적으로 진행할 수 있도록 하고, 이 병렬적 시뮬레이션이 진행되는 과정에서 설계코드에 존재하는 1 이상의 특정 설계블록들의 입력과 입출력값들을 병렬적으로 탐침하여 얻어진 2 이상의 덤프 파일들이나 이들을 테스트벤치로 변환된 파일들을 해당 설계블록들과 같이 2 이상의 시뮬레이터들을 이용하여 동시에 시뮬레이션 컴파일하여 2 이상의 시뮬레이션 실행파일들을 생성하고, 상기 2 이상의 컴퓨터들에서 병렬적으로 시뮬레이션 하는 과정의 일례를 도시한 그림이다.

도6(e) 는 도2 와 같은 장치를 이용한 설계 검증에서 앞단 시뮬레이션 단계인 1차 시뮬레이션 과정에서 시뮬레이션 전 구간에 걸쳐서 상기 가시도가 필요한 DUV에서의 2 이상의 설계객체들의 모든 입력 값들과 입력모드시의 모든 입출력 값들을 이 입력들에서나 입출력들에서 매 이벤트 마다 내지는 매 사이클 마다 내지는 매 트란젝션 마다 발생시마다 저장하고, 후단 시뮬레이션 단계인 1차 시뮬레이션 시작 이후에 처음으로 수행되는 시뮬레이션에서 2 이상의 컴퓨터에서 수행되는 2 이상의 시뮬레이터를 이용하여 상기 전단 시뮬레이션 단계인 1차 시뮬레이션과정에서 저장된 2 이상의 설계객체들의 모든 입력 값들과 입력모드시의 모든 입출력 값들을 이용하여 상기 설계객체들 각각을 독립적으로 시뮬레이션하면서 해당 설계객체들의 상태정보를 1 이상의 시뮬레이션 시점들이나 시뮬레이션 구간들에서 저장하고 후단 시뮬레이션 단계에서 그 다음으로 진행되는 시뮬레이션에서 2 이상의 컴퓨터에서 수행되는 2 이상의 시뮬레이터를 이용하여 상기 전단 시뮬레이션 단계인 1차 시뮬레이션과정에서 저장된 탐침대상이 되는 DUV부분의 저장된 모든 입력과 입력모드시의 모든 입력들과 상기 후단 시뮬레이션 단계인 1차 시뮬레이션 시작 이후에 처음 수행된 시뮬레이션 과정에서 1 이상의 시뮬레이션 시점들이나 시뮬레이션 구간들에서 저장된 2 이상의 설계객체들의 상태 정보를 이용하여 상기 탐침대상이 되는 DUV 부분에 대한 시뮬레이션을 병렬적으로 수행하면서 내부에 존재하는 모든 변수 및 신호선들 내지는 1 이상의 모든 변수 및 신호선을 탐침하는 과정의 일례를 도시한 그림이다.

도 6(a)와 도 6(d)와 도 6(e)에서 앞단 시뮬레이션 단계인 1차 시뮬레이션과 후단 시뮬레이션 단계인 1차 시뮬레이션 시작 이후에 수행되는 시뮬레이션은 같은 추상 수준에서 시뮬레이션일 수도 있고, 앞단 시뮬레이션은 추상화가 더 된 수준에서의 시뮬레이션(예로 트란젝션수준 시뮬레이션 내지는 사이클-기반 시뮬레이션)이고 후단 시뮬레이션은 추상화가 덜 된 수준에서의 시뮬레이션(예로 이벤트-구동 시뮬레이션)일 수 있다.

도7은, 컴퓨터에서 운영되는 본 발명의 검증 소프트웨어와 상이한 2 이상의 검증 플랫폼들과 컴퓨터로 구성된 본 발명에 관한 설계 검증 장치의 일 예를 개략적으로 도시한 도면이다. 이와 같은 설계 검증 장치를 이용하게 되면, 앞단 검증 단계와 후단 검증 단계를 각각 다른 검증 플랫폼을 이용하여 검증 수행이 가능하여짐으로, 특정 검증 플랫폼만을 이용하여 앞단 검증 단계에서의 검증 실행과 후단 검증 단계에서의 검증 실행에서 발생할 수 있는 문제점을 효과적으로 해소시킬 수 있다. 구체적 예를 든다면, 앞단 검증 단계를 하드웨어에뮬레이션으로 수행하고 후단 검증 단계를 1 이상의 시뮬레이터를 이용한 병렬적 내지는 순차적 시뮬레이션을 수행하게 되면 하드웨어에뮬레이션의 낮은 유연성 문제와 시뮬레이션의 낮은 성능 문제를 효과적으로 보완시킬 수 있다. 또 다른 구체적 예는 앞단 검증 단계를 하드웨어에뮬레이션으로 수행하고 후단 검증 단계를 1 이상의 모델검사기/특성검사기를 이용한 병렬적 내지는 순차적 모델검사/특성검사를 수행하게 되면 하드웨어에뮬레이션을 통한 동적기반의 검증 능력과 특성검사/모델검사의 정적기반의 검증 능력를 효과적으로 혼합시킬 수 있다. 또 다른 구체적 예는 앞단 검증 단계를 시뮬레이션가속으로 수행하고 후단 검증 단계를 1 이상의 모델검사기/특성검사기를 이용한 병 렬적 모델검사/특성검사 내지는 순차적 모델검사/특성검사를 수행하게 되면 시뮬레이션가속을 통한 동적기반의 검증 능력과 특성검사/모델검사의 정적기반의 검증 능력를 효과적으로 혼합시킬 수 있다. 또 다른 구체적 예는 앞단 검증 단계를 시뮬레이션(예로 사이클기반 시뮬레이션)으로 수행하고 후단 검증 단계를 1 이상의 모델검사기/특성검사기를 이용한 병렬적 모델검사/특성검사 내지는 순차적 모델검사/특성검사를 수행하게 되면 시뮬레이션을 통한 동적기반의 검증 능력과 특성검사/모델검사의 정적기반의 검증 능력를 효과적으로 혼합시킬 수 있다. 즉, 검증 실행을 앞단 검증 단계와 후단 검증 단계로 나누고, 각 단계에서 상이한 검증플랫폼을 이용한 다른 검증 기법을 혼용하여 사용하게 됨으로서, 각 검증 기법들이 서로 상호 보완적으로 사용되어져서 검증의 효율성을 높일 수 있게 된다.

지금부터는 점진적 검증 기법을 도 8에서부터 도 15까지를 이용하여 추가적으로 설명한다.

도 8 은, 컴퓨터에서 운영되는 본 발명의 검증 소프트웨어와 시뮬레이터를 갖는 컴퓨터와 하드웨어기반검증플랫폼으로 구성된 본 발명에 관한 설계 검증 장치의 일 예를 개략적으로 도시한 도면이다.

도 9는, 컴퓨터에서 운영되는 본 발명의 검증 소프트웨어와 시뮬레이터를 갖는 2 이상의 컴퓨터들과 하드웨어기반검증플랫폼과 이들 컴퓨터들을 연결하는 네트워크로 구성된 본 발명에 관한 설계 검증 장치의 또 다른 일 예를 개략적으로 도시한 도면이다.

도 10은, 컴퓨터에서 운영되는 본 발명의 검증 소프트웨어와 이 검증 소프트 웨어가 운영되는 컴퓨터와 하드웨어기반검증플랫폼으로 구성된 본 발명에 관한 설계 검증 장치의 또 다른 일 예를 개략적으로 도시한 도면이다.

도11 은 도8과 같은 설계 검증 장치를 이용한 검증결과 재활용의 일 실시 예를 설명하는 흐름도이다. 우선 설계 검증 대상이 되는 상위 설계객체인 DUV와 TB를 도3 에 도시된 컴퓨터(35)로 읽어 들인다(제 S10 단계). 제 S12 단계에서는 본 발명에서의 검증 소프트웨어(32)로 부가코드를 해당 설계객체에 부가한다. 제 S14 단계에서는 부가코드가추가된 상위 설계객체를 대상으로 컴파일을 수행한다. 제 S16 단계에서는 컴파일된 결과를 검증플랫폼에 로딩한다. 제 S18 단계에서는 검증플랫폼 상에서 설계 검증 대상에 대한 1회 이상의 검증을 수행하면서, 1 이상의 설계객체들에 대한 동적정보을 수집하고, 이를 저장한다. 제 S20 단계에서는 1 이상의 설계객체의 부분변경이 필요한지를 조사하여, 부분변경만이 필요하면 제 S26 단계로 진행하고 그렇치 않으면 제 S22 단계로 진행한다. 제 S22 단계에서는 모든 설계객체들의 변경이 필요한지를 조사하여, 그렇치 않으면 검증을 완료하고 종료하고 모든 설계객체들의 변경이 필요하면 제 S24 단계로 진행하여 모든 설계객체들을 변경하고 제 S12 단계로 진행한다. 제 S26 단계에서는 1 이상의 설계객체들에 대한 부분변경을 수행한다. 제 S28 단계에서는 제 S26 단계에서 진행된 부분변경을 위한 부가코드를 추가한다. 제 S30 단계에서는 재컴파일을 수행한다. 이 과정에서는 변경된 부분만을 재컴파일하는 점진적 컴파일(incremental compile)을 하여 컴파일 시간을 단축시킬 수도 있다. 제 S32 단계에서는 설계 검증 대상을 검증플랫폼에 재로딩한다. 제 S34 단계에서는 재새용입력과 변경된 설계객체들만을 대상으로 하는 검증실행을 검증시간 0에서부터 검증시간 tm까지 진행한다. 여기서 tm은 상기 부가코드에 의하여 검증실행 과정에서 자동적으로 결정되어진다. 제 S36 단계에서는 검증시간 tm에서 검증 수행을 설계객체 전체를 대상으로 하는 검증으로 전환한다. 이와 같은 전환도 상기 부가 코드에 의하여 검증실행 과정에서 자동적으로 전환된다. 제 S38 단계에서는 검증시간 tm에서부터 설계객체 전체를 대상으로 하는 검증을 실행하게 되며, 동시에 설계 전체에 대한 동적정보를 수집하고 저장한다. 제 S40 단계에서는 지금까지 수집된 모든 동적정보의 통합을 하고, 제일 최신의 정보로 수정함으로서 이 이후에 수행되는 추가적인 설계객체의 변경 이후에서의 검증 실행 과정에서도 변경 이전의 동적정보를 이용하여 검증 실행을 신속하게 수행할 수 있게 하게 된다. 제 S40 단계를 완료한 후에는 제 S20 단계로 진행한다.

도12 는 도1 을 이용한 시뮬레이션결과 재활용의 일 실시 예를 설명하는 흐름도이다. 우선 설계 검증 대상이 되는 상위 설계객체인 DUV와 TB를 도1 에 도시된 컴퓨터(35)로 읽어 들인다(제 S50 단계). 제 S52 단계에서는 본 발명에서의 검증 소프트웨어(32)로 부가코드를 해당 설계객체에 부가한다. 제 S54 단계에서는 부가코드가 추가된 상위 설계객체를 대상으로 컴파일을 수행한다. 제 S56 단계에서는 컴파일된 결과를 시뮬레이터에 로딩한다. 제 S58 단계에서는 시뮬레이터 상에서 설계 검증 대상에 대한 1회 이상의 시뮬레이션을 수행하면서, 1 이상의 설계객체들에 대한 동적정보을 수집하고, 이를 저장한다. 제 S60 단계에서는 1 이상의 설계객체의 부분변경이 필요한지를 조사하여, 부분변경만이 필요하면 제 S66 단계로 진행하고 그렇치 않으면 제 S62 단계로 진행한다. 제 S62 단계에서는 모든 설계객체들의 변경이 필요한지를 조사하여, 그렇치 않으면 검증을 완료하고 종료하고 모든 설계객체들의 변경이 필요하면 제 S64 단계로 진행하여 모든 설계객체들을 변경하고 제 S52 단계로 진행한다. 제 S66 단계에서는 1 이상의 설계객체들에 대한 부분변경을 수행한다. 제 S68 단계에서는 제 S66 단계에서 진행된 부분변경을 위한 부가코드를 추가한다. 제 S70 단계에서는 재컴파일을 수행한다. 이 과정에서는 변경된 부분만을 재컴파일하는 점진적 컴파일(incremental compile)을 하여 컴파일 시간을 단축시킬 수도 있다. 제 S72 단계에서는 설계 검증 대상을 시뮬레이터에 재로딩한다. 제 S74 단계에서는 재새용입력과 변경된 설계객체들만을 대상으로 하는 시뮬레이션을 시뮬레이션시간 0에서부터 시뮬레이션시간 tm까지 진행한다. 여기서 tm은 상기 부가코드에 의하여 시뮬레이션실행 과정에서 자동적으로 결정되어진다. 제 S76 단계에서는 시뮬레이션시간 tm에서 시뮬레이션수행을 설계객체 전체를 대상으로 하는 검증으로 전환한다. 이와 같은 전환도 상기 부가코드에 의하여 시뮬레이션실행 과정에서 자동적으로 전환된다. 제 S78 단계에서는 시뮬레이션시간 tm에서부터 설계객체 전체를 대상으로 하는 시뮬레이션을 실행하게 되며, 동시에 설계전체에 대한 동적정보를 수집하고 저장한다. 제 S80 단계에서는 지금까지 수집된 모든 동적정보의 통합을 하고, 제일 최신의 정보로 수정함으로서 이 이후에 수행되는 추가적인 설계객체의 변경 이후에서의 시뮬레이션 실행 과정에서도 변경 이전의 동적정보를 이용하여 시뮬레이션 실행을 신속하게 수행할 수 있게 하게 된다. 제 S80 단계를 완료한 후에는 제 S60 단계로 진행한다.

도13 은 임의의 검증플랫폼을 사용하여 설계 검증을 수행하는 과정에서 설계 객체 변정 전에 수행된 검증결과를 재활용을 하여 설계객체 변경 후에 수행되는 검증을 신속하게 수행하는 과정의 일 실시 예를 개략적으로 도시한 도면이다.

도14 는 임의의 하드웨어기반검증플랫폼을 사용하여 설계 검증을 수행하는 과정에서 설계객체 변경 전에 수행된 검증결과를 재활용을 하여 설계객체 변경 후에 수행되는 검증을 신속하게 수행하는 과정의 일 실시 예를 개략적으로 도시한 도면이다.

도15 는 시뮬레이터를 사용하여 설계 검증을 수행하는 과정에서 설계객체 변경 전에 수행된 시뮬레이션결과를 재활용을 하여 설계객체 변경 후에 수행되는 시뮬레이션을 신속하게 수행하는 과정의 일 실시 예를 개략적으로 도시한 도면이다.

도13 과 도14 와도15에서 도시한 과정은 공통적으로 4 단계로 구분되어져 있다. 단계 1은 1 이상의 설계객체들의 설계 변경 수행 전에 검증 실행이 수행되는 상황을 나타낸 것이다. 이 과정에서는 검증 실행 도중에 1 이상의 설계객체들에 대한 동적정보 수집 및 저장이 필요하다. 수집된 동적 정보를 1 이상의 설계객체들의 설계 변경 이후에 수행되는 검증 실행 과정에 재사용되어지게 된다. 단계 2-1은 설계 변경 이후에 설계 변경이 된 1 이상의 설계객체들과 이들의 재생용 입력정보들만을 이용한 검증 수행을 검증 시간 0에서부터 검증 시간 tm까지 수행하는 상황을 나타낸 것이다. 단계 2-2은 상기 검증 시간 tm에서 설계 수정이 이루어진 설계객체들과 설계 수정이 이루어지지 않은 나머지 설계객체들을 합하는 과정에서, 설계 수정이 이루어지지 않은 나머지 설계객체들의 동적정보를 설계수정이 이루어진 설계객체들의 동적정보와 같은 검증시간대로 정확히 맞추어 주는 상황을 나타낸 것이 다. 구체적으로는, 설계 변경 이전에 검증 실행 과정에서 설계객체들을 대상으로 하여 상태저장을 수행한 1 이상의 검증시점들에서 tm시점 과 제일 가까우면서 시간적으로 앞서있는(즉, 시간적으로 과거인) 검증시점 ts(i)으로 설계 변경이 않된 모든 설계객체들의 상태를 복원하고, ts(i)에서부터 tm까지 설계 변경이 않된 모든 설계객체들을 설계 변경 전에 수집된 동적정보를 이용하여 수행시킨다. 단계 2-3은 검증 시간 tm에서부터 설계 검증 대상 전체(여기에는 설계 변경된 1 이상의 설계객체들도 포함되어 있음)를 대상으로 하는 설계 검증을 수행하는 상황을 나타낸 것이다.

도15 의 예에서와 같이 검증수행의 전체 혹은 일부분이 시뮬레이터를 통하여 이루어지는 경우에는 전체의 검증수행을 위하여 2 이상의 프로세스들을 프로세스간 통신(Inter-Process Communication, 이를 앞으로는 IPC로 약칭함)을 사용하여 연동시켜서 하는 설계 검증 방법을 사용할 수가 있는데, 일 예로 TB를 하나의 프로세스로 생성하고 DUV를 또 다른 프로세스로 생성 하여서 IPC를 통한 통신을 통하여 TB와 DUV를 연동시키는 것이 가능하다. 이와 같은 경우에는 프로세스마다 별도의 프로세서(processor)를 할당할 수 있음으로 멀티프로세싱을 통한 검증 성능 향상의 효과도 기대할 수 있다. 이와 같은 상황에서는, 검증 수행 도중에 IPC를 사용하여 연동되는 2개 이상의 프로세스들 중에서 최소한 1 개의 프로세스에 대하여 스냅셧을 활용하여 설계 코드 변경 전의 검증 수행 과정에서 1 이상의 설계객체들에 대한 동적정보를 수집하고, 설계 코드 변경 후에 실행되는 특정 시간대에서부터의 검증 실행을 상기 동적정보를 이용한 재출발을 통하여서 수행함으로서 상기 1 이상의 설 계객체들이 변경된 후의 검증 실행의 전체 시간을 전체적으로 내지는 부분적으로 단축시키는 것도 가능하다. 이와 같은 상황에서는 IPC 이외에 시뮬레이터의 API(Application Program Interface)인 PLI(Programming Language Interface), FLI(Foreign Language Interface)등도 필요하게 된다.

도16 (a) 의 예에서는 도3, 도4, 도6(a), 도6(b), 도6(c), 도6(d), 도6(e)에서 일 예들로서 설명된 본 발명에서의 앞단 시뮬레이션인 1차 시뮬레이션과 후단 시뮬레이션인 1차 이후의 시뮬레이션으로 진행되는 시뮬레이션에서, 앞단 시뮬레이션 단계에서의 상태 저장을 시뮬레이션 한 시점이 아닌 시뮬레이션의 일정 구간에 걸쳐서 이루어지는 것과 후단 시뮬레이션 단계에서의 상태 재설정을 시뮬레이션 한 시점이 아닌 시뮬레이션의 일정 구간에 걸쳐서 이루어지는 것의 상황의 일 예를 구체적으로 자세하게 도시한 것이다.

도16 (b) 의 예에서는 도3, 도4, 도6(a), 도6(b), 도6(c), 도6(d), 도6(e)에서 일 예들로서 설명된 본 발명에서의 앞단 시뮬레이션인 1차 시뮬레이션과 후단 시뮬레이션인 1차 이후의 시뮬레이션으로 진행되는 시뮬레이션에서, 앞단 시뮬레이션 단계에서의 상태 저장을 시뮬레이션 한 시점이 아닌 시뮬레이션의 일정 구간에 걸쳐서 이루어지는 것과 후단 시뮬레이션 단계에서의 상태 재설정을 시뮬레이션 한 시점이 아닌 시뮬레이션의 일정 구간에 걸쳐서 이루어지는 것의 상황의 또 다른 일 예를 구체적으로 자세하게 도시한 것이다.

도17의 예에서는 앞단 시뮬레이션 단계인 1차 시뮬레이션의 진행 도중에서 후단 시뮬레이션 단계인 1 이상의 1차 이후의 시뮬레이션 중의 한 시뮬레이션 세션 에 존재하는 1 이상의 슬라이스에 대한 부분 시뮬레이션을 시작할 수 있는 1차 시뮬레이션의 결과가 생성되면(예로, 특정 슬라이스에 대한 부분 시뮬레이션을 시작할 수 있도록 하는 해당 슬라이스의 시작 시점에서의 상태정보와 이 슬라이스 전체 구간에 대한 입력정보가 생성되어서 저장되면), 1차 시뮬레이션의 종료를 기다리지 않고서 후단 시뮬레이션 단계인 1 이상의 1차 이후의 시뮬레이션을 진행하는 일 예를 도시한 것이다. 이와 같이 하게 되면 전체 시뮬레이션의 시간을 단축할 수 있을 뿐만 아니라, 전체 시뮬레이션 과정에서 소요되는 컴퓨터의 수와 시뮬레이터의 수를 줄일 수도 있고, 전체 검증 시간을 줄이는 것에 결정적 역할을 하는 턴어라운드시간도 크게 단축하는 것 또한 가능하다. 따라서, 후단 시뮬레이션 단계인 1 이상의 1차 이후의 시뮬레이션을 진행하는 시점들이 앞단 시뮬레이션 단계인 1차 시뮬레이션의 진행 도중일 수도 있고, 또는 앞단 시뮬레이션 단계인 1차 시뮬레이션의 진행이 완전히 종료된 후 일수도 있다. 본 특허에서는 이와 같은 두 가지의 경우를 모두 포함시킬 수 있도록, 후단 시뮬레이션을 "1차 시뮬레이션 시작 이후에 수행되는 1회 이상의 시뮬레이션" 내지는 "1차 시뮬레이션 시작 이후에 수행되는 시뮬레이션"(1차 시뮬레이션은 앞단 시뮬레이션 단계임에 유의함)으로 표기하는데, 이와 같은 후단 시뮬레이션 단계인 1차 시뮬레이션 시작 이후의 1회 이상의 시뮬레이션들 내지는 1차 시뮬레이션 시작 이후의 시뮬레이션은 상기에서 언급된 두 가지의 경우인, 후단 시뮬레이션을 진행하는 시점들이 앞단 시뮬레이션 단계인 1차 시뮬레이션의 진행 도중인 경우와 앞단 시뮬레이션 단계인 1차 시뮬레이션의 진행이 완전히 종료된 경우 모두를 포함하는 것을 의미한다. 뿐만 아니라, 앞단 시뮬레이션의 수행 시점과 후단 시뮬레이션의 수행 시점간의 시간 간격이 상당히 넓을 수 있는데, 특히 이는 앞단 시뮬레이션과 후단 시뮬레이션이 추상화 수준을 달리하여서 수행되는 경우에는 (예로, 일단 시뮬레이션을 RTL 함수적 검증 과정에서 수행하며 이 수행 과정에서 후단 시뮬레이션에 필요한 동적정보를 수집하고 난 후에, RTL 사인오프 후에 합성을 하여서 게이트수준 네트리스트를 생성하고 배치배선을 수행 한 다음에, 후단 시뮬레이션을 게이트수준 타이밍 시뮬레이션 과정에서 수행하고, 이 수행 과정에서 상기 RTL 함수적 검증 과정에서 수집된 동적정보를 이용하여 진행. 이 경우에 앞단 시뮬레이션 수행 시점과 후단 시뮬레이션 수행 시점 간의 시간 간격은 최대 수일에서 수개월까지 일 수도 있음) 더욱 그러할 수 있다. 본 특허에서 후단 시뮬레이션을 "1차 시뮬레이션 시작 이후에 수행되는 1회 이상의 시뮬레이션" 내지는 "1차 시뮬레이션 시작 이후에 수행되는 시뮬레이션"으로 표기하는 것에는 이와 같은 앞단 시뮬레이션 수행 시작 시점과 후단 시뮬레이션 수행 시작 시점 간의 시간 간격이 매우 짧은 경우(예로, 수십 초에서 수십 시간) 뿐만 아니라, 매우 긴 경우(수 일에서 수십 주까지)의 모두를 포함하고 있다.

또한 앞단 시뮬레이션 단계인 1차 시뮬레이션 과정에서 DUV에 존재하는 1 이상의 설계객체들의 상태를 1 이상의 시뮬레이션 시점들에서 저장하고, 후단 시뮬레이션 단계인 1차 시뮬레이션 시작 이후에 수행되는 1회 이상의 시뮬레이션에서의 1 이상의 슬라이스들 각각에 이들 1 이상의 저장된 상태 정보들을 나누어서 설정/복원하여 수행하고자 하는 경우에는, 이들 시뮬레이션 수행에 앞서서 각 슬라이스별로 별도의 시뮬레이션 컴파일/일레보레이션 과정들이 통상적으로 수행되어져야 한 다. 그러나, 슬라이스의 총 수보다 적은 수의 시뮬레이터 라이센스가 있거나 이 시뮬레이터를 수행시키는 컴퓨터의 수가 슬라이스의 총 수보다 작은 경우에, 이 슬라이스별로의 시뮬레이션 컴파일/일레보레이션이 오랜 시간을 요구하는 경우(일예로, 게이트-수준에서의 시뮬레이션 컴파일/일레보레이션과 같은 경우)에는 수차례의 시뮬레이션 컴파일/일레보레이션 시간이 전체 검증 시간의 큰 증가를 초래하게 된다. 뿐만 아니라, 슬라이스 개수만큼의 시뮬레이터 라이센스와 컴퓨터가 확보된 경우라고 하더라고 슬라이스 개수만큼의 시뮬레이션 컴파일/일레보레이션을 각 슬라이스별로 따로 수행하는 것은 병렬적 시뮬레이션 컴파일/일레보레이션을 통하여 컴파일/일레보레이션 시간의 증가는 초래하지 않게 할 수 있지만 자원의 효율적 활용 측면에서 전혀 바람직스럽지 못하다. 따라서 이를 해결하는 효과적인 방법으로는, 각 슬라이스별로 시뮬레이션 컴파일/일레보레이션을 따로 수행하는 것이 아니라 슬라이스가 2 이상의 복수개인 경우(예로 슬라이스가 100개인 경우나 그 이상의 경우)라도 시뮬레이션 컴파일/일레보레이션(이를 슬라이스독립적 시뮬레이션 컴파일/일레보레이션이라 칭함)은 오직 한번만 수행하고, 여기에서 생성된 하나의 시뮬레이션 실행파일을 이용하여서 각 슬라이스들을 위한 시뮬레이션 실행이 진행되어지도록 하는 것이 매우 바람직하다. 이를 위해서는 각 슬라이스별로 달라져야만 하는 해당 슬라이스 전 구간에서 필요한 입력정보들의 실제 인가값들과 해당 슬라이스의 시작시점내지는 시작구간에서 필요한 상태정보들의 실제 인가값들을 1 이상의 입력/상태 정보파일 UF에 저장시키고, 상기 슬라이스독립적 시뮬레이션 컴파일/일레보레이션의 대상이 되는 설계코드(이 설계코드는 테스트벤치 코드와 DUV 코드를 포함 하고 있음)에 시뮬레이션 실행 시점(simulation run-time)에 상기 1 이상의 입력/상태 정보파일 UF을 열고 이를 읽어 들여서 해당 입력 포트들이나 상태관련 시그널 내지는 변수들에 인가하는 코드를 두면 된다. 즉, 슬라이스별로 달라야만 하는 해당 슬라이스 전 구간에서 필요한 입력정보들의 실제 인가값들과 해당 슬라이스의 시작시점내지는 시작구간에서 필요한 상태정보들의 실제 인가값들은 시뮬레이션 런-타임 시에 동적으로 읽어들여서 처리할 수 있게 함으로서 후단 시뮬레이션 단계에서의 시뮬레이션 컴파일/일레보레이션의 횟수를 크게 줄일 수 있는데, 이와 같은 후단 시뮬레이션 단계에서의 시뮬레이션 컴파일/일레보레이션 방법을 슬라이스독립적 시뮬레이션 컴파일/일레보레이션 기법이라 칭하기로 한다.

상술한 바와 같이, 본 발명에 따른 검증 장치 및 이를 이용한 설계 검증 방법의 목적은 초대규모급 설계 검증을 위하여 초대규모급 디지털 시스템 설계에 대한 검증을 위한 시뮬레이션의 성능 및 효율성을 크게 향상시키는 시뮬레이션 기반의 설계 검증 장치 및 이를 이용한 설계 검증 방법과 이와 더불어서 정식검증, 시뮬레이션 가속, 하드웨어 에뮬레이션, 프로토타이핑들까지도 같이 이용하여서 검증하고자 하는 경우에도 검증의 성능과 효율성을 증가시키는 검증 장치 및 이를 이용한 검증 방법을 제공하는 것이다.

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

Claims (200)

1. 검증 소프트웨어와 1 이상의 시뮬레이터를 구비하는 설계검증 장치에 있어서, 상기 검증 소프트웨어는 설계 코드나 합성으로 생성된 게이트수준의 네트리스트에 자동화된 방식을 통하여 부가 코드나 부가 회로를 추가하여 앞단 시뮬레이션 단계인 1차 시뮬레이션을 수행하면서 후단 시뮬레이션 단계인 1차 시뮬레이션 시작 이후에 수행되는 1 회 이상의 시뮬레이션들을 시뮬레이션 구간들이나 설계 코드나 합성으로 생성된 게이트수준의 네트리스트에 존재하는 1 이상의 설계블록들에 대하여 시뮬레이션들이 이루어질 수 있도록 하는데 필요한 최소한의 정보를 상기 앞단 시뮬레이션 단계인 1차 시뮬레이션 과정에서 자동적으로 수집할 수 있도록 하고, 상기 1 이상의 시뮬레이터를 이용한 상기 앞단 시뮬레이션 단계인 1차 시뮬레이션을 상기 최소한의 정보를 수집하면서 빠르게 수행하고, 이 수집된 정보를 이용하여 상기 후단 시뮬레이션 단계인 1차 시뮬레이션 시작 이후에 수행되는 1회 이상의 시뮬레이션들을 가시도를 얻으면서도 신속하게 수행함으로서 시뮬레이션의 속도와 디버깅을 위한 가시도를 동시에 확보하는 것을 가능하게 하는 설계 검증 장치.
2. 시뮬레이션을 여러 개의 테스트벤치로써 수 차례 수행하여 설계 코드나 합성으로 생성된 게이트수준의 네트리스트에 존재하는 1 이상의 설계 오류들의 위치를 알아내고 이를 수정하는 설계 검증 방법에 있어서, 상기 수 차례의 시뮬레이션들에서의 각각의 시뮬레이션 과정 하나 하나를 앞단 시뮬레이션 단계인 1차 시뮬레이션 과 후단 시뮬레이션 단계인 1차 시뮬레이션 시작 이후에 수행되는 1회 이상의 시뮬레이션들로 나누어서 수행하며, 상기 앞단 시뮬레이션 단계인 1차 시뮬레이션을 수행하면서 상기 후단 시뮬레이션 단계인 1차 시뮬레이션 시작 이후에 수행되는 1회 이상의 시뮬레이션들을 시뮬레이션 구간들이나 설계 코드나 합성으로 생성된 게이트 수준의 네트리스트에 존재하는 1 이상의 설계블록들에 대하여 시뮬레이션들이 이루어질 수 있도록 하는데 필요한 최소한의 정보를 상기 앞단 시뮬레이션 단계인 1차 시뮬레이션 과정에서 자동적으로 수집할 수 있도록 설계 코드나 합성으로 생성된 게이트수준의 네트리스트에 부가 코드나 부가 회로를 검증 소프트웨어를 이용하여 자동화된 방식으로 추가하고, 상기 앞단 시뮬레이션 단계인 1차 시뮬레이션을 상기 최소한의 정보를 수집하면서 빠르게 수행하고, 이 수집된 정보를 이용하여 상기 후단 시뮬레이션 단계인 1차 시뮬레이션 시작 이후에 수행되는 1회 이상의 시뮬레이션들을 가시도를 얻으면서도 신속하게 수행함으로서 시뮬레이션의 속도와 디버깅을 위한 가시도를 동시에 확보하는 것을 가능하게 하는 검증 방법.
3. 제 1 항 내지는 제 2 항 내지는 제 12 항 내지는 제 54 항 내지는 제 55 항 에 있어서,

   최소한의 정보 수집이 앞단 시뮬레이션 단계인 1차 시뮬레이션 과정에서 일정 간격으로 혹은 1 이상의 특정 시뮬레이션 시점들에서 시뮬레이션의 상태를 1 이상의 파일 형태로 저장하는 것을 포함하는 설계 검증 방법
4. 제 1 항 내지는 제 2 항 내지는 제 12 항 내지는 제 54 항 내지는 제 55 항에 있어서,

   최소한의 정보 수집이 앞단 시뮬레이션 단계인 1차 시뮬레이션 과정에서 설계 코드나 합성으로 생성된 게이트수준의 네트리스트에 존재하는 1 이상의 설계블록들의 입력과 입출력을 시뮬레이션 전체 과정에 걸쳐서 지속적으로 탐침하여 1 이상의 파일형태로 저장하여 이를 후단 시뮬레이션 단계인 1차 시뮬레이션 시작 이후에 수행되는 시뮬레이션 과정에서 입력스티뮬러스로 이용하는 것을 포함하는 설계 검증 방법.
5. 제 3 항에 있어서,

   앞단 시뮬레이션 단계인 1차 시뮬레이션 시행 중에 1 이상의 시뮬레이션 시점에서 저장된 1 이상의 시뮬레이션 상태들 중에서 1 이상의 시뮬레이션 상태를 선정하여 후단 시뮬레이션 단계인 1차 시뮬레이션 시작 이후에 수행되는 1회 이상의 시뮬레이션들을 상기 선정된 1 이상의 시뮬레이션 상태에서부터 시작될 수 있도록 시뮬레이터를 1회 이상 설정한 후에 설정된 시뮬레이션 상태로부터 시뮬레이션을 1회 이상 진행하면서 설계 코드나 합성으로 생성된 게이트수준의 네트리스트에 존재하는 시그널들과 변수들에 대한 탐침을 수행하는 설계 검증 방법
6. 제 5 항에 있어서,

   후단 시뮬레이션 단계인 1차 시뮬레이션 시작 이후에 수행되는 시뮬레이션들 을 상기 선정된 2 이상의 시뮬레이션 상태들에서부터 시작될 수 있도록 하나의 시뮬레이터를 2회 이상 순서적으로 설정하고 2회 이상 순서적으로 시뮬레이션 진행하는 과정에 있어서, 앞단 시뮬레이션 단계인 1차 시뮬레이션 수행 시에 시뮬레이션의 상태를 저장하는 시뮬레이션 시점이 시뮬레이션 시간적으로 제일 뒤에 있는 시뮬레이션 상태를 우선 상기 하나의 시뮬레이터에 설정하여 이 시뮬레이션의 상태를 가지고 시뮬레이션을 진행하고, 이 후의 시뮬레이션들도 상기 단일 시뮬레이터로써 수행하는 과정에서 상태를 저장한 시뮬레이션 시점이 시뮬레이션 시간적으로 뒤에 있는 것들을 우선으로 하여 시뮬레이터에 설정하여 시뮬레이션들이 시뮬레이션 시간적으로 제일 뒤에서부터 앞서는 순서대로 진행하면서 설계 코드나 합성으로 생성된 게이트수준의 네트리스트에 존재하는 시그널들과 변수들에 대한 탐침을 수행하는 설계 검증 방법
7. 제 1 항 내지는 제 2 항 내지는 제 3 항 내지는 제 5 항 내지는 제 6 항 내지는 제 12 항 내지는 제 54 항 내지는 제 55 항에 있어서,

   앞단 시뮬레이션 단계인 1차 시뮬레이션 시행 중에 1 이상의 시뮬레이션 시점에서 시뮬레이션 상태를 저장하는 방법을 시뮬레이터의 save 명령어 혹은 checkpoint 명령어를 사용하고, 후단 시뮬레이션 단계인 1차 시뮬레이션 시작 이후에 수행되는 1회 이상의 시뮬레이션들을 상기 선정된 1 이상의 시뮬레이션 상태에서부터 시작될 수 있도록 시뮬레이터를 1회 이상 설정한 후에 시뮬레이션을 진행하는 방법을 시뮬레이터의 restart 명령어 혹은 restore 명령어를 사용하는 설계 검 증 방법
8. 제 4 항에 있어서,

   앞단 시뮬레이션 단계인 1차 시뮬레이션 실행 중에 설계 코드나 합성으로 생성된 게이트수준의 네트리스트에 존재하는 1 이상의 설계블록들에 대한 입력과 입출력들을 시뮬레이션 전 과정에서 탐침하여 저장한 1 이상의 탐침 파일들 중에서 1 이상을 선정하여 후단 시뮬레이션 단계인 1차 시뮬레이션 시작 이후에 수행되는 시뮬레이션들을 상기 선정된 1 이상의 탐침 파일과 해당 1 이상의 설계블록들을 이용하여 시뮬레이션 컴파일하여 생성된 1 이상의 시뮬레이션 실행 파일들 중에서 추가적인 탐침이 필요한 설계 코드나 합성으로 생성된 게이트수준의 네트리스트에 존재하는 시그널들과 변수들을 가지고 있는 해당 1 이상의 설계블록들을 컴파일된 형태로 가지고 있는 1 이상의 시뮬레이션 실행 파일을 실행시키면서 상기 추가적인 탐침을 수행함으로서 빠른 시뮬레이션 속도와 설계블럭들에 대한 가시도를 신속하게 확보하는 설계 검증 방법
9. 제 1 항 내지는 제 2 항 내지는 제 3 항 내지는 제 5 항 내지는 제 6 항 내지는 제 7 항 내지는 제 12 항 내지는 제 54 항 내지는 제 55 항에 있어서,

   후단 시뮬레이션 단계인 1차 시뮬레이션 시작 이후에 수행되는 1회 이상의 시뮬레이션을 앞단 시뮬레이션 단계인 1차 시뮬레이션 과정 중에서 저장된 2 이상의 시뮬레이션 상태들 각각을 이용하여 2회 이상의 부분 시뮬레이션을 하는 것으로 전환하여, 컴퓨터 네트워크로 연결된 2 이상의 컴퓨터에 인스톨된 2 이상의 시뮬레이터들을 이용하여 상기 2 이상의 시뮬레이터 상태들 각각을 상기 2 이상의 시뮬레이터 각각에 설정하여 2 이상의 시뮬레이션들이 서로 독립적으로 상기 2 이상의 시뮬레이터로써 병렬적으로 실행하여 빠른 시뮬레이션 속도를 제공하는 설계 검증 방법
10. 제 1 항 내지는 제 2 항 내지는 제 4 항 내지는 제 8 항 내지는 제 12 항 내지는 제 54 항 내지는 제 55 항에 있어서,

    후단 시뮬레이션 단계인 1차 시뮬레이션 시작 이후에 수행되는 1회 이상의 시뮬레이션을 앞단 시뮬레이션 단계인 1차 시뮬레이션을 통하여 얻어진 2 이상의 설계블록들과 이들 설계블록들 각각의 입력과 입출력을 앞단 시뮬레이션 단계인 1차 시뮬레이션 전과정에서 탐침한 2 이상의 탐침 파일들을 시뮬레이션 컴파일하여 얻어진 2 이상의 시뮬레이션 실행 파일들을 컴퓨터 네트워크로 연결된 2 이상의 컴퓨터에 인스톨된 2 이상의 시뮬레이터들을 이용하여 독립적으로 병렬적으로 실행하여 빠른 시뮬레이션 속도를 제공하는 설계 검증 방법
11. 제 1 항 내지는 제 2 항 내지는 제 4 항 내지는 제 8 항 내지는 제 12 항 내지는 제 54 항 내지는 제 55 항에 있어서,

    후단 시뮬레이션 단계인 1차 시뮬레이션 시작 이후에 수행회는 1회 이상의 시뮬레이션을 앞단 시뮬레이션 단계인 1차 시뮬레이션을 통하여 얻어진 2 이상의 설계블록들과 이들 설계블록들 각각의 입력과 입출력을 앞단 시뮬레이션 단계인 1차 시뮬레이션 전과정에서 탐침한 2 이상의 탐침 파일들을 변환한 2 이상의 테스트벤치 파일들을 시뮬레이션 컴파일하여 얻어진 2 이상의 시뮬레이션 실행 파일들을 컴퓨터 네트워크로 연결된 2 이상의 컴퓨터에 인스톨된 2 이상의 시뮬레이터들을 이용하여 독립적으로 병렬적으로 실행하여 빠른 시뮬레이션 속도를 제공하는 설계 검증 방법
12. 임의의 시뮬레이션 수행 내지는 시뮬레이션가속 수행 내지는 하드웨어에뮬레이션 수행 내지는 프로토타이핑 수행을 통하여 얻어진 결과를 이용한 추가적인 시뮬레이션 수행에서, 상기 추가적인 시뮬레이션 수행을 앞단 시뮬레이션 단계인 1차 1회의 시뮬레이션과 후단 시뮬레이션 단계인 1차 시뮬레이션 시작 이후에 수행되는 1회 이상의 시뮬레이션들로 나누어서 수행하며, 상기 1차 시뮬레이션을 수행하면서 상기 1차 시뮬레이션 시작 이후에 수행되는 1회 이상의 시뮬레이션을 시뮬레이션 구간들이나 설계 코드나 합성으로 생성된 게이트수준의 네트리스트에 존재하는 1 이상의 설계블록들에 한정하여 시뮬레이션들이 이루어질 수 있도록 하는데 필요한 최소한의 정보를 1차 시뮬레이션 과정에서 자동적으로 수집할 수 있도록 설계 코드나 합성으로 생성된 게이트수준의 네트리스트에 부가 코드나 부가 회로를 검증 소프트웨어를 이용하여 자동화된 방식으로 추가하고, 상기 1차 시뮬레이션을 수행하면서 상기 최소한의 정보를 수집하고, 이 수집된 정보를 이용하여 상기 1차 시뮬레이션 시작 이후에 수행되는 1회 이상의 시뮬레이션을 신속하게 수행하는 것을 가능 하게 하는 검증 방법.
13. 제 1 항 내지는 제 2 항 내지는 제 3 항 내지는 제 4 항 내지는 제 5 항 내지는 제 9 항 내지는 제 10 항 내지는 제 11 항 내지는 제 12 항 내지는 제 23 항 내지는 제 24 항 내지는 제 25 항 내지는 제 27 항 내지는 제 54 항 내지는 제 55 항에 있어서,

    앞단 시뮬레이션 단계인 1차의 시뮬레이션을 병렬 시뮬레이션으로 수행하는 검증 방법
14. 제 31 항 내지는 제 32 항에 있어서,

    앞단 시뮬레이션 단계인 1차의 시뮬레이션을 DUV의 전체 내지는 DUV내의 1 이상의 설계객체들에 대하여서 사이클-기반 시뮬레이션으로 수행하고, 후단 시뮬레이션 단계인 1차 시뮬레이션 시작 이후에 수행되는 1회 이상의 시뮬레이션은 이벤트-구동 시뮬레이션으로 수행하는 검증 방법
15. 제 31 항 내지는 제 32 항에 있어서,

    앞단 시뮬레이션 단계인 1차의 시뮬레이션을 DUV의 전체 내지는 DUV내의 1 이상의 설계객체들에 대하여서 SystemC 시뮬레이터를 이용하여 수행하고, 후단 시뮬레이션 단계인 1차 시뮬레이션 시작 이후에 수행되는 1회 이상의 시뮬레이션은 Verilog 시뮬레이터 내지는 VHDL 시뮬레이터 내지는 SystemVerilog 시뮬레이터를 이용하여 수행하는 검증 방법
16. 제 31 항 내지는 제 32 항에 있어서,

    앞단 시뮬레이션 단계인 1차의 시뮬레이션을 DUV의 전체 내지는 DUV내의 1 이상의 설계객체들에 대하여서 RTL 시뮬레이션으로 수행하고, 후단 시뮬레이션 단계인 1차 시뮬레이션 시작 이후에 수행되는 1회 이상의 시뮬레이션은 게이트수준 시뮬레이션으로 수행하는 검증 방법
17. 제 14 항 내지는 제 15 항 내지는 제 16 항 내지는 161 항 내지는 162 항 내지는 163 항 내지는 164 항 내지는 165 항 내지는 166 항에 있어서,

    상기 후단 시뮬레이션 단계인 1차 시뮬레이션 시작 이후에 수행되는 1회 이상의 시뮬레이션을 2 이상의 시뮬레이터들을 이용하여서 병렬적으로 진행하는 검증 방법
18. 시뮬레이션을 여러 개의 테스트벤치로써 수 차례 수행하여 설계 코드나 합성으로 생성된 게이트수준의 네트리스트에 존재하는 1 이상의 설계 오류들의 위치를 알아내고 이를 수정하는 설계 검증 방법에 있어서, 앞단 시뮬레이션 단계인 설계 검증의 1차 시뮬레이션 과정에서 2 이상의 시뮬레이션 시점들에서 2 이상의 시뮬레이션 상태를 저장하고, 후단 시뮬레이션 단계인 1차 시뮬레이션 시작 이후에 처음으로 수행되는 시뮬레이션에서 2 이상의 시뮬레이터를 이용하여 상기 1차 시뮬레이 션 과정에서 저장된 2 이상의 시뮬레이션 상태로부터 시뮬레이션이 병렬적으로 진행할 수 있도록 하고, 이 병렬적 시뮬레이션이 진행되는 과정에서 설계 코드에 존재하는 1 이상의 특정 설계블록들의 입력과 입출력값들을 병렬적으로 탐침하여 얻어진 2 이상의 덤프 파일들이나 이들을 테스트벤치로 변환된 파일들을 해당 설계블록들과 같이 2 이상의 시뮬레이터들을 이용하여 동시에 시뮬레이션 컴파일하여 2 이상의 시뮬레이션 실행파일들을 생성하고, 상기 2 이상의 컴퓨터들에서 병렬적으로 시뮬레이션 하는 과정을 통하여 빠른 시뮬레이션 속도와 설계블럭들에 대한 가시도를 확보하는 설계 검증 방법
19. 제 14 항 내지는 제 15 항 내지는 제 16 항 내지는 161 항 내지는 162 항 내지는 163 항 내지는 164 항 내지는 165 항 내지는 166 항에 있어서,

    상기 후단 시뮬레이션 단계인 1차 시뮬레이션 시작 이후에 수행되는 1회 이상의 시뮬레이션을 게이트수준에서 이벤트-구동 시뮬레이션으로 수행하는 검증 방법
20. 제 19 항에 있어서,

    상기 후단 시뮬레이션 단계인 1차 시뮬레이션 시작 이후에 수행되는 1회 이상의 시뮬레이션을 게이트수준에서 이벤트-구동 시뮬레이션을 배치 및 배선 결과에서 추출된 타이밍정보를 활용한 타이밍 시뮬레이션으로 수행하는 검증 방법
21. 제 14 항 내지는 제 15 항 내지는 제 19 항 내지는 제 20 항 내지는 161 항 내지는 162 항 내지는 163 항 내지는 164 항 내지는 165 항 내지는 166 항 내지는 제 167 항에 있어서,

    앞단 시뮬레이션 단계인 1차의 시뮬레이션 과정에서 1 이상의 특정 시뮬레이션 시점들 내지는 특정 시뮬레이션 구간들에서 DUV에서의 1 이상의 설계객체들에 대한 상태 정보를 얻고, 이렇게 얻어진 1 이상의 설계검증대상의 상태 정보를 이용하여 후단 시뮬레이션 단계인 1차 시뮬레이션 시작 이후에 수행되는 1회 이상의 시뮬레이션을 수행하는 검증 방법
22. 제 14 항 내지는 제 15 항 내지는 제 19 항 내지는 제 20 항 내지는 161 항 내지는 162 항 내지는 163 항 내지는 164 항 내지는 165 항 내지는 166 항 내지는 제 167 항에 있어서,

    앞단 시뮬레이션 단계인 1차의 시뮬레이션 과정에서 1 이상의 특정 시뮬레이션 시점들 내지는 특정 시뮬레이션 구간들에서 DUV에서의 1 이상의 설계객체들에 대한 상태 정보를 얻고, 이렇게 얻어진 1 이상의 설계검증대상의 상태 정보들을 이용하여 후단 시뮬레이션 단계인 1차 시뮬레이션 시작 이후에 수행되는 2회 이상의 시뮬레이션을 병렬적으로 수행하는 검증 방법
23. 제 1 항 내지는 제 2 항 내지는 제 12 항 내지는 제 54 항 내지는 제 55 항 에 있어서,

    최소한의 정보 수집이 앞단 시뮬레이션 단계인 1차 시뮬레이션 과정에서 일정 간격으로 혹은 1 이상의 특정 시뮬레이션 시점들 내지는 특정 시뮬레이션 구간들에서 DUV에서의 1 이상의 설계객체들에 대한 상태 정보 저장과 더불어, 시뮬레이션 전 구간에 걸쳐서 상기 DUV에서의 1 이상의 설계객체들의 모든 입력 값들과 입력모드시의 모든 입출력 값들을 후단 시뮬레이션 단계인 1차 시뮬레이션 시작 이후의 시뮬레이션 과정에서 입력스티뮬러스로 이용하기 위하여 상기 입력들에서나 입출력들에서 매 이벤트 발생시 내지는 매 사이클마다 내지는 매 트란젝션마다의 저장을 1 이상의 파일형태로 저장하거나 혹은 상기 일정 간격으로 혹은 1 이상의 특정 시뮬레이션 시점들 내지는 특정 시뮬레이션 구간들에서 TB의 상태 정보 저장을 1 이상의 파일 형태로 저장하는 것을 포함하는 설계 검증 방법
24. 제 1 항 내지는 제 2 항 내지는 제 12 항 내지는 제 54 항 내지는 제 55 항 에 있어서,

    최소한의 정보 수집이 앞단 시뮬레이션 단계인 1차 시뮬레이션 과정에서 일정 간격으로 혹은 1 이상의 특정 시뮬레이션 시점들 내지는 특정 시뮬레이션 구간들에서 DUV에서의 1 이상의 설계객체들에 대한 상태 정보와 상기 앞단 시뮬레이션 단계인 1차 시뮬레이션 전체 과정에서 상기 DUV에서의 1 이상의 설계객체들의 모든 입력 값들과 입력모드시의 모든 입출력 값들을 후단 시뮬레이션 단계인 1차 시뮬레이션 시작 이후의 시뮬레이션 과정에서 입력스티뮬러스로 이용하기 위하여 상기 입력들에서나 입출력들에서 매 이벤트 발생시 내지는 매 사이클마다 내지는 매 트란 젝션마다의 저장을 1 이상의 파일 형태로 저장하는 것을 포함하는 설계 검증 방법
25. 제 23 항 내지는 제 24 항에 있어서,

    앞단 시뮬레이션 단계인 1차 시뮬레이션 시행 중에 1 이상의 시뮬레이션 시점들 내지는 특정 시뮬레이션 구간들에서 저장된 1 이상의 DUV에서의 1 이상의 설계객체들의 상태 정보와 경우에 따라서는 TB의 상태 정보들 중에서 1 이상의 상태를 선정하여 후단 시뮬레이션 단계인 1차 시뮬레이션 시작 이후에 수행되는 1회 이상의 시뮬레이션들을 상기 선정된 1 이상의 DUV에서의 1 이상의 설계객체들의 상태와 경우에 따라서는 TB의 상태에서부터 시작될 수 있도록 시뮬레이터를 1회 이상 설정한 후에 시뮬레이션을 1회 이상 진행하면서 설계 코드나 합성으로 생성된 게이트수준의 네트리스트에 존재하는 시그널들과 변수들에 대한 탐침을 수행함으로서 빠른 시뮬레이션 속도 내지는 설계블럭들에 대한 가시도를 신속하게 확보하는 설계 검증 방법
26. 제 25 항에 있어서,

    후단 시뮬레이션 단계인 1차 시뮬레이션 시작 이후에 수행되는 시뮬레이션들을 상기 선정된 2 이상의 DUV에서의 1 이상의 설계객체들의 상태와 경우에 따라서는 TB의 상태들에서부터 시작될 수 있도록 하나의 시뮬레이터를 2회 이상 순서적으로 설정하고 2회 이상 순서적으로 시뮬레이션 진행하는 과정에 있어서, 앞단 시뮬레이션 단계인 1차 시뮬레이션 수행 시에 상기 DUV에서의 1 이상의 설계객체들의 상태 정보와 경우에 따라서는 TB의 상태 정보를 저장하는 시뮬레이션 시점 내지는 시뮬레이션 구간이 시뮬레이션 시간적으로 제일 뒤에 있는 DUV에서의 1 이상의 설계객체들의 상태와 경우에 따라서는 TB의 상태를 우선 상기 하나의 시뮬레이터에 설정하여 이 상태를 가지고 시뮬레이션을 진행하고, 이 후의 시뮬레이션들도 상기 단일 시뮬레이터로써 수행하는 과정에서 상태를 저장한 시뮬레이션 시점 내지는 시뮬레이션 구간이 시뮬레이션 시간적으로 뒤에 있는 것들을 우선으로 하여 시뮬레이터에 설정하여 시뮬레이션들이 시뮬레이션 시간적으로 제일 뒤에서부터 앞서는 순서대로 진행하면서 설계 코드나 합성으로 생성된 게이트수준의 네트리스트에 존재하는 시그널들과 변수들에 대한 탐침을 수행함으로서 빠른 시뮬레이션 속도 내지는 설계블럭들에 대한 가시도를 신속하게 확보하는 설계 검증 방법
27. 제 1 항 내지는 제 2 항 내지는 제 23 항 내지는 제 24 항 내지는 25 항 내지는 제 26 항 내지는 제 54 항 내지는 제 55 항 에 있어서,

    후단 시뮬레이션 단계인 1차 시뮬레이션 시작 이후에 수행되는 1회 이상의 시뮬레이션을 앞단 시뮬레이션 단계인 1차 시뮬레이션 과정 중에서 저장된 2 이상의 DUV에서의 1 이상의 설계객체들의 상태와 경우에 따라서는 TB의 상태들 각각을 이용하여 2회 이상의 부분 시뮬레이션을 하는 것으로 전환하여, 컴퓨터 네트워크로 연결된 2 이상의 컴퓨터에 인스톨된 2 이상의 시뮬레이터들을 이용하여 상기 2 이상의 DUV에서의 1 이상의 설계객체들의 상태와 경우에 따라서는 TB의 상태들 각각을 상기 2 이상의 시뮬레이터 각각에 설정하여 2 이상의 시뮬레이션들이 서로 독립 적으로 상기 2 이상의 시뮬레이터로써 병렬적으로 실행하여 빠른 시뮬레이션 속도 내지는 설계블럭들에 대한 가시도를 신속하게 확보하는 설계 검증 방법
28. 제 1 항 내지는 제 2 항 내지는 제 3 항 내지는 제 4 항 내지는 제 5 항 내지는 제 9 항 내지는 제 10 항 내지는 제 11 항 내지는 제 12 항 내지는 제 23 항 내지는 제 24 항 내지는 제 25 항 내지는 제 27 항 내지는 제 54 항 내지는 제 55 항에 있어서,

    앞단 시뮬레이션 단계인 1차의 시뮬레이션을 빠른 시뮬레이션이 수행될 수 있도록 원래의 설계 코드 대신에 원래 설계 코드와 함수적으로 등가이나 다른 구문 형식으로 변환된 설계 코드를 사용하여서 시뮬레이션하는 검증 방법
29. 시뮬레이션을 여러 개의 테스트벤치로써 수 차례 수행하여 설계 코드나 합성으로 생성된 게이트수준의 네트리스트에 존재하는 1 이상의 설계 오류들의 위치를 알아내고 이를 수정하는 설계 검증 방법에 있어서, 설계 검증의 앞단 시뮬레이션 단계인 1차 시뮬레이션 과정에서 2 이상의 시뮬레이션 시점들 내지는 특정 시뮬레이션 구간들에서 2 이상의 DUV에서의 1 이상의 설계객체들의 상태 정보와 경우에 따라서는 TB의 상태 정보들을 저장하고, 후단 시뮬레이션 단계인 1차 시뮬레이션 시작 이후에 처음으로 수행되는 시뮬레이션에서 2 이상의 시뮬레이터를 이용하여 상기 1차 시뮬레이션 과정에서 저장된 2 이상의 상기 DUV에서의 1 이상의 설계객체들의 상태와 경우에 따라서는 TB의 상태들로부터 시뮬레이션이 병렬적으로 진행할 수 있도록 하고, 이 병렬적 시뮬레이션이 진행되는 과정에서 설계 코드에 존재하는 1 이상의 특정 설계블록들의 입력과 입출력값들을 병렬적으로 탐침하여 얻어진 2 이상의 덤프 파일들이나 이들을 테스트벤치로 변환된 파일들을 해당 설계블록들과 같이 2 이상의 시뮬레이터들을 이용하여 동시에 시뮬레이션 컴파일하여 2 이상의 시뮬레이션 실행파일들을 생성하고, 상기 2 이상의 컴퓨터들에서 병렬적으로 시뮬레이션 하는 과정을 통하여 빠른 시뮬레이션 속도 내지는 설계블럭들에 대한 가시도를 확보하는 설계 검증 방법
30. 제 21 항 내지는 제 22 항 내지는 제 23 항 내지는 제 24 항 내지는 제 25 항 내지는 제 26 항 내지는 제 27 항 내지는 제 29 항 내지는 제 96 항에 있어서,

    상기 DUV에서의 1 이상의 설계객체들의 상태 정보로 상기 1 이상의 해당 설계객체들의 최소 상태 정보를 사용하는 검증 방법
31. 제 1 항 내지는 제 2 항 내지는 제 3 항 내지는 제 4 항 내지는 제 5 항 내지는 제 9 항 내지는 제 10 항 내지는 제 11 항 내지는 제 12 항 내지는 제 23 항 내지는 제 24 항 내지는 제 25 항 내지는 제 27 항 내지는 제 54 항 내지는 제 55 항에 있어서,

    앞단 시뮬레이션 단계인 1차 시뮬레이션에서 최소한 1 이상의 설계객체들에 대해서 후단 시뮬레이션 단계인 1차 시뮬레이션 시작 이후에 수행되는 1 이상의 시뮬레이션들보다 더 추상화된 설계 코드를 이용함으로서 더 추상화된 수준에서 상기 앞단 시뮬레이션 단계인 1차 시뮬레이션을 수행하고, 상기 후단 시뮬레이션 단계인 1차 시뮬레이션 시작 이후에 수행되는 1 이상의 시뮬레이션은 상기 앞단 시뮬레이션 단계인 1차 시뮬레이션보다 덜 추상화된 설계 코드를 이용하여 시뮬레이션을 수행함으로서 신속한 검증을 수행하는 검증 방법
32. 제 31 항에 있어서,

    상기 앞단 시뮬레이션 단계인 1차 시뮬레이션의 결과로 가시도가 필요한 DUV에서의 1 이상의 설계객체들의 상태 정보를 1 이상의 시뮬레이션 시점들 내지는 특정 시뮬레이션 구간들에서 저장하고, 후단 시뮬레이션 단계인 1차 시뮬레이션 시작 이후에 수행되는 1 이상의 시뮬레이션에서 상기 앞단 시뮬레이션 단계인 1차 시뮬레이션에서 저장된 가시도가 필요한 DUV에서의 1 이상의 설계객체들의 1 이상의 상태 정보를 이용하여서 1회 이상의 시뮬레이션을 2 이상의 시뮬레이터를 사용하여 병렬적으로 수행하거나 단일 시뮬레이터를 이용하여서 순차적으로 수행함으로서 신속한 검증을 수행하는 검증 방법
33. 제 23 항 내지는 제 24 항에 있어서,

    앞단 시뮬레이션 단계인 1차 시뮬레이션 시행 중에 1 이상의 시뮬레이션 시점들 내지는 특정 시뮬레이션 구간들에서 저장된 1 이상의 가시도가 필요한 DUV에서의 1 이상의 설계객체들의 상태와 상기 입력스티뮬러스로 이용하기 위하여 저장된 1 이상의 파일을 선정하여 후단 시뮬레이션 단계인 1차 시뮬레이션 시작 이후에 수행되는 1회 이상의 시뮬레이션들을 상기 선정된 1 이상의 가시도가 필요한 DUV에서의 1 이상의 설계객체들의 상태에서부터 시작될 수 있도록 시뮬레이터를 1회 이상 설정한 후에 시뮬레이션을 1회 이상 진행하면서 설계 코드나 합성으로 생성된 게이트수준의 네트리스트에 존재하는 시그널들과 변수들에 대한 탐침을 수행함으로서 빠른 시뮬레이션 속도와 설계블럭들에 대한 가시도를 신속하게 확보하는 설계 검증 방법
34. 제 33 항에 있어서,

    후단 시뮬레이션 단계인 1차 시뮬레이션 시작 이후에 수행되는 시뮬레이션들을 상기 선정된 2 이상의 가시도가 필요한 DUV에서의 1 이상의 설계객체들의 상태들에서부터 시작될 수 있도록 하나의 시뮬레이터를 2회 이상 순서적으로 설정하고 2회 이상 순서적으로 시뮬레이션 진행하는 과정에 있어서, 앞단 시뮬레이션 단계인 1차 시뮬레이션 수행 시에 상기 가시도가 필요한 DUV에서의 1 이상의 설계객체들의 상태 정보를 저장하는 시뮬레이션 시점 내지는 시뮬레이션 구간이 시뮬레이션 시간적으로 제일 뒤에 있는 DUV에서의 1 이상의 설계객체들의 상태를 우선 상기 하나의 시뮬레이터에 설정하여 이 상태를 가지고 시뮬레이션을 진행하고, 이 후의 시뮬레이션들도 상기 단일 시뮬레이터로써 수행하는 과정에서 상태를 저장한 시뮬레이션 시점 내지는 시뮬레이션 구간이 시뮬레이션 시간적으로 뒤에 있는 것들을 우선으로 하여 시뮬레이터에 설정하여 시뮬레이션들이 시뮬레이션 시간적으로 제일 뒤에서부터 앞서는 순서대로 진행하면서 설계 코드나 합성으로 생성된 게이트수준의 네트리 스트에 존재하는 시그널들과 변수들에 대한 탐침을 수행함으로서 빠른 시뮬레이션 속도와 설계블럭들에 대한 가시도를 신속하게 확보하는 설계 검증 방법
35. 제 1 항 내지는 제 2 항 내지는 제 23 항 내지는 제 24 항 내지는 제 33 항 내지는 제 34 항 내지는 제 54 항 내지는 제 55 항에 있어서,

    후단 시뮬레이션 단계인 1차 시뮬레이션 시작 이후에 수행되는 1회 이상의 시뮬레이션을 앞단 시뮬레이션 단계인 1차 시뮬레이션 과정 중에서 저장된 2 이상의 가시도가 필요한 DUV에서의 1 이상의 설계객체들의 상태들 각각을 이용하여 2회 이상의 부분 시뮬레이션을 하는 것으로 전환하여, 컴퓨터 네트워크로 연결된 2 이상의 컴퓨터에 인스톨된 2 이상의 시뮬레이터들을 이용하여 상기 2 이상의 DUV에서의 1 이상의 설계객체들의 상태들 각각을 상기 2이상의 시뮬레이터 각각에 설정하여 2 이상의 시뮬레이션들이 서로 독립적으로 상기 2 이상의 시뮬레이터로써 병렬적으로 실행하여 빠른 시뮬레이션 속도와 설계블럭들에 대한 가시도를 신속하게 확보하는 설계 검증 방법
36. 시뮬레이션을 여러 개의 테스트벤치로써 수 차례 수행하여 설계 코드나 합성으로 생성된 게이트수준의 네트리스트에 존재하는 1 이상의 설계 오류들의 위치를 알아내고 이를 수정하는 설계 검증 방법에 있어서, 앞단 시뮬레이션 단계인 설계 검증의 1차 시뮬레이션 과정에서 2 이상의 시뮬레이션 시점들 내지는 특정 시뮬레이션 구간들에서 2 이상의 가시도가 필요한 DUV에서의 1 이상의 설계객체들의 상태 와 시뮬레이션 전 구간에 걸쳐서 상기 가시도가 필요한 DUV에서의 1 이상의 설계객체들의 모든 입력 값들과 입력모드시의 모든 입출력 값들을 이 입력들에서나 입출력들에서 매 이벤트 발생시마다 내지는 매 사이클마다 내지는 매 트란젝션 마다 저장하고, 후단 시뮬레이션 단계인 1차 시뮬레이션 시작 이후에 처음으로 수행되는 시뮬레이션에서 2 이상의 시뮬레이터를 이용하여 상기 1차 시뮬레이션 과정에서 저장된 2 이상의 상기 가시도가 필요한 DUV에서의 1 이상의 설계객체들의 상태들로부터 시뮬레이션이 병렬적으로 진행할 수 있도록 하고, 이 병렬적 시뮬레이션이 진행되는 과정에서 설계 코드에 존재하는 1 이상의 특정 설계블록들의 입력과 입출력값들을 병렬적으로 탐침하여 얻어진 2 이상의 덤프 파일들이나 이들을 테스트벤치로 변환된 파일들을 해당 설계블록들과 같이 2 이상의 시뮬레이터들을 이용하여 동시에 시뮬레이션 컴파일하여 2 이상의 시뮬레이션 실행파일들을 생성하고, 상기 2 이상의 컴퓨터들에서 병렬적으로 시뮬레이션 하는 과정을 통하여 빠른 시뮬레이션 속도와 설계블럭들에 대한 가시도를 확보하는 설계 검증 방법
37. 추상화 수준으로 상위에서 표현된 설계객체와 이와 상위 추상화 수준에서 함수적으로 등가이나, 추상화 수준으로 하위에서 표현된 설계객체를 대상으로, 상기 상위수준으로 표현된 설계객체의 시뮬레이션 결과를 이용하여서 상기 하위수준으로 표현된 설계객체에 대한 시뮬레이션을 신속하게 수행하는 검증 방법
38. 제 37 항 내지는 제 57 항 내지는 제 58 항에 있어서,

    상기 상위수준에서의 시뮬레이션 결과가 1 이상의 설계객체들에 대한 상태 정보를 포함하는 검증 방법
39. 제 21 항 내지는 제 22 항 내지는 제 38 항 내지는 제 64 항 내지는 제 65 항에 있어서,

    상기 1 이상의 설계객체들에 대한 상태 정보가 완전상태 정보인 검증 방법
40. 제 21 항 내지는 제 22 항 내지는 제 38 항 내지는 제 64 항 내지는 제 65 항에 있어서,

    상기 1 이상의 설계객체들에 대한 상태 정보가 최소상태 정보인 검증 방법
41. 제 38 항 내지는 제 39 항 내지는 제 40 항 내지는 제 64 항 내지는 제 65 항에 있어서,

    하위수준에서의 시뮬레이션을 신속하게 수행하는 방법이 상기 1 이상의 설계객체들에 대한 상기 상태 정보를 이용하여서 하위수준에서 2 이상의 시뮬레이션들을 병렬적으로 수행하는 검증 방법
42. 제 41 항 내지는 제 67 항에 있어서,

    병렬적 수행이 시간적 병렬 수행인 검증 방법
43. 제 41 항 내지는 제 67 항에 있어서,

    병렬적 수행이 공간적 병렬 수행인 검증 방법
44. 제 37 항에 있어서,

    상위수준에서의 시뮬레이션 결과와 하위수준에서의 시뮬레이션 결과 중 하나를 레퍼런스로 가정하고, 1 이상의 특정 시뮬레이션 시점 내지는 시뮬레이션 구간에서 하위수준에서의 시뮬레이션 결과가 상위수준에서의 시뮬레이션 결과를 비교하여서, 하위수준에서의 시뮬레이션 결과와 상위수준에서의 시뮬레이션 결과가 다른 상황을 찾아 내어 설계를 수정함으로서, 상기 1 이상의 특정 시뮬레이션 시점 내지는 시뮬레이션 구간에서 하위수준에서의 시뮬레이션 결과와 상위수준에서의 시뮬레이션 결과를 같게 만드는 설계 검증 및 설계 수정 방법
45. 제 37 항 내지는 제 44 항 내지는 제 59 항에 있어서,

    상기 상위수준에서의 시뮬레이션이 사이클-기반 방식이고, 상기 하위수준에서의 시뮬레이션이 이벤트-구동 방식인 설계 검증 및 설계 수정 방법
46. 제 37 항 내지는 제 44 항 내지는 제 59 항에 있어서,

    상기 상위수준에서의 시뮬레이션이 SystemC 시뮬레이션이고, 상기 하위수준에서의 시뮬레이션이 RTL 시뮬레이션인 설계 검증 및 설계 수정 방법
47. 제 37 항 내지는 제 44 항 내지는 제 59 항에 있어서,

    상기 상위수준에서의 시뮬레이션이 RTL 시뮬레이션이고, 상기 하위수준에서의 시뮬레이션이 게이트수준 시뮬레이션인 설계 걸증 및 설계 수정 방법
48. 제 47 항에 있어서,

    상기 하위수준에서의 게이트수준 시뮬레이션이 타이밍 정보를 이용한 타이밍 시뮬레이션인 설계 검증 및 설계 수정 방법
49. 제 44 항 내지는 제 59 항에 있어서,

    상기 하위수준에서의 시뮬레이션 결과가 상위수준에서의 시뮬레이션 결과와 다른 상황을 신속하게 찾아내기 위하여서, 상위수준에서의 시뮬레이션 결과를 이용하여 하위수준에서 시뮬레이션을 수행하는 설계 검증 및 설계 수정 방법
50. 제 44 항 내지는 제 59 항에 있어서,

    상기 하위수준에서의 시뮬레이션 결과가 상위수준에서의 시뮬레이션 결과와 다른 상황을 신속하게 찾아내기 위하여서, 상위수준에서의 시뮬레이션 결과를 이용하여 하위수준에서 병렬적으로 시뮬레이션을 수행하는 설계 검증 및 설계 수정 방법
51. 제 49 항 내지는 제 50 항에 있어서,

    상기 하위수준에서의 시뮬레이션 결과가 상위수준에서의 시뮬레이션 결과와 다른 상황을 신속하게 찾아내기 위하여서, 상기 하위수준에서 이용하는 상위수준에서의 시뮬레이션 결과가 1 이상의 설계객체들에 대한 상태 정보를 포함하는 설계 검증 및 설계 수정 방법
52. 제 51 항에 있어서,

    상기 1 이상의 설계객체들에 대한 상태 정보가 상기 1 이상의 설계객체들에 대한 완전상태 정보인 설계 검증 및 설계 수정 방법
53. 제 51 항에 있어서,

    상기 1 이상의 설계객체들에 대한 상태 정보가 상기 1 이상의 설계객체들에 대한 최소상태 정보인 설계 검증 및 설계 수정 방법
54. 검증 소프트웨어와 1 이상의 시뮬레이터를 구비하는 설계검증 장치에 있어서, 상기 검증 소프트웨어는 설계 코드나 합성으로 생성된 게이트수준의 네트리스트에 자동화된 방식을 통하여 부가 코드나 부가 회로를 추가하여 앞단 시뮬레이션 단계인 1차 시뮬레이션을 수행하면서 후단 시뮬레이션 단계인 1차 시뮬레이션 시작 이후에 수행되는 1 회 이상의 시뮬레이션들을 시뮬레이션 구간들이나 설계 코드나 합성으로 생성된 게이트수준의 네트리스트에 존재하는 1 이상의 설계블록들에 대하여 시뮬레이션들이 이루어질 수 있도록 하는데 필요한 최소한의 정보를 상기 앞단 시뮬레이션 단계인 1차 시뮬레이션 과정에서 자동적으로 수집할 수 있도록 하고, 상기 1 이상의 시뮬레이터를 이용한 상기 앞단 시뮬레이션 단계인 1차 시뮬레이션을 상기 최소한의 정보를 수집하면서 빠르게 수행하고, 이 수집된 정보를 이용하여 상기 후단 시뮬레이션 단계인 1차 시뮬레이션 시작 이후에 수행되는 1회 이상의 시뮬레이션들을 신속하게 수행하는 것을 가능하게 하는 설계 검증 장치.
55. 시뮬레이션을 여러 개의 테스트벤치로써 수 차례 수행하여 설계 코드나 합성으로 생성된 게이트수준의 네트리스트에 존재하는 1 이상의 설계 오류들의 위치를 알아내고 이를 수정하는 설계 검증 방법에 있어서, 상기 수 차례의 시뮬레이션들에서의 각각의 시뮬레이션 과정 하나 하나를 앞단 시뮬레이션 단계인 1차 시뮬레이션과 후단 시뮬레이션 단계인 1차 시뮬레이션 시작 이후에 수행되는 1회 이상의 시뮬레이션들로 나누어서 수행하며, 상기 앞단 시뮬레이션 단계인 1차 시뮬레이션을 수행하면서 상기 후단 시뮬레이션 단계인 1차 시뮬레이션 시작 이후에 수행되는 1회 이상의 시뮬레이션들을 시뮬레이션 구간들이나 설계 코드나 합성으로 생성된 게이트수준의 네트리스트에 존재하는 1 이상의 설계블록들에 대하여 시뮬레이션들이 이루어질 수 있도록 하는데 필요한 최소한의 정보를 상기 앞단 시뮬레이션 단계인 1차 시뮬레이션 과정에서 자동적으로 수집할 수 있도록 설계 코드나 합성으로 생성된 게이트수준의 네트리스트에 부가 코드나 부가 회로를 검증 소프트웨어를 이용하여 자동화된 방식으로 추가하고, 상기 앞단 시뮬레이션 단계인 1차 시뮬레이션을 상기 최소한의 정보를 수집하면서 빠르게 수행하고, 이 수집된 정보를 이용하여 상 기 후단 시뮬레이션 단계인 1차 시뮬레이션 시작 이후에 수행되는 1회 이상의 시뮬레이션들을 신속하게 수행하는 검증 방법.
56. 모든 설계 객체들이 변경이 없는 상황에서, 같은 추상화 단계에서 수행되는 앞단 시뮬레이션에서는 시뮬레이션 과정에서 최소한도의 시뮬레이션 실행 결과만을 시뮬레이션 결과로 저장하게 하고, 상기 저장된 앞단 시뮬레이션 결과를 이용하여서 같은 추상화 단계에서 수행되는 후단 시뮬레이션을 2 이상의 시뮬레이터를 이용하여서 병렬적으로 내지는 하나의 시뮬레이터만을 이용하여서 1회 이상 순차적으로 신속하게 수행하는 동시에, 필요시에 후단 시뮬레이션에서는 1 이상의 설계 객체들에 존재하는 1 이상의 변수들 및 시그널들에 대한 덤프를 수행하여 높은 가시도도 동시에 제공하는 검증 방법
57. 제 37 항에 있어서,

    상기 상위수준에서의 시뮬레이션 결과가 시뮬레이션 파형을 저장한 1 이상의파일을 포함하고, 상기 1 이상의 파일을 하위수준에서 이용하는 검증 방법
58. 제 37 항에 있어서,

    상기 상위수준에서의 시뮬레이션 결과로 시뮬레이션 파형을 저장한 1 이상의파일이 존재함으로서, 상기 1 이상의 파일을 하위수준에서 이용하는 검증 방법
59. 제 37 항에 있어서,

    시뮬레이션 파형을 저장한 1 이상의 파일이 상기 상위수준에서의 시뮬레이션 결과로서 존재하고, 이를 하위수준의 시뮬레이션에서 레퍼런스로 활용하여, 1 이상의 특정 시뮬레이션 시점들 내지는 특정 시뮬레이션 구간들에서 하위수준에서의 시뮬레이션 결과를 상위수준에서의 시뮬레이션 결과와 비교하여서 하위수준에서의 시뮬레이션 결과가 상위수준에서의 시뮬레이션 결과와 다른 상황을 찾아내어 설계를 수정함으로서 상기 1 이상의 특정 시뮬레이션 시점들 내지는 특정 시뮬레이션 구간들에서 하위수준에서의 시뮬레이션 결과와 상위수준에서의 시뮬레이션 결과가 동일할 수 있도록 하는 설계 검증 및 설계 수정 방법
60. 제 44 항 내지는 59 항에 있어서,

    상기 1 이상의 특정 시뮬레이션 시점들 내지는 특정 시뮬레이션 구간들에서 하위수준에서의 시뮬레이션 결과를 상위수준에서의 시뮬레이션 결과와 비교하여서 하위수준에서의 시뮬레이션 결과가 상위수준에서의 시뮬레이션 결과와 다른 상황을 찾아내어 설계를 수정함으로서 상기 1 이상의 특정 시뮬레이션 시점들 내지는 특정 시뮬레이션 구간들에서 하위수준에서의 시뮬레이션 결과와 상위수준에서의 시뮬레이션 결과가 동일할 수 있도록 하는 것을, 하위수준에서의 시뮬레이션 결과를 상위수준에서의 시뮬레이션 결과와 같아지도록 함으로서 달성하는 설계 검증 및 설계 수정 방법
61. 제 44 항 내지는 제 59 항에 있어서,

    상기 1 이상의 특정 시뮬레이션 시점들 내지는 특정 시뮬레이션 구간들에서 하위수준에서의 시뮬레이션 결과를 상위수준에서의 시뮬레이션 결과와 비교하여서 하위수준에서의 시뮬레이션 결과가 상위수준에서의 시뮬레이션결과와 다른 상황을 찾아내어 설계를 수정함으로서 상기 1 이상의 특정 시뮬레이션 시점들 내지는 특정 시뮬레이션 구간들에서 하위수준에서의 시뮬레이션 결과와 상위수준에서의 시뮬레이션 결과가 동일할 수 있도록 하는 것을, 상위수준에서의 시뮬레이션 결과를 하위수준에서의 시뮬레이션 결과와 같아지도록 함으로서 달성하는 설계 검증 및 설계 수정 방법
62. 제 44 항 내지는 제 59 항에 있어서,

    상기 상위수준에서의 시뮬레이션이 트란젝션-기반 시뮬레이션이고, 상기 하위수준에서의 시뮬레이션이 사이클-기반 시뮬레이션인 설계 검증 및 설계 수정 방법
63. 제 44 항 내지는 제 59 항에 있어서,

    상기 상위수준에서의 시뮬레이션이 행위수준 시뮬레이션이고, 상기 하위수준에서의 시뮬레이션이 레지스터전송수준 시뮬레이션인 설계 검증 및 설계 수정 방법
64. 제 37 항 내지는 제 57 항 내지는 제 58 항에 있어서,

    상기 상위수준에서의 시뮬레이션 결과가 1 이상의 설계객체들에 대한 상태 정보와 시뮬레이션 전 구간에 걸친 상기 1 이상의 설계객체들에 대한 모든 입력과 입력모드시의 입출력 정보를 포함하는 검증 방법
65. 제 38 항 내지는 제 64 항에 있어서,

    상기 1 이상의 설계객체들에 대한 상태 정보가 시뮬레이션 전 구간 상에서의 모든 상태 정보가 아닌 시뮬레이션 구간 상에서의 1 이상의 특정 시뮬레이션 시점들 내지는 특정 시뮬레이션 구간들에서만의 상태 정보인 검증 방법
66. 제 37 항 내지는 제 57 항 내지는 제 58 항에 있어서,

    상기 상위수준에서의 시뮬레이션 결과가 시뮬레이션 전 구간에 걸친 상기 1 이상의 설계객체들에 대한 모든 입력과 입력모드 시의 입출력 정보를 포함하는 검증 방법
67. 제 66 항에 있어서,

    하위수준에서의 시뮬레이션을 신속하게 수행하는 방법이 상기 시뮬레이션 전 구간에 걸친 상기 1 이상의 설계객체들에 대한 모든 입력과 입력모드 시의 입출력 정보를 이용하여서 하위수준에서 2 이상의 시뮬레이션들을 병렬적으로 수행하는 검증 방법
68. 제 41 항 내지는 제 67 항에 있어서,

    병렬적 수행이 시간적 병렬 수행과 공간적 병렬 수행을 혼용한 검증 방법
69. 제 37 항 내지는 38 항 내지는 제 64 항에 있어서,

    하위수준에서의 시뮬레이션을 신속하게 수행하는 방법이 상위수준에서의 시뮬레이션 과정에서 얻어진 1 이상의 설계객체들에 대한 상태 정보와 1 이상의 설계객체들에 대한 모든 입력과 입력모드 시의 입출력 정보를 이용함으로서 하위수준에서 2 이상의 시뮬레이션들을 이용한 병렬적 수행이 시간적 병렬 수행과 공간적 병렬 수행을 혼용하여 이루어지는 검증 방법
70. 제 44 항 내지는 제 59 항에 있어서,

    상기 상위수준에서의 시뮬레이션이 트란젝션-기반 방식이고, 상기 하위수준에서의 시뮬레이션이 이벤트-구동 방식인 설계 검증 및 설계 수정 방법
71. 제 44 항 내지는 제 59 항에 있어서,

    상기 상위수준에서의 시뮬레이션이 트란젝션-기반 방식과 사이클-기반 방식을 같이 사용하고, 상기 하위수준에서의 시뮬레이션이 이벤트-구동 방식인 설계 검증 및 설계 수정 방법
72. 제 28 항에 있어서,

    상기 원래 설계 코드와 함수적으로 등가이나 다른 구문 형식으로 변환된 설계 코드에서 적어도 일부분이 논리변환 내지는 논리합성 과정을 통하여 얻어지는 검증 방법
73. 제 28 항에 있어서,

    상기 원래 설계 코드와 함수적으로 등가이나 다른 구문 형식으로 변환된 설계 코드가 적어도 부분적으로 이진결정다이아그램(BDD) 내지는 다진결정다이아그램(MDD)으로 표현되어져서 시뮬레이션되는 검증 방법
74. 하위수준에서의 시뮬레이션 결과를 이용하여서 상위수준에서의 시뮬레이션의 결과를 부분적으로 내지는 전체적으로 수정하는 상위수준에서의 재시뮬레이션을 수행하는 검증 방법
75. 제 37 항 내지는 제 74 항에 있어서,

    상위수준에서의 시뮬레이션 결과와 하위수준에서의 시뮬레이션 결과를 가지고, 1 이상의 특정 시뮬레이션 시점들 내지는 특정 시뮬레이션 구간들에서 하위수준에서의 시뮬레이션 결과가 상위수준에서의 시뮬레이션 결과를 비교하여서, 하위수준에서의 시뮬레이션 결과와 상위수준에서의 시뮬레이션 결과가 다른 상황을 찾아내어 다른 부분에서의 부분적 시뮬레이션을 1회 이상 수행함으로서, 상기 1 이상의 특정 시뮬레이션 시점들 내지는 특정 시뮬레이션 구간들에서 하위수준에서의 시 뮬레이션 결과와 상위수준에서의 시뮬레이션 결과를 같게 만드는 설계 검증 방법
76. 제 75 항에 있어서,

    상기 하위수준에서의 시뮬레이션 결과와 상위수준에서의 시뮬레이션 결과가 다른 부분에서의 1회 이상의 부분적 시뮬레이션이, 상위수준에서의 시뮬레이션 결과를 하위수준에서의 시뮬레이션에서 이용하고 이렇게 하여 얻어진 하위수준에서의 시뮬레이션 결과를 다시 상위수준에서의 시뮬레이션에서 이용하고, 이와 같은 과정을 계속적으로 반복하여 적용함으로서 하위수준에서의 시뮬레이션 결과와 상위수준에서의 시뮬레이션 결과를 같게 만드는 설계 검증 방법
77. 제 37 항 내지는 제 44 항 내지는 제 59 항에 있어서,

    상기 상위수준에서의 시뮬레이션이 타이밍 정보를 이용하지 않은 게이트수준 시뮬레이션이고, 상기 하위수준에서의 시뮬레이션이 타이밍 정보를 이용한 게이트수준에서의 타이밍 시뮬레이션인 설계 검증 및 설계 수정 방법
78. 제 47 항 내지는 77 항에 있어서,

    상기 게이트수준 시뮬레이션이 타이밍 정보를 이용하지 않은 게이트수준 시뮬레이션인 경우에 시뮬레이션 대상이 되는 설계객체의 일부분이 부분적으로 이진결정다이아그램(BDD) 내지는 다진결정다이아그램(MDD)으로 표현되어져서 시뮬레이션되는 검증 방법
79. 제 76 항에 있어서,

    상기 상위수준에서의 시뮬레이션 결과를 하위수준에서의 시뮬레이션에서 이용하고 이렇게 하여 얻어진 하위수준에서의 시뮬레이션 결과를 다시 상위수준에서의 시뮬레이션에서 이용하는 반복적인 과정이, 한번 반복할 때마다 시뮬레이션 하는 시간 구간을 좁혀가면서 적용함으로서 하위수준에서의 시뮬레이션 결과와 상위수준에서의 시뮬레이션 결과를 같게 만드는 설계 검증 방법
80. 검증 소프트웨어와 2 이상의 다른 검증 플랫폼을 구비하는 설계검증장치에 있어서 상기 검증 소프트웨어는 설계 코드나 합성으로 생성된 게이트수준의 네트리스트에 자동화된 방식을 통하여 부가 코드나 부가회로를 부가하여 상기 2 이상의 다른 검증 플랫폼들 중의 1 이상의 특정 검증 플랫폼 상에서 1차 검증 실행을 수행하면서 1차 검증 실행 시작 이후의 1차 검증 실행에 사용된 1 이상의 특정 검증 플랫폼과는 최소한 하나 이상에서 다른 1 이상의 다른 검증 플랫폼 상에서 수행되는 검증 실행을 검증사이클 시간구간들이나 설계 코드나 합성으로 생성된 게이트수준의 네트리스트에 존재하는 블록들에 대하여 검증 실행들이 이루어질 수 있도록 하는데 필요한 최소한의 정보를 1차 검증 실행 과정에서 자동적으로 수집할 수 있도록 하고, 상기 1 이상의 1차 검증 플랫폼을 이용한 1차 검증 실행을 수행하면서 상기 최소한의 정보를 수집하고, 이 수집된 정보를 이용하여 상기 1차 검증 실행에 사용된 1 이상의 특정 검증 플랫폼과는 최소한 하나 이상에서 다른 1 이상의 검증 플랫폼 상에서 1차 검증 실행 시작 이후의 1회 이상의 검증 실행을 신속하게 수행하는 것을 가능하게 하는 설계 검증 장치.
81. 제 80 항에 있어서,

    상기 2 이상의 다른 검증 플랫폼들 중의 특정 검증 플랫폼 상에서 1차 검증 실행을 수행하면서 1차 검증 실행 시작 이후의 상기 1차 검증 실행에 사용된 1 이상의 특정 검증 플랫폼과는 최소한 하나 이상에서 다른 1 이상의 검증 플랫폼 상에서 수행되는 검증 실행의 검증사이클 시간구간들이나 설계 코드나 합성으로 생성된 게이트수준의 네트리스트에 존재하는 블록들에 대하여 검증 실행들이 이루어질 수 있도록 하는데 필요한 최소한의 정보를 1차 검증 실행 과정에서 자동적으로 수집할 수 있도록 하고, 상기 1차 검증 실행을 위한 1 이상의 검증 플랫폼을 이용한 1차 검증 실행을 수행하면서 상기 최소한의 정보를 수집하고, 이 수집된 정보를 이용함으로서 상기 1차 검증 실행에 사용된 1 이상의 특정 검증 플랫폼과는 최소한 하나 이상에서 다른 1 이상의 검증 플랫폼 상에서 1차 검증 실행 시작 이후의 1회 이상의 검증 실행을 0 검증사이클 시간에서부터 시작되지 않아도 되도록 함으로서 검증을 신속하게 수행하는 것을 가능하게 하는 설계 검증 장치.
82. 제 80 항에 있어서,

    2 이상의 다른 검증 플랫폼들 중의 특정 1 이상의 검증 플랫폼 상에서 1차 검증 실행을 수행하면서 1차 검증 실행 시작 이후의 상기 1차 검증 실행에 사용된 1 이상의 특정 검증 플랫폼과는 최소한 하나 이상에서 다른 1 이상의 검증 플랫폼 상에서 수행되는 검증 실행의 검증사이클 시간구간들이나 설계 코드나 합성으로 생성된 게이트수준의 네트리스트에 존재하는 블록들에 대하여 검증 실행들이 이루어질 수 있도록 하는데 필요한 최소한의 정보를 1차 검증 실행 과정에서 자동적으로 수집할 수 있도록 하고, 상기 1차 검증 플랫폼을 이용한 1차 검증 실행을 수행하면서 상기 최소한의 정보를 수집하고, 이 수집된 정보를 이용함으로서 상기 1차 검증 실행을 위한 1 이상의 검증 플랫폼을 이용한 1차 검증 실행에 사용된 1 이상의 특정 검증 플랫폼과는 최소한 하나 이상에서 다른 검증 플랫폼 상에서 1차 검증 실행 시작 이후의 1회 이상의 검증 실행에서 설계 코드나 합성으로 생성된 게이트수준의 네트리스트에 존재하는 1 이상의 특정 블록들에 대해서만 검증 실행을 할 수 있도록 함으로서 검증을 신속하게 수행하는 것을 가능하게 하는 설계 검증 장치.
83. 2 이상의 검증 플랫폼을 혼합적으로 이용하여 설계 검증 실행을 수행함으로서 설계 코드나 합성으로 생성된 게이트수준의 네트리스트에 존재하는 설계 오류의 위치를 알아내고 이를 수정하는 설계 검증 방법에 있어서, 상기 설계 검증 실행을 상기 2 이상의 검증 플랫폼 중의 1 이상의 특정 검증 플랫폼 상에서의 1차 검증 실행과 1차 검증 실행 시작 이후의 검증 실행은 1차 검증 실행에 사용된 1 이상의 특정 검증 플랫폼과는 최소한 하나 이상에서 다른 1 이상의 검증 플랫폼 상에서의 1회 이상의 검증 실행들로 나누어서 수행하며, 상기 1차 검증 실행을 수행하면서 1차 검증 실행 시작 이후의 다른 검증 플랫폼 상에서 수행되는 1회 이상의 검증 실 행의 검증사이클 시간구간들이나 설계 코드나 합성으로 생성된 게이트수준의 네트리스트에 존재하는 블록들에 대하여 검증 실행들이 이루어질 수 있도록 하는데 필요한 최소한의 정보를 1차 검증 실행 과정에서 자동적으로 수집할 수 있도록 하고, 상기 1 이상의 1차 검증 플랫폼을 이용한 1차 검증 실행을 수행하면서 상기 최소한의 정보를 수집하고, 이 수집된 정보를 이용함으로서 상기 1차 검증 실행에 사용된 1 이상의 특정 검증 플랫폼과는 최소한 하나 이상에서 다른 1 이상의 검증 플랫폼 상에서 1차 검증 실행 시작 이후의 1회 이상의 검증 실행에서 검증 실행의 특정 검증사이클 시간구간들이나 설계 코드나 합성으로 생성된 게이트수준의 네트리스트에 존재하는 1 이상의 특정 블록들에 대해서만 검증 실행을 할 수 있도록 함으로서 검증을 신속하게 수행하는 것을 가능하게 검증 방법
84. 제 83 항에 있어서,

    2 이상의 검증 플랫폼을 혼합적으로 이용하여 설계 검증 실행을 수행함으로서 설계 코드나 합성으로 생성된 게이트수준의 네트리스트에 존재하는 설계 오류의 위치를 알아내고 이를 수정하는 설계 검증 방법에 있어서, 상기 설계 검증 실행을 상기 2 이상의 검증 플랫폼 중의 1 이상의 특정 검증 플랫폼 상에서의 1차 검증 실행과 1차 검증 실행 시작 이후의 1차 검증 실행에 사용된 1 이상의 특정 검증 플랫폼과는 최소한 하나 이상에서 다른 1 이상의 검증 플랫폼 상에서의 1회 이상의 검증 실행들로 나누어서 수행하며, 상기 1차 검증 실행을 수행하면서 1차 검증 실행 시작 이후의 다른 검증 플랫폼 상에서 수행되는 1회 이상의 검증 실행에서 검증 실 행의 특정 검증사이클 시간구간들이나 설계 코드나 합성으로 생성된 게이트수준의 네트리스트에 존재하는 1 이상의 특정 블록들에 대하여 검증 실행들이 이루어질 수 있도록 하는데 필요한 최소한의 정보를 1차 검증 실행 과정에서 자동적으로 수집할 수 있도록 하고, 상기 1 이상의 1차 검증 플랫폼을 이용한 1차 검증 실행을 수행하면서 상기 최소한의 정보를 수집하고, 이 수집된 정보를 이용하여 상기 1차 검증 실행 시작 이후의 검증 실행을 상기 1차 검증 실행에 사용된 1 이상의 특정 검증 플랫폼과는 최소한 하나 이상에서 다른 1 이상의 검증 플랫폼 상에서 0 검증사이클 시간에서부터 시작되지 않아도 되도록 함으로서 검증을 신속하게 수행하는 것을 가능하게 하는 검증 방법
85. 제 83 항 내지는 제 84 항에 있어서,

    1차 검증 실행 시작 이후의 1차 검증 실행에 사용된 1 이상의 특정 검증 플랫폼과는 최소한 하나 이상에서 다른 1 이상의 검증 플랫폼 상에서의 1회 이상의 검증 실행 각각을 2 이상의 검증 플랫폼들 상에서 병렬적으로 수행함으로서 검증을 신속하게 수행하는 것을 가능하게 하는 검증 방법
86. 제 85 항에 있어서,

    1차 검증 실행 시작 이후의 1차 검증 실행에 사용된 1 이상의 특정 검증 플랫폼과는 최소한 하나 이상에서 다른 1 이상의 검증 플랫폼 상에서의 1회 이상의 검증 실행 각각을 수행하기 위한, 상기 2 이상의 검증 플랫폼들 구성을 둘 이상의 서로 상이한 각각 다른 검증 플랫폼들로 구성하여 이들을 병렬적으로 수행함으로서 검증을 신속하게 수행하는 것을 가능하게 하는 검증 방법
87. 제 83 항 내지는 제 84 항에 있어서,

    1차 검증 실행 시작 이후의 1차 검증 실행에 사용된 1 이상의 특정 검증 플랫폼과는 다른 검증 플랫폼 상에서의 1회 이상의 검증 실행 각각을 하나의 검증 플랫폼 상에서 순서적으로 수행함으로서 검증을 수행하는 것을 가능하게 하는 검증 방법
88. 제 83 항 내지는 제 84 항 내지는 제 85 항 내지는 제 86 항 내지는 제 87 항에 있어서,

    1차 검증 실행 시작 이후의 1회 이상의 검증 실행에 있어서, 검증 실행 각각에서의 실행하고자 하는 검증사이클 전체구간이나 검증사이클 특정구간을 1 이상의 특정 검증 플랫폼을 이용한 1차 검증 실행에서 수집된 2 이상의 상태 정보들에서부터 시작될 수 있도록 1차 검증 실행에 사용된 1 이상의 특정 검증 플랫폼과는 다른 하나의 검증 플랫폼을 2회 이상 순서적으로 설정하고 2회 이상 순서적으로 상기 다른 하나의 검증 플랫폼을 실행시키는 과정에 있어서, 1차 검증 실행 시에 상태 정보를 저장하는 시뮬레이션 시점 내지는 시뮬레이션 구간이 검증시간 적으로 제일 뒤에 있는 상태 정보를 우선 상기 하나의 검증 플랫폼에 설정하여 이 상태 정보를 가지고 진행하고, 이 후의 실행들도 상기 하나의 검증 플랫폼으로써 수행하는 과정 에서 1차 검증실행 과정에서 상태 정보를 저장한 시뮬레이션 시점 내지는 시뮬레이션 구간이 검증시간 적으로 뒤에 있는 것들을 우선으로 하여 상기 하나의 검증 플랫폼에 설정하여 1차 검증 실행 시작 이후의 검증 실행들 각각이 2 이상의 상태 정보를 이용하여 검증시간 적으로 제일 뒤에서부터 앞서는 순서대로 진행하면서 설계 코드나 합성으로 생성된 게이트수준의 네트리스트에 존재하는 시그널들과 변수들에 대한 탐침을 수행하는 설계 검증 방법
89. 제 80 항 내지는 제 81 항 내지는 제 82 항 내지는 제 83 항 내지는 제 84 항에 있어서,

    최소한의 정보 수집이 1차 검증 실행 과정에서 일정 간격으로 혹은 특정 시뮬레이션 시점들 내지는 특정 시뮬레이션 구간들에서 DUV의 상태 정보와 검증사이클 전체에서 DUV의 모든 입력과 입출력 정보를 1 이상의 파일 형태로 저장하는 포함하는 설계 검증 방법
90. 제 80 항 내지는 제 81 항 내지는 제 82 항 내지는 제 83 항 내지는 제 84 항에 있어서,

    최소한의 정보 수집이 1차 검증 실행 과정에서 일정 간격으로 혹은 특정 시뮬레이션 시점들 내지는 특정 시뮬레이션 구간들에서 DUV의 상태 정보와 TB의 상태 정보를 1 이상의 파일 형태로 저장하는 포함하는 설계 검증 방법
91. 제 80 항 내지는 제 81 항 내지는 제 82 항 내지는 제 83 항 내지는 제 84 항에 있어서,

    1차 검증 실행에 사용된 검증 플랫폼이 1 이상의 시뮬레이터인 경우에 있어서, 최소한의 정보 수집이 1차 검증 실행 과정에서 일정 간격으로 혹은 특정 시뮬레이션 시점들 내지는 시뮬레이션 구간들에서 시뮬레이션 상태를 1 이상의 파일 형태로 저장하는 것을 포함하는 설계 검증 방법
92. 제 91 항에 있어서,

    상기 1 이상의 시뮬레이터를 이용한 1차 검증 실행 시행 중에 1 이상의 시점들에서 시뮬레이션 상태를 저장하는 방법을 시뮬레이터의 save 명령어를 사용하고, 1차 검증 실행 시작 이후의 검증 실행들을 상기 선정된 1 이상의 시뮬레이션 상태에서부터 추출된 상태 정보에서부터 시작될 수 있도록 하는 설계 검증 방법
93. 제 80 항 내지는 제 81 항 내지는 제 82 항 내지는 제 83 항 내지는 제 84 항에 있어서,

    최소한의 정보 수집이 1차 검증 실행 과정에서 설계 코드나 합성으로 생성된 게이트 수준의 네트리스트에 존재하는 특정 블록들의 입력과 입출력을 검증사이클 전체에서 지속적으로 탐침하여 1 이상의 파일 형태로 저장하는 것을 포함하는 설계 검증 방법.
94. 제 85 항 내지는 제 86 항에 있어서,

    1차 검증 실행 시작 이후의 검증 실행 각각을 1차 검증 실행 과정에서 저장된 2 이상의 DUV 상태 정보들 각각을 이용하여 2회 이상의 부분 검증 실행을 하는 것으로 전환하여, 컴퓨터 네트워크로 연결된 2 이상의 컴퓨터에 인스톨된 2 이상의 검증 플랫폼들을 이용하여 상기 2 이상의 상태 정보들 각각을 상기 2 이상의 검증 플랫폼 각각에 설정하여 2회 이상의 부분 검증 실행이 서로 독립적으로 상기 2 이상의 검증 플랫폼으로써 병렬적으로 실행되게 하고, 필요시 실행된 2 이상의 결과들을 컴퓨터 네트워크를 이용하여 한 컴퓨터에 전송하고 통합하여 전체의 검증 결과로 제공하는 설계 검증 방법
95. 제 85 항 내지는 제 86 항에 있어서,

    1차 검증 실행 시작 이후의 검증 실행 각각을 1차 검증 실행을 통하여 얻어진 2 이상의 블록들과 이들 블록들 각각의 모든 입력과 입출력을 1차 검증 실행 전과정에서 탐침한 2 이상의 탐침 파일들을 컴파일하여 얻어진 2 이상의 실행 파일들을 컴퓨터 네트워크로 연결된 2 이상의 컴퓨터에 인스톨된 2 이상의 검증 플랫폼들을 이용하여 독립적으로 병렬적으로 실행하고, 필요시 실행된 2 이상의 결과들을 컴퓨터 네트워크를 이용하여 한 컴퓨터에 전송하고 통합하여 전체의 검증 결과로 제공하는 설계 검증 방법
96. 제 82 항에 있어서,

    1차 검증 실행 시행 중에 1 이상의 검증 시점들 내지는 검증 구간들에서 저장된 1 이상의 설계객체들에 대한 상태 정보들 중에서 1 이상의 상태 정보를 선정하여 1차 검증 실행 시작 이후의 설계 검증들을 상기 선정된 1 이상의 상태 정보에서부터 시작될 수 있도록 1차 검증 실행에서 사용된 검증 플랫폼과는 다른 검증 플랫폼을 1회 이상 설정한 후에 검증 실행을 1회 이상 진행하면서 설계 코드나 합성으로 생성된 게이트 수준의 네트리스트에 존재하는 시그널들과 변수들에 대한 탐침을 수행하는 설계 검증 방법
97. 제 83 항에 있어서,

    1차 검증 실행 중에 설계 코드나 합성으로 생성된 게이트수준의 네트리스트에 존재하는 1 이상의 블록들에 대한 입력과 입출력들을 검증 실행의 검증사이클 전 과정에서 탐침하여 저장한 1 이상의 탐침 파일들 중에서 1 이상을 선정하여 1차 검증 실행 시작 이후의 검증 실행들을 상기 선정된 1 이상의 탐침 파일과 해당 1 이상의 블록들을 이용하여 1차 검증 실행에서 사용된 검증 플랫폼과는 다른 검증 플랫폼을 위하여 컴파일하여 생성된 1 이상의 파일들 중에서 추가적인 탐침이 필요한 설계 코드나 합성으로 생성된 게이트수준의 네트리스트에 존재하는 시그널들과 변수들을 가지고 있는 해당 1 이상의 블록들에 관계되는 파일을 이용하여 상기 추가적인 탐침을 수행하는 설계 검증 방법
98. 임의의 시뮬레이션 수행 내지는 시뮬레이션가속 수행 내지는 하드웨어에뮬레 이션 수행 내지는 프로토타이핑 수행을 통하여 얻어진 검증 실행 결과를 이용한 추가적인 설계 검증 수행에서, 상기 추가적인 설계 검증 수행을 2 이상의 검증 플랫폼 중의 1 이상의 특정 검증 플랫폼 상에서의 1차 검증 실행과 1차 검증 실행 시작 이후의 검증 실행은 1차 검증 실행에 사용된 1 이상의 특정 검증 플랫폼과는 최소한 하나 이상에서 다른 1 이상의 검증 플랫폼 상에서의 1회 이상의 검증 실행들로 나누어서 수행하며, 상기 1차 검증 실행을 수행하면서 1차 검증 실행 시작 이후의 다른 검증 플랫폼 상에서 수행되는 1회 이상의 검증 실행의 검증사이클 시간구간들이나 설계 코드나 합성으로 생성된 게이트수준의 네트리스트에 존재하는 블록들에 대하여 검증 실행들이 이루어질 수 있도록 하는데 필요한 최소한의 정보를 1차 검증 실행 과정에서 자동적으로 수집할 수 있도록 하고, 상기 1 이상의 1차 검증 플랫폼을 이용한 1차 검증 실행을 수행하면서 상기 최소한의 정보를 수집하고, 이 수집된 정보를 이용함으로서 상기 1차 검증 실행에 사용된 1 이상의 특정 검증 플랫폼과는 최소한 하나 이상에서 다른 1 이상의 검증 플랫폼 상에서 1차 검증 실행 시작 이후의 1회 이상의 검증 실행에서 검증 실행의 특정 검증사이클 시간구간들이나 설계 코드나 합성으로 생성된 게이트수준의 네트리스트에 존재하는 1 이상의 특정 블록들에 대해서만 검증 실행을 할 수 있도록 함으로서 검증을 신속하게 수행하는 것을 가능하게 검증 방법
99. 검증 소프트웨어와 1 이상의 검증플랫폼을 구비하는 설계검증 장치에 있어서, 상기 검증 소프트웨어는 1 이상의 설계객체들로 구성되는 설계 코드나 설계 회 로에 자동화된 방식을 통하여 부가코드나 부가회로를 추가하여 상기 1 이상의 검증 플랫폼들에 설계 코드나 설계 회로를 부가코드나 부가회로와 함께 구현하여 1회 이상의 검증 실행 도중에서 1 이상의 특정 검증 시점들 내지는 특정 검증 구간들에서 동적 정보의 수집을 가능하게 하고, 이 수집된 동적 정보를 1 이상의 설계객체들이 변경된 후에 실행되는 검증 실행에 재활용함으로서 1 이상의 설계객체들이 변경된 후에 실행되는 검증 실행의 전체 시간을 전체적으로 내지는 부분적으로 단축시킬 수 있게 하는 설계 검증 장치.
100. 검증 소프트웨어와 1 이상의 검증플랫폼을 이용하여, 1 이상의 설계 객체들로 구성되는 설계 코드나 설계 회로에 자동화된 방식을 통하여 부가코드나 부가회로를 추가하여 상기 1 이상의 검증 플랫폼들에 설계 코드나 설계 회로를 부가코드나 부가회로와 함께 구현하여 1회 이상의 검증 실행 도중에 1 이상의 특정 검증 시점들 내지는 검증 구간들에서 동적 정보의 수집을 가능하게 하고, 이 수집된 동적 정보를 1 이상의 설계객체들이 변경된 후에 실행되는 검증 실행에 재활용함으로서 1 이상의 설계객체들이 변경된 후에 실행되는 검증 실행의 전체 시간을 전체적으로 내지는 부분적으로 단축시킬 수 있게 하는 설계 검증 방법.
101. 제 99 항 내지는 제 100 항에 있어서,

     1 이상의 설계객체의 변경 후의 설계 검증 실행 결과가 설계객체 변경 전의 설계 검증 실행 결과와 검증 시간 측면에서 제일 처음으로 달라지는 시점을 찾는 방법을 변경된 1 이상의 설계객체들의 모든 출력과 양방향 입출력들 값들과 변경되기 전의 상기 1 이상의 설계객체들의 모든 출력과 양방향 입출력들 값들과 비교하여 자동화된 방식으로 찾아내는 설계 검증 방법.
102. 제 99 항 내지는 제 100 항에 있어서,

     1 이상의 설계객체의 변경 후의 설계 검증 실행 결과가 설계객체 변경 전의 설계 검증 실행 결과와 검증 시간 측면에서 제일 처음으로 달라지는 시점을 찾는 방법을 변경된 1 이상의 설계객체들의 모든 출력 값들과 변경되기 전의 상기 1 이상의 설계객체들의 모든 출력 값들과 비교하여 자동화된 방식으로 찾아내는 설계 검증 방법.
103. 제 99 항 내지는 제 100 항에 있어서,

     1 이상의 설계객체들의 변경 후의 설계 검증 실행 결과가 설계객체 변경 전의 설계 검증 실행 결과와 검증 시간 측면에서 제일 처음으로 달라지는 시점을 찾는 방법을 변경 전 1회 이상의 검증 실행 과정에서 얻어지는 재생용 입력정보를 변경된 1 이상의 설계객체들 만에 인가하여서 자동화된 방식으로 찾아내는 설계 검증 방법.
104. 제 99 항 내지는 제 100 항 내지는 제 101 항 내지는 제 102 항 내지는 제 103 항에 있어서,

     1 이상의 설계객체들 변경 후에 수행되는 검증 실행에서 상기 1 이상의 설계객체들의 변경에 의하여 설계 검증 실행 결과가 설계객체 변경 전의 설계 검증 실행 결과와 검증 시간 측면에서 제일 처음으로 달라지는 시점까지는 변경된 설계객체들과 이들의 재생용 입력정보만을 이용한 검증수행을 통하여 신속하게 검증하는 설계 검증 방법.
105. 제 99 항 내지는 제 100 항 내지는 제 101 항 내지는 제 102 항 내지는 제 103 항에 있어서,

     1 이상의 설계객체들 변경 후에 수행되는 검증 실행에서 상기 1 이상의 설계객체들의 변경에 의하여 설계 검증 실행 결과가 설계객체 변경 전의 설계 검증 실행 결과와 검증 시간 측면에서 제일 처음으로 달라지는 시점까지는 변경된 설계객체들과 이들의 재생용 입력정보를 이용한 검증 수행과 함께 설계 변경이 이루어지지 않은 설계객체들의 일부분만을 이용한 검증 수행만을 통하여 신속하게 검증하는 설계 검증 방법.
106. 제 99 항 내지는 제 100 항 내지는 제 101 항 내지는 제 102 항 내지는 제 103 항에 있어서,

     1 이상의 설계객체들 변경 후에 수행되는 검증 실행에서 상기 1 이상의 설계객체들의 변경에 의하여 설계 검증 실행 결과가 설계객체 변경 전의 설계 검증 실행 결과와 검증 시간 측면에서 제일 처음으로 달라지는 시점이후부터는 모든 설계 객체들을 포함한 검증실행으로 자동적으로 전환하여 검증 실행하는 설계 검증 방법.
107. 제 99 항 내지는 제 100 항 내지는 제 101 항 내지는 제 102 항 내지는 제 103 항에 있어서,

     1 이상의 설계객체들 변경 후에 수행되는 검증 실행에서 상기 1 이상의 설계객체들의 변경에 의하여 설계 검증 실행 결과가 설계객체 변경 전의 설계 검증 실행 결과와 검증 시간 측면에서 달라지는 1 이상의 특정시점에서부터 다시 같아지는 특정시점까지는 모든 설계객체들을 포함한 검증실행으로 자동적으로 전환하여 검증 실행하는 설계 검증 방법.
108. 제 99 항 내지는 제 100 항 내지는 제 101 항 내지는 제 102 항 내지는 제 103 항에 있어서,

     1 이상의 설계객체들 변경 후에 수행되는 검증 실행에서 상기 1 이상의 설계객체들의 변경에 의하여 설계 검증 실행 결과가 설계객체 변경 전의 설계 검증 실행 결과와 검증 시간 측면에서 제일 처음으로 달라지는 시점까지는 변경된 설계객체들과 이들의 재생용 입력정보를 이용하여 신속하게 검증하고, 상기 제일 처음으로 달라지는 시점이후부터는 모든 설계객체들을 포함한 검증실행으로 자동적으로 전환하여 검증 실행하는 설계 검증 방법.
109. 제 106 항 내지는 제 108 항에 있어서,

     상기 제일 처음으로 달라지는 시점이후부터는 모든 설계객체들을 포함한 검증실행으로 자동적으로 전환을 위하여, 설계 변경이 되지 않은 설계객체들의 상태 정보 복원을 상기 제일 처음으로 달라지는 시점 부근에서 설계 변경이 이루어지기 전에 수행된 검증 실행 과정에서 수집된 설계객체들의 상태 정보를 활용하여 자동화된 방식으로 이루어지는 설계 검증 방법.
110. 제 109 항에 있어서,

     상기 제일 처음으로 달라지는 시점이후부터는 모든 설계객체들을 포함한 검증실행으로 자동적으로 전환을 위하여, 설계 변경이 되지 않은 설계객체들의 상태 정보 복원을 시뮬레이터의 재출발 기능을 이용하고, 상기 제일 처음으로 달라지는 시점 부근에서 설계 변경이 이루어지기 전에 수행된 검증 실행 과정에서 수집된 설계객체들의 상태 정보를 활용하기 위한 저장을 시뮬레이터의 스냅샷 기능을 이용하는 설계 검증 방법.
111. 제 110 항에 있어서,

     상기 제일 처음으로 달라지는 시점이후부터는 모든 설계객체들을 포함한 검증실행으로 자동적으로 전환을 위하여, 설계 변경이 되지 않은 설계객체들의 상태 정보 복원을 시뮬레이터의 재출발 기능을 이용하는 경우에 이를 시뮬레이터의 restore나 restart로 하고, 상기 제일 처음으로 달라지는 시점 부근에서 설계 변경 이 이루어지기 전에 수행된 검증 실행 과정에서 수집된 설계객체들의 상태 정보를 활용하기 위한 저장을 시뮬레이터의 스냅샷 기능을 이용하는 경우에 이를 시뮬레이터의 save나 checkpoint로 하는 설계 검증 방법.
112. 제 99 항 내지는 제 100 항에 있어서,

     1 이상의 설계객체들의 변경에 의하여 설계 검증 실행 결과가 설계객체 변경 전의 설계 검증 실행 결과와 검증 시간 측면에서 제일 처음으로 달라지는 시점을 찾는 방법을 변경된 1 이상의 설계객체들의 모든 출력과 양방향 입출력들 값들과 변경되기 전의 상기 1 이상의 설계객체들의 든 출력과 양방향 입출력들 값들과 순서적으로 비교하여 자동화된 방식으로 찾아내는 설계 검증 방법.
113. 제 99 항 내지는 제 100 항에 있어서,

     1 이상의 설계객체들의 변경에 의하여 설계 검증 실행 결과가 설계객체 변경 전의 설계 검증 실행 결과와 검증 시간 측면에서 제일 처음으로 달라지는 시점을 찾는 방법을 변경되기 전의 설계객체에 대한 1 이상의 검증 시점에서의 동적정보를 병렬적으로 이용하여 자동화된 방식으로 찾아내는 설계 검증 방법.
114. 제 99 항에 있어서,

     상기 검증플래폼이 시뮬레이터 내지는, 시뮬레이션가속기 내지는, 에뮬레이터 내지는, 프로토타이핑시스템 내지는, 이들의 혼합으로 된 설계 검증 장치
115. 제 99 항 지는 제 100 항 지는 제 101 항 내지는 제 102 항 내지는 제 103 항 내지는 제 104 항 내지는 제 105 항 내지는 제 99 항 내지는 제 110 항 내지는 제 111 항에 있어서,

     상기 검증수행의 전체 혹은 일부분이 시뮬레이터를 통하여 이루어지는 경우에는 전체의 검증수행을 위하여 2 이상의 프로세스들을 프로세스간통신을 사용하여 연동시켜서 하는 설계 검증 방법
116. 제 115 항에 있어서,

     검증 수행 도중에 프로세스간통신을 사용하여 연동되는 상기 2개 이상의 프로세스들 중에서 최소한 1 개의 프로세스에 대하여 스냅셧을 활용하여 설계 코드 변경 전의 검증 수행 과정에서 1 이상의 설계객체들에 대한 동적정보를 수집하고, 설계 코드 변경 후에 실행되는 특정 시간대에서부터의 검증 실행을 상기 동적정보를 이용한 재출발을 통하여서 수행함으로서 상기 1 이상의 설계객체들이 변경된 후의 검증 실행의 전체 시간을 전체적으로 내지는 부분적으로 단축시키는 설계 검증 방법
117. 제 116 항에 있어서,

     상기 스냅셧을 시뮬레이터의 save 기능 내지는 checkpoint 기능을 이용하고, 상기 재출발을 시뮬레이터의 restart 기능 내지는 restore 기능을 이용하는 설계 검증 방법
118. 제 99 항 지는 제 100 항 지는 제 101 항 내지는 제 102 항 내지는 제 103 항 내지는 제 104 항 내지는 제 105 항 내지는 제 106 항 내지는 제 108 항 내지는 제 109 항 내지는 제 115 항 내지는 제 116 항 내지는 제 117 항에 있어서,

     검증플랫폼으로 시뮬레이션가속기를 사용하는 경우 내지는 시뮬레이션가속기가 포함된 검증플랫폼을 사용하는 설계 검증 방법
119. 제 106 항 내지는 제 108 항 내지는 제 109 항 내지는 제 110 항 내지는 제 111 항에 있어서,

     상기 설계 변경 후에 수행되는 검증 실행 과정에서 상기 자동 전환하는 시점의 결정이 상기 부가코드가 설계객체에 추가되어져서 검증 실행 과정에서 수행됨으로서 자동적으로 이루어지는 설계 검증 방법
120. 제 106 항 내지는 제 108 항 내지는 제 109 항 내지는 제 110 항 내지는 제 111 항에 있어서,

     상기 설계 변경 후에 수행되는 검증 실행 과정에서 상기 자동 전환하는 시점에서의 설계 변경된 설계객체들의 동적정보와 설계 변경이 않된 설계객체들의 동적정보와 같은 검증시간대로 정확하게 맞추어주는 것이 부가코드가 설계객체들에 추가되어져서 검증 실행 과정에서 수행됨으로서 자동적으로 이루어지는 설계 검증 방 법
121. 제 106 항 내지는 제 108 항 내지는 제 109 항 내지는 제 110 항 내지는 제 111 항에 있어서,

     상기 설계 변경 후에 수행되는 검증 실행 과정에서 상기 자동 전환하는 시점에서부터는 모든 설계객체들을 이용한 설계 검증으로 전환되어 검증 수행되는 것이 부가코드가 설계객체들에 추가되어져서 검증 실행 과정에서 수행됨으로서 자동적으로 이루어지는 설계 검증 방법
122. 제 21 항 내지는 제 22 항 내지는 제 23 항 내지는 제 24 항 내지는 제 25 항 내지는 제 26 항 내지는 제 29 항 내지는 제 32 항 내지는 제 33 항 내지는 제 34 항 내지는 제 36 항 내지는 제 44 항 내지는 제 59 항 내지는 제 60 항 내지는 제 61 항 내지는 제 65 항 내지는 제 75 항 내지는 제 88 항 내지는 제 89 항 내지는 제 90 항 내지는 제 96 항 내지는 제 99 항 내지는 제 100 항에 있어서,

     설계 코드에 존재하는 최장 지연시간을 자동화된 방법으로 조사하여 앞단 시뮬레이션 단계에서 1 이상의 특정 시뮬레이션 구간에서 상태를 저장하는 경우에 이 구간을 최장 지연시간과 같게 하는 설계 검증 방법
123. 제 21 항 내지는 제 22 항 내지는 제 23 항 내지는 제 24 항 내지는 제 25 항 내지는 제 26 항 내지는 제 29 항 내지는 제 32 항 내지는 제 33 항 내지는 제 34 항 내지는 제 36 항 내지는 제 44 항 내지는 제 59 항 내지는 제 60 항 내지는 제 61 항 내지는 제 65 항 내지는 제 75 항 내지는 제 88 항 내지는 제 89 항 내지는 제 90 항 내지는 제 96 항 내지는 제 99 항 내지는 제 100 항에 있어서,

     설계 코드에 존재하는 1 이상의 사용자클럭의 최장 주기를 자동화된 방법으로 조사하여 앞단 시뮬레이션 단계에서 1 이상의 특정 시뮬레이션 구간에서 상태를 저장하는 경우에 이 구간을 사용자클럭의 최장 주기와 같게 하는 설계 검증 방법
124. 제 21 항 내지는 제 22 항 내지는 제 23 항 내지는 제 24 항 내지는 제 25 항 내지는 제 26 항 내지는 제 29 항 내지는 제 32 항 내지는 제 33 항 내지는 제 34 항 내지는 제 36 항 내지는 제 44 항 내지는 제 59 항 내지는 제 60 항 내지는 제 61 항 내지는 제 65 항 내지는 제 75 항 내지는 제 88 항 내지는 제 89 항 내지는 제 90 항 내지는 제 96 항 내지는 제 99 항 내지는 제 100 항에 있어서,

     설계 코드에 존재하는 최장 지연시간을 자동화된 방법으로 조사하여 앞단 시뮬레이션 단계에서 1 이상의 특정 시뮬레이션 구간에서 상태를 저장하는 경우에 이 구간을 최소한 최장 지연시간보다 크게 하는 설계 검증 방법
125. 제 21 항 내지는 제 22 항 내지는 제 23 항 내지는 제 24 항 내지는 제 25 항 내지는 제 26 항 내지는 제 29 항 내지는 제 32 항 내지는 제 33 항 내지는 제 34 항 내지는 제 36 항 내지는 제 44 항 내지는 제 59 항 내지는 제 60 항 내지는 제 61 항 내지는 제 65 항 내지는 제 75 항 내지는 제 88 항 내지는 제 89 항 내지 는 제 90 항 내지는 제 96 항 내지는 제 99 항 내지는 제 100 항에 있어서,

     설계 코드에 존재하는 1 이상의 사용자클럭의 최장 주기를 자동화된 방법으로 조사하여 앞단 시뮬레이션 단계에서 1 이상의 특정 시뮬레이션 구간에서 상태를 저장하는 경우에 이 구간을 최소한 사용자클럭의 최장 주기보다 크게 하는 설계 검증 방법
126. 제 21 항 내지는 제 22 항 내지는 제 23 항 내지는 제 24 항 내지는 제 25 항 내지는 제 26 항 내지는 제 29 항 내지는 제 32 항 내지는 제 33 항 내지는 제 34 항 내지는 제 36 항 내지는 제 44 항 내지는 제 59 항 내지는 제 60 항 내지는 제 61 항 내지는 제 65 항 내지는 제 75 항 내지는 제 88 항 내지는 제 89 항 내지는 제 90 항 내지는 제 96 항 내지는 제 99 항 내지는 제 100 항에 있어서,

     설계 검증 과정에서 사용자가 설계 코드에 존재하는 최장 지연시간을 입력하고 앞단 시뮬레이션 단계에서 1 이상의 특정 시뮬레이션 구간에서 상태를 저장하는 경우에 이 구간을 최장 지연시간과 같게 하는 설계 검증 방법
127. 제 21 항 내지는 제 22 항 내지는 제 23 항 내지는 제 24 항 내지는 제 25 항 내지는 제 26 항 내지는 제 29 항 내지는 제 32 항 내지는 제 33 항 내지는 제 34 항 내지는 제 36 항 내지는 제 44 항 내지는 제 59 항 내지는 제 60 항 내지는 제 61 항 내지는 제 65 항 내지는 제 75 항 내지는 제 88 항 내지는 제 89 항 내지는 제 90 항 내지는 제 96 항 내지는 제 99 항 내지는 제 100 항에 있어서,

     설계 검증 과정에서 사용자가 설계 코드에 존재하는 최장 지연시간을 입력하고 앞단 시뮬레이션 단계에서 1 이상의 특정 시뮬레이션 구간에서 상태를 저장하는 경우에 이 구간을 최장 지연시간보다 크게 하는 설계 검증 방법
128. 제 21 항 내지는 제 22 항 내지는 제 23 항 내지는 제 24 항 내지는 제 25 항 내지는 제 26 항 내지는 제 29 항 내지는 제 32 항 내지는 제 33 항 내지는 제 34 항 내지는 제 36 항 내지는 제 44 항 내지는 제 59 항 내지는 제 60 항 내지는 제 61 항 내지는 제 65 항 내지는 제 75 항 내지는 제 88 항 내지는 제 89 항 내지는 제 90 항 내지는 제 96 항 내지는 제 99 항 내지는 제 100 항에 있어서,

     설계 검증 과정에서 사용자가 설계 코드에 존재하는 1 이상의 사용자클럭의 최장 주기를 입력하고 앞단 시뮬레이션 단계에서 1 이상의 특정 시뮬레이션 구간에서 상태를 저장하는 경우에 이 구간을 사용자클럭의 최장 주기와 같게 하는 설계 검증 방법
129. 제 21 항 내지는 제 22 항 내지는 제 23 항 내지는 제 24 항 내지는 제 25 항 내지는 제 26 항 내지는 제 29 항 내지는 제 32 항 내지는 제 33 항 내지는 제 34 항 내지는 제 36 항 내지는 제 44 항 내지는 제 59 항 내지는 제 60 항 내지는 제 61 항 내지는 제 65 항 내지는 제 75 항 내지는 제 88 항 내지는 제 89 항 내지는 제 90 항 내지는 제 96 항 내지는 제 99 항 내지는 제 100 항에 있어서,

     설계 검증 과정에서 사용자가 설계 코드에 존재하는 1 이상의 사용자클럭의 최장 주기를 입력하고 앞단 시뮬레이션 단계에서 1 이상의 특정 시뮬레이션 구간에서 상태를 저장하는 경우에 이 구간을 최소한 사용자클럭의 최장 주기보다 크게 하는 설계 검증 방법
130. 제 122 항 내지는 제 123 항 내지는 제 124 항 내지는 제 125 항 내지는 제 126 항 내지는 제 127 항 내지는 제 128 항 내지는 제 129 항에 있어서,

     후단 시뮬레이션 단계에서의 1 이상의 병렬적 내지는 순차적 시뮬레이션의 각 시뮬레이션 시작 시점을 위한 상태설정이 상기 앞단 시뮬레이션 단계에서 저장된 특정 시뮬레이션 구간의 첫 시작시점에서의 상태와 같도록 설정이 되는 설계 검증 방법
131. 제 122 항 내지는 제 123 항 내지는 제 124 항 내지는 제 125 항 내지는 제 126 항 내지는 제 127 항 내지는 제 128 항 내지는 제 129 항에 있어서,

     후단 시뮬레이션 단계에서의 1 이상의 병렬적 내지는 순차적 시뮬레이션의 각 시뮬레이션 시작 시점을 위한 상태설정이 상기 앞단 시뮬레이션 단계에서 저장된 특정 시뮬레이션 구간의 첫 시작시점에서의 상태 내지는 특정 시뮬레이션 시점에서의 상태와 같도록 설정이 되며, 계속되는 일정기간까지의 상태설정들을 계속적으로 상기 앞단 시뮬레이션 단계에서 저장된 특정 시뮬레이션 구간의 첫 시작시점 이후부터 마지막 시점까지의 1 이상의 시점들의 상태들 내지는 상기 앞단 시뮬레이션 단계에서 저장된 특정 시뮬레이션 시점에서의 상태와 같도록 하는 설계 검증 방 법
132. 제 122 항 내지는 제 123 항 내지는 제 124 항 내지는 제 125 항 내지는 제 126 항 내지는 제 127 항 내지는 제 128 항 내지는 제 129 항에 있어서,

     후단 시뮬레이션 단계에서의 1 이상의 병렬적 내지는 순차적 시뮬레이션의 각 시뮬레이션 시작 시점을 위한 상태설정이 상기 앞단 시뮬레이션 단계에서 저장된 특정 시뮬레이션 구간 안에 존재하는 임의의 1 이상의 시점에서의 상태와 같도록 설정이 되는 설계 검증 방법
133. 제 122 항 내지는 제 123 항 내지는 제 124 항 내지는 제 125 항 내지는 제 126 항 내지는 제 127 항 내지는 제 128 항 내지는 제 129 항에 있어서,

     후단 시뮬레이션 단계에서의 1 이상의 병렬적 내지는 순차적 시뮬레이션의 각 시뮬레이션 시작 시점을 위한 상태설정이 상기 앞단 시뮬레이션 단계에서 저장된 특정 시뮬레이션 구간 안에 존재하는 임의의 시점에서의 상태와 같도록 설정이 되며, 계속되는 일정기간까지의 상태설정들을 계속적으로 상기 앞단 시뮬레이션 단계에서 저장된 특정 시뮬레이션 구간 안에 존재하는 임의의 시점 이후부터 상기 앞단 시뮬레이션 단계에서 저장된 특정 시뮬레이션 구간 안에 존재하는 또 다른 임의의 시점 까지의 1 이상의 시점들의 상태들과 같도록 하는 설계 검증 방법
134. 제 1 항 내지는 제 2 항 내지는 제 4 항 내지는 제 5 항 내지는 제 6 항 내 지는 제 7 항 내지는 제 8 항 내지는 제 9 항 내지는 제 10 항 내지는 제 11 항 내지는 제 12 항 내지는 제 14 항 내지는 제 15 항 내지는 제 16 항 내지는 제 17 항 내지는 제 18 항 내지는 제 19 항 내지는 제 20 항 내지는 제 21 항 내지는 제 22 항 내지는 제 23 항 내지는 제 24 항 내지는 제 25 항 내지는 제 26 항 내지는 제 27 항 내지는 제 29 항 내지는 제 31 항 내지는 제 32 항 내지는 제 33 항 내지는 제 34 항 내지는 제 35 항 내지는 제 54 항 내지는 제 55 항 내지는 제 161 항 내지는 제 162 항 내지는 제 163 항 내지는 제 164 항 내지는 165 항 내지는 166 항 내지는 167 항에 있어서,

     앞단 시뮬레이션 시작 이후 앞단 시뮬레이션이 진행되고 있는 도중에 1 이상의 후단 시뮬레이션을 진행할 수 있는 앞단 시뮬레이션의 실행결과들이 부분적으로 생성되는 시점에서 앞단 시뮬레이션의 종료 이전에라도 상기 1 이상의 후단 시뮬레이션을 진행하는 설계 검증 방법
135. 제 134 항에 있어서,

     상기 앞단 시뮬레이션의 종료 이전에 진행되는 상기 1 이상의 후단 시뮬레이션을 앞단 시뮬레이션을 진행하는 컴퓨터와 네트워크를 통하여 연결된 1 이상의 별도의 컴퓨터를 이용하여 순차적으로 수행하는 설계 검증 방법
136. 제 134 항에 있어서,

     상기 앞단 시뮬레이션의 종료 이전에 진행되는 상기 1 이상의 후단 시뮬레이 션을 앞단 시뮬레이션을 진행하는 컴퓨터와 네트워크를 통하여 연결된 1 이상의 별도의 컴퓨터를 이용하여 병렬적으로 수행하는 설계 검증 방법
137. 제 1 항 내지는 제 2 항 내지는 제 4 항 내지는 제 5 항 내지는 제 6 항 내지는 제 7 항 내지는 제 8 항 내지는 제 9 항 내지는 제 10 항 내지는 제 11 항 내지는 제 12 항 내지는 제 14 항 내지는 제 15 항 내지는 제 16 항 내지는 제 17 항 내지는 제 18 항 내지는 제 19 항 내지는 제 20 항 내지는 제 21 항 내지는 제 22 항 내지는 제 23 항 내지는 제 24 항 내지는 제 25 항 내지는 제 26 항 내지는 제 27 항 내지는 제 29 항 내지는 제 31 항 내지는 제 32 항 내지는 제 33 항 내지는 제 34 항 내지는 제 35 항 내지는 제 54 항 내지는 제 55 항 내지는 제 161 항 내지는 제 162 항 내지는 제 163 항 내지는 제 164 항 내지는 165 항 내지는 166 항 내지는 167 항에 있어서,

     앞단 시뮬레이션 시작 이후에 1 이상의 후단 시뮬레이션을 진행할 수 있는 앞단 시뮬레이션의 실행결과들이 모두 생성되어지고 앞단 시뮬레이션의 종료 이후에 상기 1 이상의 후단 시뮬레이션을 진행하는 설계 검증 방법
138. 제 80 항 내지는 제 81 항 내지는 제 82 항 내지는 제 83 항 내지는 제 84 항 내지는 제 85 항 내지는 제 86 항 내지는 제 87 항 내지는 제 88 항 내지는 제 92 항 내지는 제 94 항 내지는 제 95 항 내지는 제 96 항 내지는 제 97 항 내지는 제 98 항에 있어서,

     앞단 검증 시작 이후 앞단 검증이 진행되고 있는 도중에 1 이상의 후단 검증을 진행할 수 있는 앞단 검증의 실행결과들이 부분적으로 생성되는 시점에서 앞단 검증의 종료 이전에라도 상기 1 이상의 후단 시뮬레이션을 진행하는 설계 검증 방법
139. 제 138 항에 있어서,

     상기 앞단 검증의 종료 이전에 진행되는 상기 1 이상의 후단 검증을 앞단 검증을 진행하는 검증플랫폼과 네트워크를 통하여 연결된 1 이상의 별도의 검증플랫폼을 이용하여 순차적으로 수행하는 설계 검증 방법
140. 제 138 항에 있어서,

     상기 앞단 검증의 종료 이전에 진행되는 상기 1 이상의 후단 검증을 앞단 검증을 진행하는 검증플랫폼과 네트워크를 통하여 연결된 1 이상의 별도의 검증플랫폼을 이용하여 병렬적으로 수행하는 설계 검증 방법
141. 제 80 항 내지는 81 항 내지는 제 82 항 내지는 제 83 항 내지는 제 84 항 내지는 제 85 항 내지는 제 86 항 내지는 제 87 항 내지는 제 88 항 내지는 제 92 항 내지는 제 94 항 내지는 제 95 항 내지는 제 96 항 내지는 제 97 항 내지는 제 98 항에 있어서,

     앞단 검증 시작 이후에 1 이상의 후단 검증을 진행할 수 있는 앞단 검증의 실행결과들이 모두 생성되어지고 앞단 검증의 종료 이후에 상기 1 이상의 후단 검증을 진행하는 설계 검증 방법
142. 제 85 항 내지는 86 항 내지는 제 94 항 내지는 제 95 항에 있어서, 앞단 검증 시작 이후에 1 이상의 후단 검증의 병렬적 검증 수행이 1 이상의 모델검사기/특성검사기를 병렬적으로 실행하는 것을 포함하고 있는 설계 검증 방법
143. 검증 소프트웨어와 1 이상의 시뮬레이터를 이용하여서 1 이상의 설계객체로 구성된 HDL 설계코드를 대상으로 하는 설계 검증 방법에 있어서, 상기 1 이상의 설계객체로 구성된 HDL 설계코드를 대상으로 시뮬레이션 시간 0이 아닌 시뮬레이션 시점 S(Ti) 내지는 시뮬레이션 시간 0을 포함하지 않는 시뮬레이션 시간구간 S(Pi)에서부터 시뮬레이션을 시작할 수 있도록 하여서 시뮬레이션 시간 0에서부터 S(Ti)까지 내지는 시뮬레이션 시간 0에서부터 S(Pi)까지에서 상기 1 이상의 설계객체로 구성된 HDL 설계코드를 대상으로 하는 시뮬레이션 시간을 단축시킬 수 있도록, 상기 1 이상의 설계객체로 구성된 HDL 설계코드의 추상화 수준보다 추상화 수준이 높게 구술된 별도의 설계코드 내지는 별도의 모델을 대상으로 하는 시뮬레이션을 시뮬레이션 시간 0에서부터 S(Ti) 내지는 시뮬레이션 시간 0에서부터 S(Pi)까지 수행하여서 얻어지는 상기 1 이상의 설계객체로 구성된 HDL 설계코드의 추상화 수준보다 추상화 수준이 높게 구술된 별도의 설계코드 내지는 별도의 모델에 존재하는 상기 1 이상의 설계객체들에 대한 S(Ti) 내지는 S(Pi)에서의 상태 정보를 상기 검증 소프트웨어를 이용하여서 상기 1 이상의 설계객체로 구성된 HDL 설계코드의 S(Ti) 내지는 S(Pi)에서의 상태 정보로 자동화된 방식으로 설정함으로서 상기 1 이상의 설계객체로 구성된 HDL 설계코드를 이용한 시뮬레이션이 시뮬레이션 시간 0이 아닌 상기 시뮬레이션 시점 S(Ti) 내지는 시뮬레이션 시간구간 S(Pi) 에서부터 시작할 수 있도록 하는 설계 검증 방법
144. 제 143 항에 있어서,

     상기 1 이상의 설계객체로 구성된 HDL 설계코드의 추상화 수준은 RTL 수준이며, 상기 1 이상의 설계객체로 구성된 HDL 설계코드의 추상화 수준보다 추상화 수준이 높게 구술된 별도의 설계코드 내지는 별도의 모델의 추상화 수준은 RTL 수준보다 상위 수준인 설계 검증 방법
145. 제 143 항에 있어서,

     상기 1 이상의 설계객체로 구성된 HDL 설계코드의 추상화 수준은 게이트 수준이며, 상기 1 이상의 설계객체로 구성된 HDL 설계코드의 추상화 수준보다 추상화 수준이 높게 구술된 별도의 설계코드 내지는 별도의 모델의 추상화 수준은 게이트 수준보다 상위수준인 설계 검증 방법
146. 제 143 항에 있어서,

     상기 1 이상의 설계객체로 구성된 HDL 설계코드의 추상화 수준은 RTL 수준이 며, 상기 1 이상의 설계객체로 구성된 HDL 설계코드의 추상화 수준보다 추상화 수준이 높게 구술된 별도의 설계코드 내지는 별도의 모델의 추상화 수준은 트란젝션 수준인 설계 검증 방법
147. 제 143 항에 있어서,

     상기 1 이상의 설계객체로 구성된 HDL 설계코드의 추상화 수준은 지연시간이 고려된 게이트 수준이며, 상기 1 이상의 설계객체로 구성된 HDL 설계코드의 추상화 수준은 지연시간이 고려되지 않은 게이트 수준인 설계 검증 방법
148. 제 143 항에 있어서,

     상기 1 이상의 설계객체로 구성된 HDL 설계코드의 추상화 수준은 지연시간이 고려된 게이트 수준이며, 상기 1 이상의 설계객체로 구성된 HDL 설계코드의 추상화 수준은 RTL 수준인 설계 검증 방법
149. 제 143 항에 있어서,

     상기 1 이상의 설계객체로 구성된 HDL 설계코드의 추상화 수준은 SDF를 이용한 지연시간이 고려된 게이트 수준이며, 상기 1 이상의 설계객체로 구성된 HDL 설계코드의 추상화 수준은 지연시간이 고려되지 않은 게이트 수준인 설계 검증 방법
150. 제 143 항에 있어서,

     상기 1 이상의 설계객체로 구성된 HDL 설계코드의 추상화 수준은 SDF를 이용한 지연시간이 고려된 게이트 수준이며, 상기 1 이상의 설계객체로 구성된 HDL 설계코드의 추상화 수준은 RTL 수준인 설계 검증 방법
151. 제 143 항에 있어서,

     상기 1 이상의 설계객체로 구성된 HDL 설계코드의 S(Ti) 내지는 S(Pi)에서의 상태 정보로 자동화된 방식으로 설정하기 위하여 HDL의 force/release 내지는 assign/deassign procedural statement를 사용하는 것을 포함하는 설계 검증 방법
152. 제 143 항에 있어서,

     상기 1 이상의 설계객체로 구성된 HDL 설계코드의 S(Ti) 내지는 S(Pi)에서의 상태 정보로 자동화된 방식으로 설정하기 위하여 HDL의 initial structured procedure statement를 사용하는 것을 포함하는 설계 검증 방법
153. 제 143 항에 있어서,

     상기 1 이상의 설계객체로 구성된 HDL 설계코드의 S(Ti) 내지는 S(Pi)에서의 상태 정보로 자동화된 방식으로 설정하기 위하여 HDL의 ＄force/＄release 시스템 테스크 내지는 force/release 명령어를 사용하는 것을 포함하는 설계 검증 방법
154. 제 164 항 내지는 제 165 항 내지는 제 166 항 내지는 제 167 항 에 있어서,

     상기 앞단 시뮬레이션 단계인 1차 시뮬레이션 과정에서 수집된 1 이상의 설계객체들에 대한 상태정보와 입력정보들로써 결정되는 2 이상의 슬라이스들이 중복 슬라이스 상황인 설계 검증 방법
155. 제 154 항 내지는 제 181 항 내지는 제 182 항 에 있어서,

     상기 중복 슬라이스 상황에서 존재하는 슬라이스 오버랩 구간을 DUV에 존재하는 최장 지연시간과 같은 설계 검증 방법
156. 제 154 항 내지는 제 181 항 내지는 제 182 항 에 있어서,

     상기 중복 슬라이스 상황에서 존재하는 슬라이스 오버랩 구간 값을 사용자로부터 입력 받는 설계 검증 방법
157. 제 154 항 내지는 제 181 항 내지는 제 182 항 에 있어서,

     상기 중복 슬라이스 상황에서 존재하는 슬라이스 오버랩 구간이 1 이사의 설계객체들에 존재하는 모든 사용자 클럭들 중의 최장 주기와 같은 설계 검증 방법
158. 제 154 항 내지는 제 181 항 내지는 제 182 항 에 있어서,

     상기 중복 슬라이스 상황에서 존재하는 슬라이스 오버랩 구간을 DUV에 존재하는 최장 지연시간보다 크게 하는 설계 검증 방법
159. 제 154 항 내지는 제 181 항 내지는 제 182 항 에 있어서,

     상기 중복 슬라이스 상황에서 존재하는 슬라이스 오버랩 구간이 1 이사의 설계객체들에 존재하는 모든 사용자 클럭들 중의 최장 주기보다 큰 설계 검증 방법
160. 제 1 항 내지는 제 2 항 내지는 제 3 항 내지는 제 4 항 내지는 제 5 항 내지는 제 9 항 내지는 제 10 항 내지는 제 11 항 내지는 제 12 항 내지는 제 23 항 내지는 제 24 항 내지는 제 25 항 내지는 제 27 항 내지는 제 31 항 내지는 제 32 항 내지는 제 47 항 내지는 제 54 항 내지는 제 55 항에 있어서,

     앞단 시뮬레이션 단계인 1차의 시뮬레이션을 원 설계코드에 존재하는 지연시간을 모두 무시한 제로지연시간 모델을 이용한 시뮬레이션으로 수행하는 검증 방법
161. 제 31 항 내지는 제 32 항에 있어서,

     앞단 시뮬레이션 단계인 1차의 시뮬레이션을 DUV의 전체 내지는 DUV내의 1 이상의 설계객체들에 대하여서 RTL 수준에서 사이클-기반 시뮬레이션으로 수행하고, 후단 시뮬레이션 단계인 1차 시뮬레이션 시작 이후에 수행되는 1회 이상의 시뮬레이션은 RTL 수준에서 이벤트-구동 시뮬레이션으로 수행하는 검증 방법
162. 제 31 항 내지는 제 32 항에 있어서,

     앞단 시뮬레이션 단계인 1차의 시뮬레이션을 DUV의 전체 내지는 DUV내의 1 이상의 설계객체들에 대하여서 RTL 수준에서 사이클-기반 시뮬레이션으로 수행하 고, 후단 시뮬레이션 단계인 1차 시뮬레이션 시작 이후에 수행되는 1회 이상의 시뮬레이션은 게이트수준에서 이벤트-구동 시뮬레이션으로 수행하는 검증 방법
163. 제 31 항 내지는 제 32 항에 있어서,

     앞단 시뮬레이션 단계인 1차의 시뮬레이션을 DUV의 전체 내지는 DUV내의 1 이상의 설계객체들에 대하여서 RTL 수준에서 사이클-기반 모드로 수행하고, 후단 시뮬레이션 단계인 1차 시뮬레이션 시작 이후에 수행되는 1회 이상의 시뮬레이션은 게이트수준에서 이벤트-구동 시뮬레이션으로 수행하는 검증 방법
164. 제 31 항 내지는 제 32 항에 있어서,

     앞단 시뮬레이션 단계인 1차의 시뮬레이션을 DUV의 전체 내지는 DUV내의 1 이상의 설계객체들에 대하여서 RTL 수준에서 사이클-기반 시뮬레이션으로 수행하고, 후단 시뮬레이션 단계인 1차 시뮬레이션 시작 이후에 수행되는 1회 이상의 시뮬레이션은 게이트 수준에서 이벤트-구동 타이밍 시뮬레이션으로 수행하는 검증 방법
165. 제 31 항 내지는 제 32 항에 있어서,

     앞단 시뮬레이션 단계인 1차의 시뮬레이션을 DUV의 전체 내지는 DUV내의 1 이상의 설계객체들에 대하여서 RTL 수준에서 사이클-기반 모드로 수행하고, 후단 시뮬레이션 단계인 1차 시뮬레이션 시작 이후에 수행되는 1회 이상의 시뮬레이션은 게이트 수준에서 이벤트-구동 타이밍 시뮬레이션으로 수행하는 검증 방법
166. 제 31 항 내지는 제 32 항에 있어서,

     앞단 시뮬레이션 단계인 1차의 시뮬레이션을 DUV의 전체 내지는 DUV내의 1 이상의 설계객체들에 대하여서 게이트 수준에서 사이클-기반 시뮬레이션으로 수행하고, 후단 시뮬레이션 단계인 1차 시뮬레이션 시작 이후에 수행되는 1회 이상의 시뮬레이션은 게이트 수준에서 이벤트-구동 타이밍 시뮬레이션으로 수행하는 검증 방법
167. 제 31 항 내지는 제 32 항에 있어서,

     앞단 시뮬레이션 단계인 1차의 시뮬레이션을 DUV의 전체 내지는 DUV내의 1 이상의 설계객체들에 대하여서 게이트 수준에서 사이클-기반 모드로 수행하고, 후단 시뮬레이션 단계인 1차 시뮬레이션 시작 이후에 수행되는 1회 이상의 시뮬레이션은 게이트 수준에서 이벤트-구동 타이밍 시뮬레이션으로 수행하는 검증 방법
168. 제 21 항 내지는 제 22 항 내지는 제 23 항 내지는 제 24 항 내지는 제 25 항 내지는 제 26 항 내지는 제 27 항 내지는 제 29 항에 있어서,

     상기 DUV에서의 1 이상의 설계객체들의 상태 정보로 상기 1 이상의 해당 설계객체들의 최소 상태 정보를 포함하는 상태 정보를 사용하는 검증 방법
169. 제 21 항 내지는 제 22 항 내지는 제 23 항 내지는 제 24 항 내지는 제 25 항 내지는 제 26 항 내지는 제 27 항 내지는 제 29 항에 있어서,

     후단 시뮬레이션 단계인 1차 시뮬레이션 시작 이후에 수행되는 1 이상의 시뮬레이션에서 시뮬레이션 대상이 되는 DUV에서의 1 이상의 설계객체들의 상태 정보로 앞단 시뮬레이션 단계인 1차 시뮬레이션에서 저장된 변수나 시그널 값들 각각에 대하여서 이벤트 값이 아닌 안정값을 사용한 검증 방법
170. 제 21 항 내지는 제 22 항 내지는 제 23 항 내지는 제 24 항 내지는 제 25 항 내지는 제 26 항 내지는 제 27 항 내지는 제 29 항에 있어서,

     후단 시뮬레이션 단계인 1차 시뮬레이션 시작 이후에 수행되는 1 이상의 시뮬레이션에서 시뮬레이션 대상이 되는 DUV에서의 1 이상의 설계객체들의 상태 정보로 앞단 시뮬레이션 단계인 1차 시뮬레이션에서 저장된 변수나 시그널 값들 각각에 대하여서 이벤트 변화가 있는 경우에는 이 이벤트 직전의 안정값을 사용한 검증 방법
171. 추상화 수준으로 상위에서 표현된 설계객체와 이와 상위 추상화 수준에서 함수적으로 등가이나 추상화 수준으로 하위에서 표현된 설계객체를 대상으로, 상기 하위수준으로 표현된 설계객체의 시뮬레이션 결과를 이용하여서 상기 상위 수준으로 표현된 설계객체를 이용한 시뮬레이션을 신속하게 수행하는 검증 방법
172. 제 21 항 내지는 제 22 항 내지는 제 38 항 내지는 제 64 항 내지는 제 65 항에 있어서,

     상기 1 이상의 설계객체들에 대한 상태 정보로서 최소상태 정보를 포함하고 있는 상태 정보를 사용하는 검증 방법
173. 제 41 항 내지는 제 67 항에 있어서,

     병렬적 수행이 공간적 병렬 수행과 시간적 병렬 수행을 혼용하는 검증 방법
174. 제 51 항에 있어서,

     상기 1 이상의 설계객체들에 대한 상태 정보에 상기 1 이상의 설계객체들에 대한 최소상태 정보를 포함하는 설계 검증 및 설계 수정 방법
175. 제 37 항 내지는 제 44 항 내지는 제 59 항에 있어서,

     상기 상위수준에서의 시뮬레이션의 일부분이 타이밍 정보를 이용하지 않은 게이트수준 시뮬레이션이고, 상기 하위수준에서의 시뮬레이션의 일부분이 타이밍 정보를 이용한 게이트수준에서의 타이밍 시뮬레이션인 설계 검증 및 설계 수정 방법
176. 제 37 항 내지는 제 44 항 내지는 제 59 항에 있어서,

     상기 상위수준에서의 시뮬레이션이 RTL 수준과 타이밍 정보를 이용하지 않은 게이트수준 의 혼합 시뮬레이션이고, 상기 하위수준에서의 시뮬레이션이 부분적으로는 타이밍 정보를 이용한 게이트수준에서의 타이밍 시뮬레이션인 설계 검증 및 설계 수정 방법
177. 제 77 항 내지는 제 175 항 내지는 제 176 항에 있어서,

     상기 상위수준에서의 타이밍 정보를 이용하지 않은 시뮬레이션이 제로지연시간 모델을 이용한 시뮬레이션인 설계 검증 및 설계 수정 방법
178. 제 99 항 내지는 제 100 항에 있어서,

     검증 소프트웨어와 1 이상의 검증플랫폼을 이용하여, 상기 1 이상의 설계객체들로 구성되는 설계 코드나 설계 회로에 자동화된 방식을 통하여 부가코드나 부가회로를 추가하여 상기 1 이상의 검증 플랫폼들에 설계 코드나 설계 회로를 부가코드나 부가회로와 함께 구현하여 1회 이상의 검증 실행 도중에 1 이상의 검증 시점들 내지는 검증 구간들에서 1 이상의 설계객체들에서 자동화된 방식을 통하여 수집된 동적 정보가 해당 설계객체들의 상태 정보로서, 임의의 1 이상의 설계객체들이 변경된 후에 실행되는 검증 실행의 시작을 상기 수집된 상태 정보들이 수집된 1 이상의 검증 시점들 내지는 검증 구간들 중에 특정 검증 시점부터 내지는 특정 검증 구간에서부터 시작할 수 있도록 상기 수집된 동적 정보에 존재하는 1 이상의 특정 설계객체들의 상태 정보를 부분적 내지는 전체적으로 이용하는 설계 검증 방법
179. 제 99 항 내지는 제 100 항에 있어서,

     검증 소프트웨어와 1 이상의 검증플랫폼을 이용하여, 상기 1 이상의 설계객체들로 구성되는 설계 코드나 설계 회로에 자동화된 방식을 통하여 부가코드나 부가회로를 추가하여 상기 1 이상의 검증 플랫폼들에 설계 코드나 설계 회로를 부가코드나 부가회로와 함께 구현하여 1회 이상의 검증 실행 도중에 1 이상의 검증 시점들 내지는 검증 구간들에서 1 이상의 설계객체들에서 자동화된 방식을 통하여 수집된 동적 정보가 해당 설계객체들의 상태 정보로서, 임의의 1 이상의 설계객체들이 변경된 후에 실행되는 검증 실행의 시작을 상기 수집된 상태 정보들이 수집된 1 이상의 검증 시점들 내지는 검증 구간들 중에 특정 검증 시점부터 내지는 특정 검증 구간에서부터 시작할 수 있도록 상기 수집된 동적 정보에 존재하는 1 이상의 특정 설계객체들의 상태 정보가 상기 설계객체들이 변경된 후에 실행되는 검증 실행의 시작에서 상기 1 이상의 특정 설계객체들의 상태 정보로 사용되어지는 설계 검증 방법
180. 제 122 항 내지는 제 123 항 내지는 제 124 항 내지는 제 125 항 내지는 제 126 항 내지는 제 127 항 내지는 제 128 항 내지는 제 129 항에 있어서,

     후단 시뮬레이션 단계에서의 1 이상의 병렬적 내지는 순차적 시뮬레이션의 각 시뮬레이션 시작 시점을 위한 상태설정을 위한 2 이상의 변수나 시그널들에 대한 설정이 상기 앞단 시뮬레이션 단계에서 저장된 특정 시뮬레이션 구간 안에 존재하는 임의의 2 이상의 각기 다른 시점에서의 해당 변수나 시그널들의 상태와 같도 록 설정이 되는 설계 검증 방법
181. 제 20 항에 있어서,

     상기 후단 시뮬레이션 단계에서 시뮬레이션에 사용되는 2 이상의 슬라이스들이 중복 슬라이스 상황인 설계 검증 방법
182. 제 48 항 내지는 제 77 항 내지는 제 175 항 내지는 제 176 항에 있어서,

     상기 추상화 상위 수준에서 수행되는 시뮬레이션 과정에서 수집된 1 이상의 설계객체들에 대한 상태정보와 입력정보들로써 결정되는 2 이상의 슬라이스들이 중복 슬라이스 상황이며, 상기 추상화 하위 수준에서 시뮬레이션에 사용되는 2 이상의 슬라이스들이 중복 슬라이스 상황인 설계 검증 방법
183. 제 89 항 내지는 제 90 항 내지는 제 94 항에 있어서,

     상기 DUV의 상태 정보로 DUV의 최소 상태 정보를 사용하는 검증 방법
184. 제 80 항 내지는 제 81 항 내지는 제 82 항 내지는 제 83 항 내지는 제 84 항 내지는 제 85 항 내지는 제 86 항 내지는 제 87 항 내지는 제 88 항 내지는 제 89 항 내지는 제 90 항 내지는 제 91 항 내지는 제 93 항 내지는 제 94 항 내지는 제 95 항 내지는 제 96 항 내지는 제 97 항 내지는 제 98 항 내지는 제 183 항에 있어서,

     상기 1차 검증 실행에서 사용되는 설계객체들의 추상화 수준이, 상기 1차 검증 실행 시작 이후의 검증 실행에서 사용되는 설계객체들의 추상화 수준보다 높은 검증 방법
185. 제 80 항 내지는 제 81 항 내지는 제 82 항 내지는 제 83 항 내지는 제 84 항 내지는 제 85 항 내지는 제 86 항 내지는 제 87 항 내지는 제 88 항 내지는 제 89 항 내지는 제 90 항 내지는 제 91 항 내지는 제 93 항 내지는 제 94 항 내지는 제 95 항 내지는 제 96 항 내지는 제 97 항 내지는 제 98 항 내지는 제 183 항에 있어서,

     상기 1차 검증 실행 시작 이후의 검증 실행에서 사용되는 설계객체들의 추상화 수준이 게이트레벨이고 상기 1차 검증 실행 시작 이후의 검증 실행에서 지연시간을 고려한 타이밍 검증을 수행하는 검증 방법
186. 제 77 항 내지는 제 164 항의 있어서,

     상기 상위수준에서의 시뮬레이션 내지는 앞단 시뮬레이션 단계인 1차의 시뮬레이션을 하드웨어-기반 검증 플랫폼을 시뮬레이터와 같이 이용하여서 수행하는 검증 방법
187. 1 이상의 하드웨어-기반 검증 플랫폼과 1 이상의 소프트웨어-방식 검증 플랫폼을 혼합적으로 이용하여 1회 이상의 설계 검증 수행을 진행함으로서 설계 코드나 합성으로 생성된 게이트수준의 네트리스트에 존재하는 설계 오류의 위치를 알아내고 이를 수정하는 설계 검증 방법에 있어서, 상기 1회 이상의 설계 검증 수행에서 수행되는 설계 검증 수행들 중에서 최소한 한번 이상의 설계 검증 수행을 상기 1 이상의 하드웨어-기반 검증 플랫폼을 이용하는 1차 검증 실행과 1차 검증 실행 시작 이후의 상기 1 이상의 소프트웨어-방식 검증 플랫폼만을 이용하는 1회 이상의 검증 실행들의 두 단계로 나누어서 수행하며, 상기 1차 검증 실행을 수행하면서 1차 검증 실행 시작 이후의 상기 1 이상의 소프트웨어-방식 검증 플랫폼만을 이용하는 1회 이상의 검증 실행에서 1 이상의 특정 검증사이클 시간구간들에 대하여 검증 실행들이 이루어질 수 있도록 하는데 필요한 상기 설계 코드나 합성으로 생성된 게이트 수준의 네트리스트에 대응되는 1 이상의 설계객체들에 대한 상태 정보를 1차 검증 실행 과정에서 자동적으로 수집할 수 있도록 하고, 상기 1 이상의 하드웨어-기반 검증 플랫폼을 이용한 1차 검증 실행을 진행하면서 상기 1 이상의 설계객체들에 대한 상태 정보를 1이상의 검증 시점에서 수집하고, 이 수집된 상태 정보들 각각을 1 이상의 소프트웨어-방식 검증 플랫폼들만을 이용하는 1차 검증 실행 시작 이후의 1회 이상의 검증 실행들 각각의 초기 상태로서 설정/복원하여 1 이상의 특정 검증사이클 시간구간들에서 상기 설계 코드나 합성으로 생성된 게이트수준의 네트리스트에 대한 소프트웨어-방식 검증 실행을 할 수 있도록 함으로서 설계 검증을 신속하게 수행하는 것을 가능하게 검증 방법
188. 1 이상의 하드웨어-기반 검증 플랫폼과 1 이상의 소프트웨어-방식 검증 플랫 폼을 혼합적으로 이용하여 1회 이상의 설계 검증 수행을 진행함으로서 설계 코드나 합성으로 생성된 게이트수준의 네트리스트에 존재하는 설계 오류의 위치를 알아내고 이를 수정하는 설계 검증 방법에 있어서, 상기 1회 이상의 설계 검증 수행에서 수행되는 설계 검증 수행들 중에서 최소한 한번 이상의 설계 검증 수행을 상기 1 이상의 하드웨어-기반 검증 플랫폼을 이용하는 1차 검증 실행과 1차 검증 실행 시작 이후의 상기 1 이상의 소프트웨어-방식 검증 플랫폼만을 이용하는 1회 이상의 검증 실행들의 두 단계로 나누어서 수행하며, 상기 1차 검증 실행을 수행하면서 1차 검증 실행 시작 이후의 상기 1 이상의 소프트웨어-방식 검증 플랫폼만을 이용하는 1회 이상의 검증 실행에서 1 이상의 특정 검증 상태공간들에 대하여 검증 탐색들이 이루어질 수 있도록 하는데 필요한 상기 설계 코드나 합성으로 생성된 게이트수준의 네트리스트에 대응되는 1 이상의 설계객체들에 대한 상태 정보를 1차 검증 실행 과정에서 자동적으로 수집할 수 있도록 하고, 상기 1 이상의 하드웨어-기반 검증 플랫폼을 이용한 1차 검증 실행을 진행하면서 상기 1 이상의 설계객체들에 대한 상태 정보를 1이상의 검증 시점에서 수집하고, 이 수집된 상태 정보들 각각을 1 이상의 소프트웨어-방식 검증 플랫폼들만을 이용하는 1차 검증 실행 시작 이후의 1회 이상의 검증 실행들 각각의 초기 상태로서 설정/복원하여 1 이상의 특정 검증 상태공간들에서 상기 설계 코드나 합성으로 생성된 게이트수준의 네트리스트에 대한 소프트웨어-방식 검증 탐색을 할 수 있도록 함으로서 설계 검증을 신속하게 수행하는 것을 가능하게 검증 방법
189. 제 187 항 내지는 제 188 항에 있어서,

     상기 1 이상의 하드웨어-기반 검증 플랫폼을 이용한 1차 검증 실행을 진행하면서 상기 1 이상의 설계객체들에 대하여 1 이상의 검증 시점에서 수집된 상태 정보가 상기 1 이상의 설계객체들에 대한 최소 상태 정보를 포함하는 검증 방법
190. 제 187 항에 있어서,

     상기 1 이상의 하드웨어-기반 검증 플랫폼을 이용한 1차 검증 실행을 진행하면서 상기 1 이상의 설계객체들에 대하여 1 이상의 검증 시점에서 수집된 상태 정보가 상기 1 이상의 설계객체들에 대한 최소 상태 정보와 해당 설계 검증 수행의 검증 사이클 전체 내지는 특정 검증 사이클에서의 입력 정보인 검증 방법
191. 제 187 항에 있어서,

     상기 1 이상의 소프트웨어-방식 검증 플랫폼이 HDL 시뮬레이터이며, 이 1 이상의 HDL 시뮬레이터를 이용한 시뮬레이션이 순차적 시뮬레이션을 통한 1 이상의 설계객체들에 대한 타이밍정보를 이용한 타이밍 시뮬레이션인 검증 방법
192. 제 187 항에 있어서,

     상기 1 이상의 소프트웨어-방식 검증 플랫폼이 2 이상의 HDL 시뮬레이터이며, 이 2 이상의 HDL 시뮬레이터를 이용한 시뮬레이션이 시간적 병렬수행을 통한 1 이상의 설계객체들에 대한 타이밍정보를 이용한 타이밍 시뮬레이션인 검증 방법
193. 제 188 항에 있어서,

     상기 1 이상의 소프트웨어-방식 검증 플랫폼이 2 이상의 모델검사기/특성검사기이며, 이 2 이상의 모델검사기/형식검사기를 이용한 검증 상태 공간 탐색이 병렬적으로 이루어지는 검증 방법
194. 제 122 항 내지는 제 123 항 내지는 제 124 항 내지는 제 125 항 내지는 제 126 항 내지는 제 127 항 내지는 제 128 항 내지는 제 129 항에 있어서,

     후단 시뮬레이션 단계에서의 1 이상의 병렬적 내지는 순차적 시뮬레이션의 각 시뮬레이션 시작 시점을 위한 상태설정이 상기 앞단 시뮬레이션 단계에서 저장된 특정 시뮬레이션 시점에서의 상태와 같도록 설정이 되며, 계속되는 일정기간까지의 상태설정들도 계속적으로 상기 앞단 시뮬레이션 단계에서 저장된 특정 시뮬레이션 시점에서의 상태와 같도록 하는 설계 검증 방법
195. 제 143 항에 있어서,

     상기 1 이상의 설계객체로 구성된 HDL 설계코드의 S(Ti) 내지는 S(Pi)에서의 상태 정보로 자동화된 방식으로 설정하기 위하여 HDL의 ＄readmemb 내지는 ＄readmemh 시스템 테스크를 사용하는 것을 포함하는 설계 검증 방법
196. 제 20 항 내지는 제 31 항 내지는 제 47 항 내지는 제 48 항 내지는 제 77 항 내지는 제 164 항 내지는 제 165 항 내지는 제 166 항 내지는 제 167 항 내지는 제 168 항 내지는 재 181 항에 있어서,

     앞단 시뮬레이션과 후단 시뮬레이션이 다른 추상화 수준에서 진행되고, 상기 후단 시뮬레이션에서의 1 이상의 시뮬레이션 수행을 위하여 상기 앞단 시뮬레이션에서 얻어진 상태정보가 최소 상태정보이며, 상기 1 이상의 후단 시뮬레이션 수행을 위하여 상기 최소 상태정보를 복원/설정하는 방법에서 상기 최소 상태정보를 복원/설정하는 시점들이 인과관계보장가능 시점설정을 만족하는 설계 검증 방법
197. 제 143 항 내지는 제 144 항 내지는 제 145 항 내지는 제 146 항 내지는 제 147 항 내지는 제 148 항 내지는 제 149 항 내지는 제 150 항 내지는 제 171 항 내지는 제 175 항 내지는 제 176 항 내지는 제 182 항 내지는 제 184 항 내지는 제 185 항에 있어서,

     상기 추상화 수준이 낮은 시뮬레이션의 신속한 수행을 위하여 상기 추상화 수준이 높은 시뮬레이션에서 얻어진 최소 상태정보를 상기 추상화 수준이 낮은 시뮬레이션에서의 최소 상태를 복원/설정하는 과정에서 최소 상태정보 복원/설정 시점들이 인과관계보장가능 시점설정을 만족하는 설계 검증 방법
198. 검증 소프트웨어와 1 이상의 시뮬레이터를 이용하여서 1 이상의 설계객체로 구성된 HDL 설계코드를 대상으로 하는 전력소비량 분석 방법을 위한 시뮬레이션에 있어서, 상기 1 이상의 설계객체로 구성된 HDL 설계코드를 대상으로 시뮬레이션 시 간 0이 아닌 시뮬레이션 시점 S(Ti) 내지는 시뮬레이션 시간 0을 포함하지 않는 시뮬레이션 시간구간 S(Pi)에서부터 시뮬레이션을 시작할 수 있도록 하여서 시뮬레이션 시간 0에서부터 S(Ti)까지 내지는 시뮬레이션 시간 0에서부터 S(Pi)까지에서 상기 1 이상의 설계객체로 구성된 HDL 설계코드를 대상으로 하는 시뮬레이션 시간을 단축시킬 수 있도록, 상기 1 이상의 설계객체로 구성된 HDL 설계코드의 추상화 수준보다 추상화 수준이 높게 구술된 별도의 설계코드 내지는 별도의 모델을 대상으로 하는 시뮬레이션을 시뮬레이션 시간 0에서부터 S(Ti) 내지는 시뮬레이션 시간 0에서부터 S(Pi)까지 수행하여서 얻어지는 상기 1 이상의 설계객체로 구성된 HDL 설계코드의 추상화 수준보다 추상화 수준이 높게 구술된 별도의 설계코드 내지는 별도의 모델에 존재하는 상기 1 이상의 설계객체들에 대한 S(Ti) 내지는 S(Pi)에서의 상태 정보를 상기 검증 소프트웨어를 이용하여서 상기 1 이상의 설계객체로 구성된 HDL 설계코드의 S(Ti) 내지는 S(Pi)에서의 상태 정보로 자동화된 방식으로 설정함으로서 상기 1 이상의 설계객체로 구성된 HDL 설계코드를 이용한 시뮬레이션이 시뮬레이션 시간 0이 아닌 상기 시뮬레이션 시점 S(Ti) 내지는 시뮬레이션 시간구간 S(Pi) 에서부터 시작할 수 있도록 하는 전력소비량 분석 방법
199. 제 41 항 내지는 제 56 항 내지는 제 67 항 내지는 제 94 항 내지는 제 97 항에 있어서,

     상기 후단 시뮬레이션 내지는 상기 추상화 수준이 낮은 수준에서의 병렬적 시뮬레이션 수행을 통하여 얻어진 시뮬레이션 결과를 이용한 전력소비량 분석 방법
200. 제 1 항 내지는 제 2 항 내지는 제 4 항 내지는 제 8 항 내지는 제 10 항 내지는 제 11 항 내지는 제 12 항 내지는 제 14 항 내지는 제 15 항 내지는 제 16 항 내지는 제 17 항 내지는 제 19 항 내지는 제 20 항 내지는 제 21 항 내지는 제 22 항 내지는 제 23 항 내지는 제 24 항 내지는 제 25 항 내지는 제 26 항 내지는 제 27 항 내지는 제 29 항 내지는 제 31 항 내지는 제 32 항 내지는 제 33 항 내지는 제 34 항 내지는 제 35 항 내지는 제 36 항 내지는 제 54 항 내지는 제 55 항 내지는 제 56 항 내지는 제 130 항 내지는 제 131 항 내지는 제 132 항 내지는 제 133 항 내지는 제 134 항 내지는 제 135 항 내지는 제 136 항 내지는 제 137 항 내지는 제 138 항 내지는 제 139 항 내지는 제 140 항 내지는 제 141 항 내지는 161 항 내지는 제 162 항 내지는 제 163 항 내지는 제 164 항 내지는 제 165 항 내지는 제 166 항 내지는 제 167 항 내지는 제 169 항 내지는 제 170 항 내지는 제 180 항 내지는 제 181 항 내지는 제 194 항 내지는 제 196 항 내지는 제 198 항 내지는 제 199 항에 있어서,

     상기 후단 시뮬레이션 내지는 후단 검증에서 각 슬라이스들별로의 2 이상의 시뮬레이션 실행을 위하여 슬라이스독립적 시뮬레이션 컴파일/일레보레이션 기법을 사용한 검증 방법

Images