KR20140141535A - 디펜던시 문제의 효율적인 병렬 계산 - Google Patents

Abstract

컴퓨팅 방법은 실행 디펜던시를 갖고 있는 다수의 프로세싱 엘리먼트(PE)를 포함하는 컴퓨팅 태스크의 정의를 수용하는 단계를 포함한다. 상기 컴퓨팅 태스크는 상기 실행 디펜던시에 의존하여 작동에 PE를 할당하는 것을 포함하여, 멀티프로세서 디바이스의 일련의 2개 이상의 작동에 PE를 배치함으로써, 상기 멀티프로세서 디바이스 상의 동시 실행을 위해 컴파일링된다. 상기 마이크로프로세서 디바이스는 상기 컴퓨팅 태스크의 결과를 산출하기 위해, 상기 일련의 2개 이상의 작동을 실행하는 소프트웨어 코드를 시행하도록 작동된다.

Description

디펜던시 문제의 효율적인 병렬 계산{EFFICIENT PARALLEL COMPUTATION OF DEPENDENCY PROBLEMS}

본원은 2008년 7월 10일에 출원된 미국 가출원 61/079,461, 2008년 8월 7일에 출원된 미국 가출원 61/086,803, 2008년 11월 3일 출원된 미국 가출원 61/110,676, 2009년 6월 10일에 출원된 미국 가출원 61/185,589, 및 2009년 6월 10일에 출원된 미국 가출원 61/185,609에 대해 우선권을 주장하는, PCT 출원 PCT/IB2009/052820의 미국 국내단계 진입된, 2010년 11월 23일 출원된 미국 특허 출원 12/994,153의 일부 계속출원이다. 이러한 관련된 출원 모두는 여기에 언급되어 통합되어 있다.

본 발명은 일반적으로 병렬 계산에 관한 것이고, 특히 병렬 프로세서에서 디펜던시 문제를 실행하기 위한 방법 및 시스템에 관한 것이다.

병렬 처리 기술은 다양한 종류의 컴퓨팅 태스크를 실행하기 위해 사용된다. 로직 설계 시뮬레이션의 분야에서, 예를 들어, Cadambi 등은 여기에 언급되어 통합된, Very Long Instruction Word(VLIW) processor in "A Fast, Inexpensive and Scalable Hardware Acceleration Technique for Functional Simulation," Proceedings of the 39th IEEE ACM Design Automation Conference (DAC 2002), New Orleans, Louisiana, June 10-14, 2002, pages 570-575에 기초하여 시뮬레이션 액셀러레이터를 기술하고 있다. VLIW 프로세서를 사용하는 로직 시뮬레이션의 특징은 또한 그 내용이 여기에 언급되어 통합된 미국 특허 7,444,276 및 미국 특허 출원 공개 2007/0219771, 2007/0150702, 2007/0129926, 2007/0129924, 2007/0074000, 2007/0073999 및 2007/0073528에 기술되어 있다.

여기에 개시된 본 발명의 실시예는 실행 디펜던시를 갖고 있는 다수의 프로세싱 엘리먼트(PE)를 포함하는 컴퓨팅 태스크의 정의(definition)를 수용하는 단계를 포함하는 컴퓨팅 방법을 제공한다. 상기 컴퓨팅 태스크는 상기 실행 디펜던시에 의존하여 작동에 PE를 할당하는 것을 포함하여, 멀티프로세서 디바이스의 일련의 2개 이상의 작동에 PE를 배치함으로써, 상기 멀티프로세서 디바이스 상의 동시 실행을 위해 컴파일링된다. 상기 멀티프로세서 디바이스는 상기 컴퓨팅 태스크의 결과를 산출하기 위해, 상기 일련의 2개 이상의 작동을 실행하는 소프트웨어 코드를 시행하도록 작동된다.

일부 실시예에서, 상기 상기 멀티프로세서 디바이스는 상기 일련의 2개 이상의 작동 내의 후속 작동을 시작하기 전에 이전의 작동을 완료하여, 상기 이전의 작동에서의 PE의 출력이 상기 후속 작동 내의 PE로의 입력으로서 사용가능하다. 일부 실시예에서, 상기 PE를 상기 작동에 할당하는 단계는 제1 PE를 제1 작동에 할당하고, 상기 실행 디펜던시에 따라 상기 제1 PE 이후에 실행될 제2 PE를 상기 일련의 2개 이상의 작동 내의 제1 작동보다 나중인 제2 작동에 할당하는 단계를 포함한다.

실시예에서, 상기 PE를 상기 작동에 할당하는 단계는 상기 멀티프로세서 디바이스의 작동에 더하여 중앙 처리 장치(CPU)의 하나 이상의 작동을 상기 일련의 2개 이상의 작동 내에 인터리빙하는 단계, 및 상기 PE의 하나 이상을 상기 CPU의 작동에 할당하는 단계를 포함한다. 실시예에서, 상기 PE를 상기 작동에 할당하는 단계는 상기 멀티프로세서에 의한 실행이 상기 CPU에 의한 실행을 능가할 것으로 예측되는 컴퓨팅 태스크의 제1 부분을 식별하는 단계, 상기 CPU에 의한 실행이 상기 멀티프로세서 디바이스에 의한 실행을 능가할 것으로 예측되는 컴퓨팅 태스크의 제2 부분을 식별하는 단계, 상기 제1 부분을 상기 멀티프로세서 디바이스의 작동에 할당하는 단계, 및 상기 제2 부분을 상기 CPU에 할당하는 단계를 포함한다.

다른 실시예에서, 상기 PE를 상기 작동에 할당하는 단계는 제1 병렬 레벨을 갖는, 상기 컴퓨팅 태스크의 제1 부분 내의 PE를 상기 멀티프로세서 디바이스의 작동에 할당하는 단계, 및 상기 제1 병렬 레벨 보다 낮은 제2 병렬 레벨을 갖는, 상기 컴퓨팅 태스크의 제2 부분 내의 PE를 상기 CPU의 작동에 할당하는 단계를 포함한다.

또 다른 실시예에서, 상기 컴퓨팅 태스크를 컴파일링하는 단계는 런타임에 평가되는 조건에 의존하여 조건적으로 실행될 PE의 시퀀스를 정의하는 단계를 포함하고, 상기 PE를 상기 작동에 할당하는 단계는 상기 시퀀스가 실행되지 않을 가능성을 최대화하는 것을 목표로 하는 기준을 평가하는 단계를 포함한다. 상기 기준을 평가하는 단계는 상기 컴퓨팅 태스크를 로지컬 콘(logical cone)으로 나누는 단계, 및 상기 로지컬 콘의 각 베이스에서 작동 경계를 설정하는 단계를 포함하고, 각 로지컬 콘은 각 작동에서 마지막인 정점 PE 및 상기 정점 PE가 의존하는 PE의 그룹을 포함하고, 상기 로지컬 콘의 최대 깊이 및 최대 베이스 크기는 상기 가능성에 기초하여 명시된다.

또한, 본 발명의 실시예에 따라, 인터페이스 및 프로세서를 포함하는 컴퓨팅 장치가 제공된다. 상기 인터페이스는 실행 디펜던시를 갖고 있는 다수의 프로세싱 엘리먼트(PE)를 포함하는 컴퓨팅 태스크의 정의를 수용하도록 구성되어 있다. 상기 프로세서는 상기 실행 디펜던시에 의존하여 작동에 PE를 할당하는 것을 포함하여, 멀티프로세서 디바이스의 일련의 2개 이상의 작동에 PE를 배치함으로써, 상기 멀티프로세서 디바이스 상의 동시 실행을 위해 상기 컴퓨팅 태스크를 컴파일링하도록 구성되고, 상기 컴퓨팅 태스크의 결과를 산출하기 위해, 상기 일련의 2개 이상의 작동을 실행하는 소프트웨어 코드를 시행하도록 상기 멀티프로세서 디바이스를 작동하도록 구성되어 있다.

또한, 본 발명의 실시예에 따라, 실행 디펜던시를 갖고 있는 다수의 프로세싱 엘리먼트(PE)를 포함하는 컴퓨팅 태스크의 정의를 수용하는 단계를 포함하는 컴퓨팅 방법이 제공된다. 상기 컴퓨팅 태스크는 런타임에 조건을 평가하고, 상기 조건에 의존하여, 주어진 실행 시퀀스의 실행을 가능하게 하거나 금지시키는 보조 로직을 상기 주어진 실행 시퀀스에 대해 컴파일링하는 단계를 포함하고, 상기 PE를 다수의 실행 시퀀스에 배치함으로써 멀티프로세서 디바이스 상의 동시 실행을 위해 컴파일링된다. 상기 멀티프로세서 디바이스는 상기 컴퓨팅 태스크의 결과를 산출하기 위해, 상기 실행 시퀀스를 실행하는 소프트웨어 코드를 시행하도록 작동된다.

일부 실시예에서, 상기 보조 로직을 컴파일링하는 단계는 상기 조건을 평가하고 상기 실행을 가능하게 하거나 금지시키는 보조 PE를 주어진 실행 시퀀스의 시작에 정의하는 단계를 포함한다. 실시예에서, 상기 조건은 상기 주어진 실행 시퀀스로의 입력이 상기 주어진 실행 시퀀스의 이전의 실행 이후에 변하지 않았다는 것을 식별할 때에 상기 주어진 실행 시퀀스의 실행을 금지시킨다. 다른 실시예에서, 상기 조건은 상기 주어진 실행 시퀀스에서 시뮬레이팅된 컴포넌트의 트리거 신호가 어써팅(assert)되지 않았다는 것을 식별할 때에 상기 주어진 실행 시퀀스의 실행을 금지시킨다. 또 다른 실시예에서, 상기 조건은 상기 주어진 실행 시퀀스의 실행이 상기 주어진 실행 시퀀스의 출력에 영향을 주지 않을 것이라는 것을 식별할 때에 상기 주어진 실행 시퀀스의 실행을 금지시킨다.

또한, 본 발명의 실시예에 따라, 인터페이스 및 프로셋를 포함하는 컴퓨팅 장치가 제공된다. 상기 인터페이스는 실행 디펜던시를 갖고 있는 다수의 프로세싱 엘리먼트(PE)를 포함하는 컴퓨팅 태스크의 정의를 수용하도록 구성된다. 상기 프로세서는 런타임에 조건을 평가하고, 상기 조건에 의존하여, 주어진 실행 시퀀스의 실행을 가능하게 하거나 금지시키는 보조 로직을 상기 주어진 실행 시퀀스에 대해 컴파일링하는 단계를 포함하고, 상기 PE를 다수의 실행 시퀀스에 배치함으로써 멀티프로세서 디바이스 상의 동시 실행을 위해 상기 컴퓨팅 태스크를 컴파일링하도록 구성되고, 상기 컴퓨팅 태스크의 결과를 산출하기 위해, 상기 실행 시퀀스를 실행하는 소프트웨어 코드를 시행하도록 상기 멀티프로세서 디바이스를 작동하도록 구성된다.

또한, 본 발명의 실시예에 따라, 트리거링 신호에 의해 트리거된 복수의 로직 섹션을 포함하는 컴퓨팅 태스크의 정의를 수용하는 단계를 포함하는 컴퓨팅 방법이 제공된다. 상기 컴퓨팅 태스크의 정의는 상기 복수의 로직 섹션을 실행하는 결합 로직으로서, 트리거링 신호가 어써팅된 로직 섹션에 상응하는 컴퓨팅 태스크의 일부의 실행을 선택적으로 가능하게 하는 보조 로직을 포함하는 결합 로직을 생성하도록, 마이크로프로세서 디바이스에서의 동시 실행을 위해 컴파일링된다. 상기 멀티프로세서 디바이스는 상기 컴퓨팅 태스크의 결과를 산출하기 위해, 상기 결합 로직을 실행하는 소프트웨어 코드를 시행하도록 작동된다.

일부 실시예에서, 상기 정의를 컴파일링하는 단계는 트리거링 신호가 어써팅된 로직 섹션에 상응하는 실행 시퀀스 내의 프로세싱 엘리먼트(PE) 만의 실행을 가능하게 하도록 상기 보조 로직을 구성하는 단계를 포함하여, 상기 다수의 로직 섹션을 실행하는 단일 실행 시퀀스를 생성하는 단계를 포함한다. 실시예에서, 상기 트리거링 신호는 클록 신호, 셋 신호 및 리셋 신호로 구성된 타입의 그룹으로부터 선택된 적어도 하나의 신호 타입을 포함한다.

다른 실시예에서, 상기 정의를 컴파일링하는 단계는 상기 각 로직 섹션을 실행하는 다수의 실행 시퀀스를 생성하는 단계, 및 상기 각 트리거링 신호에 의존하여 상기 실행 시퀀스의 실행을 선택적으로 가능하게 하는 보조 프로세싱 엘리먼트(PE)를 각 실행 시퀀스에 삽입하는 단계를 포함한다.

또한, 본 발명의 실시예에 따라, 인터페이스 및 중앙 처리 장치(CPU)를 포함하는 컴퓨팅 장치가 제공된다. 상기 인터페이스는 트리거링 신호에 의해 트리거된 복수의 로직 섹션을 포함하는 컴퓨팅 태스크의 정의를 수용하도록 구성된다. 상기 CPU는 상기 복수의 로직 섹션을 실행하는 결합 로직으로서, 트리거링 신호가 어써팅된 로직 섹션에 상응하는 컴퓨팅 태스크의 일부의 실행을 선택적으로 가능하게 하는 보조 로직을 포함하는 결합 로직을 생성하도록, 마이크로프로세서 디바이스에서의 동시 실행을 위해 상기 컴퓨팅 태스크의 정의를 컴파일링하도록 구성되고, 상기 컴퓨팅 태스크의 결과를 산출하기 위해, 상기 결합 로직을 실행하는 소프트웨어 코드를 시행하도록 상기 멀티프로세서 디바이스를 작동하도록 구성된다.

본 발명은 다음의 도면과 함께 다음의 실시예의 상세한 설명으로부터 보다 상세히 이해될 것이다.

도 1은 본 발명의 실시예에 따른, 디펜던시 문제를 실행하기 위한 시스템을 개략적으로 설명하는 블록도이다.
도 2는 본 발명의 실시예에 따른, 그래픽스 처리 유닛(GPU)을 개략적으로 설명하는 블록도이다.
도 3은 본 발명의 실시예에 따른, 디펜던시 그래프에 의해 표시된 디펜던시 문제를 개략적으로 설명하는 도면,
도 4는 본 발명의 실시예에 따른, 스태틱 인보케이션 데이터베이스(SID)를 개략적으로 설명하는 도면,
도 5는 본 발명의 실시예에 따른, 디펜던시 문제를 실행하기 위한 방법을 개적으로 설명하는 도면,
도 6은 본 발명의 실시예에 따른, SID 생성에 사용된 워프의 그리드를 개략적으로 설명하는 도면,
도 7은 본 발명의 실시예에 따른, 워프의 그리드에 프로세싱 엘리먼트(PE)를 할당하기 위한 할당 인터벌을 개략적으로 설명하는 도면,
도 8은 본 발명의 실시예에 따른, SID를 생성하기 위한 방법을 개략적으로 설명하는 순서도이다.
도 9는 본 발명의 실시예에 따른, 캐쉬 관리 체계를 개략적으로 설명하는 도면,
도 10a 및 도 10b는 본 발명의 실시예에 따른, 변수 프리페칭 체계를 개략적으로 설명하는 도면,
도 11은 본 발명의 실시예에 따른, 변수 프리오더링 체계를 개략적으로 설명하는 도면,
도 12은 본 발명의 실시예에 따른, 다수의 SID를 개략적으로 설명하는 도면,
도 13은 본 발명의 실시예에 따른, 인터 SID 통신을 위한 방법을 개략적으로 설명하는 순서도이다.
도 14a, 및 도 14b는 본 발명의 실시예에 따른, 인트라-SID를 개략적으로 설명하는 도면,
도 15는 본 발명의 실시예에 따른, 인터-SID 및 인트라-SID 통신을 사용하는 SID를 개략적으로 설명하는 도면,
도 16은 본 발명의 실시예에 따른, 인터-SID 통신을 감소시키기 위한 방법을 개략적으로 설명하는 상태도이다.
도 17은 본 발명의 실시예에 따른, 인터-SID 통신을 감소시키기 위한 방법을 개략적으로 설명하는 순서도이다.
도 18은 본 발명의 실시예에 따른, 디지털 필터를 나타내는 디펜던시 그래프를 개략적으로 설명하는 도면, 및
도 19는 본 발명의 실시예에 따른, 고속 푸리에 변환(FFT) 계산 엘리먼트를 나타내는 디펜던시 그래프를 개략적으로 설명하는 도면이다.
도 20은 본 발명의 실시예에 따른, 멀티플 클록-셋-리셋 로직의 병렬화된 실행을 위한 체계를 개략적으로 설명하는 도면이다.
도 21은 본 발명의 실시예에 따른, 디펜던시 문제의 실행 그래프를 개략적으로 설명하는 도면이다.
도 22는 본 발명의 실시예에 다른, 중앙 처리 장치(CPU)와 GPU 사이의 실행 그래프를 분할하기 위한 방법을 개략적으로 설명하는 순서도이다.
도 23은 본 발명의 실시예에 따른, 다수의 GPU 작동을 개략적으로 설명하는 도면이다.
도 24는 본 발명의 실시예에 따른, 실행 시퀀스를 페이즈(phase)로 분할하기 위한 프로세스를 개략적으로 설명하는 도면이다.
도 25는 본 발명의 실시예에 따른, 실행 시퀀스를 페이즈로 분할하기 위한 방법을 개략적으로 설명하는 순서도이다.
도 26은 본 발명의 실시예에 따른, 감도 정보를 사용하여 불필요한 실행을 피하기 위한 방법을 개략적으로 설명하는 순서도이다.
도 27은 본 발명의 실시예에 따른, 트리거된 엘리먼트를 갖는 실행 시퀀스를 개략적으로 설명하는 도면이다.
도 28은 본 발명의 실시예에 따른, 멀티플렉싱된 출력을 갖는 실행 시퀀스를 개략적으로 설명하는 도면이다.

개요

다양한 범위의 다양한 타입의 컴퓨팅 태스크는 디펜던시 문제, 즉, 실행 디펜던시를 갖는 아토믹(atomic) 프로세싱 엘리먼트의 세트로서 표시될 수 있다. 디펜던시 문제는 자주 크고, 복잡하고, 이들의 실행은 자주 높은 계산 복잡도 및 실행 시간을 수반하고 있다. 따라서, 병렬로 동작하는 다수의 프로세서에서의 디펜던시 문제를 실행하는 것은 유익하다. 그러나, 이러한 프로세싱 엘리먼트 간의 실행 디펜던시는 자주 디펜던시 문제를 병렬 컴퓨팅 태스크로 분할하는 것을 어렵게 한다.

본 발명의 실시예는 병렬 프로세서에 의해 디펜던시 문제를 실행하기 위한 향상된 방법 및 시스템을 제공한다. 여기에 기술된 실시예는 주로 하드웨어 설계의 시뮬레이션을 나타내고 있지만, 개시된 기술은 다양한 다른 분야 및 적용에 적용될 수 있다. 이러한 개시된 방법 및 시스템은, 실행 디펜던시를 갖는 아토믹 프로세싱 엘리먼트(PE)를 포함하는, 디펜던시 문제에 작용한다. 컴파일러는 그래픽스 프로세싱 유닛(GPU)와 같은, 다수의 프로세서를 포함하는 멀티프로세서 디바이스에서의 동시 실행을 위해 디펜던시 문제를 컴파일링한다.

일부 실시예에서, 컴파일레이션 프로세스는 페이즈로도 불리는, 일련의 GPU 작동으로 PE를 배열한다. 일련의 작동으로 분할하는 것은 동기화 메커니즘으로서 사용되는데, 정의에 의해, GPU는 이러한 일련의 작동에서 그 다음 작동을 실행하기 시작하기 전에, 주어진 작동의 실행을 종료한다. 그래서, 주어진 작동에서의 PE의 출력은 후속 작동에서의 PE에 대한 입력으로서 사용가능하도록 보장된다. 따라서, 일부 실시예에서, 컴파일러는 작동에 PE를 적절하게 할당함으로써 PE 사이의 실행 디펜던시를 보존한다. 이러한 방식으로 동기화를 유지하는 것은 다른 가능한 동기화 메커니즘과 비교하여 단지 작은 처리 오버헤드를 유발한다.

일부 실시예에서, 컴파일러는 GPU 보다는 중앙 처리 장치(CPU)에 의해 실행되기 위한 디펜던시 문제의 일부를 할당한다. 이러한 실시예에서, 컴파일레이션 프로세스는 일련의 작동을 생성하는데, 일부는 CPU에 대한 것이고 일부는 GPU에 대한 것이다. 보통, 컴파일러는 CPU가 GPU를 능가하는 것으로 예측되는 디펜던시 문제의 부분(예를 들어, 낮은 병렬 부분), 및 GPU가 CPU를 능가할 것으로 예측되는 디펜던시 문제의 부분(예를 들어, 높은 병렬 부분)을 식별한다. 전자 부분은 CPU에 의한 실행을 위해 할당되고, 후자 부분은 GPU에 할당된다. 보통, CPU 작동은 전체 실행 그래프의 시작과 끝에서 발생하는 경향이 있지만 반드시 그런 것은 아니다.

실행을 페이즈로 나누는 또 다른 동기는 PE 실행 시퀀스의 불필요한 실행을 피하기 위한 것이다. 일부 실시예에서, 컴파일러는 런타임에 검출되는 다양한 조건하에, PE 시퀀스의 불필요한 실행을 금지시키는 로직을 PE 실행 시퀀스에 삽입할 수 있다. 실행을 페이즈로 나눔으로써, 이러한 조건을 충족하고 불필요한 실행을 피할 가능성이 증가된다. 이러한 목표를 달성하는 분할 예가 설명되어 있다.

이러한 실시예에서, 컴파일러는 런타임에 검출될 때, 주어진 PE 시퀀스의 실행이 불필요하다는 것을 나타내는 다양한 조건을 정의할 수 있다. 실시예에서, 컴파일러는 이러한 조건을 검출하고 이에 따라 시퀀스 실행을 가능하게 하거나 금지시키는 보조 PE를 주어진 PE 시퀀스에 삽입한다. 이러한 조건은 예를 들어, 주어진 PE 시퀀스로의 입력이 시퀀스의 이전의 실행 이후에 변하지 않았다는 것, 시퀀스를 따른 시뮬레이팅된 컴포넌트로의 트리거가 어써팅되지 않았다는 것, 또는 시퀀스의 실행이 시퀀스 출력에 영향을 주지 않을 것이라는 것을 검출할 수 있다. 많은 실제 시나리오에서, 이러한 조건하에 PE 시퀀스의 실행을 금지시킴으로써 런타임을 상당히 감소시킬 수 있다.

여기에 기술된 다른 실시예는 병렬을 거의 또는 전혀 갖고 있지 않은 설계에도 GPU의 병렬 처리 기능을 활용하도록 도움을 준다. 예를 들어, 일부 하드웨어 설계는 다수의 트리거링 신호(예를 들어, 클록, 셋 및/또는 리셋 신호)에 의해 트리거되는 광대한 수의 낮은 병렬 로직 섹션을 포함하고 있다. 일부 실시예에서, 컴파일러는 높은 병렬을 갖는 다수의 로직 섹션을 시뮬레이팅하는 결합 로직을 생성한다. 정확한 기능을 보존하기 위해, 결합 로직은 트리거링 신호가 어써팅된 로직 섹션에 상응하는 결합 로직의 일부만을 선택적으로 활성화하는 보조 로직을 포함한다.

시스템 설명

도 1은 본 발명의 실시예에 따른, 디펜던시 문제를 실행하기 위한 시스템(20)을 개략적으로 설명하는 블록도이다. 다양한 종류의 컴퓨팅 태스크는 디펜던시 문제로서, 즉, 실행 디펜던시를 갖는 아토믹 프로세싱 태스크의 세트로서 표현될 수 있다. 디펜던시 문제는 예를 들어, 디지털 하드웨어 설계 시뮬레이션, 실시간 비디오 프로세싱, 이미지 프로세싱, 소프트웨어-디파인드 라디어(SDR), 다양한 통신 애플리케이션 및 에러 보정 코딩에서의 패킷 프로세싱과 같은 광범위한 분야 및 적용예에서 발견될 수 있다. 시스템(20)은 디펜던시 문제로서 표시될 수 있는 임의의 적합한 컴퓨팅 태스크의 효율적인 실행을 위해 사용될 수 있다. 특정 컴퓨팅 태스크의 다수의 예, 및 이러한 태스크로의, 개시된 기술의 적용이 아래에 더 설명되어 있다.

본 예에서, 시스템(20)은 인터페이스(26), 중앙 처리 장치(28) 및 하나 이상의 그래픽스 처리 유닛(GPU; 32)을 포함하는 서버(24)를 포함한다. 서버(24)는 임의의 적합한 워크스테이션 또는 컴퓨팅 플랫폼을 포함할 수 있다. 아래에 설명되는 바와 같이, 각각의 GPU는 병렬로 작동시키는 매우 큰 수의 프로세싱 코어를 포함한다. 여기에 설명되는 방법 및 시스템에 의해 GPU 코어의 병렬 사용이 최대화되어서, 시스템(20)이 비교적 짧은 실행 시간으로 매우 복잡한 디펜던시 문제를 실행할 수 있다.

서버(24)는 사용자 스테이션(36)을 통해 사용자와 상호작용한다. 서버(24)는 인터페이스(26)를 통해 사용자로부터 실행될 디펜던시 문제를 받는다. 서버는 이러한 입력된 디펜던시 문제를 컴파일링하여 소프트웨어 코드를 생성한 후 이러한 코드를 CPU(28) 및 GPU(32)에서 실행한다. 시스템(20)의 기능은 애플리케이션에 따라, 다양한 방법으로 CPU(28)와 GPU(32) 사이에 분할될 수 있다. 여기에 설명된 실시예는 단일 GPU를 가리키고 있다. 그러나, 일반적으로, 임의의 요구되는 수의 GPU가 사용될 수 있다.

보통, CPU(28)는 여기에 설명되는 기능을 수행하기 위해 소프트웨어로 프로그래밍된, 범용 프로세서를 포함한다. 이러한 소프트웨어는 예를 들어, 네트워크를 통해 전자 형태로 프로세서에 다운로딩될 수 있거나, 대안으로 또는 추가적으로, 자기, 광학, 또는 전자 메모리와 같은 접촉가능한 매체에 제공되고 및/또는 저장될 수 있다.

시스템(20)의 구성은 단지 개념을 분명히 하기 위해 선택된 예시 구성이다. 임의의 다른 적합한 시스템 구성이 또한 사용될 수 있다. 예를 들어, 사용자 스테이션(36)은 국부적으로 또는 통신망을 통해 서버(24)와 통신할 수 있다. 대안의 예에서, 사용자 스테이션 기능은 서버(24)에 직접 구현될 수 있다.

로직 설계 시뮬레이션을 위한 시스템(20)과 같은 시스템을 사용하는 일부 구성이, 여기에 언급되어 통합되고 본 발명의 양수인에게 양도된 2009년 3월 25일에 출원된 "병렬 프로세서를 사용하는 설계 시뮬레이션" 표제의 PCT 출원 PCT/IL2009/000330에 기술되어 있다.

도 2는 본 발명의 실시예에 따른, GPU)32)의 내부 구조를 개략적으로 설명하는 블록도이다. 본 발명의 예에서, GPU(32)는 다수의 멀티프로세서(40)를 포함한다. 각각의 멀티프로세서(40)는 역시 프로세싱 코어로서 여기에 언급된 다수의 프로세서(44)를 포함한다. 일부 실시예에서, 각각의 멀티프로세서(40)는 당업계에 알려진 바와 같이, 단일 구조 멀티플 스레드(SIMT) 프로세서를 포함한다. 대안의 실시예에서, 각각의 멀티프로세서(40)는 모든 프로세서(44)가 각각의 클록 사이클에서 동일한 명령을 실행하는 단일 명령 멀티플 데이터(SIMD)를 포함한다. (그러나, 상이한 프로세서가 상이한 데이터에 동일한 명령을 실행할 수 있다.) 보통의 애플리케이션에서, 전체 GPU내의 모든 프로세서(44)는 동일한 명령을 실행한다. 상이한 프로세서의 기능간의 차별화는 이러한 데이터에 의해 유도된다. 개시된 기술은 SIMD 및 SIMT 프로세서 모두에 적용가능하다.

각각의 프로세서(44)는 다수의 로컬 레지스터(48)에 접속할 수 있다. 주어진 멀티프로세서(40)내의 상이한 프로세서는 공유 메모리(52)에 데이터를 저장할 수 있다. 이러한 공유 메모리는 주어진 멀티프로세서의 프로세서(44)에 접속가능하지만 다른 멀티프로세서의 프로세서에는 접속가능하지 않다. 전형적인 GPU에서, 각 멀티프로세서는 또한 멀티프로세서의 동작을 관리하는 명령 유닛(60)을 포함한다. 전형적인 멀티프로세서에서, 명령 유닛(60)은 동시 스레드를 생성하고, 관리하고, 실행한다. 특히, 명령 유닛(60)은 멀티프로세서에 실행되는 상이한 스레드의 동작을 동기화하는 하드웨어 메커니즘을 포함할 수 있다.

GPU(32)는 외부 메모리로서 여기에 언급되는 디바이스 메모리(56)를 더 포함한다. 메모리(56)는 동적 랜덤 액세스 메모리(DRAM)를 보통 포함한다. 공유 메모리(52)와 달리, 디바이스 메모리(56)는 보통 모든 멀티프로세서(40)의 프로세서에 접속가능하다. 한편, 디바이스 메모리(56)로의 접속은 보통 대기시간 및 처리량에 있어서 비용이 많이 든다. 디바이스 메모리(56)에 효율적으로 접속하기 위해, 보통 연속적으로 정렬된 메모리 어드레스로부터 판독 및 기록하는 것이 보통 바람직하다. 여기에 기술된 방법의 일부는 디바이스 메모리(56)에 효율적으로 접속하는 코드를 생성하는 것과 관련되어 있다.

각각의 프로세서(44)가 임의의 주어진 시간에 실행하는 기본 소프트웨어 코드 유닛은 스레드로서 불린다. 보통, CPU(28)는 GPU에 스레드의 블록을 제공함으로써 GPU(32)를 작동한다. 주어진 스레드의 블록은 SIMD 또는 SIMT 모드에서 단일 멀티 프로세서(40)의 프로세서에서 실행되는 것이 보장된다. 따라서, 주어진 블록내의 스레드는 공유 메모리(52)를 통해 서로 통신할 수 있다.

보통, 블록당 스레드의 수는 멀티프로세서내의 프로세서의 수보다 클 수 있다. GPU에 제공된 블록수의 수는 일반적으로 멀티프로세서의 수보다 클 수 있다. GPU는 CPU(28)로부터 실행을 위한 블록을 수용하고 특정 내부 기준에 따라 스레드 및 블록의 실행을 스케줄링하는 블록 매니저(60)를 포함한다. 이러한 기준은 여기에서 빌티인 스케줄링 폴리시라고 불린다.

따라서, 주언진 블록의 스레드가 동일한 멀티프로세서에서 실행되는 것을 보장하는 것 이외에, 주어진 블록의 스레드가 멀티프로세서에서 실행되는 순서에 대한 아무런 보장이 없다. 또한, 상이한 블록이 GPU에서 실행되는 순서에 대한 아무런 보장이 없다. 즉, CPU(28)는 보통 GPU의 내부 스케줄링 폴리시에 대해 아무런 제어도 하지 못한다.

여기에 기술된 방법 및 시스템의 일부는 주어진 블록내의 스레드 가운데 데이터를 동기화하고 공유하는 능력과 같은, GPU의 구조적 특징을 사용하는, 코드를 생성한다. 디펜던시 문제를 스레드로 분할할 때, 개시된 방법 및 시스템은 GPU 내의 스레드 및 블록 실행의 보증된 특성이 주어지지 않은 경우(즉, GPU의 스케줄링 폴리시에 관계없이), 상이한 아토믹 프로세싱 태스크 사이의 고유의 디펜던시를 보존한다.

특히, GPU는 보통 특정 수의 블록을 동시에 실행하도록 되어 있다. GPU가 보다 큰 수의 블록으로 작동되면, 블록은 블록 매니저(60)에 의해 스케줄링된다. 여기에 설명된 방법 및 시스템의 일부는 동시에 실행될 수 있는 블록의 최대수를 초과하지 않는 블록의 수를 가진 GPU를 작동한다. 결과적으로, 블록 매니저(60)의 내부 스케줄링 폴리시는 효과적으로 바이패스된다. 이러한 특징은 아래에 보다 상세하게 설명된다.

도 2의 GPU 구성은 단지 개념을 분명히 하기 위해 선택된, 예시 구성이다. 대안의 실시예에서, 임의의 다른 적합한 GPU 구성이 또한 사용될 수 있다. 이러한 목적을 위해 사용될 수 있는 전형적인 GPU 디바이스는 NVIDIA Corp.(캘리포니아, 산타클라라)에 의해 생산된 GTX285이다. 이러한 디바이스는 각각 8개의 프로세싱 코어를 포함하는 30개의 멀티프로세서를 포함한다. 또한, 대안으로, 여기에 기술된 실시예가 GPU의 사용을 언급하고 있지만, 개시된 방법 및 시스템은 디지털 시그널 프로세서(DSP) 및 멀티코어 중앙 처리 장치(CPU)와 같이 다수의 처리 코어를 병렬로 작동시키는 다양한 다른 타입의 프로세서와 함께 사용될 수 있다.

디펜던시 그래프를 사용하는 디펜던시 문제 표현

CPU(28)는 여기에 프로세싱 엘리먼트(PE)로서 언급된 아토믹 실행 태스크에 대해 입력 디펜던시 문제를 표시한다. 이러한 디펜던시 문제가 GPU(32)에 의해 실행될 때, 각 PE는 특정 프로세서(44)에 의해 실행되는 스레드에 상응한다. CPU는 보통 각 타입이 특정 아토믹 태스크(예를 들어, 룩업 테이블 룩업, 플립플롭, 버퍼링 동작, 메모리 접속 동작, 멀티플렉싱 동작, 대수학 동작, 논리 동작 또는 임의의 적합한 태스크 타입)를 실행하는 PE 타입의 라이브러리를 홀딩한다. 각 PE는 이러한 타입중 하나에 속하고 특정 데이터에 동작한다.

프로세서(44)가 SIMT 모드에서 동작할 때, 각 스레드는 보통 상이한 PE 타입을 실시할 수 있는 코드를 포함한다. 이러한 스레드가 실행될 때, 이러한 스레드에 의해 실행되는 실제 PE 타입은 데이터에 의해 선택된다. 이러한 스레드에 의해 판독된 데이터는 예를 들어, 요구되는 PE 기능을 실행하는 프로그램 어드레스로 점핑함으로써, 또는 임의의 다른 적합한 선택 수단을 사용함으로써 실제 PE 타입을 선택할 수 있다. 따라서, 전형적인 스레드는 다음의 플로를 실행할 수 있다.

-요구되는 PE 타입을 메모리(56)로부터 판독하고, 이러한 PE 타입을 구현하는 적합한 어드레스로 점핑한다.

- PE 파라미터 및 입력값을 메모리(56)로부터 판독한다.

- 요구되는 PE 기능을 실행한다.

- PE 출력값을 메모리(56)에 기록한다.

(메모리(56)에 효율적으로 접속하기 위해, CPU(28)는 PE를 PE 그룹-PEG으로 분할할 수 있다. 이러한 특징은 아래에 그리고 상술된 PCT 출원 PCT/IL2009/000330에 보다 상세하게 언급되어 있다.) 보통, 스레드 부하 및 저장 동작은 스레이드의 PE 파라미터와 연결되지 않는다. 예를 들어, 주어진 PEG는 디바이스 메모리로부터 공유 메모리로 64개에 달하는 로드 커맨드를 지원할 수 있다. 주어진 스레드는 그 PE에 의해 사용되지 않는 데이터를 로딩할 수 있다.

SIMT 프로세서에서 상술된 기술을 사용할 때, 주어진 멀티프로세서 SIMT 유닛에서 동시에 실행되도록 스케줄링된 스레드는 동일한 PE 타입을 실시하여 이러한 유닛이 SIMD 모드에서 효율적으로 실시하는 것이 보통 바람직하다.

도 3은 본 발명의 실시예에 따른, 디펜던시 그래프에 의해 표시된 디펜던시 문제를 개략적으로 설명하는 도면이다. CPU(28)는 실행 디펜던시에 의해 상호접속된, 다수의 PE를 사용하여 디펜던시 문제를 표시한다. 주어진 디펜던시는 ("드라이빙" PE로 언급된) 특정 PE의 출력이 ("구동된" PE로 언급된) 또다른 PE로의 입력으로서 사용될 것을 명시한다. 즉, 구동된 PE는 구동하는 PE에 의존한다. 이러한 디펜던시는 구동하는 PE가 구동된 PE 전에 실행되는 것을 의미하는데, 그 이유는 그렇지 않은 경우에, 구동된 PE의 입력이 유효하지 않을 것이기 때문이다.

도 3은 디펜던시 그래프(72)로 변환되는, 디펜던시 문제(68)의 예를 도시하고 있다. 그래프(72)는 실행 디펜던시를 표시하는 방향지정된 에지(80) 및 PE를 표시하는 다수의 버티클(76)을 포함한다. 주어진 에지는 구동하는 PE로부터 구동된 PE로 지향된다. 일부 실시예에서, CPU(28)는 디펜던시 그래프(72)로부터 다수의 서브그래프(78)를 생성한다. 보통 순환적일 수 있는 디펜던시 그래프(72)와 달리, 각 서브그래프(78)는 비순환적이다.

아래에 설명되는 방법은 GPU(32)에서 실행되는 코드로 주어진 비순환 서브그래프를 변환한다. 디펜던시 문제가 다수의 서브그래프를 사용하여 표시된다면, 개시된 방법은 보통 각 서브그래프로 별개로 적용된다. 일부 실시예에서, 상이한 서브그래프 가운데 변수간의 공통성은 계산 효율을 증가시키기 위해 사용될 수 있다. 이러한 특징은 아래에서 더 언급되어 있다.

스태틱 인보케이션 데이터베이스(SID)를 사용한 디펜던시 표시 및 실행

일부 실시예에서, CPU(28)는 여기에 스태틱 인보케이션 데이터베이스(SID)로 불리는 작동 데이터 구조를 생성하도록 입력 디펜던시 문제를 컴파일링한다. SID는 실행을 위해 GPU(32)에 제공된다. CPU(28)는 보통 SID를 생성하는 컴파일러 프로그램을 실행한다. 이어지는 설명에서, CPU(28)에 의해 실행되는 액션은 이해를 위해 컴파일러에 의해 실행되는 것으로 언급되어 있다. 그러나, 대안의 실시예에서, 컴파일러는 임의의 적합한 프로세서에서 실행할 수 있어서 SID를 생성한다. 그다음, 최종 SID는 실행을 위해 시스템(20)에 제공될 수 있다.

SID는 GPU의 내부 스케줄링 폴리시에 관계없이, 서로 병렬로 그리고 특정 순서로 실시되도록 보장되는 PE 실행 시퀀스의 세트를 포함한다. GPU가 SID와 함께 작동될 때, 각 실행 시퀀스는 스레드의 블록으로서 GPU에 제공된다. 따라서, 각 시퀀스내의 PE는 GPU(32)의 동일한 멀티프로세서(40)에서 실행하도록 보장된다. 또한, SID내의 실행 시퀀스의 수는 GPU에 의해 동시에 실행될 수 있는 블록의 최대수를 초과하지 않는다. 그 결과, 실행 시퀀스는 GPU에서 동시에 실행되도록 보장되고, 보통 블록 매니터(60)의 내부 스케줄링 폴리시에 의해 영향을 받지 않는다. 즉, GPU의 내부 스케줄링 폴리시는 효과적으로 바이패스되고, PE의 실행 순서는 온전히 SID에 의해 제어된다.

도 4는 본 발명의 실시예에 따라, SID(90)를 개략적으로 설명하는 도면이다. SID(90)는 본 예의 4개의 시퀀스(98A...98D)에서, 실행 시퀀스의 세트를 포함한다. 그러나, 일반적으로 GPU에 의해 동시 실행될 수 있는 블록의 최대수를 초과하지 않지만 하나 보다 큰 임의의 적합한 수의 시퀀스가 사용될 수 있다. 각 실행 시퀀스는 순차적으로 실행되는 PEG(94)의 시리즈를 포함한다. (PE의 PEG로의 그룹핑은 아래에 더 설명된다.)

GPU가 동시에 실행될 수 있는 블록의 수는 보통 각 멀티프로세서에 의해 동시 실행될 수 있는 블록수의 수에 의해 승산된 멀티프로세서(40)의 수에 의해 주어진다. 멀티프로세서 당 동시 블록의 실제 수는 때로 멀티프로세서 리소스(예를 들어, 레지스터, 공유 메모리 또는 스레드 카운트)에 의해 제한될 수 있어서, 멀티프로세서 당 동시 블록의 특정 수보다 작을 수 있다.

일부 경우에, 멀티프로세서 당 동시 블록의 실제 수는 min((multiprocessor_register_count/program_reg_count),(multiprocessor_shared_memory_size/progrm_shared_memory),(number of threads per multiprocessor/number of threads per block), specified number of concurrent blocks per multiprocessor)로서 기록될 수 있다. 예를 들어, GTX285 GPU는 30개의 멀티프로세서(40)를 갖고 있다. 각 멀티프로세서는 16,384개의 레지스터 및 16Kbyte 공유 메모리를 포함하고, 1,024개에 이르는 동시 스레드 및 8개에 이르는 동시 블록을 지원한다. 하나의 실시예에서, 컴플라이어에 의해 생성된 GPU 코드는 2KB의 공유 메모리 및 스레드당 15개의 레지스터를 사용하고, 각각의 블록은 64개의 스레드를 포함한다. 이러한 코드는 모두 블록당 15×64=240개의 레지스터를 갖는다. 이러한 예에서, 멀티프로세서 당 동시 블록의 수는 min(16KB/2KB,16384/240,1024/64,8)=min(8,68,16,8)=8이다. 전체 GPU에 의해 동시 실행될 수 있는 동시 블록의 최대수는 따라서 8×30=240이다.

상이한 실행 시퀀스는 일반적으로 상이한 길이, 즉, 상이한 실행 시간을 가질 수 있다. 보통, CPU(28)는 실행 시간이 최소인 SID로 디펜던시 문제를 컴파일링 시도한다. 즉, CPU는 시퀀스의 최대 허용 수를 초과하지 않고 최단 실행 시퀀스를 갖고 있는 SID를 생성 시도한다. 이러한 종류의 SID 생성 프로세스의 예는 아래에 보다 상세하게 기술되어 있다.

각각의 실행 시퀀스가 동일한 멀티프로세서(40)에서 실행되는 것이 보장되는 스레드의 블록을 포함하기 때문에, 주어진 시퀀스내의 PEG는 정확한 순서로 실행되는 것이 보장된다. 따라서, 구동 PE를 동일한 실행 시퀀스내의 각각의 구동된 PE 전에 배치함으로써 PE 간의 실행 디펜던시가 파괴되지 않도록 보장된다. 또한, 동일한 실행 시퀀스에 속하는 PEG는 이러한 시퀀스를 실행하는 멀티프로세서의 공유 메모리(52)를 사용하여 데이터를 교환할 수 있다.

그러나, 많은 디펜던시 문제에서, 동일한 실행 시퀀스내의 의존 PE의 모든 쌍을 배치하는 제한은 너무 심하다. 이러한 제한은 자주 적은 수의 극히 긴 실행 시퀀스를 생성하고, 따라서, 실행 시간을 증가시키고 달성가능한 병렬화를 제한한다. 많은 경우에, 여전히 실행 디펜던시가 보존되는 동안 상이한 실행 시퀀스에 의존 PE를 배치하는 것이 바람직하다.

일부 경우에, 컴파일러는 상이한 시퀀스내에 배치된 PE 간의 디펜던시를 보존하기 위해 SID내의 상이한 실행 시퀀스 사이를 강제 동기화시킨다. 도 4에서, 예를 들어, 시퀀스(98B)내의 PEG(102)는 디펜던시(110)로 지시된 바와 같이, 시퀀스(98A)내의 PEG(106)에 종송된다. (보다 정확하게, PEG(102)는 PEG(106)내의 PE에 종속되는 PE를 포함한다.) PEG(102)가 실행 개시하기 전에 PEG(106)가 온전히 실행되는 것을 보장하기 위해, 컴파일러는 예를 들어, PEG(102)전에 시퀀스(98B)내에 동기화 엘리먼트, 예를 들어, SYNC PEG(114)를 배치한다. SYNC(114)는 PEG(106)가 실행을 완료하고 유효 출력을 생성할 때까지 시퀀스(98B)의 실행을 중지시킨다. 그다음, PEG(016)의 출력은 PEG(102)에 입력으로서 제공되고, 시퀀스(98B)는 실행을 재개할 수 있다. 마찬가지로, 시퀀스(98C)내의 PEG(118)는 디펜던시(126)에 의해 지시된 바와 같이, 시퀀스(8D)내의 PEG(122)에 종송된다. 이러한 디펜던시를 보존하기 위해, 컴파일러는 PEG(118)전에 시퀀스(98C)내의 SYNC PEG(130)를 배치한다.

시퀀스간의 동기화는 보통 디바이스 메모리(56)를 사용하여 구현된다. 예를 들어, 구동 PEG는 디바이스 메모리(56)내의 특정 영역에 기록함으로써 실행 상태를 시그널링할 수 있다. SYNC PEG는 구동 PEG가 온전한 실행을 가질 때만 이러한 영역을 폴링하고 그 시퀀스의 실행을 재개할 수 있다.

그러나, 상이한 시퀀스내의 모든 쌍의 의존 PE가 반드시 SYNC PEG의 추가를 필요로 하지 않는다는 것에 주목해야 한다. 예를 들어, 시퀀스(98C)내의 마지막 PEG가 시퀀스(98D)내의 제1 PEG에 의존한다고 가정하자. 이러한 경우에, 기존의 SYNC PEG(130)가 시퀀스((98D)내의 제1 PEG가 실행을 완료하지 않으면 시퀀스(98C)내의 마지막 PEG가 실행되지 않을 것을 이미 보장하기 때문에, 반드시 시퀀스(98C)에 또 다른 SYNC PEG를 추가할 필요는 없다.

일반적으로, 특정 SYNC PEG는 사전 한정된 세트의 구동 PEG가 실행을 완료할 때까지 임의의 요구된 수의 시퀀스내의 임의의 바람직한 수의 PEG에 종속될 수 있다. 즉 주어진 시퀀스의 실행을 중지시킬 수 있다. 일부 실시예에서, 동기화 기능은 전용 SYNC PEG를 사용하지 않고, 구동된 PEG내에 포함될 수 있다.

시퀀스간의 강제 동기화를 통해 상이한 시퀀스의 실행 시간의 평형을 매우 효율적으로 할 수 있어서, 병렬화를 증가시킬 수 있다. 즉, 동기화 메커니즘은 잠재성을 유도하고 디바이스 메모리(56)로의 고비용 접속을 수반한다. 아래에 설명되는 바와 같이, 컴파일러는 보통 SID의 최저 전체 실행 시간을 달성하기 위해 이러한 장단점을 거래 시도한다.

도 5는 본 발명의 실시예에 따른, 디펜던시 문제를 실행하기 위한 방법을 개략적으로 설명하는 순서도이다. 이러한 방법은 그래프 입력 단계(134)에서, 디펜던시 그래프로 표현되는, 입력 디펜던시 문제를 수신하는 CPU(28)와 함께 시작한다. 이러한 CPU는 분할 단계(138)에서, 디펜던시 그래프를 지향된, 비순환 서브그래프로 분할한다. 디펜던시 그래프를 지향된, 비순환 서브그래프로 분할하는 방법은 예를 들어, 상술된 PCT 출원 PCT/IL2009/000330에 기술되어 있다. 각각의 서브그래프에 대해, CPU는 그룹핑 단계(142)에서 PE를 PEG로 그룹화하고, 이러한 SID 구성 단계(146)에서, SID에 상술된 SID를 배열한다. 이러한 CPU는 작동 단계(150)에서, SID를 실행하기 위해 GPU(32)를 작동한다. 이러한 GPU는 컴퓨팅 태스크의 결과를 산출하기 위해, SID내의 PEG 시퀀스를 실행한다.

효율적인 SID 생성

상술된 바와 같이, CPU(28)에서 실행하는 컴파일러는 보통 주처진 최대수의 실행 시퀀스에 대해 최단 실행 시간을 갖는 SID를 생성 시도한다. 이러한 프로세스로의 입력은 SID로 전환될, PE의 지향된, 비순환 디펜던시 서브 그래프이다. 일부 실시예에서, 컴파일러는 PE 사이의 실행 디펜던시를 보존하는 방식으로, 2차원 그리드의 워프를 PE로 점진적으로 채움으로써 SID를 생성한다.

워프는 주어진 멀티프로세서에서 동시에 그리고 효율적으로 실행하는 동일한 타입의 스레드의 그룹이다. 워프내의 최대수의 스레드 (그리고 따라서 PE)는 하나의 GPU 타입으로부터 다른 GPU 타입으로 변할 수 있다. 예를 들어, NVIDIA GTX285 디바이스에서, 각각의 워프는 32개의 스레드를 실행시킨다. 아래에 도시되는 바와 같이, 다수의 워프가 나중에 PEG를 형성하기 위해 결합될 수 있다.

도 6은 본 발명의 실시예에 따른, SID 생성을 위해 사용된 워프 그리드(160)를 개략적으로 도시하는 도면이다. 워프 그리드(16)는 각각 다수의 워프 슬롯(168)을 포함하는, 다수의 실행 시퀀스(164)를 포함한다. 이러한 워프 슬롯은 처음에 비어 있고, 컴파일러는 이들을 PE로 점진적으로 채운다. 상이한 실행 시퀀스 사이를 강제 동기화시키기 위해, 컴파일러는 때로 SYNC 워프(172)를 이러한 시퀀스 안에 삽입한다. (SYNC 워프는 이들이 실행을 위한 스레드를 포함하지 않는다는 점에서 정상 워프와 상이하다는 것에 주목해야 한다. SYNC 워프는 이러한 시퀀스내에 삽입될 SYNC 동작의 잠재성을 모방한다.) 이러한 프로세스의 끝에서, 입력된 서브 그래프내의 각각의 PE는 상술된 워프 슬롯중 하나에 배치된다(각각의 워프 슬롯은 동이한 타압의 다수의 PE를 포함할 수 있다.) 그다음, 이러한 컴파일러는 2개 이상의 인접한 워프를 주어진 시퀀스 안에서 결합하여 PEG를 형성하는 경우에, 상술된 워프로부터 PEG(176)를 형성한다. PEG의 그리드는 요구되는 SID로서 출력된다.

보통, 그리드(160)내의 실행 시퀀스(164)의 수는 GPU가 동시에 실행할 수 있는 스레드 블록의 최대수를 초과하지 않도록 설정되어서, 최종 SID의 실행은 내부 GPU 스케줄링에 의해 이루어지지 않을 것이다. 시퀀스당 워프 슬롯의 수는 보통 입력된 서브그래프내의 최장 경로의 길이로서 초기화된다.

PE간의 디펜던시 때문에, 각각의 PE는 그리드(160)의 컬럼의 특정 부분 서브세트에만 배치될 수 있다. 이러한 서브세트는 PE의 할당 인터벌로서 부른다. 예를 들어, 또 다른 PE에 종속된 PE는 워프 그리드의 제1 컬럼(즉, 임의의 실행 시퀀스의 초기)에 배치될 수 없는데, 그 이유는 이러한 구동이 먼저 실행되어야만 하기 때문이다. 마찬가지로, 또 다른 PE를 구동하는 PE는 그리드의 마지막 컬럼에 배치될 수 없다.

일반적으로, 서브 그래프내의 각 PE는 PE가 잠재적으로 배치될 수 있는 그리드(160)의 컬럼을 한정하는, 특정 할당 인터벌을 갖고 있다. PE x의 할당 인터벌은 백워드 페이즈(BP(x)로 부른다) 및 포워드 페이즈(PE(x)로 부른다)로 불리는 2개의 파라미터에 종속된다. 주어진 PE의 백워드 페이즈는 이러한 PE에 이르는 서브그래프내의 최장 경로를 따른 PE의 수로서 정의된다. 주어진 PE의 포워드 페이즈는 이러한 PE에서 시작하는 서브그래프내의 최장 경로를 따른 PE의 수로서 정의된다.

이러한 용어를 사용하여, 서브그래프내의 최장 경로의 길이(워프 그리드(160)내의 컬럼의 수)는 L=max(BP(x)+FP(x))+1로 주어지고, 이러한 최대수는 서브그래프내의 모든 PE에 대해 취해진다. PE x의 할당 인터벌은 [BP(x),L-FP(x)]로 주어진다. 이러한 할당 인터벌은 할당 프로세스의 시작의 상황을 반영한다. 이러한 할당 인터벌은 보통 할당 프로세스가 진행됨에 따라 변한다.

도 7은 본 발명의 실시예에 따라, 워프의 그리드에 PE를 배치하기 위한 할당 인터벌을 개략적으로 설명하는 도면이다. 도 7은 A...H로 표시된 8개의 PE(76)를 포함하는, 서브그래프(180)의 예를 설명하고 있다. PE는 2개의 시퀀스(164)를 갖고 있는 워프 그리드에 배치될 것이다. 이러한 그래프를 통과하는 최장 경로가 3개의 PE의 길이를 갖기 때문에, 이러한 예의 각 시퀀스(164)는 3개의 워프 슬롯(168)을 포함한다.

8개의 PE의 포워드 및 백워드 페이즈는 다음의 표에 주어져 있다.

할당 프로세스의 시작에서, 즉, 워프 그리드가 여전히 비어있는 상태에서, 8개의 PE는 도면에 도시된 바와 같이 할당 인터벌(184)을 갖는다. 이러한 예에서, PE A 및 PE B는 이들 각각이 2개의 PE의 경로를 구동하기 때문에, 그리드의 제1 컬럼에만 배치될 수 있다. PE C는 마지막 컬럼을 제외하고 어디에나 배치될 수 있는데, 그 이유는 이것이 하나의 PE 경로를 구동하기 때문이다. PE D 및 PE E는 제2 컬럼에만 배치될 수 있는데, 그 이유는 이들의 각각이 특정 PE에 의해 구동되고 특정 PE를 구동하기 때문이다. PE F는 제1 컬럼을 제외하고 어디에나 배치될 수 있는데, 그 이유는 하나의 PE 경로에 의해 구동되기 때문이다. 마지막으로, PE G 및 PE H는 마지막 컬럼에만 배치될 수 있는데, 그 이유는 이들의 각각이 2개의 PE 경로에 의해 구동되기 때문이다.

도 7의 예는 일부 PE가 이들을 그리드(160)에 배치하는 확률에 대해 다른 것 보다 보다 큰 제한을 받는다는 것을 설명하고 있다. 짧은 할당 인터벌을 갖는 PE는 보다 큰 제한을 받고, 보다 긴 할당 인터벌을 갖는 PE는 할당에 있어 보다 많은 정도의 자유도를 갖고 있다.

도 8은 본 발명의 실시예에 따른, SID를 생성하기 위한 방법을 개략적으로 설명하는 순서도이다. 이러한 방법은 입력 단계(190)에서, SID로 전환하기 위한 디펜던시 서브 그래프를 수용하는 CPU(28)에서 실행하는 컴파일러와 함께 시작한다. 일부 실시예에서, 이러한 컴파일러는 또한, 서브그래프가 유도되었고, 보통 추가의 PE 및 디펜던시를 포함하는 온전한 디펜던시 그래프를 수용한다. 다른 SID에 관계없이 단일 SID를 생성할 때, 온전한 그래프를 수용하는 것은 보통 필요하지 않다. 이러한 컴파일러는 그러나, 샘플 그래프의 다른 서브그래프의 다른 SID를 고려할 때, 온전한 그래프를 사용할 수 있다. 이러한 특징은 아래에 보다 더 상세하게 기술되어 있다. 또한, 이러한 컴파일러는 실행 시퀀스의 수 N, 워프 슬롯 유닛내의 SYNC의 레이턴시 D, 워프 사이즈(즉, 워프 당 PE의 수) 및 PE 타입을 입력으로서 수용할 수 있다.

이러한 컴파일러는 인터벌 초기화 단계(194)에서, 서브그래프내의 각 PE에 대한 할당 인터벌을 초기화한다. 상술된 바와 같이, PE x의 초기 할당 인터벌은 [BP(x),L-FP(x)]로 주어진다.

컴파일러는 한정 단계(198)에서 PE 입출력 그룹을 한정한다. 입력 그룹은 공통 입력을 갖는 PE의 그룹(즉, 동일한 구동 PE에 의해 구동되는 PE)를 포함한다. 이러한 공통 구동 PE는 상술된 그룹의 피봇으로 불린다. 출력 그룹은 공통 출력을 갖는 PE의 그룹(즉, 동일한 구동된 PE를 구동하는 PE)을 포함한다. 이러한 공통 구동된 PE는 상술된 그룹의 피봇으로서 불린다.

예를 들어, 컴파일러는 전체 디펜던시 그래프내의 모든 PE에 대한 출력 그룹을 생성할 수 있어서, PE는 이러한 그룹의 피봇이다. 이러한 출력 그룹내의 PE는 PE x를 구동하는, 서브 그래프내의 PE를 포함한다. 마찬가지로, 컴파일러는 전체 디펜던시 그래프내의 모든 PE x에 대한 입력 그룹을 생성할 수 있어서, PE x는 상술된 그룹의 피봇이다. 이러한 입력 그룹내의 PE는 PE x에 의해 구동된, 서브그래브내의 PE를 포함한다. 이러한 예에서, 컴파일러는 전체 그래프내의 각 PE에 대한 입출력 그룹을 생성한다는 것에 주목해야 한다. 하지만, 이러한 그룹내의 PE는 서브그래프에서만 선택되고 전체 그래프에서 선택되지 않는다.

입출력을 구성하기 이유는 일반적으로 (상이한 워프에서 가능하지만) 동일한 실행 시퀀스에 공통 입력 및/또는 출력을 갖고 있는 PE를 배치하는 것이 바람직하기 때문이다. 전체 그래프를 고려하는 이유는 때로 다른 SID에 PE의 공통 입력 또는 출력으로서 기능하는 동일한 시퀀스 PE내에 배치하는 것이 바람직하기 때문이다. 컴파일러는 PE를 포함하는 입출력 그룹의 수로서 정의되는 그룹 스코어를 서브그래프내의 각 PE에 할당한다.

이러한 컴파일러는 그리드 초기화 단계(202)에서 L 개의 워프 슬롯을 각각 갖는 N개의 실행 시퀀스를 갖고 있는 워프의 그리드를 초기화한다.

일부 실시예에서, 컴파일러는 소팅 단계(206)에서 서브그래프의 PE를 사전 소팅한다. 컴파일러는 PE의 할당 인터벌의 크기가 증가하는 순서로 PE를 소팅한다. 동일한 할당 인터벌 사이즈를 갖는 PE는 이들의 그룹 스코어가 감소하는 순서로 소팅된다. 결과적으로, 컴파일러는 소팅된 순서에 따라 그리드에 배치하기 위한 PE를 선택한다. 따라서, 최단 할당 인터벌을 갖는 PE는 먼저 그리드에 배치된다. 주어진 할당 인터벌 사이즈에 대해, 큰 그룹 스코어를 갖는 PE(큰 수의 입력 및/또는 출력 그룹의 멤버인 PE)가 먼저 배치된다. 대안의 실시예에서, 컴파일러는 최단 할당 인터벌을 갖는 M 개의 PE를 선택함으로써 그리드내에 배치하기 위한 그다음 PE를 선택할 수 있다(M은 사전정의된 정수를 가리킨다). 이러한 PE로부터, 컴파일러는 최대 그룹 스코어를 갖는 PE를 선택한다. 상술된 할당 순서는 가장 크게 제한되는 PE를 먼저 할당하여서, 연속 할당 반복을 위해 많은 정도의 자유도를 남긴다.

컴파일러는 현 PE 선택 단계(210)에서, 소팅된 PE 가운데로부터 그리드내에 배치하기 위한 그다음 PE를 선택한다. 그다음, 컴파일러는 할당 비용 계산 단계(214)에서, 이러한 PE를 그리드내에 배치하는 각각의 확률에 대해 각각의 할당 비용을 계산한다. 보통, 컴파일러는 N 개의 실행 시퀀스에서, PE의 할당 인버발내의 워프 슬롯을 심사한다. (일부의 경우에, 특정 워프는 그것이 PE의 할당 인터벌내에 있다하더라도 주어진 PE를 배치하기 위한 후보가 아니다. 예를 들어, 워프는 이미 온전히 팝풀레이팅될 수 있거나, 심사된 PE의 것과 상이한 타입을 가진 PE를 포함할 수 있다.)

일부 실시예에서, 컴파일러는 주어진 PE의 할당 인버발에서 경미하게 외측에 있는 워프 슬롯을 심사할 수 있다. 예를 들어, 일부 경우에, (SID 실행 시간에서 보다 악화된 페널티를 유발할 수 있는) SYNC를 추가하는 것과 반대로, PE를 그 할당 인터벌을 넘어 외측에 고의로 배치하는 것이 바람직할 수 있다(그래서 SID 실행 시간을 경미하게 증가시킨다). 따라서, 일부 실시예에서, 컴파일러는 SYNC에 의해 유도된 레이턴시의 오더의 워프 슬롯의 수 플러스 할당 인터벌을 심사한다.

컴파일러는 각 잠재 워프 슬롯에 대한 할당 비용을 계산한다. 이러한 할당 비용은 특정 워프 슬롯에 상술된 PE를 배치하는 잠재적 페널티를 나타내는 양적 측정값이다.

컴파일러는 할당 비용을 계산하는데 있어 임의의 적합한 기준 또는 체험을 적용할 수 있다. 하나의 구현예에서, 다음의 룰이 사용될 수 있다.

- 심사된 워프 슬롯에 PE를 배치함으로써 유발되는, 전체 SID 실행 시간에서의 각각의 워프-슬롯 지연에 대해 비용을 1000배 증가시킨다. 이러한 룰은 전체 실행 시간을 증가시키기 위해 상당한 페널티를 부과한다.

- 이미 심사된 워프 슬롯과 동일한 시퀀스내에 배치되고 또한 심사된 PE를 포함한 입력 또는 출력 그룹의 멤버인, 각각의 PE에 대해 비용을 1/10 감소시킨다. 이러한 룰은 동일한 시퀀스에 입력 또는 출력 그룹의 멤버를 배치하는 것에 우선순위를 부여한다.

- 심사된 PE와 연관되어 있고 심사된 워프 슬롯과 동일한 시퀀스내에 잔존하는 다른 PE를 가진, 각각의 실행 디펜던시(직간접, 포워드 또는 백워드)에 대해 비용을 1/10 감소시킨다. 이러한 룰은 동일한 시퀀스에 실행 디펜던시의 양 단부를 배치하는 것 (그리고 시퀀스간에 SYNC의 삽입을 잠재적으로 회피하는 것)에 우선순위를 부여한다.

- 심사된 PE의 최적 컬럼으로부터의 컬럼 거리 만큼 비용을 증가시킨다. PE x의 최적 컬럼은 BP(x)ㆍL/ORIG_L로서 정의되는데, 여기에서 L은 그리드내의 팝풀레이팅된 컬럼의 현재 수를 나타내고, L_ORIG는 서브그래프내의 최장 경로를 나타낸다. 최적 컬럼은 PE의 할당 인터벌의 외측에 있음을 주목해야 한다.

일부 실시예에서, 컴파일러는 PE가 특정 워프 슬롯에 배치되었다는 가정하에, PE를 트랜스버싱하는 상이한 크리티컬 서브 그래프 경로를 심사함으로써 그리고 이들의 지속시간을 계산함으로써 할당 비용을 계산할 수 있다. 이러한 종류의 계산은 추가되는 추가 SYNC 및 이들의 연관된 비용을 고려한다. 보다 추가적으로 또는 대안으로, 컴파일러는 임의의 적합한 기준 또는 체험을 사용하여, 심사된 PE의 할당 인터벌내의 상이한 워프 슬롯에 할당 비용을 할당할 수 있다.

컴파일러는 이제 배치 단계(218)에서 최하 할당 비용을 갖는 워프 슬롯에 PE를 배치한다. 새로운 배치로 인해 필요하다면, 컴파일러는 SYNC 삽입 단계(222)에서 SYNC를 삽입한다. SYNC는 정수의 워프 슬롯, 예를 들어, 2개의 슬롯의 사전정의된 지속시간을 갖는다. 각 SYNC는 자체 시퀀스의 실행을 재개하기 전에 종료되어야 하는 실행을 가진 하나 이상의 워프의 리스트를 포함한다. 주어진 SYNC에 의해 폴링된 워프는 임의의 수의 시퀀스에 위치할 수 있다. 이러한 리스트는 보통 동일한 시퀀스로부터 다수의 워프를 포함할 수 없다.

컴파일러는 인터벌 갱신 단계(226)에서, 나머지 비할당된 PE의 할당 인터벌을 갱신하여 새로운 배치에 이은 배치 확률을 반영한다.

일부 실시예에서, 컴파일러는 그룹 스코어 갱신 단계(230)에서 새로운 배치에 이은 나머지 PE의 그룹 스코어를 갱신한다. 예를 들어, 컴파일러는 새롭게 배치된 PE와 동일한 입력 또는 출력 그룹을 공유하는 PE의 그룹 스코어를 증가시킬 수 있다. 이러한 룰은 이미 부분적으로 할당된 멤버를 갖는 입력 또는 출력 그룹에 우선순위를 부여한다. 또 다른 예로서, 컴파일러는 새롭게 배치된 PE와 실행 디펜던시(직접 또는 간접, 포워드 또는 백워드)를 공유하는 PE의 그룹 스코어를 증가시킬 수 있다.

컴파일러는 체킹 단계(234)에서, 서브그래프내의 모든 PE가 워프 그리드내에 배치되었는지를 체크한다. 할당을 위한 나머지 PE가 존재하다면, 본 방법은 컴파일러가 채리될 그 다음 PE를 선택하는 상기 단계(210)으로 루프백한다. 모든 PE가 할당되었다면 컴파일러는 PEG 생성 단계(238)에서 연속 워프를 PEG로 그룹화한다. 보통, 각각의 PEG는 가능하면 SYNC 플러스, 동일한 시퀀스의 특정수의 연속 워프, 예를 들어, 최대 2개의 워프만을 포함할 수 있다. 추가로, PEG는 서로 독립적인 PE만을 포함할 수 있는데, 그 이유는 PEG내의 PE 실행의 순서에 대해 아무런 보장이 없기 때문이다. 위 도 6에서, 예를 들어, 일부 PEG(176)는 단일 워프만을 포함하고, 일부 PEG는 2개의 워프를 포함하고, PEG중 하나는 하나의 워프 및 하나의 SYNC를 포함한다.

이러한 단계에서, 컴파일러는 출력 단계(242)에서, 최종 팝풀레이팅된 워프 그리드(N개의 PEG 실행 시퀀스의 세트)를 요구되는 SID로서 출력한다.

보통, 상술된 SID 생성 공정은 워프 슬롯 듀레이션이 로드, 동기화, 실행 및 저장 명령와 같은 상이한 PEG 동작의 듀레이션을 고려한다는 것을 가정한다. 그러나, 일부 경우에, 로드 및 저장 명령 듀레이션은 무시될 수 있다. 상기 기재는 모든 워프가 동일한 듀레이션이고 SYNC의 듀레이션이 워프 슬롯의 정수배인 것을 가정한다. 이러한 기재는 또한, PEG의 듀레이션이 그 워프 및 SYNC의 듀레이션의 합이라하는 것을 가정한다. 그러나, 이러한 가정 모두는 의무적인 것은 아니고, 대안의 SID 생성 체계가 다른 가정을 만들 수 있다.

일부 경우에, 컴파일러는 최대 실행 시퀀스 길이, 즉, 토탈 SID 실행 시간을증가시켜야만 한다. L의 증가는 예를 들어, 컴파일러가 PE 할당 인터벌로 워프중 하나에 특정 PE를 배치할 수 없을 때 필요할 수 있다. L은 또한 일부 SYNC 삽입이 L의 증가를 유발하지 않지만 SYNC의 삽입에 이어 증가될 수 있다. L에서의 증가는 보통 이전에 배치된 워프 및 특정 칼럼을 넘는 SYNC가 우측에 푸시되는 것을 의미한다. 이러한 푸시는 다른 워프 및/또는 SYNC의 연속 푸시 라이트 동작의 체인을 트리거링할 수 할 수 있다. (상기 214 단계에서) 특정 워프 포지션의 할당 비용을 계산할 때, 이러한 비용은 오직, 전체 SID 실행 시간 L을 증가시키는 푸시 라이트 동작에 응답하여 보통 증가된다. L을 변경시키지 않는 푸시 라이트 동작은 할당 비용을 유발하지 않는다.

많은 상황에서, 컴파일러는 주어진 PE를 배치하기 위한 다수의 옵션을 인카운터한다. 일부 경우에, 이러한 배치는 미래의 PE 배치에 상당한 페널티를 유발할 수 있기 때문에, (상기 218 단계에서) 최하 비용 포지션에 주어진 PE를 배치하는 것은 전세계적으로 최적이 아닐 수 있다. 따라서, 컴파일러는 2개 이상의 대안의 SID를 병렬로 고려함으로써 PE 할당 프로세스를 향상시킬 수 있고, 2개 이상의 각각의 대안의 할당 프로세스를 이러한 SID에서 실행할 수 있다. "A-스타" 체계 또는 훨씬 일반적인 서치 알고리즘과 같은 다양한 서치 방법이 전세계적으로 최상인 SID에 수렴하도록 사용될 수 있다.

효율적인 SID 동작을 위한 메모리 관리

이해할 수 있는 바와 같이, SID를 GPU(32)에서 실행하는 것은 자주 광대한 수의 메모리 접속 동작을 수반한다. GPU에서, 데이터는 디바이스 메모리(56) 또는 공유 메모리(52)에 저장될 수 있다. 디바이스 메모리(56)는 큰 저장공간(예를 들어, 수 기가바이트)를 보통 제공하지만 이러한 메모리로의 접속은 레이턴시 면에서 비싸다. 보통, 멀티프로세서(40)는 큰 입도(예를 들어, 한번에 512 비트)에서 디바이스 메모리(56)에 접속한다. 따라서, 디바이스 메모리(56)에 대한 단일 비트의 판독 또는 기록의 비용은 512 비트의 판독 또는 기록의 비용과 유사하다. 디바이스 메모리(56)에 대한 판독 및 기록 명령은 이러한 큰 입도 어드레스에 정렬된다. 한편, 각 멀티프로세서내의 공유 메모리(52)는 작은 입도에서 그리고 정렬 없이, 비교적 고속 접속 타임에서 이러한 멀티프로세서의 프로세서(44)에 의해 접속될 수 있다. 그러나, 공유 메모리(52)의 크기는 디바이스 메모리의 것 보다 상당히 작다(예를 들어, 기가바이트에 대조되는 킬로바이트 정도).

본 발명의 일부 실시예에서, SID내의 PEG 시퀀스는 디바이스 메모리(56)에 효율적으로 접속하고 연관된 레이턴시 페널티를 최소화하기 위해 캐시 메모리로서 공유 메모리(52)를 사용한다. 아래의 설명에서, 용어 "공유 메모리" 및 "캐시"는 종종 상호교환되어 사용된다.

여기에 기술된 캐시 및 메모리 관리 체계는 컴파일레이션 동안 온전히 결정되고, SID 실행을 통해 결정적인 것으로 남는다에 주목하는 것이 중요하다. 이러한 특징은 동작이 런타임에 데이터에 따라 변할 수 있어서 특성상 통계학적인 일부 공지된 캐싱 체계과 대조적이다. 여기에 기술된 기술에서, 데이터가 요구되고 상이한 PEG 시퀀스에 의해 생성되는 패턴 및 타이밍은 컴파일레이션 동안 "연역적인" 것으로 알려져 있다. 이러한 컴파일러는 이러한 지식을 이용할 수 있고 디바이스 메모리(56)에 효율적으로 접속하는 특정 최적 메모리 관리 수단에서 결정할 수 있다(예를 들어, 특정 시각에 특정 변수의 캐싱 인 또는 아웃, 또는 다수의 판독 요구를 단일 판독 동작으로 통합). 이러한 수단은 런타임에 GPU에 의해 결정적으로 수행될 것이다.

도 9는 본 발명의 하나의 실시예에 따라, 캐시 관리 체계를 대략적으로 설명하는 도면이다. 도 9는 P1...P9로 표시된 9개의 PEG를 포함하는 특정 PEG 실행 시퀀스를 설명한다. PEG는 입력으로서 A...F로 표시된 6개의 변수를 사용하고, 각 PEG는 이러한 변수의 특정 부분집합을 사용한다. 이러한 실시예에서, 공유 메모리(52)는 임의의 주어진 시각에 3개의 변수의 최대값을 홀딩할 수 있다. 컴파일러는 특정 변수가 디바이스 메모리(56)로부터 공유 메모리(52)로 페칭될 때와 특정 변수가 버려질 때를 특정하는 결정론적인 캐싱 패턴을 결정하여서 제한된 크기 공유 메모리의 사용을 최적화하고 디바이스 메모리로부터 판독 동작의 수를 최소화한다.

이러한 도면의 상부의 영역(250)은 각 PEG에 의해 입력으로서 사용된 변수를 도시한다. 예를 들어, PEG1은 입력으로서 변수 A 및 B를 사용하고, PEG2는 변수 B 및 C를 사용하고, PEG3은 변수 A만을 사용한다. 업포인팅 화살표는 상응하는 PEG에 의해 입력으로 사용되기 위해 디바이스 메모리(56)로부터 공유 메모리(52)로 페칭되는 변수를 나타낸다. 다운포인트 화살표는 그다음 PEG에서 필요한 변수를 위한 자유 공간을 위해, PEG의 실행에 이어지는 공유 메모리로부터 버려지는 변수를 나타낸다. 두꺼운 프레임으로 마크된 변수는 캐시 히트, 즉, 캐시에 이미 존재하고 디바이스 메모리로부터 페치될 필요가 없는 변수를 나타낸다. 예를 들어, PEG2 실행을 준비하기 위해, 디바이스 메모리로부터 변수 B를 페치할 필요가 없는데, 그 이유는 그것이 이전의 PEG로부터 공유 메모리에 이미 존재하기 때문이다.

이러한 도면의 바닥의 영역(254)은 각 PEG의 시작에서 공유 메모리(52)의 컨텐트를 도시한다. 예를 들어, PEG P1의 시작에서 공유 메모리는 변수 A 및 B를 홀딩한다. 변수 C는 PEG P2의 시작에서 페치되고, 따라서 공유 메모리는 변수 A, B 및 C를 홀딩한다. 캐시는 PEG P3 동안 변하지 않는다. 하지만, PEG P4는 입력으로서 변수 D를 필요로 한다. 따라서, 변수 A는 PEG P3의 끝에서 버려지고 변수 D는 PEG P4의 시작에서 페치된다. 이러한 공정은 PEG 시퀀스 실행 내내 계속된다.

주어진 시각에 공유 메모리에 존재하는 각 변수에 대해, 컴파일러는 이러한 변수를 입력으로서 요구할 시퀀스에 그다음 PEG의 아이덴티티를 기록한다. 컴파일러는 보통 실행 순서에 따라 PEG 시퀀스를 스캐닝함으로써 이러한 PEG 아이덴티티를 결정한다. 이렇게 기록된 PEG 아이덴티티는 도면의 바닥의 영역(254)에 도시되어 있다. 예를 들어, 변수 A 및 B가 PEG P1의 시작에서 페치될 때, 컴파일러는 변수 A가 PEG P3에 의해 다음으로 요구될 것이고 변수 B는 PEG P2에 의해 다음으로 요구될 것을 언급한다. 또 다른 예로서, PEG P3의 시작에서, 컴파일러는 변수 A가 PEG P5에 의해 다음으로 요구될 것이고, 변수 B 및 C가 PEG P4에 의해 다음으로 요구될 것이라는 것에 주목한다. 심볼 ∞은 시퀀스내의 연속 PEG중 어느 하나에 의해 요구되지 않을 변수를 가리킨다.

이러한 레코드를 사용하여, 컴파일러는 스페이스가 공유 메모리에 자유화될 때 어느 변수가 버려질 지를 결정한다. 변수가 버려질 필요가 있을 때, 컴파일러는 보통 시퀀스에서 가장 멀리 있는, 즉, 현 PEG로부터 가장 큰 거리를 갖는 PEG에 의해 요구될 변수를 버리기 위해 선택한다. 예를 들어, PEG P3의 끝의 상황을 고려해보자. 이러한 시점에서, 공유 메모리는 변수 A,B,C를 홀딩한다. 이러한 변수중 하나는 PEG P4에 대한 변수 D의 페칭을 위해 플러싱될 필요가 있다. 변수 A는 PEG P5에 의해 요구될 것이고 변수 B 및 C는 PEG P4에 의해 보다 일찍 요구될 것이기 때문에, 변수 A는 버려진다.

도 9의 실시예는 특정 시퀀스, 특정 변수 및 특정 캐시 크기를 나타낸다. 그러나, 일반적으로, 이러한 캐시 관리 체계는 임의의 다른 적합한 PEG 시퀀스, 변수의 세트 및 캐시 사이즈와 함께 사용될 수 있다. 대안의 실시예에서, 컴파일러는 임의의 다른 적합한 기준을 사용하여 공유 메모리(52)내의 변수의 캐싱인 및 캐싱아웃을 설계할 수 있다. 주어진 PEG 시퀀스를 실행하기 위해 GPU에 의해 할당된 멀티프로세서(40)는 컴파일러에 의해 설정된 결정적 패턴에 따라 디바이스 메모리(56)로부터 공유 메모리(52)에 변수를 페치한다. 보통, 유사한 프로세스는 SID내의 각 PEG 시퀀스에 대해 수행된다. 컴파일러는 상이한 변수를 요구할 PEG를 기록하기 위한 임의의 적합한 데이터 구조를 사용할 수 있다.

일부 실시예에서, 컴파일러는 단일 페치 명령으로 디바이스 메모리(56)로부터 공유 메모리(52)로 다수의 변수의 페칭을 통합하여, 디바이스 메모리로부터 고비용의 페치 동작의 수를 감소시킨다. 상술된 바와 같이, 전형적인 GPU에서, 디바이스 메모리로부터의 단일 변수의 페칭의 오버헤드는 512 비트를 채우는 변수 페칭의 오버헤드와 유사하고, 따라서, 단일 명령으로 광대한 수의 변수를 통합하고 페치하는 것이 유리하다.

도 10a 및 도 10b는 본 발명의 실시예에 따른 변수 프리페칭 체계를 개략적으로 설명하는 도면이다. 본 예는 P1...P9으로 표시된 9개의 PEG를 포함하는 PEG 실행 시퀀스를 나타낸다. 변수 A...D는 본 SID를 내적으로 사용되고, 변수 S 및 T는 인터-SID 변수를 포함한다. 도 10a 및 도 10b의 각각에서, 각 컬럼은 상술된 시퀀스내의 특정 PEG에 상응하고, 각 행은 특정 변수에 상응한다.

각 변수는 이러한 변수가 특정 PEG에 의해 입력으로서 요청되는 포인트로부터, 세이디드 패턴으로 마킹된다. 예를 들어, 변수 B는 먼저 PEG P3에 의해 요청되고, 따라서, 이러한 변수는 PEG P3 로부터 쭉 세이디드 패턴으로 마킹된다. 수직선(258)은 현 PEG 시퀀스와 연속된 PEG에 의해 수행되는 일부 다른 시퀀스 사이의 SYNC를 가리킨다. 본 예에서, SYNC는 PEG P1, P4 및 P7에 의해 수행된다. 각 SYNC(258)에 대해, 하나 이상의 마크(262)는 SYNC에 의해 동기화되는 특정 변수를 가리킨다. 예를 들어, PEG4에 의해 수행된 SYNC는 변수 C 및 D가 또 다른 시퀀스에 준비될 때까지 실행을 중지한다.

일부 실시예에서, 컴파일러는 PEG 시퀀스를 스캐닝하고 각 명령에 의해 페치되는 변수는 물론 디바이스 메모리 페치 명령의 타이밍을 세팅한다. 보통, 컴파일러는 (1) 각 변수를 필요로 할 PEG에 대한 거리, 및 (2) 효율적인 것으로 생각되는 수많은 명령 당 페치 동작을 고려하면서 페치 명령의 타이밍 및 컨텐트를 설정 시도한다. 이러한 정보에 기초하여, 컴파일러는 단일 명령으로 2개 이상의 변수의 페칭을 조합 시도한다.

일부 실시예에서, 컴파일러는 역순으로(즉, 실행순서의 반대로) PEG 시퀀스를 스캐닝한다. 각 변수에 대해, 컴파일러는 각 페칭 인터벌, 즉, 변수가 페칭될 수 있는 타임 인터벌을 마킹한다. 이러한 타임 인터벌은 변수가 유효일 때 시작하고, 먼저 이러한 변수를 입력으로서 요청하는 PEG에서 종료한다. 그다음 컴파일러는 이러한 타임 인터벌에 기초하여 페치 동작의 타이밍 및 컨텐트를 설정한다.

보통, 각 변수 및 각 PEG에 대해, 컴파일러는 변수가 유효한 동안 이러한 변수를 먼저 요청할 PEG로부터 PEG의 거리(PEG 단위)를 마킹한다. 주어진 변수는 이러한 변수와 연관된 최후의 SYNC(258)에 이어 유효할 것으로 주정될 수 있다. 이러한 예에서 컴파일러에 의해 마킹된 거리는 도 10a 및 도 10b에 도시되어 있다. 예를 들어, 변수 D는 먼저 PEG P6에 의해 요청되고, (이러한 변수를 기다리는 SYNC를 따르는) PEG P4로부터 시작하는 임의의 시간에 페칭될 수 있다. 컴파일러는 마킹된 거리에 기초하여 페치 동작의 타이밍 및 컨텐트를 설정한다. 예를 들어, 컴파일러는 실행 순서를 따라 PEG 시퀀스를 스캐닝할 수 있고, 페칭될 필요가 있는 변수를 식별하고, 이들을 다른 변수의 페칭과 조합시켜 효율적인 페치 명령을 산출한다. 이러한 컴파일러는 페칭 인터벌이 오버랩하는 2개 이상의 변수를 조합할 수 있다. 조합된 페치 명령은 이러한 오버랩 동안 포지셔닝된다.

예를 들어, 2개의 변수를 페치하는 명령이 효율적인 것으로 생각되지만, 오직 단일 변수를 페치하는 명령은 효율적인 것으로 생각되지 않는다고 가정해보자. 도 10b의 예에서, 아무런 변수도 PEG P1 및 P2에 대해 준비되어 페칭될 필요가 없다. 그러나, PEG P3는 변수 B를 입력으로서 필요로 하고, 따라서, 컴파일러는 디바이스 메모리(56)로부터 페치 명령을 정의하여 PEG P3에 대비한다. 이러한 디바이스 메모리에 효율적으로 접속하기 위해, 컴파일러는 또 다른 변수 페칭을 동일한 명령으로 통합한다. 컴파일러는 현 PEG로부터의 거리(즉, 현 PEG로부터 먼저 이러한 변수를 요청할 PEG까지의 거리)가 최소인 유효 변수를 선택한다.

본 예에서, 변수 S 및 T는 이 때에 유효하고, 변수 T는 보다 작은 거리(6에 비교되는 3)를 갖는다. 따라서, 컴파일러는 변수 B 및 T를 페치하도록 페치 명령을 정의한다. 일단 이러한 변수가 페치되면, 이들은 이들이 다시 페치되지 않도록 리스트로부터 크로싱 아웃된다. 이러한 프로세스는 유사한 로직을 사용하면서 계속되고, 컴파일러는 2개의 추가 페치 명령을 정의하는데, 하나는 PEG P4 전에 변수 C 및 D를 페치하고, 또다른 하나는 PEG P9전에 변수 A 및 S를 페치한다. 이러한 기술을 사용하여, 각 변수는 유효화된 후에 그리고 먼저 입력으로 필요하기 전에 페치되고, 페치 명령은 명령 당 다수의 변수의 페칭을 통합함으로써 효율적으로 정의된다.

도 10a 및 도 10b의 예는 특정 시퀀스, 특정 변수, 명령 당 특정 수의 페치 및 특정 선택 기준을 나타낸다. 그러나, 일반적으로, 컴파일러는 임의의 다른 적합한 PEG 시퀀스, 변수, 명령 당 페치의 수 및/또는 선택 기준을 갖는 프리페칭 체계를 적용할 수 있다. 보통, 유사한 프로세스가 SID내의 각 PEG 시퀀스에 대해 수행된다. 컴파일러는 상술된 타임 인터벌 및 거리를 기록하기 위한 임의의 적합한 데이터 구조를 사용할 수 있다.

일부 실시예에서, 컴파일러는 디바이스 메모리(56)내의 변수 (PEG에 의해 산출된 출력)의 저장을 지연시키고 저장 명령 당 다수의 변수를 통합한다. 명령 당 다수의 변수를 저장하는 단계는 디바이스 메모리(56)내의 저장과 연관된 레이턴시 및 오버헤드를 감소시킨다. 이러한 종류의 지연된 저장 메커니즘은 도 10a 및 도 10b의 프리페칭 메커니즘에 유사한 기준을 사용하여 수행될 수 있다. 예를 들어, 컴파일러는 각 변수에 대해, (예를 들어, 상이한 SID에 속할 수 있는, 또 다른 시퀀스내의 PEG에 의해) 변수가 입력으로서 필요되는 포인트까지 변수값을 산출한 PEG로부터 타임 인터벌을 식별할 수 있다. 변수가 또 다른 SID내의 시퀀스에 의해 입력으로서 필요될 때, 컴파일러는 이러한 변수를 산출하는 (그리고 이러한 시퀀스내의 개별적인 PEG가 아니다) 시퀀스의 엔드를 변수가 준비되는 시각으로서 여길 수 있다. 그다음, 컴파일러는 이러한 타임 인터벌에 기초하여 멀티 변수 저장 명령을 정의할 수 있다.

상기 도 9에 도시된 바와 같이, 주어진 멀티프로세서(40)가 주어진 PEG 시퀀스를 실행할 때, 멀티프로세서는 특별한 결정적 순서로 디바이스 메모리(56)로부터 변수를 로딩하고, 이들을 공유 메모리에 캐싱하고 이들을 입력으로서 시퀀스내의 상이한 PEG에 제공한다. 일부 실시예에서, 컴파일러는 PEG 시퀀스가 변수를 로딩할 순서에 따라 디바이스 메모리(56)에 변수를 미리 순서지정한다. 이러한 메커니즘을 사용할 때, 주어진 PEG 시퀀스는 연속 메모리 어드레스로의 페치 동작의 순서지정된 시퀀스를 사용하여 디바이스 메모리(56)로부터 변수를 페치할 수 있다.

도 11은 본 발명의 실시예에 따라, 다양한 사전 오더링 체계를 개략적으로 설명하는 도면이다. 도 11의 예는 상기 도 9의 캐싱 메커니즘을 도시한다. 이러한 도면의 상부의 영역(266)은 시퀀스내의 상이한 PEG에 의해 공유 메모리(52)내로 캐싱되고 그로부터 플러싱 아웃되는 변수를 도시한다. 영역(270)은 각 PEG에 대비하여 디바이스 메모리(56)로부터 페치되는 변수를 도시한다. 볼드 프레임은 시퀀스내의 이전 PEG에 의해 이미 판독되었지만 중간에 공유 메모리로부터 플러싱 아웃된 변수를 표시한다.

일부 실시예에서, 컴파일러는 피더 영역(274)내의 디바이스 메모리(56)에 변수를 저장한다. 특정 PEG 시퀀스의 피더 영역(274)에서, 변수는 이들이 PEG 시퀀스에 의해 페치될 순서로 저장된다. 주어진 변수는 PEG 시퀀스가 제한된 캐시 크기로 인해 변수를 재판독할 수 있기 때문에 피더 영역을 따라 2개 이상의 상이한 위치에서 저장될 수 있음에 주목해야 한다. 또한, 각 PEG 시퀀스는 디바이스 메모리(56)내의 상응하는 피더 영역을 갖고 있음에 주목해야 한다. 주어진 변수는 상이한 PEG 시퀀스의 다수의 피더 영역에 저장될 수 있다.

보통, 사전 순서지정된 변수는 GPU의 메모리 정렬 및 크기 사양에 합치하는 기본 섹션내의 디바이스 메모리에 배열된다. 이렇나 섹션은 캐시 라인으로서 여기에서 불린다. 전형적인 GPU에서, 각 캐시 라인은 512 비트를 포함한다.

보통, 상이한 시퀀스내의 PEG는 캐시 라인 유닛에서 변수를 산출하고, 소비하고 교환한다.

인터 및 인트라 SID 통신

상술된 바와 같이, 컴파일러는 각 디펜던시 서브트리를 SID로 전환한다. 일부 실시예에서, 하나의 SID내의 PEG에 의해 산출된 변수는 또 다른 SID내의 PEG에 의해 입력으로서 사용된다. 상이한 SID내의 PEG 사이의 통신은 보통 디바이스 메모리(56)를 통해 수행된다. 일부 실시예에서, 컴파일러는 메일박스로 불리는 데이터 구조에 SID 사이에서 통신되는 변수를 저장한다. 각 메일박스는 공통 PEG 시퀀스에 의해 생성되고 및/또는 사용되는 변수를 포함한다. SID 사이의 통신은 캐시 라인을 메일박스로 기록하고 판독함으로써 수행된다. 따라서, 디바이스 메모리(56)로의 접속은 상이한 변수 사이의 사용 및 생성 공통성을 활용함으로써 효율적으로 수행된다.

도 12는 본 발명의 실시예에 따라, 다수의 SID를 개략적으로 설명하는 도면이다. 본 실시예는 SID-X 및 SID-Y로 표시된 2개의 SID를 도시한다. SID-X는 각각 4개의 PEG(280)를 포함하는 2개의 PEG를 포함한다. SID-Y는 각각 2개의 PEG를 포함하는 2개의 PEG 시퀀스를 포함한다. 각각의 PEG는 (각 블록의 좌측에 도시된) 3개에 이르는 입력 변수를 입력으로서 수용하고 (각 블록의 우측에 도시된) 출력 변수를 산출한다. 예를 들어, SID-X 내의 PEG 1/1은 입력으로서 변수 A 및 C를 수용하고 변수 D를 생성한다. SID-X 내의 PEG 2/3과 PEG 1/4 사이와 같은, 시퀀스 사이의 일부 디펜던시가 또한 각 SID 안에 존재할 수 있다.

특정 변수가 들어가고 나가는 변수, 즉, CPU (또는 다른 호스트 환경)로 각각 입출력되는 변수로서 정의된다. 본 실시예에서, 들어가는 변수는 변수 A, B, C, F 및 Q를 포함한다. 나가는 변수는 변수 S, G, H 및 P를 포함한다.

주어진 SID에서, 변수는 (SID에 의해 생성되는) 생성된 변수, (SID 내의 PEG에 의해 입력으로서 사용되는) 사용된 변수 및 (SID 내의 PEG에 의해 입력으로서 사용되지만 SID 내에 내적으로 산출되지 않는) 입력된 변수로 분류될 수 있다. 오버랩이 때로 상이한 클래스 사이에 존재할 수 있다. 본 실시예에서, 변수 분류가 다음 표에 나타나 있다.

도 13은 본 발명의 실시예에 다른 인터-SID 통신에 대한 방법을 개략적으로 설명하는 순서도이다. 이러한 방법은 인터-SID 식별 단계(284)에서, 컴파일러가 인터-SID 변수의 세트를 식별함으로써 시작된다. 인터-SID 변수는 입출 변수가 아니고 상이한 SID 사이에서 교환될 변수를 포함한다. 컴파일러는 (1) 모든 SID의 모든 입력 변수의 세트를 식별하고, (2) 이러한 세트로부터 출입되는 변수를 제거함으로써 인터-SID 변수를 식별할 수 있다. 본 실시예에서, SID X 및 SID Y의 입력 변수의 세트는 {A, B, C, E, F, M, L, Q, N, V, P}이고, 들어가는 변수의 세트는 {A, B, C, F, Q}이고, 나가는 변수의 세트는 {S, G, H, P}이다. 따라서, 인터-SID 변수의 세트는 {E, M, L, N, V}이다.

그다음, 컴파일러는 사용/생성 맵핑 단계(288)에서, 상이한 SID의 상이한 PEG 시퀀스에 의한 인터-SID 변수의 사용 및 생성의 관점에서 인터-SID 변수를 맵핑한다. 본 실시예에서, 상이한 인터-SID 변수의 사용 및 생성은 다음의 표에 제공되어 있다.

여기에서, M->(X1)은 예를 들어, 변수 M이 SID-X 내의 시퀀스 1에 의해 생성된다는 것을 표시한다. 일반적으로, 주어진 인터-SID 변수는 임의의 요구되는 수의 SID에 속하는 임의의 요구되는 수의 시퀀스에 의해 생성되고 및/또는 사용될 수 있다.

그다음 컴파일러는 그룹핑 단계(292)에서, 공통 시퀀스에 의해 생성되고 공통 시퀀스에 의해 사용되는 인터-SID 변수를 함께 그룹화한다. 이러한 컴파일러는 이러한 각 그룹에 대해, 메일박스로서 불리는 데이터 구조를 정의한다. 이러한 메일박스는 디바이스 메모리(56)의 특정 영역에 저장된다. 각 메일박스는 하나 이상의 캐시라인을 보통 포함한다. 본 실시예에서, 컴파일러는 다음의 4개의 메일박스를 정의할 수 있다.

런타임에서, 상이한 SID는 인터-SID 통신 단계(296)에서, 메일박스에 캐시라인을 기록하고 메일박스로부터 캐시라인을 판독함으로써 서로 통신한다. 각 메일박스가 동일한 시퀀스에 의해 생성되고 동일한 시퀀스에 의해 사용된 인터-SID 변수를 포함하기 때문에, 디바이스 메모리(56)로의 접속은 효율적이다.

메일박스 메커니즘의 효율은 적어도 부분적으로, 각 SID내의 PEG 시퀀스로의 PE의 할당에 종속된다. 상기 도 8에서 설명된 바와 같이, 컴파일러는 다른 SID내의 동일한 PE와 통신하는 시퀀스 PE를 동일한 PEG에서 그룹화 시도한다. 이러한 그룹화가 성공적이고 양호하게 형성되면, 도 13의 방법은 각각이 비교적 큰 수의 변수를 포함하는 메일박스의 비교적 작고 잘 형성된 그룹을 생성할 것이다.

일부 실시예에서, 컴파일러는 PEG 시퀀스에 의해 요구되는 순서에 따라 각 메일박스내의 변수를 순서지정함으로써 디바이스 메모리(56)로의 접속 효율을 보다 더 향상시킬 수 있다.

일부 실시예에서, 동일한 SID내의 상이한 PEG 시퀀스는 서로에게 변수를 전송할 수 있다. 이러한 통신 형태는 여기에서 인트라-SID 통신으로 불린다. 보통 동일한 SID내의 PEG 시퀀스는 디바이스 메모리(56)를 통해 변수값을 포함하는 캐시라인을 교환함으로써 통신한다. 인트라-SID 통신은 보통 변수 유효성 제한에 영향을 받는다. 즉, 특정 PEG 시퀀스는 변수를 샌출하는 PEF가 실행을 종료한 후에만 다른 시퀀스에 벽수를 전송할 수 있다. 일부 실시예에서, 컴파일러는 (캐시라인 레졸루션에서) 트랜잭션의 수를 최소화하고 실행 디펜던시를 보존하는 방식으로, PEG 시퀀스 사이에서 트랜잭션을 통신한다. 인트라-SID 통신은 보통 시퀀스 사이에 유도되는 SYNC 엘리먼트상에 수행된다. 즉, 다른 시퀀스내의 하나 이상의 PEG가 실행을 종료할 때까지 하나의 시퀀스의 실행을 중지시키는 SYNC 엘리먼트는 또한 이러한 다른 시퀀스로부터 중지된 시퀀스에 변수를 전송할 수 있다.

도 14a 및 도 14b는 본 발명의 실시예에 따른, 인트라-SID 통신 체계를 대략적으로 설명하는 도면이다. 도 14a는 3개의 PEG 시퀀스를 갖고 있는 SID의 에를 도시하고 있다. 각각의 PEG에 대해, 입력 변수는 PEG 블록의 좌측에 도시되어 있고, 출력 변수는 블록의 우측에 도시되어 있다.

도 14b는 도 14a의 SID내의 PEG 시퀀스 사이에서 변수를 전송하기 위해 컴파일러에 의해 정의된 4개의 캐시라인(300)을 도시하고 있다. 각 캐시라인에 의해 통과된 변수는 도면에서 브래킷에 마크되어 있다. 컴파일러는 캐시라인(300)을 정의하기 위해, 다양한 동적 프로그래밍 기술과 같은 임의의 적합한 프로세스를 사용할 수 있다. 보통 솔루션은 유일하지 않고 다수의 솔루션이 가능하다. 컴파일러는 캐시라인(300)의 수를 최소화시키는 것과 같이, 사전정의된 기준을 충족시키는 솔루션을 식별시도한다.

인터-SID 통신 효율을 향상시키기 위한 기술

상술된 바와 같이, 상이한 SID 사이의 인터-SID 변수의 교환은 디바이스 메모리(56)내의 메일박스내의 변수를 저장함으로써 수행된다. 각 메일박스는 하나 이상의 캐시라인을 포함하고, (하나 이상의 소스 SID내의) 하나 이상의 소스 실행 시퀀스의 세트 및 (하나 이상의 타겟 SID내의) 하나 이상의 타겟 실행 시퀀스의 세트와 연관되어 있다. 보통, 인터-SID 변수는 (1) 동일한 세트의 SID 및 실행 시퀀스에 의해 생성되고 사용되는 변수가 동일한 메일박스에 할당되고, (2) 동일한 세트의 SID 및 시퀀스에 의해 생성되고 사용되는 변수가 동일한 캐시라인을 공유하지 않도록 별개의 메일박스에 할당되고, (3) 각 변수가 메일박스의 콜렉션에 정확하게 한번 나타나도록 메일박스에 할당된다.

그러나, 일부 경우에, 인터-SID 변수의 생성 및 사용은 변수가 메일박스에 효율적으로 그룹화되도록 하지 않는다. 이러한 그룹화는 소수의 변수를 갖는 메일박스를 산출할 수 있다. 디바이스 메모리가 캐리라인에 존재하는 변수의 실제 수에 관계없이 캐시라인 유닛에서 판독되기 때문에, 적은 수의 변수를 갖는 메일박스는 불량한 캐시라인 사용을 유발할 수 있다.

일부 실시예에서, 컴파일러는 조밀한 캐시라인을 생성하기 위해, 희박하게 분포된 메일박스로부터 2개 이상의 인터-SID 캐시라인를 조합한다. 캐시라인을 조합함으로써, 디바이스 메모리로부터의 로드 동작의 수는 감소될 수 있다. 감소의 정도는 조합되는 캐시라인의 선택에 달려 있다. 예를 들어, 컴파일러는 타겟 실행 시퀀스의 세트에서 비교적 큰 오버랩을 갖는 인터-SID 캐시라인을 조합하도록 시도할 수 있다.

예를 들어, 시퀀스 S1 및 S2에 의해 사용된 캐시라인 A 및 시퀀스 S1, S2 및 S3에 의해 사용된 캐시라인 B를 생각해보자, 또한, 캐시라인 A 및 B가충분히 드물어, 이들을 캐시라인 크기 제한을 초과함 없이 새로운 캐시라인 C로 조합하는 것이 가능하다고 가정해보자. 이러한 예에서, 캐시라인 A 및 B를 캐시라인 C를 형성하기 위해 조합한 후에, 시퀀스 S1 및 S2의 각각은 2개의 캐시라인 대신에 오직 단일 캐시라인 (조합된 캐시라인 C)을 로딩해야 할 것이다. 시퀀스 S3는 여전히 단일 캐시라인 (캐시라인 B 대신에 캐시라인 C)을 로딩해야 할 것이다. 전체적으로, 디바이스 메모리로부터의 로드 동작의 수는 캐시라인 A 및 B를 조합한 결과로서 감소된다. 대안의 실시예에서, 컴파일러는 임의의 요구되는 수의 캐시라인을 조합할 수 있다.

대안으로, 컴파일러는 인트라-SID 통신 메커니즘을 사용하여 (즉, 시퀀스 사이의 동기화 엘리먼트를 사용하여) 타겟 SID내의 타겟 실행 시퀀스 사이에서 전송될 수 있는 변수를 가진 인터-SID 캐시라인을 조합할 수 있다. 인터-SID 통신을 향상시키기 위해 덜 사용된 인트라-SID 통신 소스를 활용하는 개념이 아래에 보다 잘 상세하게 설명되어 있다. 예를 들어, 3개의 실행 시퀀스 S1, S2, S3 및 3개의 캐시라인 A, B, C의 구성을 생각해보자. 이러한 예에서, 시퀀스 S1은 캐시라인 A로부터 입력 변수를 갖고, 시퀀스 S2는 캐시라인 B로부터 입력 변수를 갖고, 시퀀스 S3는 캐시라인으로부터 입력 변수를 갖는다. 또한, 시퀀스 사이의 동기화 메커니즘이 시퀀스 S1로부터 시퀀스 S2로의 데이터 전송을 가능케 한다고 가정해보자. 시퀀스 S2에서, 캐시라인 B로부터의 입력 변수는 시퀀스 S1과 동기화 후에 위치지정되는 PEG에 의해서만 필요로 된다. 이러한 상황에서, 캐시라인 A를 캐시라인 B와 조합하고, 캐시라인 B의 변수를 시퀀스 S1과 시퀀스 S2 사이의 동기화 메커니즘을 통해 전송하는 것이 유리하다. 이러한 체계를 사용할 때, 시퀀스 S2는 캐시라인 B를 로딩할 필요할 필요가 없는데, 그 이유는 동기화 메커니즘을 통해 시퀀스 S1로부터 그 변수를 수신하기 때문이다. 따라서, 컴파일러는 (1) 상이한 타겟 시퀀스에 의해 사용되는 캐시라인을 조합함으로서 그리고, (2) 인트라-SID 통신을 사용하여 하나의 타겟 시퀀스로부터 또 다른 타겟 시퀀스로 변수를 전송함으로써 디바이스 메모리로부터의 로드 동작의 수를 감소시킬 수 있다.

인터-SID 캐시라인이 조합되는지에 관계없이, 컴파일러는 다음에서 설명되는 바와 같이, 덜 사용된 인트라-SID 통신 소스를 활용함으로써 디바이스 메모리로부터의 인터-SID 캐시라인 로드 동작의 수를 감소시킬 수 있다.

도 15는 본 발명의 실시예에 따른, 인터-SID 및 인트라-SID 통신을 모두 사용하는 SID(310)을 대략적으로 설명하는 도면이다. SID(310)는 인터-SID 캐시라인(314)을 로딩함으로써 또 다른 SID로부터 인터-SID 변수를 수신한다. 본 실시예에서, 캐시라인(314)으로부터의 인트라-SID 변수는 SID(310)내의 3개의 실행 시퀀스 (318A...318C)에 의해 사용된다. (SID(310)는 이러한 인터-SID 캐시라인으로부터의 변수를 사용하지 않는 추가 실행 시퀀스를 포함하는 물론이다.)

인트라-SID 소스를 인터-SID 변수를 전송하는데 사용하지 않고, 3개의 시퀀스 (318A...318C)의 각각은 입력 변수를 얻기 위해, 디바이스 메모리(56)내의 적합한 메일박스로부터 별개로 캐시라인(314)을 로딩할 필요가 있다. 따라서, 3개의 별개의 로드 동작이 요청된다. 대안으로, 캐시라인(314)은 시퀀스의 부분집합에 의해서만(예를 들어, 단일 시퀀스에 의해서만) 로딩될 수 있고, 또 다른 시퀀스는 인트라-SID 통신을 사용하여 변수를 수신할 수 있다.

SID(310)에서, 예를 들어, SYNC(326A)는 시퀀스(318A)내의 특정 PEG에 시퀀스(318B)내의 특정 PEG를 동기화하고, SYNC(326B)는 시퀀스(318B)내의 특정 PEG에 시퀀스(318C)내의 특정 PEG를 동기화한다. 각 SYNC는 SYNC에 종속되고 동기화하는 시퀀스로부터 동기화된 시퀀스로 (또는 보다 정확하게, 동기화하는 PEG로부터 동기화된 PEG로) 변수를 전송하는 인트라-SID 캐시라인과 연관되어 있다. 예를 들어, SYNC(326A)는 시퀀스(318A)로부터 시퀀스(318B)로 변수를 전송하는 인트라-SID 캐시라인과 연관되어 있다.

인트라-SID 캐시라인이 자유 비할당된 대역폭을 갖고 있는 것으로 가정하면, 이들 캐시라인은 시퀀스(318A)로부터 시퀀스(318B)로 그리고 시퀀스(318B)로부터 시퀀스(318C)로 데이터를 전송하는데 사용될 수 있다. 따라서, 일부 경우에, 모든 3개의 시퀀스(318A...C)는 오직 시퀀스(318A)만이 실제로 디바이스 메모리로부터 캐시라인을 로딩하도록 함으로써 인터-SID 캐시라인(314)의 변수를 취득할 수 있고, 그 후에 이러한 변수를, SYNC(326A, 326B) 내지 시퀀스(318B, 318C)에 종속된 인트라-SID 캐시라인을 통해 변수를 전송할 수 있다.

이러한 솔루션은 주어진 시퀀스에서, 인터-SID 변수를 사용하는 PEG가 이러한 변수를 상술된 시퀀스에 전송하기 위해 사용되는 인트라-SID 캐시라인을 가진 SYNC 뒤에 위치된다고 가정할 때, 실행가능하다. 시퀀스(318A)내의 PEG(322A)는 시퀀스(318A)가 디바이스 메모리(56)로부터 인터-SID 캐시라인을 실제로 로딩하는 시퀀스이기 때문에 인터-SID 변수로의 접속을 가지고 있다. 시퀀스(318B)에서, PEG(322B)는 시퀀스(318B)가 SYNC(326A) 뒤에 위치되기 때문에, 전송된 변수로의 접속을 가지고 있다. 시퀀스(318C)에서, PEG(322D)는 시퀀스(318C)가 SYNC(326B) 뒤에 위치되기 때문에, 전송된 변수로의 접속을 가지고 있다. 한편, PEG(322C)는 SYNC(326B) 뒤에 위치되기 때문에, 전송된 변수로의 접속을 갖고 있지 않다.

만약 PEG(322C)가 인터-SID 캐시라인(314)으로부터 변수를 사용할 필요가 있다면, 시퀀스(318C)는 이러한 인터-SID 캐시라인을 별개로 로딩할 필요가 있고, 이것은 추가 로드 동작을 유발한다. 이러한 시나리오에서, SYNC(326B)의 인트라-SID 캐시라인은 인터-SID 캐시라인(314)로부터의 변수 전송을 위해 사용되지 않을 것이다.

일부 실시예에서, 컴파일러는 인터-SID 변수를 운반하기 위한 인트라-SID SYNC를 통해 사용가능한 리소스를 할당함으로써, 주어진 SID에 의해 실행되는 인터-SID 캐시라인 로드 동작의 수를 감소하려고 시도한다. 이러한 프로세스는 보통 각 SID에 대해 실행된다. 이러한 종류의 프로세스의 예는 아래의 도 16 및 도 17에 설명되어 있다. 그러나, 대안으로, 임의의 다른 적합한 프로세스가 또한 사용될 수 있다.

도 16 및 도 17의 프로세스는 F 및 P로 표시된 2개의 함수를 사용한다. 주어진 실행 시퀀스 s 및 인터-SID 변수 a에 대해, 함수 F(s,a)는 변수 a를 입력으로서 사용하는 시퀀스 s의 제1 엔트리(PEG)를 리턴하는 스태틱 함수이다. 즉, 변수 a는 F(s,a)보다 늦지 않게 시퀀스 s의 공유 메모리에 제공되어야 한다. 변수가 시퀀스 내의 임의의 곳에서 입력으로서 사용되지 않는다면, F(s,a)=∞이다.

함수 P(s_seq, s_off, t_seq, t_off, req_size)는 주어진 사이즈 req_size의 데이터가 소스 시퀀스 s_seq로부터 타겟 t_seq로 전송될 수 있는 SID를 통한 (하나 이상의) 경로의 세트를 리턴한다. 이러한 리턴된 경로는 오프셋 s_off 또는 이후에 소스 시퀀스에서 시작하고, 오프셋 t_off 또는 이전에 타겟 시퀀스에 도달한다. 함수 P는 인트라-SID 통신 리소스의 할당에 응답하여 컴파일레이션 동안 변할 수 있다. 일부 실시예에서, P는 또한 t_off에서 사용될 필요가 있는 변수의 어레이를 수신한다. 함수 P는 보통 이러한 변수의 일부가 시퀀스 사이의 동기화를 통해 이미 전송된 것을 고려한다. 일부 실시예에서, P는 데이터 전송에 대해 사용될 수 있는 다수의 경로의 조합을 리턴한다.

이러한 프로세스는 또한 H로 표시된 데이터베이스를 사용한다. SID에 의해 사용된 각 인터-SID 캐시라인에 대해, 데이터베이스 H는 이러한 캐시라인을 다수의 클래스로 사용하는 시퀀스의 분류화를 홀딩한다. 이러한 클래스는 보통 각 리스트에 의해 표시된다. 본 실시예에서, 시퀀스는 6개의 클래스로 분류된다.

- Must Load (ML): 인트라-SID SYNC를 통해 인터-SID 변수를 수신할 수 없기 때문에 디바이스 메모리(56)로부터 캐시라인을 로딩해야 하는 시퀀스.

- Should Load (SL): ML 시퀀스가 아님에도 불구하고, 디바이스 메모리(56)로부터 캐시라인을 로딩하도록 프로세스에 의해 요청되는 시퀀스.

- Placed (PL): 캐시라인을 로딩함 없이 다른 시퀀스로부터 인터-SID 변수를수신할 시퀀스로서, 적합한 리소스가 인트라-SID 캐시라인을 통해 할당된 시퀀스.

- Root Dependent (RD): SL, ML 또는 P 클래스로 아직 양도되지 않은 시퀀스로서, 인트라-SID 캐시라인을 통해 SL, ML 또는 PL 클래스에서의 적어도 하나의 시퀀스에 도달될 수 있는 시퀀스.

- Far Dependent (FD): SL, ML 또는 PL 클래스내의 시퀀스의 어느 하나에 도달될 수 없는 시퀀스.

- Unresolved (U): 클래스가 아직 결정되지 않은 시퀀스. (클래스 FD 및 U 사이의 차이점은 클래스 FD 내의 시퀀스가 클래스 RD 또는 FD내의 시퀀스로부터 도달될 수 있지만, SL, ML 또는 PL 클래스내의 시퀀스로부터 도달될 수 없다는 것이다.)

이어지는 설명은 클래스로의 시퀀스의 연관된 분류화를 갖는 주어진 인터-SID 캐시라인에 대한 것이다. 아래에 기술된 프로세스는 보통 각 인터-SID 캐시라인에 대해 반복된다.

임의의 주어진 시간에, 각 클래스는 임의의 수의 시퀀스를 포함할 수 있지만, 주어진 시퀀스는 오직 하나의 클래스에 나타날 수 있다. 상술된 바와 같이, 문제의 인터-SID 캐시라인으로부터의 변수를 사용하는 시퀀스만이 분류된다. 도 16 및 도 17의 프로세스는 U 클래스내의 모든 시퀀스와 함께 시작하는 반복적 프로세스이다. (보통, U 클래스는 처음에 문제의 인터-SID 캐시라인을 통해 전송된 변수를 사용하는 시퀀스만을 포함한다. 다른 시퀀스는 보통 무시된다.) 이러한 프로세스는 클래스 U 가 비어 있고 모든 시퀀스가 SL, ML 또는 P 클래스로 배정된 상태로 종료된다. 이러한 프로세스가 종료될 때, ML 및 SL 클래스내의 각 시퀀스는 인터-SID 캐시라인을 개별적으로 로딩하도록 정의되고, P 클래스내의 시퀀스는 캐시라인을 로딩하지 않고 다른 시퀀스로부터 인터-SID 변수를 수신하도록 정의된다. 인트라-SID SYNC의 적합한 리소스는 P 클래스내의 시퀀스로 인터-SID 변수를 배송하도록 배정된다.

도 16은 본 발명의 실시예에 따른, 인터-SID 통신량을 감소시키기 위한 방법을 대략적으로 도시한 상태도(330)이다. 상태도(330)는 U, ML, SL, P, RD 및 FD 클래스를 각각 나타내는 상태(334, 338, 342, 346, 348, 350)를 포함한다. 상태간의 천이는 도면에서 화살표로 표시되었다. 반복 할당 프로세스는 클래스 U가 비고 모든 시퀀스가 SL, ML 또는 P 클래스에 도달할 때까지 이러한 천이를 통해 클래스로부터 클래스로 (상태에서 상태로) 시퀀스를 이동시킨다.

도 17은 본 발명의 실시예에 따른, 인터-SID 통신량을 감소시키기 위한 방법을 대략적으로 도시한 순서도이다. (보통 이러한 프로세스는 각 인터-SID 캐시라인에 대해 반복된다.) 이러한 방법은 초기화 단계(360)에서 컴파일러가 데이터베이스 H를 초기화함으로써 시작한다. 현 처리되는 인터-SL,ML 또는 P 클래스 캐시라인은 c로 표시된다. 캐시라인 c를 사용하는 각 시퀀스 s(즉, F(s,c)≠∞를 충족시키는 시퀀스)에 대해, 컴파일러는 이러한 시퀀스를 클래스 U에 추가한다.

그다음, 컴파일러는 결정 단계(364)에서, 캐시라인 c를 리졸빙하려고, 즉, 함수 S 및 P를 사용하여, U 내의 시퀀스를 분류하려고 시도한다. 이러한 분류 단계는 다음과 같이 연속으로 실행되는 다수의 스테이지를 포함한다.

1) ML 결정 스테이지: 클래스 U 내의 각 시퀀스 s에 대해, 컴파일러는 시퀀스 s에 의해 사용된 캐시라인 c의 변수가 이러한 캐시라인을 사용하는 다른 시퀀스로부터 취득될 수 있는지를 체크한다. (변수를 제공하기 위한 가능한 시퀀스는 함수 F를 사용하여 식별된다. 변수를 전송하기 위한 가능한 경로는 함수 P를 사용하여 식별된다.) 시퀀스 s 로의 변수를 취득하기 위한 시퀀스 및 경로가 전혀 발견되지 않는다면, 컴파일러는 U 클래스로부터 시퀀스 s를 제거하고 이것을 ML 클래스에 추가한다.

2) RD 결정 스테이지: 클래스 U 내의 각 시퀀스 s에 대해, 컴파일러는 캐시라인으로부터 필요한 변수를 취득할 수 있는 시퀀스를 SL,ML 또는 P 클래스내의 시퀀스로부터 (F 및 P를 사용하여) 식별한다. 컴파일러는 클래스 U로부터 이러한 식별된 시퀀스를 제거하고 이것을 클래스 RD에 추가한다.

3) 컴파일러는 클래스 U가 빌 때까지 다음의 3개의 서브-스테이지를 반복한다.

a) RD 서브-스테이지: 함수 F 및 P를 사용하여, 컴파일러는 캐시라인 c로부터 필요한 변수를 클래스 SL내의 시퀀스로부터 취득할 수 있는 시퀀스를 식별한다. 컴파일러는 이러한 시퀀스를 클래스 U로부터 제거하고 이들을 클래스 RD에 추가한다.

b) FD 서브-스테이지: 함수 F 및 P를 사용하여, 컴파일러는 캐시라인 c로부터 필요한 변수를 클래스 RD 또는 FD내의 시퀀스로부터 취득할 수 있는 시퀀스를 식별한다. 컴파일러는 이러한 시퀀스를 클래스 U로부터 제거하고 이들을 클래스 FD에 추가한다. 적어도 하나의 시퀀스가 발견되었다면, FD 서브-스테이지가 반복된다.

c) SL 서브-스테이지: 프로세스의 이러한 스테이지는 2개 이상의 시퀀스 가운데 비순환 디펜던시 패턴을 식별하고 결정한다. 비순환 디펜던시의 상세한 예는 상술된 미국 특허 가출원 61/185,609호의 섹션 10.3.1.2.4에 기술되어 있다.

1. 컴파일러는 캐시라인 c의 클래스 U 리스트내의 시퀀스 s를 선택한다. req_offset 로 표시된 변수는 F(s,c)로 설정된다.

2. 함수 P를 사용하여, 컴파일러는 (시퀀스 s 이외의) 클래스 U 내의 시퀀스를 스캐닝하고 컴파일러는 req_offset 이후가 아닌 오프셋에서 시퀀스 s에의해 필요한 캐시라인 c의 변수를 제공할 수 있는 소스 시퀀스를 식별하려고 시도한다.

3. 소스 시퀀스 ss가 발견되면, s는 s=ss가 되도록 설정되고, req-offset는 ss가 캐시라인 c가 사용가능하도록 할 필요가 있는 오프셋이 되도록 설정된다. 이러한 프로세스는 상기 단계 2로 루프 백 한다.

4. 아무런 소스 시퀀스가 발견되지 않으면, 컴파일러는 클래스 U로부터 시퀀스 s를 제거하고 이것을 SL 클래스에 추가한다.

결정 단계(364)를 완료한 후에, 주어진 인터-SID 캐시라인 c에 대해, 클래스 U는 비어 있고 캐시라인 c를 사용하는 시퀀스는 클래스 ML, SL,RD 및 FD로 분류된다. ML 및 SL 클래스내의 시퀀스는 디바이스 메모리(56)로부터 캐시라인 c를 개별적으로 로딩하는 것으로 정의되고, 이러한 정의는 이러한 프로세스의 연속 반복에 의해 변하지 않을 것이다.

컴파일러는 이제 배치 단계(368)에서 인터-SID 변수를 제공하기 위한 인트라-SID 리소스를 RD 클래스내의 시퀀스에 할당하려고 시도한다. 보통, 데이터베이스 H 내의 RD 클래스 리스트의 어느 하나에 시퀀스가 남아 있는 한, 컴파일러는 주어진 인터-SID 캐시라인 c에대해 다음의 프로세스를 실행한다.

1) 캐시라인 c의 RD 클래스내의 시퀀스중에서, 컴파일러는 이러한 캐시라인으로부터 필요한 최소 데이터 사이즈를 갖고 있는 시퀀스 s 를 선택한다. 컴파일러는 요구되는 변수를 이미 소유하고 있는 시퀀스로부터 시퀀스 s로 이러한 요구되는 변수를 배송하기 위해 인트라-SID 캐시라인 리소스의 최소량을 사용하는 경로 p (또는 다수의 경로의 조합)을 (함수 P를 사용하여) 선택한다. 경로 p가 하나 보다 홉(hop)을 트래버싱한다면 이러한 경로를 따른 다수의 인트라-SID 캐시라인을 통한 리소스가 고려되어야 한다는 것에 주목해야 한다.

2) 아무런 적합한 p가 발견되지 않았다면, 단계(368)을 종료한다.

3) 적합한 경로 p가 발견되었다면, 컴파일러는 클래스 RD로부터 시퀀스 s를 제거하고 이것을 클래스 PL에 추가한다.

4) 컴파일러는 시퀀스 s에 의해 요구되는 캐시라인 c의 인터-SID 변수를 전송하기 위해 인트라-SID 캐시라인의 사용을 제공(할당)한다. 컴파일러는 새롭게 할당된 리소스로 인해 가능한 경로내의 가능한 변화를 반영하기 위해 함수 P를 리프레싱한다.

이러한 스테이지에서, 컴파일러는 보통 클래스 RD 내의 시퀀스의 일부에 인트라-SID 통신 리소스를 제공하였고, 이에 따라, 이들을 클래스 PL로 이동시켰다. 클래스 RD에 남아 있는 시퀀스에 대해, 컴파일러는 필요한 인터-SID 변수를 제공하기 위한 사용가능한 리소스를 가진 경로를 발견하는데 성공하지 않았다.

이제 컴파일러는 리셔플링 단계(372)에서, 클래스 RD 및 FD내의 시퀀스를 리셔플링한다. 이러한 단계에서, 컴파일러는 (남아 있다면) RD 및 FD 클래스내의 모든 시퀀스를 클래스 U로 이동시킨다. 컴파일러는 빔 체크 단계(376)에서 클래스 U가 비어 있는지를 체크한다. 클래스 U에남아 있는 시퀀스가 있다면 방법은 상기 단계 364로 루프 백하고, 컴파일러는 현 미결정된 시퀀스를 결정하려고 계속 시도한다. 클래스 U가 비어 있다면, 모든 시퀀스는 클래스 ML, SL 또는 PL로 분류되고, 방법은 종료 단계(380)에서 종료한다. 클래스 ML 및 SL내의 각 시퀀스는 디바이스 메모리로부터 인터-SID 캐시라인을 개별적으로 로딩할 것이다.

클래스 PL내의 각 시퀀스는 하나 이상의 인트라-SID 캐시라인의 사전정의되고 사전커밋팅된 경로를 통해 다른 시퀀스로부터, 필요한 인터-SID 변수를 수신할 것이다. 따라서, 이러한 기술을 사용할 때, 디바이스 메모리(56)로부터의 인터-SID 캐시라인 로드 동작의 수는 감소되고, 전체 SID 실행 시간은 이에 따라 감소된다.

디펜던시 문제 적용예

여기에 기술된 방법 및 시스템은 광범위한 분야의 디펜던시 문제를 해결하는데 사용될 수 있다. 일반적으로, 실행 디펜던시를 갖고 있는 프로세싱 엘리먼트(PE)의 세트로 표현될 수 있는 임의의 컴퓨팅 태스크는 개시된 기술을 사용하여 효율적으로 병렬화될 수 있고 실행될 수 있다. 이어지는 설명은 디펜던시 문제의 다수의 타입예의 아웃라인이다. 개시된 기술은 그러나, 이러한 실시예에 제한되지 않고, 임의의 다른 적합한 타입의 디펜던시 문제를 해결하는데 사용될 수 있다.

일부 실시예에서, 시스템(20)에 의해 해결된 디펜던시 문제는 시뮬레이션에 의해 하드웨어 설계를 검증하는 태스크를 포함한다. 이러한 적용은 상술된 PCT 출원 PCT/IL2009/000330에 기술되어 있다. 전형적인 설계 검증 적용에서, 도 1의 서버(24)는 사용자, 예를 들어, 검증 엔지니어로부터 시뮬레이팅될 설계의 정의를 수용한다. 이러한 설계는 보통 VHDL 또는 Verilog와 같은 하드웨어 디스크립션 랭귀지(HDL)로 기록된 하나 이상의 파일로서 수용된다. 이러한 서버는 또한 설계의 검증 환경을 특정하는 테스트-벤치 정의를 수용한다. 이러한 테스트-벤치는 설계에 적용될 외부의 비동기 이벤트(예를 들어, 클록 신호, 리셋 신호 및 다양한 입력)를 특정한다. 이러한 테스트-벤치는 또한 시뮬레이팅된 설계에 적용될 테스트를 특정한다. 이러한 테스트 벤치는 보통 C, Verilog 또는 E 또는 System-Verilog와 같은 검증-특정 랭귀지로 기록된 소프트웨어를 포함한다.

CPU(28)에서 동작하는 컴파일러는 시뮬레이션 코드를 산출하기 위해 테스트-벤치 및 설계를 컴파일링한 후, 이러한 시뮬레이션 코드를 CPU(28) 및 GPU(32)에서 실행한다. 특히, 컴파일러는 설계 및 테스트-벤치를 PE 및 디펜던시를 갖고 있는 디펜던시 그래프로 표현하고, 이러한 디펜던시 그래프로부터 비순환 서브그래프를 추출하고, 이러한 서브-그래프에 대해 SID를 생성한다. 그다음, GPU는 상이한 SID를 실행하도록 작동되어 시뮬레이션 결과를 산출한다. 이러한 시뮬레이션 (예를 들어, 어느 테스트가 통과하였는지 및 실패하였는지에 대한 보고서, 예측되는 오류, 오류 위치 및/또는 설계를 검증하는데 사용자를 도울 수 있는 임의의 다른 정보)가 사용자에게 제공된다.

대안으로, 여기에 기술된 방법 및 시스템은 실시간 비디오 처리, 이미지 처리, 소프트웨어-디파인드 라디오(SDR), 다양한 통신 애플리케이션에서의 패킷 처리 및 에러 보정 코딩과 같은 애플리케이션에서 만나는 컴퓨팅 태스크를 수행하는데 사용될 수 있다. 이러한 애플리케이션 모두는 보통 예를 들어, 디지털 필터링 및 고속 푸리에 변환(FFT) 계산과 같은 디펜던시 문제로서 펴현도리 수 있는 복잡한 컴퓨팅 태스크를 수반한다. 이러한 태스크는 여기에 설명된 방법 및 시스템을 사용하여 병렬화 및 해결에 자연적으로 자체를 렌딩한다. 디펜던시 그래프를 사용하여 디지털 필터 및 FFT 컴퓨팅 엘리먼트를 표현하는 특정 예가 아래의 도 18 및 도 19에 도시되어 있다. 일단 주어진 컴퓨팅 태스크(예를 들어, 여기에 주어진 예 또는 임의의 다른 태스크)가 디펜던시 그래프로서 표현되면, 이러한 태스크는 여기에 설명된 방법 및 시스템을 사용하여 병렬화될 수 있고 해결될 수 있다. 상술된 바와 같이, 디펜던시 그래프는 서브-그래프의 세트로 변환될 수 있고, 각 서브-그래프는 SID를 산출하도록 컴파일링되고 GPU는 이러한 SID를 실행하여 결과를 산출한다.

도 18은 본 발명의 실시예에 따른, 유한 임펄스 응답(FIR) 디지털 필터를 나타내는 디펜던시 그래프(400)를 대략적으로 도시하는 도면이다. 그래프(400)에 의해 표현된 디지털 필터는 a₀,...a_N-1로 표시된 필터 계수의 세트 N에 의해 입력 신호 x[n]을 필터링하여, 필터링된 출력 신호 y[n]을 산출한다. 이러한 필터 동작은

에 의해 주어진다.

이러한 종류의 FIR 필터는 통신 송수신기, 이미지 처리 애플리케이션 및 의료 이미징 애플리케이션과 같은, 많은 신호 처리 애플리케이션에서 공통이다.

그래프(400)는 공통 클록 신호, 멀티플라이어 PE(414) 및 가산기 PE(418)에 동기화되는 다수개의 타입의 PE, 예를 들어, 플립플롭 PE(410)를 포함한다. 실행 디펜던시는 도면에서 화살표로서 도시되어 있다. 예를 들어, 주어진 클록 사이클에서, 주어진 멀티플라이어 PE(414)는 주어진 플립 PE가 실행을 종료하고 그 출력이 유효한 후에만, 주어진 플립플롭 PE(410)의 출력을 상응하는 필터 계수에 의해 승산할 수 있다. 무한 임펄스 응답(IIR) 필터와 같은 다른 종류의 디지털 필터가 또한 유사한 방식으로 디펜던시 그래프로서 표현될 수 있다.

도 19는 본 발명의 실시예에 따른, 고속 푸리에 변환(FFT) 컴퓨팅 엘리먼트를 표현하는 디펜던시 그래프(420)를 대략적으로 도시하는 도면이다. 당업계에 주지된 바와 같이, FFT 계산은 때로 "버터플라이"로 불리는 기본적인 컴퓨팅 엘리먼트에 의해 효율적으로 실행될 수 있다. 디펜던시 그래프(420)는 단일 컴퓨팅 엘리먼트를 표표현한다. 전형적인 FFT 애플리케이션에서, 이러한 다수의 엘리먼트는 직렬로 및/또는 병렬로 연결되어 있다. 디펜던시 그래프(420)는 가산기/승산기 PE(424)를포함한다. 각 PE(424)는 2개의 입력을 수용한다. 특정 PE 입력이 웨이트 W_N ^K로 마크될 때, PE는 입력을 웨이트에 의해 승산한 후에 이것을 다른 입력에 가산한다. 예를 들어, 도면의 좌측상단에 있는 PE는 v[0]+v[1]ㆍW₄₀에 의해 주어진 출력을 산출한다. W_N ^K는 W_N ^K=e^(i2πK/N)에 의해 주어진다. N=4의 전형적인 구현에서, 웨이트는 W₄ ⁰=1, W₄ ¹=i, W₄ ²=-1 및 W₄ ³=-i에 의해 주어진다. 대안으로, 임의의 다른 적합한 웨이트값이 사용될 수 있다. 이러한 종류의 FFT 컴퓨팅 엘리먼트는 주파수 도메인 신호 처리 및 에러 보정 코딩(ECC)과 같은 광범위한 애플리케이션에서 공통이다.

추가 실시예 및 변형

일부 실시예에서, 컴파일러는 PE를 PEG로 머징 시도하는 프로세스를 적용한다. 이러한 프로세스의 출력은 (PEG를 표현하는) 베티클 및 (인터-PEG 디펜던시를 표현하는) 에지를 포함하는 그래프이다. 이러한 프로세스는 보통 인터-PEG 디펜던시의 수를 최소화하는 방법으로 PE를 PEG로 그룹화하려고 시도한다. 이러한 종류의 그룹화에 의해 보통 보다 적은 인터-시퀀스 SYNC를 갖는 SID를 결과로 얻는다. 머징 프로세스의 예가 상술된 미국 특허 가출원 61/110,676의 섹션 5.5.1에 기술되어 있다.

일부 실시예에서, 컴파일러는 PE 실행 시간을 따라 진행하면서 SID를 반복적으로 구축하도록 시도한다. 이러한 프로세스에서, 컴파일러는 긴 포워드 페이즈(FP)를 갖는 PE를 먼저 배치하고, 이들을 보다 덜 팝풀레이팅된 실행 시퀀스에 배치한다. 또한, 컴파일러는 SYNC의 추가를 필요로 하지 않는 시퀀스에 PE를 배치하는 것에 보다 높은 우선순위를 준다. SID 생성 프로세스의 예가 상술된 미국 특허 가출원 61/110,676의 섹션 6.3.6에 기술되어 있다. 일반적으로, 컴파일러는 PE의 FP 길이, 실행 시퀀스의 점유 레벨 및/또는 SYNC의 가능한 추가를 고려하는 임의의 다른 기준 또는 체험에 기초하여 실행 시퀀스에 PE를 배치할 수 있다.

일부 실시예에서, CPU 및 GPU는 조합하여, 디펜던시 문제를 시뮬레이팅하는 이벤드 구동(EDE) 시뮬레이터를 실행한다. 이벤트 구동 동작은 예를 들어, 상술된 미국 특허 가출원 61/086,461의 섹션 6.8에 그리고 상술된 미국 특허 가출원 61/086,803의 섹션 5.1-5.3에 기술되어 있다. 특히, 컴파일러는 특정 SID를 실행하는 것이 CPU에 실행되는 시뮬레이션의 순시 개신을 위해 필요조건에서 다른 SID의 실행을 트리거링하는 경우를 식별할 수 있다. 이러한 체계는 GPU와 CPU 사이의 인터랙션의 레이턴시를 세이브한다. 이러한 기술은 예를 들어, 상술된 미국 특허 가출원 61/086,803의 섹션 5.2.1에 기술되어 있다.

다수의 클록-셋-리셋 로직의 병렬 실행

일부 하드웨어 설계는 각각 상이한 상이한 각각의 신호에 의해 트리거되는, 광대한 수의 비교적 작은 로직 섹션을 특징으로 한다. 예를 들어, 이러한 설계는 전체 설계의 각 작은 섹션을 각각 트리거하는, 광대한 수의 클록 신호를 포함할 수 있다. 다른 예로서, 플립플롭을 사용하는 설계에서, 셋 및 리셋 신호는 보통 상이한 로직 섹션을 트리거한다. 많은 실제의 경우에, 각 개별적인 로직 섹션은 병렬화에 제한되어 있고 단독으로 GPU(32)의 병렬 처리 기능을 이용하는 것과는 거리가 있다.

일부 실시예에서, CPU(28)에 의해 실행되는 컴파일레이션 처리는 광대한 수의 로직 섹션을 병렬로 실행하는 고도의 병렬 SID(90)를 산출한다. 상술된 바와 같이, 각 섹션은 각 신호, 예를 들어, 클록, 셋 또는 리셋 신호에 의해 트리거된다.

일반적으로, SID(90)에서의 병렬은 주어진 시퀀스에서 병렬로 실행하는 임의의 요구되는 수의 실행 시퀀스(98) 및/또는 임의의 요구되는 수의 PE(76)를 사용하여 구현될 수 있다. 여기에 설명된 실시예는 다수의 로직 섹션이 단일 실행 시퀀스로 컴파일링되는 구현예에 초점을 맞추고 있다.

한편, 이러한 종류의 SID 생성에 의해 GPU의 병렬 처리 기능을 보다 더 잘 이용할 수 있다. 다른 한편, 설계의 참 기능을 유지하기 위해, 각 섹션에 상응하는 로직은 그 트리거링 신호가 실제 발생된 경우에만 실행되어야 한다.

따라서, 일부 실시예에서, CPU(28)는 트리거링 신호가 발생된 로직 섹션에 상응하는 로직만을 선택적으로 실행하는, 보조 PE로 불리는, 하나 이상의 추가 PE를 실행 시퀀스로 컴파일링한다. 특정 로직 섹션이 그 트리거링 신호가 발생되지 않았기 때문에, 실행되지 않아야 한다면, 보조 로직은 해당 로직 섹션의 현 상태를 유지한다.

예를 들어, LC1 및 LC2로 표시되는 2개의 로직 클라우드를 시뮬레이팅하는 PE를 포함하는 실행 시퀀스를 생각해보자. 이러한 예에서, LC1은 클록 신호 CLK1의 상승 에지에서 플립플롭 FF1에 의해 샘플링되어 있고, LC2는 다른 클록 신호 CLF2의 상승 에지에서 플립플롭 FF2에 의해 샘플링되어 있다. 컴파일러는 CLK1 및/또는 CLK2의 상승 에지에서 실행될 이러한 실행 시퀀스를 정의한다. CLK1 만이 상승한다면, 보조 로직은 FF2에 대해 정확한 값을 유지해야 한다. 하나의 가능한 구현은 FF2의 이전의 값을 다시 샘플링하는 것이다. CLK2만이 상승한다면, FF1의 현 상태는 유사한 방식으로 유지된다.

(일부 실시예에서, 특정 로직 섹션의 실행을 금하는 것은 반드시 보다 적은 로직일 필요는 없고, 추가 로직의 실행을 수반한다는 것에 유의해야 한다. 예를 들어, 실행 금지가 FF의 이전의 값을 샘플링함으로써 구현될 때, 이러한 샘플링은 추가 로직을 수반할 수 있다.)

대안의 실시예에서, 각 실행 시퀀스는 각 로직 섹션에 상응하고, 이러한 로직 섹션의 트리거링 신호(예를 들어, 클록, 셋 및/또는 리셋 신호)가 어써팅되는지 여부를 체크하는 보조 PE로 시작한다. 어써팅된다면, 보조 PE는 이러한 시퀀스의 실행을 가능하게 한다. 그렇지 않으면, 보조 PE는 이러한 시퀀스의 실행을 금한다.

동일한 실행 시퀀스 내의 다수의 로직 섹션을 결합하는 실시예는 보통 많은 로직 섹션이 동시에 실행될 가능성이 높은 시나리오에서 바람직하다. 별개의 실행 시퀀스에 각 로직 섹션을 맵핑하는 실시예는 보통 소수의 로직 섹션만이 동시에 실행되는 활동성이 낮은 시나리오에서 잘 실행된다.

상기 설명은 플립플롭 회로와 같은, 샘플링을 수반하는 로직을 주로 언급하였다. 이러한 로직은 보통 3개의 단계-샘플림 전의 로직의 계산 단계, 트리거링 신호에 응답하여 샘플링하는 단계 및 가시 신호의 생성으로 나누어진다. 이러한 종류의 로직에서, 로직으로의 입력 신호와 트리거링 신호(예를 들어, 클록, 셋 또는 리셋)를 구별한다. 개시된 기술은 또한 출력에서의 가시 신호가 입력으로부터 즉시 산출될 때 결합 로직 및 다른 타입의 로직을 시뮬레이팅하도록 사용될 수 있다. 이러한 종류의 로직에서, 각 입력 신호는 또한 트리거링 신호로서 간주된다.

도 20은 본 발명의 실시예에따른 다수의 클록-셋-리셋 로직의 병렬 실행을 위한 상술된 체계를 개략적으로 설명하는 도면이다. 이러한 예에서, 시뮬레이팅될 오리지널 설계는 역시 로직 클라우드로도 불리는 다수의 로직 섹션(430A...430E)을 포함한다. 로직 섹션(430A...430E)은 각 트리거링 신호(434A...434E)에 의해 트리거된다. (설명을 위해, 본 예는 입력 신호가 트리거링 신호로도 간주되는 결합 로직과 보다 더 관련되어 있다. 플립플롭 또는 다른 샘플링 로직에서, 트리거링 신호는 플립플롭에 영향을 주는 신호, 예를 들어, 클록, 셋 또는 리셋 신호이다.)

컴파일레이션 처리의 일부로서, CPU(28)에서 실시되는 컴파일러는 섹션(430A...430E)의 기능을 결합하는 결합 로직 클라우드(438)를 생성한다. 결합된 클라우드는 다수의 트리거링 신호(434A...434E)를 입력으로서 수신한다.

컴파일러는 결합 클라우드(438)를, 하나 이상의 실행 시퀀스(446)을 포함하는 SID(442)로 전환한다. 하나의 실시예에서, SID는 다양한 트리거링 신호를 입력으로서 수용하는 단일 실행 시퀀스를 포함한다. SID가 런타임에 작동될 때, 보조 로직이 트리거링 신호를 체크한다. 특정 로직 섹션에 상응하는 트리거링 신호가 어써팅된다면, 보조 로직은 이러한 로직 섹션에 상응하는 PE의 실행을 가능하게 한다. 그렇지 않으면, 보조 로직은 이러한 PE의 실행을 금지한다.

대안의 실시예에서, SID는 각 로직 섹션 당 하나씩 다수의 실행 시퀀스(446)를 포함한다. 이러한 각 실행 시퀀스는 보조 PE(450)으로 시작하고, 이어서 하나 이상의 PE 그룹(PEG)(454)가 이어진다. SID가 런타임에 작동될 때, 주어진 실행 시퀀의 보조 PE는 이러한 시퀀스 내의 PE를 구동하는 트리거링 신호중 어느 하나가 어써팅되는지 여부를 체크한다. 어써팅된다면, 보조 PE는 이러한 시퀀스의 실행을 가능하게 한다. 그렇지 않으면, 보조 PE는 이러한 시퀀스의 실행을 금지한다. 보통 각 보조 PE는 다른 보조 PE와 관계없이 동작한다. 즉, 이네이블/금지 판정은 각 실행 시퀀스에 대해 독립적으로 취해진다.

상기 구성을 사용할 때, SID(442)는 고도로 병렬화되어서 개별적인 로직 섹션(클라우드(430A...430E))이 병렬성을 거의 또는 전혀 갖고 있지 않다 하더라도 GPU의 병렬 처리 기능을 활용한다.

CPU와 GPU 사이의 PE 실행의 분할

보통, CPU(28)와 GPU(320는 일반적으로 이들의 병령 실행 기능 및 처리력에서 서로 상이하다. GPU는 보통 고도의 병렬 태스크를 실행하는데 있어 CPU를 능가한다. 하지만, 태스크가 병렬성을 거의 또는 전혀 갖고 있지 않을 때, GPU의 이론적인 처리력을 활용하는 것이 불가능할 수 있는데, 이러한 경우에, CPU는 GPU를 능가할 수 있다.

일부의 경우에, 컴파일레이션 시간에, CPU(28) 내의 컴파일러는 이러한 설계(또는 다른 디펜던시 문제)를 GPU가 CPU를 능가할 것으로 예측되는 높은 병렬 페이즈, 및 CPU가 GPU를 능가할 것으로 예측되는 낮은 병렬 페이즈로 분할한다. 그 다음, 컴파일러는 GPU에 의한 높은 병렬 페이즈 및 CPU에 의한 낮은 병렬 페이즈를 실행하도록 적합한 SID를 생성한다.

도 21은 본 발명의 실시예에 따른, 디펜던시 문제의 실행 그래프(458)를 개략적으로 설명하는 도면이다. 그래프(458)는 다수의 PE(76)와 이러한 PE 사이의 실행 디펜던시(80)를 포함하고 있다. 도면에서 볼 수 있는 바와 같이, 그래프(458)는 3개의 연속 페이즈(462A...462C)로 나눌 수 있다.

페이즈(462A, 462C)는 하나 또는 소수의 PE(76)만이 병렬로 실행되는 낮은 병렬 페이즈이다. 페이즈(462B)는 비교적 많은 수의 PE가 병렬로 실행되어야 하는 높은 병렬 페이즈이다. 본 예에서 그리고, 많은 실제 시나리오에서) 낮은 병렬 페이즈는 실행 그래프의 시작 및/또는 끝에서 발생한다. 그러나, 일반적으로, 개시된 기술은 실행 그래프에서 임의의 적합한 위치에서 발생할 수 있는, 임의의 적합한 수의 낮은 병렬 페이즈 및 높은 병렬 페이즈와 함께 사용될 수 있다.

다양한 페이즈에서의 PE 병렬의 레벨에 기초하여, 페이즈(462A, 462C)에서, CPU는 GPU를 능가할 것으로 예측되고, 페이즈(462B)에서, GPU는 CPU를 능가할 것으로 예측된다. 일부 실시예에서, 컴파일러는 실행 그래프를 이러한 낮은 병렬 페이즈 및 높은 병렬 페이즈로 분할하고, CPU(28)에 의한 실행을 위해 낮은 병렬 페이즈를 할당하고, GPU(32)에 의한 실행을 위해 높은 병렬 페이즈를 할당한다.

도 22는 본 발명의 실시예에 따른, CPU(28)와 GPU(32) 사이의 실행 그래프를 분할하기 위한 방법을 개략적으로 설명하는 순서도이다. 이러한 방법은 보통 CPU(28)에 의해 컴파일레이션 시간에 수행된다.

이러한 방법은 CPU 및 GPU에 적합한 병렬 레벨을 정의하는 컴파일러로 시작한다. 실시예에서, 이러한 정의는 CPU가 여전히 GPU를 능가할 것으로 예측되는 병렬 PE의 최대수 및 GPU가 CPU를 능가할 것으로 예측되는 병렬 PE의 최소수를 명시한다. 대안으로, 다른 적합한 정의 또는 기준이 사용될 수 있다.

그다음, 컴파일러는 상기 정의를 사용하여, 그래프 분할 단계(474)에서, 실행 그래프를 (CPU가 능가할 것으로 예측되는 낮은 병렬 페이즈 및 (GPU가 능가할 것으로 예측되는) 높은 병렬 페이즈로 나눈다. 이러한 컴파일러는 낮은 병렬과 높은 병렬 페이즈 사이의 경계를 선택하기 위한 임의의 적합한 기준을 사용할 수 있다.

컴파일러는 SID 생성 단계(478)에서, 실행 그래프의 각 페이즈를 각 SID로 전환한다. 상술된 방법와 같은 임의의 적합한 SID 생성 방법이 사용될 수 있다. 낮은 병렬 페이즈를 시뮬레이팅하는 SID가 CPU(그리고 CPU SID로 부른다)에 의한 실행을 위해 할당된다. 높은 병렬 페이즈를 시뮬레이팅하는 SID는 GPU(그리고 GPU SID로 부른다)에 의한 실행을 위해 할당된다.

상기 도 21의 예에서, 페이즈(462A)는 CPU SID로 전환되고, 페이즈(462B)는 462A의 CPU SID가 실행을 완료한 후에 작동되는 GPU SID로 전환되고, 페이즈(462C)는 462B의 GPU SID가 실행을 완료한 후에 작동되는 CPU SID로 전환된다. 일반적으로, 컴파일러는 임의의 적합한 수의 인터리빙된 CPU 및 GPU SIDs를 생성할 수 있다.

보통, 컴파일러는 후속 SID의 경계에서 데이터 동기화를 유지한다. 데이터 동기화는 하나의 SID에 의해 생성된 신호가 시퀀스 내의 그 다음 SID에, 작동될 때에 사용가능하게 된다는 것을 의미한다.

실행을 다수의 GPU 작동으로 분할함으로써 실행 시퀀스 사이를 동기화하기

도 4 및 도 6과 같은, 상술된 실시예의 일부에서, 컴파일러는 전용 SYNC PE를 시퀀스에 삽입함으로써 상이한 실행 시퀀스 사이의 동기화를 달성하였다. SYNC PE는 보통 다른 실행 시퀀스가 임의의 사전정의된 실행 스테이지에 도달할 때까지 그 실행 시퀀스를 중지한다.

그러나, 일부 GPU 또는 다른 멀티프로세서 장치에서, SYNC PE는 상당한 오버헤드를 유발하고 처리력 측면에서 고비용이다. 대안의 실시예에서, 컴파일러는 실행 시퀀스를 다수의 GPU 작동으로 분할함으로써 실행 시퀀스 사이에 요구되는 동기화를 강제로 실현한다. 이어지는 설명에서, 이러한 작동은 또한 페이즈로도 부르고, 이러한 2개의 용어는 때로 상호교환하여 사용된다. 이러한 솔루션의 다른 장점은, SYNC PE를 사용할 때, 실행 시퀀스의 수는 GPU(32)가 동시에 시행할 수 있는 스레드 블록의 수를 초과하지 않는다는 것이다. 다수의 GPU 작동으로 분할함으로써 얻어지는 동기화는 이러한 제약을 제거한다.

도 23은 본 발명의 실시예에 따른, 다수의 GPU 작동으로 분할된 실행 시퀀스를 개략적으로 설명하는 도면이다. 이러한 예에서, 컴파일러는 실행 시퀀스를 GPU(32)의 5개의 연속 작동(484)으로 분리한다. 런타임에, 각 작동에서, GPU(32)는 하나 이상의 SID(480)를 실행한다.일부 실시예에서, 각 SID(480)가 단일 시퀀스의 PEG를 포함하지만 이에 제한되는 것은 아니다. 오히려, 대안으로, SID는 다수의 PEG 시퀀스를 포함할 수 있다.

(용어 "GPU 작동"은 GPU(32)가 각 개별적인 작동에 대해 별개로 CPU(28)에 의해 작동되는 것을 의미하는 것은 아니다. 보통, CPU(28)는 도 23에 도시된 전체 세트의 작동(484)으로 GPU(32)를 작동하고, GPU는 이러한 작동을 스케줄링하고 이들의 사이에 데이터 동기화를 유지하는 기능을 갖고 있다.)

GPU 제어하에, 각 GPU 작동(484)은 그 다음 작동이 시작하기 전에 전부 실행된다. 따라서, 주어진 작동 내의 모든 SID는 GPU가 그 다음 작동의 임의의 SID를 실행하기 시작하기 전에 실행을 완료하고 출력을 산출하도록 보장받는다. 따라서, GPU(32)의 작동 메커니즘을 사용함으로써, 컴파일러는 상이한 실행 시퀀스 사이를 강제 동기시키는 것이 가능하다.

예를 들어, PE2가 PE1의 출력에 의존하지만 이들 2개의 PE는 상이한 실행 시퀀스에 속해 있다고 가정해보자. 이러한 의존성을 보존하기위해, 컴파일러는 하나의 GPU 작동에 PE1을 배치하고 후속 GPU 작동에 PE2를 배치함으로써 강제 동기화할 수 있다. 일부 GPU 또는 다른 멀티프로세서장치에서, 다수의 작동에 의해 발생된 오버헤드는 SYNC PE에 의해 발생된 오버헤드 보다 작다. 이러한 경우에, 도 23의 기술이 바람직할 수 있다.

실행 시퀀스를 페이즈로 분할하는 기준

실행 시퀀스를 페이즈(작동)로 분할하기 위한 다른 동기는 실행 시퀀스의 분필요한 실행을 피하기 위함이다. 아래에서 상세하게 설명되는 바와 같이, 컴파일러는 실행 시퀀스에 불필요한 실행을 금지하는 로직을 삽입할 수 있다.

이러한 종류의 로직은 예를 들어, 특정 실행 시퀀스로의 입력이 시퀀스의 이전의 실행 이후에 변하지 않았다는 것, 이러한 시퀀스 내의 하류의 소자(예를 들어, 플립플롭)가 트리거되지 않았다는 것, 또는 이러한 시퀀스의 출력이 사용되고 있지 않다는 것을 검출할 수 있다. 이러한 모든 경우에, 실행 시퀀스를 실행하는 것은 아무런 의미가 없다. 컴파일러에 의해 삽입된 로직은 런타임에 이러한 조건을 검출하고 이에 따라 시퀀스의 실행을 금지시킨다. 이러한 메커니즘은 시뮬레이션 런타임을 줄이는데 매우 효과적이다.

실행 시퀀스를 페이즈로 분할하는 것은 이러한 불필요한 실행을 피하는 기능에 상당한 영향을 준다. 예를 들어, 짧은 페이즈(즉, SID 당 짧은 실행 시퀀스)는 상기 조건을 충족할 보다 나은 기회를 갖고 되어서 불필요한 실행을 피하는 기능을 강화시킨다. 다른 한편으로는, 짧은 페이즈는 이들이 GPU 작동의 수를 증가시키기 대문에 보다 많은 처리 오버헤드를 유발한다. 일부 실시예에서, 컴파일러는 불필요한 실행을 피하는 것과 작동 오버헤드를 감소시키는 것 사이의 적합한 균형을 유지하면서 이러한 실행 시퀀스를 페이즈로 분할한다.

도 24는 본 발명의 실시예에 따른, 실행 시퀀스를 페이즈로 분할하기 위한 프로세스예를 개략적으로 설명하는 도면이다. 이러한 방법에서, 컴파일러는 디펜던시 그래프에서 "로지컬 콘"을 식별하고, 이들을 사용하여 그래프를 페이즈로 분할한다. "로지컬 콘"은 특정 페이즈(작동)에서 마지막인 ("정점 PE"로 불리는) PE와 이러한 PE를 특정 깊이까지 구동시키는 PE의 그룹으로 정의된다. 각 PE는 콘의 외부(예를 들어, 콘 외부의 PE 또는 CPU)로부터 콘 내의 PE에 의해 수시노딘 입력 신호의 세트로서 정의되는 "베이스"를 갖고 있다.

이러한 개념을 분명히 하기 위해, 도 24는 2개의 페이즈 경계(490, 492) 및 로지컬 콘(488)의 예가 표시된 디펜던시 그래프의 예를 도시하고있다. 로지컬 콘(488)은 (콘 내의 PE의 최장 체인으로서 정의되는) 3의 깊이 및 (로지컬 콘의 외부로부터 수신된 입력 신호의 수로서 정의된) 2의 베이스 크기를 갖고 있다. 대안으로, 임의의 다른 적합한 값이 사용될 수 있다.

시퀀스로의 입력이 마지막 실행 후에 변하지 않았다면 시퀀스의 실행이 금지되는 상술된 메커니즘을 생각해보자. 보통, 큰 베이스 크기를 갖는 로지컬 콘은 작은 베이스 크기를 갖는 로컬 콘과 비교하여, 실행이 금지될 가능성이 더 낮다. 큰 베이스 콘은 보통 광대한 수의 입력을 갖고 있고, 이것은 보통 이들 입력의 어떤 것도 변하지 않을 작은 확률을 의미한다. 작은 베이스 콘은 보다 적은 수의 입력을 갖고 있어서, 입력의 어떤 것도 변하지 않을 확률이 보다 크다.

일부 실시예에서, 컴파일러는 일부 선택 기준에 따라 로지컬 콘을 선택하고, 콘의 베이스에서 페이즈 사이의 경계를 설정한다. 콘 선택 기준은 보통 불필요한 실행을 줄이는 것과 작동 오버헤드 사이에 요구되는 균형을 설정하는 목표를 갖고 있다. 일부 실시예에서, 컴파일러는 사전정의된 최대 베이스 크기를 초과하지 않도록 그리고 사전정의된 최대 깊이를 초과하지 않도록 로지컬 콘을 선택한다. 그러나, 대안으로, 임의의 다른 적합한 선택 기준이 사용될수 있다.

프로세스예에서, 컴파일러는 페이즈 경계(492)로부터 시작한다. 컴파일러는 후속 페이즈에서 처음에 위치된(즉, 경계(492) 바로 다음의), 도 24의 PE(76B)를 처음에 선택한다. PE(76B)는 PE(76A)로부터 단일 입력을 수신한다. 따라서, PE(76B)는 깊이=1 및 베이스=1을 갖는 로지컬 콘으로서 간주된다.

이러한 예에서, 이러한 콘 크기는 아직 최대 콘 크기를 초과하지 않았기 때문에 컴파일러는 콘에 다음 PE(PE(76C))를 추가한다. PE(76C)를 로지컬 콘에 추가하기 위해서는 PE(76D) 역시 추가될 필요가 있다. 다라서, 이러한 단계에서, 로지컬 콘은 PE(76B, 76C, 76D)를 포함한다. 이러한 콘은 깊이=2 및 베이스=2를 갖는다.

이러한 예에서, 이러한 콘 크기는 여전히 최대 콘 크기를 초과하지 않았으므로, 컴파일러는 다은 PE(PE(76E))를 콘에 추가한다. PE(76E)의 추가는 현재의 페이즈에서 PE(76E)를 구동시키는 모든 PE 역시 추가되는 것을 의미한다. 따라서, 이러한 단계에서, 로지컬 콘은 커브(488)에 의해 둘러싸인 모든 콘을 포함한다.

다음 반복에서 컴파일러는 다음 PE(PE(76E)에 의해 구동되는 PE) 및 이러한 PE를 구동시키는 PE를 콘에 추가한다. 마지막 콘은 선택 기준에서 정의된 허용 콘 크기를 초과한다. 따라서, 반복 프로세스는 선택된 콘(488) 및 이러한 콘의 정점으로서 기능하는 PE(76E)로 정지한다. 컴파일러는 PE(76E)에 바로 이어지는 다음 v이스(라인 490)에 대한 경계를 설정한다. 상기 프로세스는 전체 디펜던시 그래프가 페이즈로 분할될 때까지 계속된다.

도 25는 본 발명의 실시예에 따른, 실행 시퀀스를 페이즈로 분할하기 위한 방법을 개략적으로 설명하는 순서도이다. 방법은 기준 정의 단계 500에서, 로지컬 콘에 대한 최대 베이스 크기 최대 깊이를 정의하는 CPU(28) 내의 컴파일러로 시작한다. 컴파일러는 콘 정의 단계 504에서, 디펜던시 그래프를 스캔하고 이러한 그래프를 로자콜 콘으로 분할한다. 컴파일러는 단계(500)의 선택 기준(본 예에서는 최대 베이스 크기 및 최대 깊이)를 충족시키는 방식으로 로지컬 콘을 정의한다. 그다음, 컴파일러는 이러한 그래프를 페이즈 분할 단계 508에서, 로지컬 콘에 기초하여 페이즈로 분할한다.

감도 정보를 사용하여 불필요한 실행 피하기

일부 실시예에서, 각 실행 시퀀스는 실행 시퀀스로의 입력중 임의의 하나가 시퀀스의 이전의 실행 이후에 변경되었는지 여부를 나타내는 표시를 유지하고 있다. 여기에서 감도 정보로 불리는 이러한 표시는 런타임에 변경될 수 있다. 작동될 때, 실행 시퀀스는 현 감도 정보를 체크한다. 이러한 시퀀스로의 입력의 하나 이상이 이전의 실행 이후에 변경되었다는 것을 감도 정보가 나타낸다면, 실행 시퀀스는 실행된다. 그렇지않다면, 실행 시퀀스는 금지된다.

런타임에서의 감도 정보의 갱신은 다양한 방법으로 수행될 수 있다. 일부 실시예에서, 실행 시퀀스가 작동될 때, GPU는 시퀀스로의 현 입력을 체크하고, 이들을 이전의 입력값과 비교하고 필요한 대로 시퀀스의 감도 정보를 갱신한다. 대안의 실시예에서, 특정 신호가 변할 때마다, GPU는 이러한 신호를 입력으로서 수용하는 시퀀스 모두의 감도 정보를 갱신한다.

도 26은 본 발명의 실시예에 따른, 감도 정보를 사용하여 불필요한 실행을 피하기 위한 방법을 개략적으로 설명하는 순서도이다. 이러한 방법은 시퀀스 생성 단계 510에서 실행 시퀀스를 생성하는 컴파일러로 시작한다. 삽입 단계 514에서, 컴파일러는 시퀀스로의 입력이 이전의 실행 이후에 변하였는지 여부를 체크하는 보조 PE를 각 실행 시퀀스에 삽입한다.

런타임에서, GPU는 작동 단계 518에서, 작동된 특정 실행 시퀀스를 실행하도록 준비한다. 작동된 시퀀스의 보조 PE에 의해 GPU는 감도 체크 단계 522에서 감도 정보를 체크한다. 시퀀스로의 하나 이상의 입력이 이전의 작동 이후에 변경되었다는 것을 감도 정보가 보인다면, GPU는 실행 단계 526에서 시퀀스를 실행한다. 그렇지 않으면, GPU는 금지 단계 530에서, 시퀀스의 실행을 금지한다.

트리거 정보를 사용하여 불필요한 실행을 피하기

실행 시퀀스의 불필요한 실행을 수반하는 다른 시나리오는 시퀀스를 따른 하류의 시뮬레이팅된 컴포넌트(예를 들어, 플립플롭)가 트리거되지 않을 때 일어나고, 따라서, 시퀀스에서 계산된 로직을 샘플링하지 않을 것이다. 즉, 트리거의 부재시에, 시퀀스의 출력은 입력과 시퀀스에 의해 실행된 처리에 관계없이 변하지 않을 것이다. 따라서, 관심의 엘리먼트가 트리거되지 않는다면 시퀀스를 실행하는 것은 아무런 의미가 없다.

일부 실시예에서, 실행 시퀀스가 작동될 때, 시퀀스(예를 들어, 시퀀스 내의 제1 PE)는 하류의 엘리먼트에 대한 트리거의 존재를 체크한다. 발견되지 않는다면, 시퀀스는 금지된다. 트리거 신호의 존재 또는 부재는 런타임에 결정되고, 따라서 시퀀스를 실행할지에 대한 여부의 선택 역시 런타임에 결정된다.

도 27은 본 발명의 실시예에 따른, 트리거된 엘리먼트를 갖는 실행 시퀀스를 개략적으로 설명하는 도면이다. 본 예는 2개의 실행 시퀀스를 포함한다. 즉 제1 시퀀스는 로직(540A), 이어서 로직(542A)을 포함하고, 이러한 로직(542A)의 출력은 D 플립플롭(FF)(544A)에 입력된다. 제2 시퀀스는 로직(540B), 이어서 로직(542B)를 포함하고, 이러한 로직(542B)의 출력은 D 플립플롭(FF)(544B)에 입력된다. 각 로직 클라우드(540A, 542A, 54B, 542B)는 하나 이상의 PE를 포함할 수 있다. FF(544A, 544B)는 각각 트리거 신호 T1 및 T2에 의해 트리거된다.

일부 실시예에서, 도 27의 실행 시퀀스를 컴파일링할 때, 컴파일러는 보조 PE(보통 실행될 제1 PE)를 각 시퀀스에 삽입한다. 제1 시퀀스의 보조 PE는 트리거 T1이 어써팅되었는지 여부를 체크하도록 구성되어 있다. 이러한 트리거가 어써팅되지 않았다면, 보조 PE는 (T1 이 없다면, 제1 시퀀스를 실행하는 것은 시퀀스 출력에 영향을 주지 않을 것이기 때문에) 시퀀스의 실행을 금지한다. 제2 시퀀스의 보조 PE는 트리거 T2에 대해 유사하게 동작한다.

많은 실제 경우에, 실행 시퀀스(예를 들어, 로직(540A, 542A))는 크고 복잡하고, 그 실행을 피하면 시뮬레이션 효율을 상당히 증가시킬 수 있다. 이벤트 구동된 시뮬레이션 기술과 대조되어, 도 27의 기술은 시퀀스의 하류에서 일어나는 미래의 이벤트에 기초하여 시퀀스를 실행할지 여부를 판단한다.

시퀀스 출력 룩어헤드를 사용하여 불필요한 실행 피하기

실행 시퀀스의 불필요한 실행을 수반하는 또 다른 시나리오는 어떤 이유로 인해 시퀀스 실행이 그 출력에 영향을 주지 않을 때 일어난다. 아래의 도 28은 이러한 하나의 시나리오를 설명한다.

도 28은 본 발명의 실시예에 다른, 멀티플렉싱된 출력을 갖는 실행 시퀀스를 개략적으로 설명하는 도면이다. 이러한 실행 시퀀스는 로직(550), 이어서 로직(554)을 포함하고, 이러한 로직(554)의 출력은 멀티플렉서(MUX)(562)에 입력으로서 제공된다. MUX로의 다른 입력은 로직(558)에 의해 제공된다. SELECT 신호는 MUX 입력의 어느 것이 MUX 출력으로 전송될 것이지를 선택한다. 선택된 MUX 출력은 트리거 신호 T에 의해 트리거되는 D-FF(566)에 제공된다.

이러한 예에서, MUX(562)가 로직(554)의 출력을 FF(566)에 전송하지 않으면 로직(550, 554)을 실행하는 것은 아무런 의미가 없다. 즉, 로직(550)의 입력에서의 신호가 변한다 할지라도, 그리고 FF(566)의 트리거 T가 어써팅된다고 할지라도, MUX(562)가 로직(554)의 출력을 선택하지 않으면, 로직(550, 554)을 실행하는 것이 시퀀스 출력에 영향을 주지 않을 것이다.

일부 실시예에서, 로직(550, 554)는 크고 복잡하고, 로직(558)은 보통이다. 이러한 상황은 예를 들어, 집적회로(IC) 설계의 자동 테스트 패턴 생성(ATPG) 회로에서 일반적이다. 이러한 경우에, 로직(550, 554)의 불필요한 실행을 피하는 잠재적인 성능 이득은 매우 높다.

일부 실시예에서, 도 28의 실행 시퀀스를 컴파일링할 때, 컴파일러는 보조 PE(보통 실행될 제1 PE)를 시퀀스에 삽입한다. 런타임에, 보조 PE는 MUX(562)가 로직(554)의 출력 또는 로직(558)의 출력을 선택하도록 설정되어 있는지 여부를 체크하도록 구성되어 있다. 후자라면, 보조 PE는 로직(550, 554)의 실행을 금지시킨다. 전자라면, 보조 PE는 전체 시퀀스의 실행을 가능하게 한다.

도 28에 도시된 MUX 구현은 순수하게 예로서 선택되어 있다. 대안의 실시예에서, 보조 PE(또는 임의의 다른 로직)는 시퀀스의 실행이 시퀀스 출력에 영향을 줄지를 일반적으로 체크할 수 있다. 영향을 주지 않는다면, 시퀀스 실행은 금지된다. 상기 도 27의 체계와 같이, 도 28의 룩어헤드 체계는 이벤트 구동 시뮬레이션 기술과 극명하게 대조되고, 시뮬레이션 런타임을 줄이는데 매우 효과적이다.

상술된 실시예는 단지 예일 뿐이고 본 발명은 여기에 설명된 것에 제한되지 않는다는 것을 이해할 것이다. 본 발명의 범위는 종래기술에 개시되지 않고 상기 설명을 읽을 때 당업자에게 가능한 수정 및 변형은 물론 여기에 기술된 다양한 특징의 조합 및 부조합 모두를 포함한다.

Claims (34)

1. 실행 디펜던시를 갖고 있는 다수의 프로세싱 엘리먼트(PE)를 포함하는 컴퓨팅 태스크의 정의를 수용하는 단계;
   상기 실행 디펜던시에 의존하여 작동에 PE를 할당하는 것을 포함하여, 멀티프로세서 디바이스의 일련의 2개 이상의 작동에 PE를 배치함으로써, 상기 멀티프로세서 디바이스 상의 동시 실행을 위해 상기 컴퓨팅 태스크를 컴파일링하는 단계;
   상기 컴퓨팅 태스크의 결과를 산출하기 위해, 상기 일련의 2개 이상의 작동을 실행하는 소프트웨어 코드를 시행하도록 상기 멀티프로세서 디바이스를 작동시키는 단계를 포함하는 것을 특징으로 하는 컴퓨팅 방법.
2. 제1항에 있어서, 상기 멀티프로세서 디바이스는 상기 일련의 2개 이상의 작동 내의 후속 작동을 시작하기 전에 이전의 작동을 완료하여, 상기 이전의 작동에서의 PE의 출력이 상기 후속 작동 내의 PE로의 입력으로서 사용가능한 것을 특징으로 하는 컴퓨팅 방법.
3. 제1항에 있어서, 상기 PE를 상기 작동에 할당하는 단계는 제1 PE를 제1 작동에 할당하고, 상기 실행 디펜던시에 따라 상기 제1 PE 이후에 실행될 제2 PE를 상기 일련의 2개 이상의 작동 내의 제1 작동보다 나중인 제2 작동에 할당하는 단계를 포함하는 것을 특징으로 하는 컴퓨팅 방법.
4. 제1항에 있어서, 상기 PE를 상기 작동에 할당하는 단계는 상기 멀티프로세서 디바이스의 작동에 더하여 중앙 처리 장치(CPU)의 하나 이상의 작동을 상기 일련의 2개 이상의 작동 내에 인터리빙하는 단계, 및 상기 PE의 하나 이상을 상기 CPU의 작동에 할당하는 단계를 포함하는 것을 특징으로 하는 컴퓨팅 방법.
5. 제4항에 있어서, 상기 PE를 상기 작동에 할당하는 단계는 상기 멀티프로세서에 의한 실행이 상기 CPU에 의한 실행을 능가할 것으로 예측되는 컴퓨팅 태스크의 제1 부분을 식별하는 단계, 상기 CPU에 의한 실행이 상기 멀티프로세서 디바이스에 의한 실행을 능가할 것으로 예측되는 컴퓨팅 태스크의 제2 부분을 식별하는 단계, 상기 제1 부분을 상기 멀티프로세서 디바이스의 작동에 할당하는 단계, 및 상기 제2 부분을 상기 CPU에 할당하는 단계를 포함하는 것을 특징으로 하는 컴퓨팅 방법.
6. 제4항에 있어서, 상기 PE를 상기 작동에 할당하는 단계는 제1 병렬 레벨을 갖는, 상기 컴퓨팅 태스크의 제1 부분 내의 PE를 상기 멀티프로세서디바이스의 작동에 할당하는 단계, 및 상기 제1 병렬 레벨 보다 낮은 제2 병렬 레벨을 갖는, 상기 컴퓨팅 태스크의 제2 부분 내의 PE를 상기 CPU의 작동에 할당하는 단계를 포함하는 것을 특징으로 하는 컴퓨팅 방법.
7. 제1항에 있어서, 상기 컴퓨팅 태스크를 컴파일링하는 단계는 런타임에 평가되는 조건에 의존하여 조건적으로 실행될 PE의 시퀀스를 정의하는 단계를 포함하고, 상기 PE를 상기 작동에 할당하는 단계는 상기 시퀀스가 실행되지 않을 가능성을 최대화하는 것을 목표로 하는 기준을 평가하는 단계를 포함하는 것을 특징으로 하는 컴퓨팅 방법.
8. 제7항에 있어서, 상기 기준을 평가하는 단계는 상기 컴퓨팅 태스크를 로지컬 콘으로 나누는 단계, 및 상기 로지컬 콘의 각 베이스에서 작동 경계를 설정하는 단계를 포함하고, 각 로지컬 콘은 각 작동에서 마지막인 정점 PE 및 상기 정점 PE가 의존하는 PE의 그룹을 포함하고, 상기 로지컬 콘의 최대 깊이 및 최대 베이스 크기는 상기 가능성에 기초하여 명시되는 것을 특징으로 하는 컴퓨팅 방법.
9. 실행 디펜던시를 갖고 있는 다수의 프로세싱 엘리먼트(PE)를 포함하는 컴퓨팅 태스크의 정의를 수용하도록 구성된 인터페이스;
   상기 실행 디펜던시에 의존하여 작동에 PE를 할당하는 것을 포함하여, 멀티프로세서 디바이스의 일련의 2개 이상의 작동에 PE를 배치함으로써, 상기 멀티프로세서 디바이스 상의 동시 실행을 위해 상기 컴퓨팅 태스크를 컴파일링하도록 구성되고, 상기 컴퓨팅 태스크의 결과를 산출하기 위해, 상기 일련의 2개 이상의 작동을 실행하는 소프트웨어 코드를 시행하도록 상기 멀티프로세서 디바이스를 작동하도록 구성된 프로세서를 포함하는 것을 특징으로 하는 컴퓨팅 장치.
10. 제9항에 있어서, 상기 멀티프로세서 디바이스는 상기 일련의 2개 이상의 작동 내의 후속 작동을 시작하기 전에 이전의 작동을 완료하여, 상기 이전의 작동에서의 PE의 출력이 상기 후속 작동 내의 PE로의 입력으로서 사용가능한 것을 특징으로 하는 컴퓨팅 장치.
11. 제9항에 있어서, 상기 프로세서는 상기 PE를 상기 작동에 할당하는 단계는 제1 PE를 제1 작동에 할당하고, 상기 실행 디펜던시에 따라 상기 제1 PE 이후에 실행될 제2 PE를 상기 일련의 2개 이상의 작동 내의 제1 작동보다 나중인 제2 작동에 할당하도록 구성된 것을 특징으로 하는 컴퓨팅 장치.
12. 제9항에 있어서, 상기 프로세서는 상기 멀티프로세서 디바이스의 작동에 더하여 중앙 처리 장치(CPU)의 하나 이상의 작동을 상기 일련의 2개 이상의 작동 내에 인터리빙하고, 상기 PE의 하나 이상을 상기 CPU의 작동에 할당하도록 구성된 것을 특징으로 하는 컴퓨팅 장치.
13. 제12항에 있어서, 상기 프로세서는 상기 멀티프로세서에 의한 실행이 상기 CPU에 의한 실행을 능가할 것으로 예측되는 컴퓨팅 태스크의 제1 부분을 식별하고, 상기 CPU에 의한 실행이 상기 멀티프로세서 디바이스에 의한 실행을 능가할 것으로 예측되는 컴퓨팅 태스크의 제2 부분을 식별하고, 상기 제1 부분을 상기 멀티프로세서 디바이스의 작동에 할당하고, 및 상기 제2 부분을 상기 CPU에 할당하도록 구성된 것을 특징으로 하는 컴퓨팅 장치.
14. 제12항에 있어서, 상기 프로세서는 제1 병렬 레벨을 갖는, 상기 컴퓨팅 태스크의 제1 부분 내의 PE를 상기 멀티프로세서디바이스의 작동에 할당하고, 상기 제1 병렬 레벨 보다 낮은 제2 병렬 레벨을 갖는, 상기 컴퓨팅 태스크의 제2 부분 내의 PE를 상기 CPU의 작동에 할당하는 단계를 포함하도록 구성된 것을 특징으로 하는 컴퓨팅 장치.
15. 제9항에 있어서, 상기 프로세서는 런타임에 평가되는 조건에 의존하여 조건적으로 실행될 PE의 시퀀스를 정의하고, 상기 시퀀스가 실행되지 않을 가능성을 최대화하는 것을 목표로 하는 기준을 평가함으로써 상기 PE를 상기 작동에 할당하도록 구성된 것을 특징으로 하는 컴퓨팅 장치.
16. 제15항에 있어서, 상기 프로세서는 상기 컴퓨팅 태스크를 로지컬 콘으로 나누고, 상기 로지컬 콘의 각 베이스에서 작동 경계를 설정하도록 구성되고, 각 로지컬 콘은 각 작동에서 마지막인 정점 PE 및 상기 정점 PE가 의존하는 PE의 그룹을 포함하고, 상기 로지컬 콘의 최대 깊이 및 최대 베이스 크기는 상기 가능성에 기초하여 명시되는 것을 특징으로 하는 컴퓨팅 장치.
17. 실행 디펜던시를 갖고 있는 다수의 프로세싱 엘리먼트(PE)를 포함하는 컴퓨팅 태스크의 정의를 수용하는 단계;
    런타임에 조건을 평가하고, 상기 조건에 의존하여, 주어진 실행 시퀀스의 실행을 가능하게 하거나 금지시키는 보조 로직을 상기 주어진 실행 시퀀스에 대해 컴파일링하는 단계를 포함하고, 상기 PE를 다수의 실행 시퀀스에 배치함으로써 멀티프로세서 디바이스 상의 동시 실행을 위해 상기 컴퓨팅 태스크를 컴파일링하는 단계;
    상기 컴퓨팅 태스크의 결과를 산출하기 위해, 상기 실행 시퀀스를 실행하는 소프트웨어 코드를 시행하도록 상기 멀티프로세서 디바이스를 작동시키는 단계를 포함하는 것을 특징으로 하는 컴퓨팅 방법.
18. 제17항에 있어서, 상기 보조 로직을 컴파일링하는 단계는 상기 조건을 평가하고 상기 실행을 가능하게 하거나 금지시키는 보조 PE를 주어진 실행 시퀀스의 시작에 정의하는 단계를 포함하는 것을 특징으로 하는 컴퓨팅 방법.
19. 제17항에 있어서, 상기 조건은 상기 주어진 실행 시퀀스로의 입력이 상기 주어진 실행 시퀀스의 이전의 실행 이후에 변하지 않았다는 것을 식별할 때에 상기 주어진 실행 시퀀스의 실행을 금지시키는 것을 특징으로 하는 컴퓨팅 방법.
20. 제17항에 있어서, 상기 조건은 상기 주어진 실행 시퀀스에서 시뮬레이팅된 컴포넌트의 트리거 신호가 어써팅되지 않았다는 것을 식별할 때에 상기 주어진 실행 시퀀스의 실행을 금지시키는 것을 특징으로 하는 컴퓨팅 방법.
21. 제17항에 있어서, 상기 조건은 상기 주어진 실행 시퀀스의 실행이 상기 주어진 실행 시퀀스의 출력에 영향을 주지 않을 것이라는 것을 식별할 때에 상기 주어진 실행 시퀀스의 실행을 금지시키는 것을 특징으로 하는 컴퓨팅 방법.
22. 실행 디펜던시를 갖고 있는 다수의 프로세싱 엘리먼트(PE)를 포함하는 컴퓨팅 태스크의 정의를 수용하도록 구성된 인터페이스;
    런타임에 조건을 평가하고, 상기 조건에 의존하여, 주어진 실행 시퀀스의 실행을 가능하게 하거나 금지시키는 보조 로직을 상기 주어진 실행 시퀀스에 대해 컴파일링하는 단계를 포함하고, 상기 PE를 다수의 실행 시퀀스에 배치함으로써 멀티프로세서 디바이스 상의 동시 실행을 위해 상기 컴퓨팅 태스크를 컴파일링하도록 구성되고, 상기 컴퓨팅 태스크의 결과를 산출하기 위해, 상기 실행 시퀀스를 실행하는 소프트웨어 코드를 시행하도록 상기 멀티프로세서 디바이스를 작동하도록 구성된 프로세서를 포함하는 것을 특징으로 하는 컴퓨팅 장치.
23. 제22항에 있어서, 상기 프로세서는 상기 조건을 평가하고 상기 실행을 가능하게 하거나 금지시키는 보조 PE를 주어진 실행 시퀀스의 시작에 정의하도록 구성된 것을 특징으로 하는 컴퓨팅 장치.
24. 제22항에 있어서, 상기 조건은 상기 주어진 실행 시퀀스로의 입력이 상기 주어진 실행 시퀀스의 이전의 실행 이후에 변하지 않았다는 것을 식별할 때에 상기 주어진 실행 시퀀스의 실행을 금지시키는 것을 특징으로 하는 컴퓨팅 장치.
25. 제22항에 있어서, 상기 조건은 상기 주어진 실행 시퀀스에서 시뮬레이팅된 컴포넌트의 트리거 신호가 어써팅되지 않았다는 것을 식별할 때에 상기 주어진 실행 시퀀스의 실행을 금지시키는 것을 특징으로 하는 컴퓨팅 장치.
26. 제22항에 있어서, 상기 조건은 상기 주어진 실행 시퀀스의 실행이 상기 주어진 실행 시퀀스의 출력에 영향을 주지 않을 것이라는 것을 식별할 때에 상기 주어진 실행 시퀀스의 실행을 금지시키는 것을 특징으로 하는 컴퓨팅 장치.
27. 트리거링 신호에 의해 트리거된 복수의 로직 섹션을 포함하는 컴퓨팅 태스크의 정의를 수용하는 단계;
    상기 복수의 로직 섹션을 실행하는 결합 로직으로서, 트리거링 신호가 어써팅된 로직 섹션에 상응하는 컴퓨팅 태스크의 일부의 실행을 선택적으로 가능하게 하는 보조 로직을 포함하는 결합 로직을 생성하도록, 마이크로프로세서 디바이스에서의 동시 실행을 위해 상기 컴퓨팅 태스크의 정의를 컴파일링하는 단계; 및
    상기 컴퓨팅 태스크의 결과를 산출하기 위해, 상기 결합 로직을 실행하는 소프트웨어 코드를 시행하도록 상기 멀티프로세서 디바이스를 작동시키는 단계를 포함하는 것을 특징으로 하는 컴퓨팅 방법.
28. 제27항에 있어서, 상기 정의를 컴파일링하는 단계는 트리거링 신호가 어써팅된 로직 섹션에 상응하는 실행 시퀀스 내의 프로세싱 엘리먼트(PE) 만의 실행을 가능하게 하도록 상기 보조 로직을 구성하는 단계를 포함하여, 상기 다수의 로직 섹션을 실행하는 단일 실행 시퀀스를 생성하는 단계를 포함하는 것을 특징으로 하는 컴퓨팅 방법.
29. 제27항에 있어서, 상기 트리거링 신호는 클록 신호, 셋 신호 및 리셋 신호로 구성된 타입의 그룹으로부터 선택된 적어도 하나의 신호 타입을 포함하는 것을 특징으로 하는 컴퓨팅 방법.
30. 제27항에 있어서, 상기 정의를 컴파일링하는 단계는 상기 각 로직 섹션을 실행하는 다수의 실행 시퀀스를 생성하는 단계, 및 상기 각 트리거링 신호에 의존하여 상기 실행 시퀀스의 실행을 선택적으로 가능하게 하는 보조 프로세싱 엘리먼트(PE)를 각 실행 시퀀스에 삽입하는 단계를 포함하는 것을 특징으로 하는 컴퓨팅 방법.
31. 트리거링 신호에 의해 트리거된 복수의 로직 섹션을 포함하는 컴퓨팅 태스크의 정의를 수용하도록 구성된 인터페이스:
    상기 복수의 로직 섹션을 실행하는 결합 로직으로서, 트리거링 신호가 어써팅된 로직 섹션에 상응하는 컴퓨팅 태스크의 일부의 실행을 선택적으로 가능하게 하는 보조 로직을 포함하는 결합 로직을 생성하도록, 마이크로프로세서 디바이스에서의 동시 실행을 위해 상기 컴퓨팅 태스크의 정의를 컴파일링하도록 구성되고, 상기 컴퓨팅 태스크의 결과를 산출하기 위해, 상기 결합 로직을 실행하는 소프트웨어 코드를 시행하도록 상기 멀티프로세서 디바이스를 작동하도록 구성된 중앙 처리 장치(CPU)를 포함하는 것을 특징으로 하는 컴퓨팅 장치.
32. 제31항에 있어서, 상기 CPU는 트리거링 신호가 어써팅된 로직 섹션에 상응하는 실행 시퀀스 내의 프로세싱 엘리먼트(PE) 만의 실행을 가능하게 하도록 상기 보조 로직을 구성하는 단계를 포함하여, 상기 다수의 로직 섹션을 실행하는 단일 실행 시퀀스를 생성하도록 구성된 것을 특징으로 하는 컴퓨팅 장치.
33. 제31항에 있어서, 상기 트리거링 신호는 클록 신호, 셋 신호 및 리셋 신호로 구성된 타입의 그룹으로부터 선택된 적어도 하나의 신호 타입을 포함하는 것을 특징으로 하는 컴퓨팅 장치.
34. 제31항에 있어서, 상기 CPU는 상기 각 로직 섹션을 실행하는 다수의 실행 시퀀스를 생성하고, 상기 각 트리거링 신호에 의존하여 상기 실행 시퀀스의 실행을 선택적으로 가능하게 하는 보조 프로세싱 엘리먼트(PE)를 각 실행 시퀀스에 삽입하도록 구성된 것을 특징으로 하는 컴퓨팅 장치.
    

Images