KR20190044518A

KR20190044518A - 병렬 컴퓨팅

Info

Publication number: KR20190044518A
Application number: KR1020180123864A
Authority: KR
Inventors: 시몬 크리스티안 노우레스
Original assignee: 그래프코어 리미티드
Priority date: 2017-10-20
Filing date: 2018-10-17
Publication date: 2019-04-30
Also published as: KR102168565B1; GB2569270B; GB2569270A; US10585716B2; TWI687818B; GB201717292D0; US20190121678A1; TW201923612A

Abstract

복수의 컴퓨팅 유닛과 상기 컴퓨팅 유닛에 연결된 상호연결을 포함하는 프로세서에 의해 구현되는 컴퓨터 프로그램을 실행하는 방법으로서, 각각의 컴퓨팅 유닛은 프로세싱 유닛과 적어도 2 개의 메모리 포트를 갖는 메모리를 포함하고, 각 포트 상기 메모리의 하나 이상의 각각의 영역에 할당가능하며, 각 컴퓨팅 유닛에서, 상기 방법은, 상기 메모리의 출력 영역에 대한 초기 출력 값 및 입력에 대한 초기 입력 값을 기록하도록 상기 프로그램의 초기 단계를 수행하는 단계; 메모리의 영역; 계산 단계에서, 상기 2 개의 포트 중 하나를 상기 입력 영역 및 상기 출력 영역 모두에 할당하는 단계; 상기 프로세싱 유닛상의 코드 시퀀스들을 실행하여 하나 이상의 새로운 출력 값들의 출력 세트를 계산하고, 상기 출력 세트를 상기 초기 출력 및 초기 입력 값들로부터 계산 된 상기 출력 세트에 기록하는 단계를 포함하며, 계산 단계의 한 포트. 상기 계산 단계가 완료되었을 때, 교환 단계에서, 상기 2 개의 포트 중 제 1 포트를 상기 출력 영역에 할당하고 상기 2 개의 포트 중 제 2 포트를 입력 영역에 할당하는 단계; 및 상기 제 1 포트를 통해 상기 출력 영역으로부터 상기 출력 세트의 새로운 출력 값을 검색하고, 상기 검색된 값을 상기 상호 접속을 통해 다른 컴퓨팅 유닛에 전송하고, 상기 상이한 컴퓨팅에 의해 계산 된 새로운 입력 값을 상기 상호 접속을 통해 수신하는 단계를 포함한다.

Description

병렬 컴퓨팅{PARALLEL COMPUTING}

본 발명은 병렬 컴퓨팅에 관한 발명이다.

병렬 컴퓨팅은 여러 작업들이 병렬 컴퓨터의 여러 프로세싱 유닛들에 의해 동시에 수행되는 계산의 한 형태이다. 병렬 프로그래밍 모델은 병렬 컴퓨터에서 컴파일되고 실행될 병렬 컴퓨터 프로그램을 작성하기 위한 모델이다. 병렬 프로그래밍 모델은 개별 프로세서에서 수행할 작업을 정의하는 방법 외에도 시퀀셜 모델 이상을 지정해야 하며 병렬 프로그래밍 모델은 다음을 지정해야 한다.

·이용가능한 병렬처리(parallelism), 즉 동시에, 때때로 실행될 수 있는 태스크들로 프로그램을 분해.

·동시 태스크들 간의 통신(경로 및 유형).

·프로그램 의미, 즉 인과관계(causuality)를 보존하기 위해 필요한 동기화.

·집단 종료 기준(Collective termination criteria), 예컨대 프로그램이 합의 또는 다수결(majority)로 종료되는지 여부.

병렬 프로그램은 성능을 최적화하기 위해 필수 동기화 정보 이외에 스케줄(부분 실행 순서)을 또한 지정할 수도 있다.

간단하고 널리 사용되는 소프트웨어 병렬 프로그래밍 모델은, "병렬 계산을 위한 브리징 모델"(Leslie G. Valiant, ACM, 33권 8호, 1990년 8월)에 설명된 BSP(Bulk Synchronous Parallel) 모델이다. 도 1은 BSP의 원리에 대한 높은 레벨의 표현을 도시한다. BSP 모델에 부합하는 소프트웨어는 데드락 프리덤(deadlock freedom)을 보장하고 그리고 우선순위(precedence)를 명시적으로 나타낸다. Valiant에 의해 애초에 서술된 BSP 모델에서, 계산은 여러 개의 "슈퍼스텝(supersteps)"으로 진행된다. 슈퍼스텝(102)은 배리어 동기화에 의해 분리된다. 각 슈퍼스텝(102) 동안, 태스크(104)는 독립적이다(즉, 병렬로 실행될 수 있다). 배리어(106)는 모든 태스크가 그 슈퍼스텝에서 실행을 완료했을 때에만 다음 슈퍼스텝을 시작하도록 교차된다. 도 1의 화살표들로 도시된 바와 같이, 태스크들은 메시지를 각 슈퍼스텝 중 언제든지 자신이나 다른 태스크들에 포스팅할 수 있다. (도 1에는 이것이 명시적으로 반영되지는 않음).

그러나 다음 슈퍼스텝이 시작될 때까지 이러한 메시지들은 수신자들에게 보이지 않는다. 각 슈퍼스텝에서, 각 태스크는 이전 슈퍼스텝에서 그 태스크 자체에 의해 생성된 출력 데이터 및/또는 이전 슈퍼스텝에서 다른 태스크에 의해 생성된 출력 데이터에 대해 연산할 수 있다.

일반적으로, 다수의(아마도 매우 많은 수의) 작업들이 각 슈퍼스텝에서 각 프로세서 상에서 실행될 것이다. 즉, 일반적으로, 물리적 프로세서들 보다 더 많은(아마도 훨씬 많은) 태스크들이 존재할 것이다. 각 슈퍼스텝 동안, 각 프로세서는 자신의 로컬 메모리 또는 레지스터의 데이터에 대해 연산을 수행할 수 있는데, 이것은 이전의 슈퍼스텝에서 다른 프로세서로부터 메시지들로서 수신된 데이터(즉, 이전 슈퍼스텝에서 상이한 프로세서들에서 실행되는 태스크들에 의해 생성된 출력 데이터) 및/또는 이전 슈퍼스텝에서 그 프로세서 자체에 의해 산출된 출력 데이터(즉, 이전 슈퍼스텝에서 동일한 프로세서에서 실행되는 태스크에 의해 생성된 출력 데이터)를 포함할 수 있다.

이러한 BSP 모델에 따르면, 슈퍼스텝 당 하나인, 모든 프로세서들의 단일 동기화가 존재하며 그리고 슈퍼스텝은 계산 및 메시지들의 교환 둘다를 포함한다.

병렬 컴퓨팅은 머신 학습의 맥락에서 유용한 어플리케이션을 가지고 있다. 지금까지, 분산형, 클라우드-기반 컴퓨터 시스템에서 BSP를 사용하여 머신 학습 알고리즘을 구현하는데 노력들이 주력되고 있다.

본 발명의 제 1 양상은 컴퓨터 프로그램을 실행하는 방법을 제공하며, 상기 방법은 복수의 계산 유닛들과 상기 계산 유닛들에 연결된 인터커넥트를 포함하는 프로세서에 의해서 구현되며, 각각의 계산 유닛은 프로세싱 유닛 및 적어도 2개의 메모리 포트들을 갖는 메모리를 포함하며, 각각의 메모리 포트는 상기 메모리의 하나 이상의 각 영역들에 할당될 수 있으며, 상기 방법은 각각의 계산 유닛에서, 상기 메모리의 출력 영역에 초기 출력값을 기입하고 상기 메모리의 입력 영역에 초기 입력값을 기입하도록 상기 프로그램의 초기 단계(initial step)를 수행하는 것; 및 상기 프로그램의 후속 단계(subsequent step)를 수행하는 것을 포함하되, 상기 프로그램의 후속 단계를 수행하는 것은, 계산 페이즈(computing phase)에서: 상기 2 개의 메모리 포트들 중 하나의 메모리 포트를 상기 입력 영역과 상기 출력 영역 둘다에 할당하는 것; 하나 이상의 새로운 출력값들의 출력 세트를 계산하도록 상기 프로세싱 유닛 상에서 코드 시퀀스들을 실행하고, 상기 출력 세트를 상기 출력 영역에 기입하는 것, 상기 출력 세트는 상기 초기 출력값 및 초기 입력값으로부터 계산되고, 상기 초기 출력값 및 초기 입력값 각각은 상기 계산 페이즈에서 상기 하나의 메모리 포트를 통해 검색되며; 상기 계산 페이즈가 완료되면 교환 페이즈에서: 상기 2개의 메모리 포트들 중 제 1 메모리 포트를 상기 출력 영역에 할당하고 제 2 메모리 포트를 입력 영역에 할당하는 것; 및 상기 출력 세트의 새로운 출력값을 상기 제 1 메모리 포트를 통해 상기 출력 영역으로부터 검색하고 상기 검색된 값을 상기 인터커넥트를 통해 상이한 계산 유닛으로 전송하고, 그리고 상기 후속 단계에서 상기 상이한 계산 유닛에 의해 계산된 새로운 입력값을 상기 인터커넥트를 통해 수신하고 수신된 값을 상기 제 2 메모리 포트를 통해 상기 입력 영역에 기입하는 것을 포함한다.

교환 페이즈의 시간 효율성은 각 컴퓨팅 유닛(타일)에서 교환 페이즈의 입력 및 출력 영역에 서로 다른 포트들을 할당하여 메시지들이 동시에 송수신될 수 있게함으로써 최대화된다. 하지만, 본 발명의 발명자는 계산 페이즈에서 동일한 포트를 통해 입력 및 출력 영역에 액세스하는 것이 더 시간 효율적이라는 것을 발견했다. 이는 왜냐하면 계산 페이즈의 맥락에서, 새로운 출력 세트를 계산하는데 사용된 이전(earlier) 값들 중 어느 것이 동일한 계산 유닛(즉, 온 타일(on tile))에 의해 계산되었는지 다른 계산 유닛(들)(즉, 오프 타일(off tile))에 의해 계산되었는지가 관련이 없기 때문이며, 따라서 이전의 온 타일 및 오프 타일 값들 모두가 교환 페이즈에서 동일한 포트를 통해 코드 시퀀스들(코드릿들)에 의해서 액세스되는 것이 더 간단하고 더 빠르다. 달리 말하면, 이러한 방식으로 포트 할당을 동적으로 변경함으로써, 교환 페이즈를 완료하는데 걸리는 전체 시간과 계산 페이즈를 완료하는데 걸리는 전체 시간을 감소시킬 수 있다.

일실시예에서, 상기 하나의 포트는 또한 계산 단계에서 제 1 작업공간 영역에 할당될 수 있다. 출력 세트는 컴퓨팅 유닛(이하, "컴퓨팅 유닛" 또는 "계산 유닛" 이라 함)에 로컬(local)(즉, 임의의 다른 컴퓨팅 유닛으로 전송되지는 않지만 문제의 프로세싱 유닛에서만 생성되고 업데이트되는)인 제 1 작업 데이터를 사용하여 계산될 수 있고, 제 1 작업공간 영역에 유지되고 그리고 계산 페이즈에서 상기 하나의 포트를 통해 검색될 수 있다.

2 개의 포트들 중 다른 하나의 포트는 계산 페이즈에서 메모리의 제 2 작업공간 영역에 할당될 수 있다. 출력 세트는 컴퓨팅 유닛에 로컬인 제 2 작업 데이터를 사용하여 계산될 수 있고, 제 2 작업공간 영역에 유지되고 그리고 계산 페이즈에서 상기 다른 하나의 포트를 통해 검색될 수 있다.

또한, 본 발명자는 소정 유형들의 작업 데이터는 상기 동일한 포트 및 입력 및 출력 영역을 통해 보다 효율적으로 액세스될 수 있는 반면에, 다른 유형의 작업 데이터는 다른 '스페어(spare)' 포트를 통해 보다 효율적으로 액세스될 수 있다는 점을 발견하였다. 따라서, 이러한 실시예들은 계산 단계의 효율이 더 증가될 수 있는 메커니즘을 제공한다.

예를 들어, 발명자는 서로 다른 코드릿들 사이의 통신 경로(에지)를 정의하는 작업 데이터는 통신된 데이터 자체와 동일한 포트를 통해 가장 효율적으로 액세스될 수 있음을 인지하였으며 반면에, 출력값들의 새로운 세트를 생성하기 위해 통신된 데이터를 조작하는데 사용되는 데이터는 상기 스페어 포트를 통해 가장 효율적으로 액세스될 수 있음을 인지하였다. 특정 일례는 신경망을 구현하는 프로세서로서, 이하에서 상세히 설명한다.

일 실시예에서, 상기 하나의 포트는 또한 계산 페이즈에서 제 1 작업공간 영역에 할당될 수 있으며, 상기 출력 세트는 상기 계산 유닛에 로컬인 제 1 작업 데이터를 사용하여 계산되고, 상기 제 1 작업공간 영역에 유지되고 그리고 계산 페이즈에서 상기 하나의 포트를 통해 검색된다.

제 1 작업 데이터는 초기 출력값이 유지되는 상기 출력 영역의 제 1 위치 및/또는 초기 입력값이 유지되는 상기 입력 영역의 제 2 위치를 식별할 수 있다.

제 1 작업 데이터는 상기 제 1 위치에 대한 제 1 메모리 포인터 및/또는 상기 제 2 위치에 대한 제 2 메모리 포인터를 포함할 수 있다.

상기 2개의 메모리 포트들 중 다른 하나의 메모리 포트는 상기 계산 페이즈에서 상기 메모리의 제 2 작업공간 영역에 할당되며, 상기 출력 세트는 상기 계산 유닛에 대해 로컬인 제 2 작업 데이터를 이용하여 계산되고, 상기 제 2 작업공간 영역에 유지되며, 그리고 상기 계산 페이즈에서 상기 다른 하나의 메모리 포트를 통해 검색된다.

상기 제 2 작업 데이터는 로컬 값을 포함할 수 있으며, 상기 출력 세트의 적어도 하나의 새로운 출력값은, 상기 로컬 값과 상기 초기 출력값 및/또는 초기 입력값을 입력으로 하는 함수를 평가함으로써 상기 계산 페이즈에서 계산되며, 상기 초기 출력값 및/또는 초기 입력값은 상기 하나의 포트를 통해 검색되고 상기 로컬 값은 상기 다른 하나의 포트를 통해 검색된다.

상기 제 2 작업 데이터는 제 1 및 제 2 로컬 값을 포함할 수 있으며, 그리고 적어도 하나의 새로운 제 1 값은 합산의 비선형 함수(nonlinear function of a summation)로서 계산되며, 상기 합산(summation)은 적어도 상기 제 1 로컬 값과 상기 초기 출력값의 곱(product) 및 상기 제 2 로컬 값과 상기 초기 입력값의 곱(product)이며, 상기 초기값들은 상기 하나의 포트를 통해 검색되고 상기 로컬 값들은 상기 다른 하나의 포트를 통해 검색된다.

새로운 출력값은 상기 출력 영역에서 검색 및 전송되고 그리고 상기 새로운 입력값은 상기 프로세싱 유닛 상에서 하나의 통신 명령을 실행함으로써 상기 입력 영역에 기입될 수 있다.

상기 하나의 통신 명령은, 상기 새로운 출력값이 유지되는 상기 출력 영역의 위치를 식별하는 출력 오퍼랜드 및 상기 수신된 새로운 입력값이 기입되는 상기 입력 영역의 위치를 식별하는 입력 오퍼랜드를 가질 수 있다.

상기 교환 페이즈는 다수의 서브-페이즈들을 차례로 수행함으로써 수행되고, 각각의 서브-페이즈에서, 각각의 계산 유닛은 기껏해야(at most) 하나의 각각의 다른 계산 유닛으로 데이터를 전송하고, 상기 각각의 다른 계산 유닛은 그 서브-페이즈에서 임의의 다른 계산 유닛으로부터 데이터를 수신하지 않으며, 그리고 그 계산 유닛은 상기 교환 페이즈의 임의의 다른 서브-페이즈에서 상기 각각의 다른 계산 유닛으로 데이터를 전송하지 않는다.

상기 서브-페이즈들의 개수는 상기 프로세싱 유닛들의 개수보다 하나 적을 수 있다.

스케줄이 각각의 프로세싱 유닛에서 유지될 수 있으며, 이는 각각의 서브-페이즈에 대해, 상기 각각의 다른 계산 유닛을 식별한다.

상기 스케줄은 라틴 스퀘어(Latin square)의 적어도 일부를 포함할 수 있다.

상기 하나의 통신 명령은 상기 서브-페이즈들 중 하나에서 실행되고 그리고 상기 다른 프로세싱 유닛을 식별하는 임의의 오퍼랜드를 포함하지 않을 수 있다.

각각의 계산 유닛은 개별 대역폭을 가지는 각각의 연결에 의해 인터커넥트에 연결될 수 있으며, 상기 인터커넥트는 적어도 상기 개별 대역폭들의 총합만큼 큰 대역폭을 가질 수 있다.

각각의 프로세싱 유닛은 하나 이상의 제어 레지스터들을 가질 수 있으며, 상기 하나의 메모리 포트는 계산 페이즈 분할 데이터를 상기 제어 레지스터(들) 중 적어도 하나에 기입함으로써, 상기 계산 페이즈에서 상기 입력 및 출력 영역들 둘다에 할당되며, 그리고 상기 제 1 및 제 2 포트는 교환 페이즈 분할 데이터를 상기 제어 레지스터(들) 중 적어도 하나에 기입함으로써, 상기 교환 페이즈에서 상기 출력 및 입력 영역들에 각각 할당된다.

상기 계산 페이즈 분할 데이터는 상기 메모리 내의 단일 어드레스의 형태를 가질 수 있으며, 상기 교환 페이즈 분할 데이터는 상기 메모리 내의 다른 단일 어드레스의 형태를 가질 수 있다.

상기 프로세서는 각각의 계산 유닛에 연결된 동기화 로직을 포함하고, 각각의 계산 유닛에서: 상기 계산 페이즈의 말미에서, 그 계산 유닛은 교환 요청 신호를 상기 동기화 로직으로 발생시킬 수 있으며(instigate), 상기 교환 요청 신호들이 모든 계산 유닛들로부터 수신된 때에만 상기 동기화 로직은 교환 진행 신호를 각각의 계산 유닛으로 발생시킬 수 있다. 그리고 그 계산 유닛은 상기 교환 진행 신호를 수신함에 응답하여 교환 페이즈를 개시할 수 있다.

상기 각각의 계산 유닛에서: 상기 초기 입력값은 상기 초기 단계의 교환 페이즈에서 수신될 수 있으며, 상기 교환 페이즈의 말미에서, 그 계산 유닛은 계산 요청 신호를 상기 동기화 로직으로 발생시키고(instigate)하고, 상기 계산 요청 신호들이 모든 계산 유닛들로부터 수신된 때에만 상기 동기화 로직은 계산 진행 신호를 각각의 계산 유닛으로 발생시킬 수 있으며, 그리고 그 계산 유닛은 상기 계산 진행 신호를 수신함에 응답하여 상기 후속 단계의 계산 페이즈를 개시할 수 있다.

상기 동기화 로직은 전용 동기화 하드웨어일 수 있다.

상기 후속 단계는 차례로 수행되는 다수의 후속 단계들 중 첫번째 후속 단계이고, 상기 다수의 후속 단계들 각각은 그 단계의 계산 페이즈에서 출력 영역에 기입되는 하나 이상의 각각의 새로운 출력값들의 각각의 출력 세트를 계산하고, 그리고 그 단계의 교환 페이즈에서 입력 영역에 기입되는 각각의 새로운 입력값을 수신함으로써 수행되며, 상기 각각의 출력 세트는, 선행 단계의 계산 페이즈에서 상기 출력 영역에 기입되었던 출력값 및/또는 선행 단계의 교환 페이즈에서 상기 입력 영역에 기입되었던 입력값으로부터 계산된다.

각각의 후속 단계에 대해, 상기 로컬 값은 선행 단계의 계산 페이즈에서 상기 출력 영역에 기입되었던 출력값 및/또는 선행 단계의 교환 페이즈에서 상기 입력 영역에 기입되었던 입력값에 기초하여 업데이트되며; 그리고 적어도 하나의 각각의 새로운 출력값은, 그 단계를 위해 업데이트되는 로컬 변수(local variable)와 선행 단계의 계산 페이즈에서 상기 출력 영역에 기입되었던 출력값 및/또는 선행 단계의 교환 페이즈에서 상기 입력 영역에 기입되었던 입력값을 함수의 입력들로 하는 상기 함수를 평가함으로써, 각 후속 단계의 계산 페이즈에서 계산될 수 있다.

본 발명의 다른 양상은 컴퓨터 프로그램을 실행하는 프로세서를 제공하며, 상기 프로세서는 복수의 계산 유닛들과 상기 계산 유닛들에 연결된 인터커넥트를 포함하고, 각각의 계산 유닛은 프로세싱 유닛 및 적어도 2개의 메모리 포트들을 갖는 메모리를 포함하며, 각각의 메모리 포트는 상기 메모리의 하나 이상의 각 영역들에 할당될 수 있으며, 각각의 계산 유닛은, 상기 메모리의 출력 영역에 초기 출력값을 기입하고 상기 메모리의 입력 영역에 초기 입력값을 기입하도록 상기 프로그램의 초기 단계(initial step)를 수행하고; 그리고 상기 프로그램의 후속 단계(subsequent step)를 수행하도록 구성되되, 상기 프로그램의 후속 단계를 수행하는 것은, 계산 페이즈(computing phase)에서: 상기 2 개의 메모리 포트들 중 하나의 메모리 포트를 상기 입력 영역과 상기 출력 영역 둘다에 할당하고; 하나 이상의 새로운 출력값들의 출력 세트를 계산하도록 상기 프로세싱 유닛 상에서 코드 시퀀스들을 실행하고 그리고 상기 출력 세트를 상기 출력 영역에 기입하며, 상기 출력 세트는 상기 초기 출력값 및 초기 입력값으로부터 계산되고, 상기 초기 출력값 및 초기 입력값 각각은 상기 계산 페이즈에서 상기 하나의 메모리 포트를 통해 검색되며; 상기 계산 페이즈가 완료되면 교환 페이즈에서: 상기 2개의 메모리 포트들 중 제 1 메모리 포트를 상기 출력 영역에 할당하고 제 2 메모리 포트를 입력 영역에 할당하고; 그리고 상기 출력 세트의 새로운 출력값을 상기 제 1 메모리 포트를 통해 상기 출력 영역으로부터 검색하고 상기 검색된 값을 상기 인터커넥트를 통해 상이한 계산 유닛으로 전송하고, 그리고 상기 후속 단계에서 상기 상이한 계산 유닛에 의해 계산된 새로운 입력값을 상기 인터커넥트를 통해 수신하고 수신된 값을 상기 제 2 메모리 포트를 통해 상기 입력 영역에 기입한다.

본 발명의 다른 양상은 실행가능한 명령들을 포함하는 컴퓨터 프로그램 제품을 제공하며, 상기 명령들은 프로세서 상에서 실행될 때, 상기 방법을 구현한다.

본 발명의 다른 양상은 컴퓨터 프로그램을 실행하기 위해 프로세서에서 사용하기 위한 계산 유닛을 제공하며, 상기 계산 유닛은 프로세싱 유닛 및 적어도 2개의 메모리 포트들을 갖는 메모리를 포함하며, 각각의 메모리 포트는 상기 메모리의 하나 이상의 각 영역들에 할당될 수 있으며, 상기 계산 유닛은, 상기 메모리의 출력 영역에 초기 출력값을 기입하고 상기 메모리의 입력 영역에 초기 입력값을 기입하도록 상기 프로그램의 초기 단계(initial step)를 수행하고; 그리고 상기 프로그램의 후속 단계(subsequent step)를 수행하도록 구성되되, 상기 프로그램의 후속 단계를 수행하는 것은, 계산 페이즈(computing phase)에서: 상기 2 개의 메모리 포트들 중 하나의 메모리 포트를 상기 입력 영역과 상기 출력 영역 둘다에 할당하고; 하나 이상의 새로운 출력값들의 출력 세트를 계산하도록 상기 프로세싱 유닛 상에서 코드 시퀀스들을 실행하고 그리고 상기 출력 세트를 상기 출력 영역에 기입하며, 상기 출력 세트는 상기 초기 출력값 및 초기 입력값으로부터 계산되고, 상기 초기 출력값 및 초기 입력값 각각은 상기 계산 페이즈에서 상기 하나의 메모리 포트를 통해 검색되며; 상기 계산 페이즈가 완료되면 교환 페이즈에서: 상기 2개의 메모리 포트들 중 제 1 메모리 포트를 상기 출력 영역에 할당하고 제 2 메모리 포트를 입력 영역에 할당하고; 그리고 상기 출력 세트의 새로운 출력값을 상기 제 1 메모리 포트를 통해 상기 출력 영역으로부터 검색하고 상기 검색된 값을 상기 프로세서의 인터커넥트를 통해 상이한 계산 유닛으로 전송하고, 그리고 상기 후속 단계에서 상기 상이한 계산 유닛에 의해 계산된 새로운 입력값을 상기 인터커넥트를 통해 수신하고 수신된 값을 상기 제 2 메모리 포트를 통해 상기 입력 영역에 기입한다.

본 발명의 다른 양상은 컴퓨터 프로그램을 실행하는 방법을 제공하며, 상기 방법은 다수의 계산 유닛들 및 상기 계산 유닛들에 연결된 인터커넥트를 포함하는 프로세서에 의해 구현되며, 각 계산 유닛은 프로세싱 유닛 및 상기 프로세싱 유닛에 액세스가능한 메모리를 포함하고, 상기 방법은 각각의 계산 유닛에서: 단계들의 시퀀스의 초기 이터레이션(initial iteration)을 수행하고, 상기 시퀀스는 이전 단계(earlier step) 및 나중 단계(later step)를 포함하며; 그리고 상기 단계들의 시퀀스의 후속 이터레이션(subsequent iteration)을 수행하고; 각 단계의 각 이터레이션은 다음에 의해 수행되는바: 하나 이상의 출력 값들의 출력 세트를 계산하기 위해 상기 프로세싱 유닛 상에서 코드 시퀀스들을 실행하고, 상기 출력 세트를 상기 메모리에 기입하고, 상기 인터커넥트를 통해 상기 출력 세트의 출력값을 다른 계산 유닛으로 전송하고, 동일한 단계의 동일한 이터레이션에서 다른 계산 유닛에 의해 계산된 입력값을 상기 인터커넥트를 통해 수신하며, 그리고 상기 입력값을 메모리에 기입하며; 여기서: i) 상기 이전 단계의 초기 이터레이션에서 계산된 상기 출력 세트의 적어도 제 1 출력값은, 상기 나중 단계의 후속 이터레이션에서 출력 세트를 계산하는데 사용되거나 및/또는 상기 나중 단계의 후속 이터레이션에서 다른 계산 유닛으로 전송되며, 그리고 ii) 상기 이전 단계의 후속 이터레이션에서 계산된 상기 출력 세트의 적어도 제 2 출력값은, 상기 나중 단계의 후속 이터레이션에서 출력 세트를 계산하는데 사용되거나 및/또는 상기 나중 단계의 후속 이터레이션에서 다른 계산 유닛으로 전송된다.

이러한 것은 종래의 BSP와 비교하여, 프로그래머에게 더 큰 유연성을 제공하는바, 코드 시퀀스들(코드릿들) 사이에서 서로 다른 레벨들의 통신을 허용함으로써, 즉 인터-이터레이션 및 인트라-이터레이션 통신 둘다를 허용함으로써, 더 큰 유연성을 제공한다.

도 1은 통상적인 BSP의 일부 원리들에 대한 높은 레벨의 개략적인 표현을 제공한다.
도 2는 멀티 프로세서의 개략적인 블록도를 도시한다.
도 3은 멀티 프로세서의 개략적인 블록도를 더 상세하게 도시한다.
도 4는 본 명세서에 제시된 병렬 컴퓨팅 모델의 높은 레벨의 개략적 개요를 제공한다.
도 5와 6은 새 모델로 작성된 프로그램을 컴퓨터에서 실행되기 위해 해석할 수 있는 방법에 대한 개략적인 개요를 제공한다.
도 6a는 다중 분석 그래프를 포함하는 컴퓨터 프로그램을 도시한다.
도 7은 로드 밸런싱 매커니즘의 원리를 도시한다.
도 8은 컴파일러의 기능적 구성 요소를 도시한다.
도 8a는 컴파일된 병렬 프로그램을 실행함으로써 야기되는 동작의 개략적인 그래픽적 예시를 제공한다.
도 9는 컴파일된 병렬 프로그램을 실행하기 위한 방법에 대한 흐름도이다.
도 10a는 병렬 프로그램의 실행 동안 구현되는 메모리 포트 할당 매커니즘을 도시한다.
도 11a는 병렬 프로그램의 교환 페이즈에서 메시지 교환 프로세스를 개략적으로 도시한다.
도 11b는 라틴 스퀘어의 개략도를 도시한다.

도 2 및 도 3을 참조하면, 분산 메모리 멀티 프로세서(202)(분석 컴퓨팅 모듈)는 병렬로 계산을 수행하도록 구성될 수 있는 다수의 프로세싱 유닛들(304.0, ..., 304.N)을 포함한다.

멀티 프로세서(202)는 마이크로 프로세서이다. 이것은 예를 들어, 단일 칩 또는 다이에 내장되거나, 또는 2개 이상의 상호연결된 다이 세트 및/또는 단일 집적 회로(IC) 패키지에 내장될 수 있다. 분석 컴퓨팅 모듈(202)은 병렬 컴퓨터 프로그램을 실행하여, 입력 값(들)로부터 하나 이상의 출력값(들)의 형태인 출력 데이터를 생성한다.

분석 컴퓨팅 모듈(202)은 자신의 병렬 구조로 인해 특히나 적합한 태스크들을 수행할 수 있다. 예를 들어, 분석 컴퓨팅 모듈(202)은 특정 데이터로부터 학습되고 유사 데이터로부터 예측을 수행하는데 사용될 수 있는 머신 학습(machine learning, ML) 모델을 구현할 수 있다. 모델은 오프라인 트레이닝 페이즈 및/또는 온라인 상태에서 학습될 수 있으므로, 상기 모델은 이용되는 바에 따라 학습한다. 분석 컴퓨팅 모듈은 입력 값을 수신하고 그리고 모델을 기반으로 예측을 할 수 있다.

도 3은 분산 메모리 멀티 프로세서(202)의 블록도를 도시한다. 프로세서(202)는 복수의 N 타일들(컴퓨팅 유닛들), 상기 N 개의 타일들(302.0, 302.1, ..., 302.N-1)이 연결된 인터커넥트(interconnect)(308), 및 상기 N 개의 타일들(302.0, 302.1, ..., 302.N-1)이 또한 연결된 동기화 로직(310)을 포함한다. 여기서, "302.n" 이라는 표기는 텍스트 및 다양한 도면들에서 N 개의 타일들(302.0, 302.1, ..., 302.N-1) 중 하나를 나타내는데 사용된다. "*.n" 이라는 형식의 참조 문자는 N 개 타일들 각각에 의해 개별적으로 표시된 피처들을 지칭하는데 사용된다. 따라서, 타일 "302.n" 또는 그 임의의 피처 "*.n"에 관한 임의의 설명은 N 개의 타일들(302.0, 302.1, ..., 302.N-1) 중 임의의 하나에 개별적으로 적용될 수 있다. 참조 번호(304)은 프로세싱 유닛들을 집합적으로 지칭하는데 사용된다. 다음을 유의해야 하는바, 때때로, 개별 프로세싱 유닛들은 본 명세서에서 프로세서들로 지칭될 수도 있는데, "프로세서"가 멀티 프로세서(202)를 지칭하는지 또는 개별 프로세싱 유닛(304.n)을 지칭하는지는 문맥으로부터 명백할 것이다. 본 일례에서, 동기화 로직(310)은 전용 동기화 하드웨어로서 구현되지만, 다른 가능성들, 예컨대 소프트웨어 또는 결합된 하드웨어/소프트웨어 구현들도 배제되지 않는다.

각각의 타일(302.n)은 적어도 하나의 제어 레지스터(Rn)를 갖는 각각의 프로세싱 유닛(304.0) 및 제 1 메모리 포트(pA.n)와 제 2 메모리 포트(pB.n)를 갖는 각각의 메모리(306.n)를 포함한다. 각각의 타일(302.n)의 개별 프로세싱 유닛(304.n)은 (선형) 코드 시퀀스들, 즉 한번에 하나씩 실행되는 저레벨 머신 코드 명령들의 시퀀스들을 실행하도록 구성된다. 각각의 코드 시퀀스를 서로 동시에 실행하는 N 개의 프로세싱 유닛들(304.0, 304.1, ..., 304.N-1)의 각각에 의해서, 상기 N 개의 프로세싱 유닛(304.0, 304.1, ..., 304.N-1)은 병렬 계산들을 유효하게 수행할 수 있다. 비록 도 3에 명시적으로 도시되지는 않았지만, 메모리(306.n)는 일련의 독립적인 메모리 뱅크로 형성되고, 각 뱅크는 고유한 메모리 어드레스를 갖는다. 각각의 뱅크는 본 명세서에서 사용되는 메모리 위치의 일례이다. 메모리(306.n)는 메모리의 제 1 포트(pA.n) 또는 제 2 포트(pB.n)를 통해 프로세서(304.n)에 액세스 가능하다. 특히, 메모리(304.n)는 제 1 포트(pA.n) 및 제 2 포트(pB.n)를 통해 동시에 액세스 가능한바, 따라서, 프로세서(304.n)는 제 1 포트(pA.0)를 통해 메모리(306.n)의 하나의 위치로부터/로 값을 판독/기록하면서, 이와 동시에 제 2 포트를 통해 메모리(306.n)의 다른 위치로부터/로 값을 판독하거나 기록할 수 있다. "동시에" 라는 용어는 연산들이 시간적으로 적어도 일부 겹치는 것을 의미한다.

인터커넥트(308)는 서로 다른 프로세싱 유닛들 사이에서 메시지들의 통신을 가능케 한다. 각각의 프로세싱 유닛(304.n)은 인터커넥트(308)를 통해 임의의 다른 프로세싱 유닛(304.n', 여기서 n'≠ n 임)으로 데이터를 전송할 수 있고, 그리고 상기 다른 프로세싱 유닛(304.n')에 의해서 그 프로세싱 유닛(304.n)으로 통신되었던 인터커넥트(308)를 통해 유사한 방식으로 임의의 다른 프로세싱 유닛(304.n')으로부터 데이터를 수신할 수 있다. 2 개의 포트들(pA.n, pB.n)을 활용함으로써, 각각의 프로세싱 유닛(302.n)은 연산들의 동시 전송 및 수신을 수행할 수 있는바, 인터커넥트(308)를 통해 수신된 데이터를 상기 포트들 중 하나(예를 들어, 제 2 포트 pB.n)를 통해 메모리(304.n)에 기록하고 이와 동시에 다른 포트(예를 들어, 제 1 포트 pA.n)를 통해 전송하기 위해 데이터를 검색함으로써, 인터커넥트(308)를 통해 데이터를 각각 전송 및 수신할 수 있다.

전체 태스크를 수행하기 위해 프로세서(202) 상에서 실행되는 소프트웨어 프로그램은 전체 태스크를 다수의 부분들로 분할하는바, 이러한 다수의 부분들은 본 명세서에서 "태스크릿(tasklet)" 이라고 지칭되며, 태스크릿은 병렬로 동작할 수 있다. 각각의 태스크릿은 본 명세서에서 "코드릿(codelet)" 이라 지칭되는 프로그램 코드의 대응 부분, 및 상기 코드릿이 동작하는 프로그램 데이터의 대응 부분을 포함한다. 여기서, "태스크릿을 수행한다(performing tasklet)"(또는, 유사한 표현)은 대응하는 프로그램 데이터 상에서 대응하는 코드릿을 실행하는 것을 의미한다. 각각의 코드릿은 개별 프로세싱 유닛(304)들 중 하나에서 실행되는 코드 시퀀스의 형태이다. 소위(so-called) 데이터-병렬 프로그램의 경우, 모든 코드릿들은 동일하다(비록, 일반적으로 이들은 서로 다른 데이터 요소에서 동작할 것이지만). 소위 태스크-병렬 프로그램의 경우, 프로그램 태스크릿들은 다를 수 있다. 종종 병렬 컴퓨터 프로그램은 2개 유형들의 병렬 처리를 결합한다. 다음을 유의해야 하는바, 본 발명의 주제는 모든 유형의 병렬 프로그램에 적용될 수 있다.

태스크릿들은 인터커넥트(308)를 통해 서로 메시지들을 전송함으로써 상호작용한다. 임의의 공유 메모리가 필요없다; 도 3의 프로세서에는 그 어떤 것도 존재하지않으며, 따라서 메시지 전달(message-passing)은 태스크릿들이 데이터를 교환하는 유일한 메커니즘이다. 본 실시예에서, 전용 동기화 하드웨어(이하 참조)를 이용하여 다수의 타일(302)에 걸친 글로벌 동기화가 달성된다. 그럼에도 불구하고, 다른 실시예에서 글로벌 동기화 및/또는 다른 목적을 위해 공유 메모리를 사용하는 것은 배제되지 않는다.

본 명세서는 병렬 컴퓨팅 모델을 제공하며, 그 세부 사항이 이제 설명될 것이다. 본 모델에 따라 구성된 병렬 프로그램은 버텍스들 및 에지들을 포함하는 그래프로 표현될 수 있으며, 버텍스들은 태스크릿들(코드릿 및 데이터 포함)을 나타내고, 에지들은 메시지들이 전송될 수 있는 경로들을 나타낸다. 이러한 에지들은 데이터 종속성 및 다른 우선순위 관계를 나타내는 계산 순서를 나타내기 위한 것이다.

일례로서, 도 4는 분석 컴퓨팅 모듈(202) 상에서 실행될 수 있는 병렬 컴퓨터 프로그램(410)의 예시적인 하이-레벨 그래프 표현의 일례를 도시한다. 컴퓨터 프로그램(410)은 버텍스들 V(분석 그래프)의 그래프(406)로 표현된다. 버텍스들(V) 각각은 프로세싱 유닛(304.n)상에서 대응하는 코드릿을 실행함으로써 구현되는 태스크릿(tasklet)을 나타낸다. 코드릿은 실행될 때, 다른 태스크릿(들)(제 2 값)에 의해 생성되거나 및/또는 외부 소스로부터 공급된 값(버텍스들로 향하는 에지들로 표시됨)에 작용하여, 값(들)(제 1 값(들) 또는 등가적으로는 "출력값(들)")을 생성하며, 이들은 다른 태스크릿들로 공급되거나 및/또는 외부 소스로 반환된다(버텍스들로부터의 에지들로 표시됨). 그래프(406)는(즉, 그래프(406)에 의해 표현된 병렬 연산들은) 복수회 이터레이션되며, 최초의 이터레이션(iteration)을 제외하고는 각각 이전의 이터레이션에서 생성된 제 2 값들에 기초하여 제 1 값들이 생성된다. 분석 그래프의 이터레이션은 본 명세서에서 등가적으로 "컴퓨팅 사이클" 이라고 지칭된다. "I(m)" 이라는 표기는, 본 명세서에서 406과 같은 분석 그래프의 m 번째 이터레이션 또는 그러한 그래프들의 시퀀스를 나타내기 위해 사용된다(아래의 도 6a에 첨부된 텍스트 참조). 이터레이션들(iterations)은 도 4의 배리어(408)에 의해 표현된 바와 같이 배리어 동기화되는바, 현재 이터레이션 I(m)의 모든 태스크릿들이 전부다 완료될 때까지 그래프(406)의 다음 이터레이션 I(m + 1)이 개시되지 않는다는 점에서, 배리어 동기화된다. 도 4에서 "pe"로 라벨링된, 배리어로 향하거나 배리어로부터 온 에지들은, 이전 이터레이션 I(m-1)로부터 수신되었고 그리고 다음 이터레이션 I(m + 1)에서 수신될 메시지들에 각각 대응한다. 이 정도까지는, 앞서 개략적으로 설명한 BSP 모델과 유사한 프로그래밍 모델에 따라 상기 프로그램(410)이 구성된다. 하지만, BSP와는 달리, "ce"로 라벨링된 에지들이, 배리어(408)를 경유하지 않고 버텍스들 사이에서 또한 허용된다는 점에 유의해야 한다. "ce"로 라벨링된 에지들은, 이들이 생성된 동일한 이터레이션 I(m) 내의 버텍스에 의해 수신되고, 상기 버텍스에 보여지게 되며, 따라서 상기 버텍스에 의해 이용될 수 있는 메시지들을 나타낸다. 즉, 프로그램의 이러한 그래프적 표현에서 루프들의 표시를 허용하기 위해서, 2개 유형들의 에지들이 서로 구별되는바, 현재 이터레이션 동안 수신되는 메시지들(비-파이프라인 메시지)을 운반하는 에지들, 및 다음 이터레이션에서에서 수신될 메시지들(파이프라인 메시지)을 운반하는 에지들이 서로 구별된다. 전자는 "비-파이프라인 에지"("ce"로 라벨링됨)로 지칭되고, 후자는 "파이프라인 에지"("pe"로 라벨링됨)로 지칭된다.

알 수 있는 바와 같이, 상기 프로그램(410)은 설명의 목적으로 크게 단순화된 것이며 그리고 일반적으로는 매우 많은 수의 버텍스들 및 에지들을 포함할 것이다.

BSP 만큼 제한적이지는 않지만, 본 발명의 프로그래밍 모델은 프로그램 구조에 대해 여전히 다음과 같은 제한들을 갖고 있다.

·분석 그래프(406)는 비순환적(acyclic)이어야 한다. 즉, 임의의 버텍스 V에서 시작하여, 배리어(408)를 경유함이 없이 그 버텍스로 루프백할 수 있는 비-파이프라인 에지들 ce 의 임의의 시퀀스는 존재할 수 없다.

·버텍스들 V로 표시되는 태스크릿들은 인과적으로(causally) 스케줄링되어야 한다. 즉, 다른 태스크릿으로 향하는 비-파이프라인 에지를 갖는 모든 태스크릿에 대하여, 후자(다른 태스크릿)가 시작되기 전에 전자(비-파이프라인 에지를 갖는 태스크릿)가 완전히 완료되도록 스케줄링되어야 한다.

·프로그램은 합의에 기반한다. 즉, 현재 이터레이션의 모든 태스크릿들이 완전히 완료될 때까지 다음 이터레이션은 시작될 수 없다.

·버텍스 간의 메시징은 우편(postal)이다. 즉, 버텍스 V는 프로그램의 임의의 포인트에서 버텍스 V'에 메시지를 보낼 수 있다(버텍스 V' 가 예를 들어, 메시지를 통보받을 필요없이 또는 메시지 알림 상태에 있을 필요없이).

이러한 제한 사항들이 지켜지는 경우, 본 발명의 모델은 데드락이 없이, 보장된 결정론적 프로그램 거동들(guaranteed deterministic program behaviours)을 제공할 수 있으면서도, 기존의 BSP보다 더 큰 유연성을 프로그래머에게 제공할 수 있다.

일반적으로, 병렬 컴퓨팅 프로그램(410)의 태스크릿들과 분석 컴퓨팅 모듈(202)의 N 개의 프로세싱 유닛들(304) 사이에서 일대일(one-to-one) 맵핑은 없을 것이다. 성능 확장성 및 효율적인 머신 활용을 위해, 머신 병렬처리(machine parallelism) 보다 더 많은 태스크릿 병렬처리(tasklet parallelism)를 표현하는 것이 일반적으로 병렬 프로그래머의 우선순위이다. 이것을 뒷받침하는 이유 중 일부가 도 7을 참조하여 설명될 것이다. 일반적으로, 서로 다른 태스크릿들은 상이한 복잡성을 가질 것이며 따라서, 완료하는데 서로 다른 양의 시간들이 소요될 것이다. 태스크릿들과 N 개의 프로세싱 유닛들(304) 사이의 일대일 맵핑의 극단적인 경우에서, 각 태스크릿이 완료하는데 서로 다른 시간 분량이 걸린다고 가정하면, N 개의 프로세싱 유닛들(302) 중 하나를 제외한 모든 것이 각 이터레이션 I(m)의 적어도 일부에 대해 점유되지 않을 것이며 그리고 많은 프로세싱 유닛들이 이터레이션 I(m)의 대부분에 대해 점유되지 않을 것인바, 이것은 비효율적이다. 이러한 것이 도 7의 좌측에 도시되어 있다(도 7에서 각각의 수직 바는 프로세싱 유닛(304.n)이 하나의 태스크릿에 의해 점유되는 시간 인터벌을 나타낸다). 하지만, 도 7의 우측에 예시된 바와 같이, 바이어싱되지 않은 방식(예를 들어, 라운드-로빈 방식)으로 다수의 태스크릿들을 각각의 프로세싱 유닛에 할당함으로써, 서로 다른 완료 시간들이 평균화되며, 따라서 각각의 프로세싱 유닛(304.n)은 각 이터레이션의 전부 또는 대부분에서 점유된 채로 남아있으며, 이는 프로세싱 리소스들을 효율적으로 사용할 수 있게 한다.

따라서, 각각의 프로세싱 유닛(304.n)은 프로그램 실행의 각각의 이터레이션 동안 많은 태스크릿들을 일반적으로 구현할 것이다. 프로그램을 표현하는 그래프(406)는 프로세싱 유닛(304.n) 당 하나씩인, N 개의 서브-그래프들로 분할되고, 각각의 서브-그래프는 그 각각이 태스크릿들을 나타내는 많은 버텍스들을 갖는다. 따라서, 그래프의 일부 에지들(메시지 경로들)은 프로세싱 유닛(304.n)에 대해 완전히 로컬이며, 다른 것들은 비-파이프라인 및 파이프라인 에지 종속성들 모두를 구현하기 위해, 인터커넥트(308)를 통한 서로 다른 프로세싱 유닛들 사이에서의 메시지 전송을 필요로 한다. 따라서, 하나의 이터레이션 내에서(비-파이프라인 에지 종속성들로 인하여) 그리고 서로 다른 이터레이션들 사이에서(파이프라인 에지 종속성들로 인하여), 결정론적 프로그램을 구현하기 위하여 태스크릿들 사이에서 소정의 조정이 요구된다. 예를 들어, 선행 관계(precedence relationship)가 존중되어야만 하며 그리고 데드락이 회피되어야만 한다.

이하에서 상세히 설명하는 바와 같이, 본 발명의 프로그래밍 모델에 따라 구성된 반복적인 병렬 프로그램을 실행하기 위하여, 상기 프로그램은 다수의 BSP 슈퍼스텝들로 분할되고, 따라서 다수의 슈퍼스텝들은 그래프(406)의 각 이터레이션에서 수행된다. 본 명세서에서, "슈퍼스텝" 은 때로는 단순히 "단계(step)"로 언급되기도 함을 유의해야 한다. 이는 도 4에 도입된 병렬 프로그램(410)에 대하여 도 5 및 도 6에서 일례로서 예시되어 있다. 프로그램(410)의 개별 태스크릿들을 나타내는 6개의 버텍스들이 도시되어 있으며, 이들에 대하여 라벨들(V0a, V0b, V1, V2, V3a, V3b)이 도 5 및 도 6에서 채택된다.

각각의 버텍스에는 다음의 레벨 할당 규칙들에 따라 레벨이 할당된다:

·파이프라인 에지(들)만이 지향되는 각각의 버텍스에는 가장 낮은 레벨(l = 0)이 할당된다.

·다른 버텍스 각각에는 레벨(l'+ 1)이 할당되며, 여기서 l'은 다른 버텍스로 지향된 비-파이프라인 에지가 발원된 버텍스의 최고 레벨이다.

따라서, 예시적인 프로그램(410)의 경우, 버텍스 V0a 및 V0b 는 레벨 0에 할당받는데, 왜냐하면 파이프라인 에지들만이 이들 버텍스로 지향되기 때문이다. 다른 버텍스들 모두에게 지향되는 비-파이프라인 에지들이 존재하기 때문에, 이들은 0 보다 큰 레벨을 할당받는다. V1으로 향하는 2개의 비-파이프라인 에지들이 존재하며, 이들 비-파이프라인 에지들 둘다는 레벨 0 버텍스들로부터 온 것이기 때문에, V1은 레벨 0 + 1 = 1이 할당된다. 다음으로, V2로부터 버텍스들(V3a, V3b)로 향하는 비-파이프라인 에지가 존재하므로, 버텍스들(V3a, V3b) 각각은 2 + 1 = 3인 레벨을 할당받는다(비록, V1으로부터 V3a로 향하는 에지가 있지만, V2가 V1 보다 레벨이 높기 때문에).

일단 라벨들이 할당되면, 프로세싱 유닛들(304.n) 각각에서 L 개의 BSP-타입 슈퍼스텝들의 시퀀스를 수행함으로써 그래프(406)의 각각의 이터레이션이 구현되며, 여기서 L은 버텍스들에 할당된 서로 다른 레벨들의 전체 개수이다(본 일례에서 L = 4). 이에 대해서는 아래에서 자세히 설명한다.

먼저, 다음을 유의해야 하는바, 배경 기술 부분에서 언급된 Valiant의 오리지널 BSP의 변형예에 따라, 본 문맥에서 "슈퍼스텝(superstep)"이 정의된다. 이러한 변형예에서, BSP 프로그램은 계산 페이즈와 메시지 교환 페이즈 사이에서 교번한다. 계산 페이즈에서, 각각의 프로세싱 유닛(304.n)은, 이전 교환 페이즈에서 다른 프로세싱 유닛들(304.n')으로부터의 메시지들에서 수신된 임의의 데이터를 포함하여, 로컬 메모리(306.n)의 데이터에 대해 계산을 수행하는 것이 허용된다. 계산 페이즈 동안, 프로세싱 유닛들은 다른 프로세싱 유닛들로 전송될 메시지들을 준비할 수 있지만, 이러한 메시지들은 다음 교환 페이즈까지 전송되지 않는다. 모든 프로세서가 그것의 로컬 계산을 완료하는 때에, 교환 페이즈가 시작된다. 교환 페이즈 동안, 모든 메시지들이 인터커넥트(308)를 통해 전송 및 수신되어, 다음 계산 페이즈에서 계산에 이용될 수 있게 된다. 본 명세서에서 용어가 사용되는 바와 같이, 하나의 슈퍼스텝은 단일 계산 페이즈 및 단일 교환 페이즈를 포함할 수 있다. 중요한 것은 이러한 변형예에서, 계산과 교환 사이, 교환과 다음 계산 사이에서 2배의 동기화(즉, 2배의 배리어들)가 있다는 것이다.

비록, 프로세서 동기화 수를 2배로 늘리지만, BSP의 이러한 변형예는 계산 및 교환 작업을 완전히 분리하기 때문에 유리한다. 이것은 배선 구조(interconnection fabric), 즉 인터커넥트(408)의 사용을 최대로 효율적으로 사용하기 위해 메시지들의 교환을 조정할 수 있다는 점을 포함하는, 다수의 장점들을 제공한다. 이 동작은 다음에 서술될 것이다.

먼저, 도 5로 돌아가면, 중앙의 도면은 그래프(406)의 단일 이터레이션 I(m)이 슈퍼스텝들의 시퀀스로서 어떻게 구현될 수 있는지를 나타내고, SS(0,m), SS(1,m) ..., SS(L-1,m) 라는 표기들이 사용된다. SS(l,m)는 406과 같은 분석 그래프 또는 그와 같은 그래프들의 시퀀스의 m 번째 이터레이션 I(m)에서 수행된 l 번째 슈퍼스텝을 의미한다. 각각의 슈퍼스텝 SS(l,m)에서, 레벨 l의 버텍스들에 의해 표현된 태스크릿들만이 수행된다. 도 5의 오른쪽에 나와 있듯이, 이터레이션은 종래의 BSP 슈퍼스텝 SS의 L 개의 반복들(repetitions)로 볼 수 있다(다음에 서술될 중요한 차이점이 있지만). 이는 모든 레벨의 버텍스들 V0, ... V3b로 표시되는 모든 태스크릿들을 포함하며, 각각의 반복 l 에서, 태스크릿들의 서브세트(즉, 레벨 l인 것들)만이 수행되도록 제한된다. 전술한 BSP 변형예에 따르면, 도 6의 우측에 도시된 바와 같이, 슈퍼스텝 SS의 각각의 반복(즉, 각각의 슈퍼스텝 SS(l, m))은, 도 6에 도시된 별도의 계산 및 교환 페이즈 배리어들(508C 및 508E)로 표시되는 바와 같은, 일시적으로 구별되는 계산 및 교환 페이즈들을 포함한다.

도 6a는 병렬 프로그램이 다수의 분석 그래프들(406a, 406b, 406c)을 어떻게 포함할 수 있는지를 예시하며, 분석 그래프들(406a, 406b, 406c) 각각은 전술한 바와 같은 방식으로 구현될 수 있다. 개별 분석 그래프들(예컨대, 406a 및 406b) 또는 분석 그래프들의 시퀀스들(예컨대, 406a 및 406b에 의해 형성되는)는 한 번 이상 이터레이션될 수 있다. 분석 그래프 또는 그래프들의 시퀀스의 말미에서, 루프 조건이 평가될 수 있는바, 분석 그래프 또는 그래프들의 시퀀스의 또 다른 이터레이션을 수행할지의 여부 또는 프로그램의 다른 곳으로, 예를 들면 다른 분석 그래프로(406a에서 406b로 또는 406b에서 406c로) 분기할지의 여부를 결정하기 위하여 코드 시퀀스(602a, 602b)를 실행함으로써, 루프 조건이 평가될 수 있다.

다음을 유의해야 하는바, 임의의 주어진 레벨 l에 대하여, 동일한 코드릿들은 모든 이터레이션 마다 m = 0,1, ..., M (하지만 상이한 데이터에 대해) 모든 슈퍼스텝 SS(l, m)에서 실행된다. 즉, 코드 시퀀스들의 각각의 세트는 각각의 슈퍼스텝의 매 이터레이션마다 실행된다.

위에서 언급한 중요한 차이점은 다음과 같은바, 임의의 소정 이터레이션 I(m)의 임의의 소정 슈퍼스텝 S(l, m) 내에서, 임의의 소정 태스크릿은 다음과 같은 것들에서 작동하지 않을 수 있다:

1) l > 0 인 경우, SS(l-1, m)로부터의 파이프라인된 메시지들. 즉, 동일한 이터레이션 l(m)의 선행 슈퍼스텝; 및/또는

2) 선행 이터레이션 I(m-1)의 임의의 하나 이상의 슈퍼스텝들 SS(0,m-1), SS(1, m-1), ..., SS(L, m-1)에서 전송된 메시지들.

1)은 프로그램(410)의 비-파이프라인 에지들 ce 로 인해 발생하고; 2)는 프로그램(410)의 파이프라인 에지들 pe로 인해 발생한다. 이것은, 비-파이프라인 메시지들은 이들이 수신되는 동일한 이터레이션 I(m)에서 사용되는 반면에, 파이프라인 메시지들은 이전의 이터레이션 I(m-1)으로부터 오기 때문이다. 따라서, 소정의 슈퍼스텝 SS(1, m)에서, 동일한 또는 상이한 태스크릿들은 현재 이터레이션 I(m) 및 선행 이터레이션 I(m-1) 모두에서 전송된 메시지들에 대해 동시에 동작할 수 있다. 두 가지 유형의 메시지들을 필요할 때 사용할 수 있도록 하는 메커니즘이 아래에 제공된다.

도 8은 라벨러(labeller)(804) 및 컨버터(806)의 형태인, 컴파일러(802)의 기능적 구성요소들을 도시한다. 라벨러 및 컨버터(804, 806)는 컴퓨터 상에서 실행되는 코드로서 구현된다. 라벨러는 본 발명의 컴퓨팅 모델에 따라 구성된 하이 레벨 병렬 컴퓨팅 언어로 작성된 하이 레벨 병렬 프로그램 "[code, info]"를 수신한다. "code"는 프로그래머가 작성한 여러 가지 태스크릿들(즉, 버텍스들)을 정의하는 하이 레벨 코드를 나타낸다. "info"는 병렬 프로그램에 필요한 추가 정보를 나타내고, 태스크릿 간의 통신 및 태스크릿들의 동기화(즉, 버텍스 사이의 에지)를 정의하며, 해당 에지가 비-파이프라인 또는 파이프라인인지 여부를 정의한다. 도 8의 일례에 예시된 바와 같이, 프로그램 "[code, info]"는 4 개의 버텍스들 V0i, V0ii, V1i, V1ii 및 다음의 에지들을 정의한다:

· 파이프라인 에지들:

o V0ii에서 V1i로의 pe1,

o V0ii에서 V0i로의 pe2,

o V01i에서 V0i로의 pe3,

o V01ii에서 V0ii로의 pe4, 및

· 비-파이프라인 에지들:

o V0ii에서 V1ii로의 ce1, 및

o V0i에서 V1i로의 ce2.

버텍스들 V0i, ..., V1ii 및 에지들 pe1, ..., ce2는 M 회 이터레이션되는 분석 그래프를 구성한다. 전술한 라벨링 체계에 따르면, V0i, V0ii는 레벨 0의 버텍스들이고, V1i, V1ii는 레벨 0의 버텍스들이지만, 본 일례에서 이들의 레벨들은 프로그램 [p, info]에서 명시적으로 식별되지는 않는다. 에지들에 대한 순전히 예시적인 것이다: V0ii 이 레벨 1의 버텍스로 향하는 비-파이프라인 에지(V1ii로 향하는 ce1)와 레벨 1의 버텍스로 향하는 파이프라인 에지(V1i로 향하는 pe1) 둘다를 갖는다는 사실 말고는 에지들의 이러한 선택은 특별한 중요성을 갖지 않는다. 따라서, 전술한 원리들에 따르면, 분석 그래프는 2개의 슈퍼스텝들(통틀어 2개의 레벨들이 존재하므로)의 시퀀스로서 구현될 것이고, M 회 이터레이션된다.

라벨러(804)는 프로그램 [code,info]를 파싱하여, 라벨링 메카니즘에 따라 다양한 버텍스들의 레벨들을 식별하고 그리고 각 버텍스의 식별된 레벨을 나타내는 라벨 데이터로 각각의 버텍스를 라벨링한다. 컴파일러(802)는 전술한 원리들에 따라 동작하여, 그래프를 여러 번 이터레이션되는 BSP 슈퍼스텝들의 시퀀스로 변환한다. 라벨링된 프로그램은 컨버터(806)로 입력되며, 컨버터는 하이 레벨 프로그램을 프로세서(202) 상에서 실행되기에 적합한 로우(low) 레벨 프로그램 p로 변환하며, 로우 레벨 프로그램 p가 컴파일러(802)에 의해 출력된다. 로우 레벨 프로그램 p는 머신 코드 시퀀스들(C0i, C0ii, C1i, C1ii)의 세트를 포함하며, 이들 각각은 개별 프로세싱 유닛(304.n)상에서 실행되기에 적합하다. 코드 시퀀스들(C0i, C0ii, C1i, C1ii)은 로우 레벨 머신 코드 형태인 코드릿들이며, 이들 각각은 버텍스들 V0i, V0ii, V1i, V1ii에 대응한다. 또한, 프로그램 p는 N 개의 슈퍼바이저 스레드들 S0, ..., SN-1의 세트를 포함하며, 이들은 머신 코드 명령들의 시퀀스들을 포함한다. 각각의 슈퍼바이저 코드 시퀀스 S.n은 각각의 타일(302.n) 상에서 실행하기 위한 것이고, 그 타일(3022.n) 상에서 실행될 코드릿들의 서브세트의 실행을 조정하며, 다른 것들 중에서도 코드릿들 사이의 다양한 에지들을 정의한다. 즉, 프로그램의 그래프 구조는 슈퍼바이저 코드 시퀀스에 의해 구현된다.

또한, 프로그램 p는 각 레벨에 대해 해당 레벨의 각 코드릿을 식별하는 각각의 레벨 데이터를 포함한다. 관련된 슈퍼바이저 코드 시퀀스는, 실행될 때, 각 이터레이션에서, 실행을 위해 레벨 0으로 식별된 코드릿들을 먼저 선택하고, 다음으로 레벨 1로 식별된 코드릿들을 선택하고, 기타 등등함으로써, 레벨 데이터에 기초하여 코드릿들을 스케줄링한다.

각 슈퍼바이저 코드 시퀀스는 또한 각 슈퍼스텝의 교환 페이즈를 구현한다. 오직 슈퍼바이저 코드 시퀀스만이 교환 페이즈에서 실행된다. 코드릿 C0i, ..., C0ii는 그렇지 않다.

도 9는 도 8의 예시적인 프로그램 p와 같은 컴파일된 병렬 프로그램을 실행하기 위한 방법의 흐름도를 도시한다. 도 9의 방법에서, 현재 슈퍼스텝으로서 제 1 이터레이션 I(0)의 제 1 슈퍼스텝 SS(0,0)에서 시작하여, 슈퍼스텝들 SS(0,m), SS(1,m), ...의 시퀀스의 다수의 이터레이션 I(m)(여기서, m = 0,1, ..)이 수행된다.

각 이터레이션의 각 슈퍼스텝 S(1, m)은 각각의 계산 페이즈 C(1, m)로 시작한다. 각각의 계산 페이즈 (l, m)에서:

· 단계 S2에서, 아래에 설명된 이유로, 제 1 작업공간(workspace), 입력 및 출력 영역들 WA.n, IN.n 및 OUT.n 에는 제 1 포트 pA.n 가 할당되고, 제 2 작업공간 영역 WB.n에는 제 2 포트 pB.n 가 할당된다. 이러한 일례에서, 분할 경계(partitioning boundary)를 적절하게 이동시키기 위해 그 타일(302.n)에서 분할 어드레스(partitioning address)를 수정함으로써 할당이 수행된다;

· 단계 S4에서, 현재 계산 페이즈 C(1, m)에 대해 하나 이상의 출력값들의 각각의 세트가 계산되며, 이는 선행 슈퍼스텝 SS(1-1,m) 및/또는 선행 이터레이션 I(m-1)에서 계산된 이전 값들에 기초할 수 있다. 출력 세트는 출력 영역 OUT.n에 기록된다.

일단 계산 페이즈 C(l, m)가 전부 완료되면, 상기 방법은 현재 슈퍼스텝 SS(l, m)의 교환 페이즈 E(1, m)(S6-S8)로 진행된다. 교환 페이즈 E(1, m)에서, 각각의 타일(304.n)에서:

· 단계 S6에서, 교환 페이즈 분할 데이터가 해당 타일의 제어 레지스터 R.0에 기록된다. 분할 어드레스는 메모리(306.n)의 메모리 어드레스를 지정하며, 그 어드레스 아래에는 제 2 포트(pB.n)가 액세스할 수 있고, 그 어드레스 위에는 제 1 포트(pA.n)가 액세스할 수 있다. 이러한 방식으로, 지정된 메모리 어드레스의 위 및 아래의 어드레스들을 정의하는 상이한 영역들이 그 타일(302.n)의 제 1 및 제 2 포트들(pA.n, pB.n)에 각각 할당된다(이하 참조).

· 단계 S8에서, 메시지 교환 프로세스가 다음과 같이 수행된다. 현재 슈퍼스텝 SS(l,m)의 계산 페이즈 C(l,m)에서 그 타일(302.n)에 의해 계산되었던 값들은 제 1 포트(pA.n)를 통해 메모리(306.n)에서 액세스되고, 인터커넥트(308)를 통해 다른 타일들로 전송되며; 동일한 슈퍼스텝 SS(l,m)의 계산 페이즈 C(l,m)에서 다른 타일들에 의해 유사하게 계산된 값들("제 2 값" 또는 동일하게 "입력 값(들)")은 또한 인터커넥트(308)를 통해 교환 페이즈 E(l, m)에서 수신되고, 그리고 제 2 포트(pB.n)를 통해 메모리(306.n)에 기록된다.

도 9의 프로세스를 통한 첫 번째 실행을 위한 현재 슈퍼스텝은 S(0,0)이다. 하지만, 단계들은 동일한 및 이후의 이터레이션들의 이후 슈퍼스텝들에 대해 반복적으로 이터레이션되므로, 더 일반적인 표기법이다.

메시지 교환(S8) 동안, 인터커넥트(308)의 완전히 효율적인 사용은, 모든 프로세싱 유닛이 최대 속도로 메시지 트래픽을 동시에 송신 및 수신함으로써 달성된다. 이를 "모든 맞춤화된 통신(all-to-all personalised communication)" 이라 지칭한다; 매 순간마다 각각의 프로세싱 유닛은 제 2 프로세서로 메시지 데이터를 보내고 제 3 프로세싱 유닛으로부터 메시지 데이터를 수신한다.

이를 달성하기 위해 여러 프로세싱 유닛들이 조정하는 스케줄들은, 라틴 스퀘어 스케줄(Latin squares schedules)이라고 알려져 있다. d-차원 라틴 스퀘어는 숫자들의 d-by-d 행렬이며, 여기서 모든 로우(row: 이하, "행" 또는 "로우" 라고 함)와 모든 컬럼(column: 이하, "열" 또는 "컬럼" 이라고 함)에는 0부터 d-1까지의 각 숫자가 출현한다(본 일례에서는 0부터 시작하지만, 이것은 중요한 것이 아니며 임의의 숫자가 선택될 수 있다). 반면에, 모든 행과 모든 열은 이들 숫자들의 서로 다른 시퀀스를 갖는다. 4 차원(d = 4)인 라틴 스퀘어 L의 간단한 일례가 도 11b에 도시되어 있다. 라틴 스퀘어에 따라 구성된 교환 스케줄은 다음과 같이 작동한다. N 차원(d = N)의 라틴 스퀘어가 생성되며, 여기서 N은 프로세싱 유닛들의 개수이다. S6의 메시지 교환 프로세스는 N-1 개의 서브-페이즈들에서 수행되며, 이러한 서브-페이즈들 각각은 "서브-페이즈 p" 혹은 유사한 표현으로 지칭된다. 곧 명백해질 편의상의 이유 때문에, p∈{1, ..., N-1} 인 관례(convention)가 채택된다.

생성된 라틴 스퀘어는 N 개의 로우들(r.n) 및 N 개의 컬럼들(c.n)을 가지며, 여기서 n = 0, ..., N-1이다. 도 11b에는 4개의 로우들이 도시되어 있다. 본 일례에서, 프로세싱 유닛들(304)은 0부터 N-1까지 번호가 매겨져 있다. 각각의 서브 페이즈 p ∈ {1, ..., N-1}에서, 라틴 스퀘어의 각각의 로우(r.p)는 각각의 프로세싱 유닛(304.n)으로부터 전송된 메시지들의 목적지를 특정하는바, 따라서 프로세싱 유닛(304.n)에 대한 목적지는 로우(r.p)의 컬럼(c.n)에 넘버링된다. 라틴 스퀘어의 로우들 중 하나(본 예제에서는 r.0)는 각 프로세싱 유닛 자체에 대한 매핑을 나타내는 숫자 시퀀스 [0,1,2, ... N-1]를 포함한다; 이 로우는 사용되지 않으며, 이것은 S8의 메시지 교환 프로세스의 N 서브 페이즈들이 아니라 N-1 을 갖는 이유이다.

S8의 교환 프로세스는 라틴 스퀘어 L의 로우들에 의해서 정의된 이들 각각의 서브-페이즈들이 중첩되지 않도록 수행된다. 이 경우, 프로세싱 유닛들(304)과 인터커넥트(308) 사이의 총 대역폭(aggregate bandwidth)과 동등한 이분 대역폭(bisection bandwidth)을 갖는 임의의 인터커넥트(308)는 비-차단(non-blocking)이 보장되고, 따라서 교환은 가능한 가장 빠른 속도로 진행될 것이다. 임의의 중요 차원 p에 대하여, 가능한 많은 라틴 스퀘어가 존재함을 유의해야 한다. 도 11b는 모듈러스(modulus)(시프팅) 방식에 따라 구성된 라틴 스퀘어 L을 도시하는데, 이는 프로세싱 유닛(304)이 계산하기에 특히 간단하다는 점에 매우 유용하지만, 그럼에도 불구하고 차원 N의 임의의 라틴 스퀘어가 사용될 수 있다.

각각의 프로세서는 라틴 스퀘어를 개별적으로 계산할 수도 있고, 또는 그것이 사용하는 구성요소들만을 계산할 수도 있다. 각 프로세싱 유닛(304.n)은, 라틴 스퀘어 또는 그 관련 구성요소들이 각 교환 페이즈에서 사용하기 위해 보유되는 전용 스케줄링 레지스터(들)을 가질 수 있다.

전술한 바와 같은 메시지들의 전속력 교환을 지원하기 위해, 각각의 프로세싱 유닛(304.n)은 판독 및 기록 둘다를 동시에 할 수 있도록 구성된다. 특히, 메모리(306.n)는 이러한 동시 판독-기록 속성을 갖는바, 왜냐하면 메모리(306.n)는 일반적으로 메시지 데이터의 소스 및 목적지이기 때문이다. 메모리 밀도는 컴퓨터 설계, 특히 프로세싱 유닛(304.n)과 함께 실리콘에 집적되는 경우에 매우 중요하다. 만일, 2 이상의 판독/기록 포트를 제공해야만 하는 경우라면, 실리콘 메모리의 밀도가 크게 감소한다. 따라서, 전술한 바와 같은 본 발명의 계산 모델을 지원하는 도 2 및 도 3의 멀티 프로세서(202)에서는, 교환 프로세스 동안 하나의 부분이 판독되는 동안에 다른 부분이 기록될 수 있도록, 메모리(306.n)를 2 개의 부분들(영역들)로 분할하는 것이 가장 효과적이다. 교환 동안 개별적으로 액세스할 수 있는 메모리의 2개의 영역들은, 입력 영역 및 출력 영역으로 지칭되는데, 입력 영역에서는 다른 프로세서들로부터 메시지 데이터가 수신되고, 출력 영역에서는 다른 프로세서들로 메시지 데이터가 전송된다. 입력 영역 및 출력 영역은 서로 별개이다. 즉, 서로 겹치지 않는다. 도 10a는 메모리(306.n)의 입력 영역 IN.n 및 출력 영역 OUT.n을 도시한다. 또한, 제 1 작업공간 영역 WA.n 및 제 2 작업공간 영역 WB.n이 도시되며, 그 목적은 이하에서 설명된다.

이것은 부분적으로 도 9의 단계 S6에서의 포트 할당의 이유이다.

특히, 현재 슈퍼스텝 SS(1, m)의 교환 페이즈 E(1, m)을 유발하기 전에 상기 단계 S6에서 교환 페이즈 분할 데이터가 각 타일(302.n)의 제어 레지스터(R.n)에 기록되어 다음을 할당한다:

· 출력 영역과 제 1 작업공간 영역 OUT.n, WA.n 모두에 대한 제 1 포트 pA.n. 과

· 입력 영역 IN.n 및 제 2 작업공간 영역 WB.n에 대한 제 2 포트 pB.n.

이것은 도 10a의 우측에 도시되어 있다. 도 10a에서, 메모리 어드레스는 도시된 바와 같이 아래 방향으로 증가하지만, 이는 단지 예시일 뿐이다.

이와 같이 할당된 포트들을 이용하여, 각각의 프로세싱 유닛(304.n)은 현재 교환 페이즈 E(1, m)에서 로드/스토어 명령을 입력 영역 IN.n을 포함하는 메모리의 일부분으로 발행할 수 있으며, 이와 동시에 다른 로드/스토어 동작을 출력 영역 OUT.n을 포함하는 메모리의 일부분으로 발행할 수 있다. 이러한 방식으로, 도 11b에 도시된 바와 같이, 다른 타일들로부터 수신된 제 2 값들이 입력 영역(IN.n)에 저장되는 것(제 2 포트 pB.n 를 통해)과 동시에, 제 1 값들이 출력 영역 OUT.n으로부터 액세스되어 검색된다(제 1 포트 pA.n를 통해).

서로 다른 프로그램들은 태스크릿들의 내부 상태, 이들 사이의 메시지 트래픽 양 및 프로세서들 간의 태스크릿 그래프의 분할에 따라, 2개의 영역들에서 서로 다른 분량의 메모리를 필요로 할 수 있다. 따라서, 계산 또는 교환 동안 사용되는 각각의 메모리 포트에 대해 하나씩 2 개의 전용 메모리들을 각각의 프로세서에 구비하는 것 보다는, 각 타일(302.n)에 하나의 파티션가능한 메모리(306.n)를 제공하는 것이 바람직하다. 언급된 바와 같이, 프로세싱 유닛 제어 레지스터 R.n은 입력 영역 IN.n 및 제 2 작업공간 영역 W.B.n으로부터 제 1 작업공간 영역 WA.n 및 출력 영역 OUT.n을 분할하는 어드레스(파티션)를 식별한다. 이러한 목적으로 하나의 제어 레지스터가 사용될 수 있다. 즉, R.n에서 식별된 어드레스 아래(또는 이하에서)에서 하나의 포트(예: pB.n)가 액세스하고 그리고 그 어드레스 위에서(또는 이상에서) 다른 포트(예: pA.n)가 액세스할 수 있다. 메모리가 다수의 독립적인 뱅크들로 구성되어 있고 파티션이 뱅크 경계에 있도록 제한되어 있다면, 각 뱅크는 단일 포트만을 지원할 필요가 있으며 그리고 메모리 306.n의 최대 밀도가 획득될 수 있다.

두 개의 오퍼랜드를 갖는 통신 명령은 일례로서 본 명세서에서 "COMM"이라 지칭된다. COMM은 2 개의 오퍼랜드를 갖는다: 출력 영역 OUT.n의 출력값의 어드레스(addr_out)와 입력 영역 IN.n의 입력 값의 어드레스:

COMM addr_out addr_in

COMM는 교환 페이즈 E(l, m)에서 프로세싱 유닛(304.n) 상에서 실행되어, 인터커넥트(108)를 통해 수신된 입력 값을 addr_in 에 기록하고 이와 동시에, addr_out 으로부터 출력값을 검색하여 이를 인터커넥트(308)에 공급한다. 오퍼랜드는 위치들을 특정할 수 있으며, 또는 위치들이 식별되는 레지스터들을 식별할 수 있다. 예컨대, addr_out 및 addr_in이 항상 전용 레지스터에 기록되는 경우에는, 오퍼랜드가 필수적인 것은 아니다. 다음을 유의해야 하는바, COMM은 addr_out의 출력값이 목적지로 하는 타일을 식별하는 임의의 오퍼랜드를 가질 필요는 없는데, 왜냐하면 이것은 라틴 스퀘어 스케줄에 의해서 대신 판별될 수 있기 때문이다. 즉, 목적지는 교환 페이즈의 현재 sub-phase 에 의해 결정된다.

따라서, 교환 페이즈는 상이한 오퍼랜드들로 하나 이상의 COMM 명령들을 실행함으로써 구현될 수 있다. 컴파일 프로그램 p에서, COMM 명령들은 슈퍼바이저 코드 시퀀스 S0, ..., SN-1에 포함될 것이다.

입력 및 출력 둘다를 동시에 처리할 수 있는 하나의 통신 명령을 제공함으로써, 교환 페이즈에서 실행되어야 하는 명령들의 개수를 감소시킬 수 있다.

교환 페이즈(S8)의 모든 N-1 개의 서브-페이즈가 완료되면, 본 방법은 다음과 같은 방식으로 다음 슈퍼스텝으로 진행한다. 단계 S10에서, 현재 이터레이션 I(m)의 말미에 도달했는지, 즉 현재 이터레이션 I(m)의 최종 슈퍼스텝이 수행되었는지 여부가 결정된다. 그렇다면, 방법은 단계 S12로 진행하여, 예를 들어 프로그램에서 루프 종료 조건을 평가함으로써, 슈퍼스텝들의 시퀀스의 다른 이터레이션을 수행할지의 여부가 결정된다. 루프 종료 조건은 예를 들어, 이터레이션 카운터가 임계값에 도달하는 것, 특정 출력값(들)이 안정된 값으로 수렴하는 것, 기타 등등이 될 수 있다. 조건이 충족되면, 실행은 프로그램의 다른 부분으로 분기할 수 있다(예를 들어, 슈퍼스텝들의 다른 시퀀스를 수행하기 위해 또는 프로그램을 종료하기 위해)(S16).

만일, 단계 S10에서 현재 이터레이션 I(m)의 말미에 도달하지 않았다면, 본 방법은 현재 이터레이션 I(m)의 다음 슈퍼스텝 S(1 + 1, m)의 계산 단계 C(l + 1, m)로 진행한다. 즉, S(l + 1, m)에 대해 S2-S4가 반복된다. 최하위 레벨에서부터 최상위 레벨의 모든 코드릿들이 관련 계산 페이즈들에서 실행되었을 때, 현재 이터레이션이 완료된다. 레벨 카운터는 어떤 레벨의 코드릿들이 실행되었는지를 추적하고, 이에 의해서 현재 이터레이션 I(m)의 말미에 언제 도달하였는지를 확인하는데 사용될 수 있다.

단계 S12로 되돌아가서, 현재 이터레이션 I(m)의 최종 슈퍼스텝에 도달한 경우, 방법은 다음 이터레이션 I(m + 1)로 진행하고, 다음 이터레이션 I(m + 1)에 대해서 전술한 바와 같이 진행한다.

이제부터, 포트 할당들을 변경하는 이유들에 대해 설명할 것이다.

다음을 유의해야 하는바, 메시지는 교환 페이즈 E(1, m) 동안 한 번만 인터커넥트(306)를 통해 전송될 필요가 있지만, 수신 프로세서의 많은 태스크릿은 다음 계산 페이즈 C(l+1, m) 동안 상기 메시지를 소비할 수 있다. 다음을 상기해야 하는바, 프로그램을 형성하는 태스크릿 그래프의 일부 에지들은 프로세싱 유닛(304.n)에 대해 내부에 있을 것이므로, 교환 페이즈 동안 인터커넥트(308)를 통해 전송되는 임의의 대응 메시지도 요구하지 않을 것이다. 이러한 메시지들은 여전히 출력 영역 OUT.n에서 준비될 수 있다. 그러나 교환 페이즈 E(1, m) 동안 입력 영역 IN.n에 메시지를 복사하는 것은 메모리를 낭비할 것인데 왜냐하면, 동일한 프로세싱 유닛(304.n)의 메모리(306.n)에 2 개의 동일한 복사본이 존재하기 때문이다.

이제 계산 페이즈 C(l, m) 동안 메모리(306.n)의 사용예를 고려하자. 프로세싱 유닛(304.n)은 자신의 태스크릿들에 대한 입력들인 메시지들에 대한 판독 액세스를 필요로 할 것이다 - 이들 메시지들은 다른 프로세싱 유닛에서 실행되는 태스크릿에 대한 입력 영역 IN.n에 있게 되거나 또는 또는 동일한 프로세싱 유닛(304.n)에서 실행되는 태스크릿에 대한 출력 영역 OUT.n에 있게 될 것이다. 또한, 프로세싱 유닛(304.n)은 새로운 출력 메시지를 형성하기 위하여 출력 영역 OUT.n에 대한 기입 액세스를 필요로 하고, 그리고 태스크릿의 영속 상태 및 태스크릿 계산 동안의 중간 값들을 저장하기 위하여 일부 작업 메모리, 즉 작업공간 영역 WA.n, W.B.n의 적어도 하나에 대한 판독/기입 액세스를 필요로 한다.

계산 페이즈 C(l, m) 동안, 2 개의 메모리 포트 pA.n, pB.n 가, 2 개의 동시 발행된 로드/스토어 명령에도 이용가능한 경우에는 성능을 향상시킬 수 있다. 즉, 교환 페이즈에는 최대 효율을 위해 2 개의 메모리 포트가 필요하기 때문에, 계산 페이즈에서도 2 개의 포트를 모두 사용할 수 있도록 하는 것이 바람직하다.

이제 컴파일러 또는 어셈블리 프로그래머가 태스크릿에 대한 입력 데이터의로드 명령과 함께 작업공간에 로드/스토어 명령을 스케줄링하기를 원한다고 가정하자. 태스크릿 입력은 입력 영역 IN.n(로컬 메시지의 경우) 또는 출력 영역 OUT.n(다른 프로세싱 유닛들로부터의 메시지들의 경우) 중 하나로부터 올 수 있다. 만일, 이러한 영역들이 서로 다른 메모리 포트들을 통해 액세스된다면, 하나의 경우 또는 다른 하나의 경우는, 작업 영역에 대한 액세스와 충돌할 것이다. 따라서, 동일한 포트(pA.n 또는 pB.n)를 통해 입력 영역 IN.n과 출력 영역 OUT.n 둘다가 액세스되고, 그리고 다른 포트(pB.n 또는 pA.n)를 통해 작업공간 영역(예컨대, WB.N)이 액세스되도록, 계산 페이즈에서 메모리를 재-매핑(즉, 재-분할)하는 것이 유리하다. 즉, 작업공간 영역(예컨대, WB.n)은 각각의 계산 페이즈에서 전용 포트를 갖는다.

따라서, 계산 페이즈에서 메모리 어드레스들에 대한 메모리 포트들의 매핑은, 교환 페이즈에서의 그것과 다르다. 본 일례에서, 입력 영역 IN.n은 하나의 메모리 포트의 어드레스 공간으로부터 다른 메모리 포트의 어드레스 공간으로 이동한다. 이것은 단지 예일 뿐이며, 대안적으로는 출력 영역 OUT.n이 이동될 수도 있다.

도 10a의 좌측에는 예시적인 계산 페이즈 체계가 도시되는바, 여기서 제 2 포트(pB.n)는 제 2 작업공간 영역(pB.n)에 전용되고, 그리고 입력, 출력 및 제 1 작업공간 영역(IN.n, OUT.n, WA.n)은 모두 제 1 포트 pA.n을 공유한다.

각각의 교환 페이즈 E(l, m)에서, 각 타일은 다음 슈퍼스텝 SS(l + 1, m) 또는 SS(0, m + 1)에서 오프 타일 태스크릿(off tile tasklets)에 의해 요구되는 것이 무엇인지에 따라, 파이프라인된 데이터, 비-파이프라인된 데이터 또는 이들의 조합을 전송할 수 있다. 즉, 현재 및 레거시 출력 값들 모두가 교환 페이즈에서 다른 타일(들)로 전송될 수 있다.

소정의 주어진 계산 페이즈 C(l, m)에서, 새로운 제 1 값들이 다음으로부터 각 타일(302.n)에서 계산될 수 있다:

1) 각각의 슈퍼스텝 SS(l> 0, m) 즉, 현재 이터레이션 I(m)의 제일 첫 번째 슈퍼스텝을 제외한 각 슈퍼스텝에 대하여:

i. 동일한 타일(302.n)에서의 현재 이터레이션 I(m)의 선행 슈퍼스텝 SS(l-1, m)의 계산 페이즈 C(l-1, m)에서 계산된 하나 이상의 제 1 값들. 이들은 출력 영역 OUT.n에 유지되고 그리고 계산 페이즈에서 제 1 포트 pA.n을 통해 액세스된다; 및/또는

ii. 다른 타일(들)에서의 현재 이터레이션 I(m)의 선행 슈퍼스텝 SS(l-1, m)의 계산 페이즈 C(l-1, m)에서 계산된 하나 이상의 제 2 값들. 이들은 인터커넥트(308)를 통해 수신될 것이고 입력 영역 IN.n에 보유되며 그리고 또한 계산 페이즈에서 제 1 포트 pA.n을 통해 액세스된다; 및/또는

2) 각 이터레이션 I(m> 0), 즉 제일 첫번째 이터레이션 I(0)을 제외한 각각의 이터레이션에 대하여: 동일한 타일(302.n)에서의 선행 이터레이션 I(m-1)에서 생성된 레가시 세트(legacy set)의 하나 이상의 값들. 이들 값들은 제 2 포트 pB.n을 통해 액세스된다; 및/또는

3) 제 1 또는 제 2 작업공간 영역 WA.n, WB.n에 보유되는 로컬 작업 데이터, 이는 프로그램 실행 중 임의의 포인트에서 생성될 수 있다.

1)은 프로그램에서 비-파이프라인 에지를 수용해야 하므로 필요한 반면에 2)는 파이프라인 에지를 수용하는데 필요하다.

위의 일례에서, 입력 영역 IN.n은 제 2 포트 pB.n (교환 페이즈에서) 및 제 1 포트 pA.n (계산 페이즈에서) 사이에서 재할당되지만, 출력 영역 OUT.n은 제 1 포트 pA.n. 에 할당된 채로 남아있는다. 똑같이 유효한 대안예는, 출력 영역 OUT.n을 이런 방식으로 재할당하고 대신에 제 1 포트 pA.n에 할당된 입력 영역을 그대로 남겨 두는 것이다.

제 1 및 제 2 작업공간들 WA.n, WB.n은 계산 페이즈뿐만 아니라 교환 페이즈 동안 어드레싱될 수 있다(이 예에서 각각 제 1 포트 pA.n 및 제 2 포트 pB.n을 통해). 이것은 필수적인 것은 아니지만, 작업 영역은 교환 페이즈 조정 과정에서 동시에 프로세서에 유용할 수 있다.

모든 N 개의 타일들(302)에 대한 계산 및 교환 페이즈들의 글로벌 동기화는 동기화 로직(310)에 의해 조정된다. 각 타일(302.n)은, 현재 슈퍼스텝의 교환 페이즈에서 그것의 코드릿들 중 마지막 코드릿을 실행하면, 동기화기(310)로 교환 요청 신호를 발생시킨다(instigate). 모든 타일들(302)이 이것을 행한 경우에만, 동기화기(310)는 각각의 교환 진행 신호를 각 타일(3022.n)로 발생시킨다. 각각의 교환 진행 신호에 응답하여, 현재의 슈퍼스텝의 교환 페이즈 E(l, m)가 각 타일(302.n)에서 시작된다. 유사하게, 각각의 타일(302.n)은 교환 페이즈에서 전송하고자 하는 모든 출력값들을 전송하면, 계산 요청 신호를 동기화기(310)로 보낸다. 계산 요청 신호가 모든 타일(302)로부터 수신된 경우에만, 동기화기(310)는 각각의 타일(3022.n)에 대한 각각의 계산 진행 신호를 발생시키고, 이에 응답하여 타일(302.n)은 다음 슈퍼스텝의 계산 페이즈를 개시한다.

설명을 돕기 위해, 도 9의 흐름도의 단계들 중 일부는 멀티 프로세서(402)상에서 실행될 때 도 8의 컴파일된 프로그램 p에 대해 도 8a에 그래픽적으로 도시된다. 도 8 및 도 8a에서, "i" 및 "o" 는 프로그램 p의 시작과 끝에서 입력값과 출력값을 나타낸다. 예를 들어, 레벨 0 코드릿 C0ii의 파이프라인된 버전과 비-파이프라인된 버전 모두가 각 이터레이션의 두 번째 슈퍼스텝의 계산 페이즈에서 레벨 1 코드릿 C1i 및 C1ii에 의해 동시에 사용되므로, 2 개의 버전들이 메모리에 유지될 필요가 있음을 유의해야 한다.

설명을 돕기 위해, 머신 러닝과 관련하여 본 발명의 주제에 대한 예시적인 구현예가 설명될 것이다. 이는 예시적인 것이며 다른 구현예가 본 발명의 범위 내에 속함을 알 수 있을 것이다.

서로 다른 코드 시퀀스들 사이의 에지들을 정의하는 작업 데이터는 통신된 데이터 자체와 동일한 포트 AA.n을 통해 가장 효율적으로 액세스할 수 있지만, 출력값들의 새로운 세트를 생성하기 위해 통신된 데이터를 조작하는데 사용되는 데이터는 "스페어"포트 WB.n(이전의 슈퍼스텝 및/또는 이터레이션에서 계산된 값을 검색할 필요가 없다는 점에서 각 계산 페이즈에서 스페어임)를 통해 가장 효율적으로 액세스될 수 있다. 에지를 정의하는 작업 데이터는 이전 태스크릿에 의해 생성되고 현재 태스크릿에 의해 요구되는 출력들이 입력 또는 출력 영역 IN.n, OUT.n에 저장되는 위치를 식별한다. 이들은 예를 들어 적절한 메모리 포인터들에 의해 식별될 수 있다.

잘 알려진 바와 같이, 신경망은 "뉴런들"을 통신하는 층들에 의해 구현된다. 제 1 층을 제외한 각 층의 각각의 뉴런은 출력을 계산하며, 상기 출력은 통상적으로는

의 비선형 함수이며, 여기서 x 는 벡터이고 상기 벡터의 각 성분은 선행하는 층의 뉴런에 의해 생성된 출력이며, 그리고 w 는 그 뉴런에 대해 로컬인 가중치들 wi 의 벡터이며, 이는 신경망을 훈련시키기 위해 이터레이션적으로 업데이트된다.

본 문맥에서, 각각의 층은 개별적인 단계로서 구현될 수 있고, 그 층의 각각의 뉴런은 코드릿으로서 구현될 수 있는데, 이는 x 및 w 각각에 대하여 w.x 를 계산하기 위해서 그 단계에서 실행된다. 전형적으로는, x 의 개별 성분들 xi (본 문맥에서는, 이들은 타일 상에서(on tile)(OUT.n 에서) 계산된 출력 값들이거나 및/또는 타일 밖에서(off tile)(IN.n 에서) 계산된 수신된 입력 값들임)은, 메모리에 공간적으로 분산될 것이며; 이들이 코드릿에 의해서 필요에 따라 검색가능하기 위하여 타일의 메모리 내에서의 이들의 위치들은 예컨대, 메모리 포인터들을 이용하여 메모리에 매핑될 수 있으며 - 매핑들은 성분들 x 자체와 동일한 포트를 통해 가장 효율적으로 액세스될 수 있는바 따라서, 상기 성분들은 제 1 작업공간 영역(WA.n)에 가장 효율적으로 저장된다. 이와 반대로, 가중치들 wi 이 스페어 포트를 통해 액세스 및 업데이트되는 경우가 가장 효율적이며, 따라서 이들은 효율성을 최대화하기 위해 제 2 작업공간 영역(WB.n)에 저장될 수 있다.

각 타일의 슈퍼바이저는:

· 적절한 시간들에서 태스크릿들을 작업자들 WT.n에게 위임(delegating)함으로써 태스크릿들을 스케줄링하고;

· 계산 및 교환 페이즈들을 분리하도록, 작업자들의 배리어 동기화를 구현하고;

· 시퀀스(예컨대, 분석 그래프 또는 분석 그래프들의 시퀀스)의 이터레이션의 말미에서 루프 조건을 평가하여, 그 시퀀스의 다른 이터레이션을 수행할지(조건이 충족되는 경우) 또는 프로그램의 다른 위치(예컨대, 다른 분석 그래프로)로 분기할지를 결정하고;

· 계산 및 교환 요청 신호를 발생시키고, 계산/교환 진행 신호에 응답하여 계산/교환 페이즈를 동기화한다.

작업자들 WT.n 각각은 위임된 임의의 태스크릿을 수행한다.

비록, 앞선 일례에서는 연속적으로 서술되었지만, 영역들은 반드시 연속적일 필요는 없다.

"시퀀스의 이전(earlier) 단계와 이후(later) 단계"의 맥락에서 "이전" 과 "이후"는 해당 시퀀스의 주어진 이터레이션의 문맥에서만 서로 관련이 있다. 즉, 해당 시퀀스의 초기 이터레이션의 이후 단계(later step)는, 그 시퀀스의 후속(subsequent) 이터레이션의 이전 단계(earlier step) 전에 수행된다.

초기(initial)라는 용어는 반드시 이터레이션의 제일 첫 번째 슈퍼스텝을 지칭하거나 또는 프로그램의 제일 첫 번째 이터레이션을 지칭하는 것은 아니다(이를 배제하는 것은 아님). 즉, "초기" 슈퍼스텝 또는 이터레이션은, 서술되는 슈퍼스텝들 또는 이터레이션들의 (서브)세트의 문맥에서만 초기일 수 있다.

컴퓨팅 유닛이 "다른" 컴퓨팅 유닛과 데이터를 송수신한다고 언급되는 경우, 상기 "다른" 컴퓨팅 유닛은 송신자(sender)/수신자(receiver)와는 다른 임의의 컴퓨팅 유닛을 의미한다. "다른 컴퓨팅 유닛으로/로부터 제 1 값을 송신/수신하고 그리고 다른 컴퓨팅 유닛으로/로부터 제 2 값을 송신/수신한다" (또는 이와 유사한 것)을 언급하는 경우, 전자는 후자와 같을 수도 있고 그렇지 않을 수도 있다. 즉, 이 용어는, 송신자/수신자와 다른 하나의 컴퓨팅 유닛 및 송신자/수신자와 다를 뿐만 아니라 서로 다른 다수의 컴퓨팅 유닛들을 커버한다.

개시된 기술들의 다른 변형예 또는 응용예는 본 명세서의 개시 내용이 주어지면 당업자에게 명백해질 수 있다. 본 발명의 범위는 상술한 예시적인 실시예에 의해 제한되지 않고 첨부된 청구항에 의해서만 제한된다.

Claims

컴퓨터 프로그램을 실행하는 방법으로서, 상기 방법은 복수의 계산 유닛들과 상기 계산 유닛들에 연결된 인터커넥트를 포함하는 프로세서에 의해서 구현되며, 각각의 계산 유닛은 프로세싱 유닛 및 적어도 2개의 메모리 포트들을 갖는 메모리를 포함하며, 각각의 메모리 포트는 상기 메모리의 하나 이상의 각 영역들에 할당될 수 있으며, 상기 방법은 각각의 계산 유닛에서,
상기 메모리의 출력 영역에 초기 출력값을 기입하고 상기 메모리의 입력 영역에 초기 입력값을 기입하도록 상기 프로그램의 초기 단계(initial step)를 수행하는 것; 및
상기 프로그램의 후속 단계(subsequent step)를 수행하는 것을 포함하되,
상기 프로그램의 후속 단계를 수행하는 것은,
계산 페이즈(computing phase)에서:
상기 2 개의 메모리 포트들 중 하나의 메모리 포트를 상기 입력 영역과 상기 출력 영역 둘다에 할당하는 것;
하나 이상의 새로운 출력값들의 출력 세트를 계산하도록 상기 프로세싱 유닛 상에서 코드 시퀀스들을 실행하고, 상기 출력 세트를 상기 출력 영역에 기입하는 것, 상기 출력 세트는 상기 초기 출력값 및 초기 입력값으로부터 계산되고, 상기 초기 출력값 및 초기 입력값 각각은 상기 계산 페이즈에서 상기 하나의 메모리 포트를 통해 검색되며;
상기 계산 페이즈가 완료되면 교환 페이즈에서:
상기 2개의 메모리 포트들 중 제 1 메모리 포트를 상기 출력 영역에 할당하고 제 2 메모리 포트를 입력 영역에 할당하는 것; 및
상기 출력 세트의 새로운 출력값을 상기 제 1 메모리 포트를 통해 상기 출력 영역으로부터 검색하고 상기 검색된 값을 상기 인터커넥트를 통해 상이한 계산 유닛으로 전송하고, 그리고 상기 후속 단계에서 상기 상이한 계산 유닛에 의해 계산된 새로운 입력값을 상기 인터커넥트를 통해 수신하고 수신된 값을 상기 제 2 메모리 포트를 통해 상기 입력 영역에 기입하는 것
을 포함하는 것을 특징으로 하는 컴퓨터 프로그램을 실행하는 방법.
제1항에 있어서,
상기 하나의 메모리 포트가 또한 상기 계산 페이즈에서 제 1 작업공간 영역(first workspace region)에 할당되고, 상기 출력 세트는 상기 계산 유닛에 대해 로컬(local)인 제 1 작업 데이터(working data)를 이용하여 계산되고, 상기 제 1 작업공간 영역에 저장되며, 그리고 상기 계산 페이즈에서 상기 하나의 메모리 포트를 통해 검색되는 것을 특징으로 하는 컴퓨터 프로그램을 실행하는 방법.
제2항에 있어서,
상기 제 1 작업 데이터는 상기 초기 출력값이 유지되는 상기 출력 영역의 제 1 위치 및/또는 상기 초기 입력값이 유지되는 상기 입력 영역의 제 2 위치를 식별하는 것을 특징으로 하는 컴퓨터 프로그램을 실행하는 방법.
제3항에 있어서,
상기 제 1 작업 데이터는 상기 제 1 위치에 대한 제 1 메모리 포인터 및/또는 상기 제 2 위치에 대한 제 2 메모리 포인터를 포함하는 것을 특징으로 하는 컴퓨터 프로그램을 실행하는 방법.
제1, 2, 3, 또는 4항에 있어서,
상기 2개의 메모리 포트들 중 다른 하나의 메모리 포트는 상기 계산 페이즈에서 상기 메모리의 제 2 작업공간 영역에 할당되며, 상기 출력 세트는 상기 계산 유닛에 대해 로컬인 제 2 작업 데이터를 이용하여 계산되고, 상기 제 2 작업공간 영역에 저장되며, 그리고 상기 계산 페이즈에서 상기 다른 하나의 메모리 포트를 통해 검색되는 것을 특징으로 하는 컴퓨터 프로그램을 실행하는 방법.
제5항에 있어서,
상기 제 2 작업 데이터는 로컬 값을 포함하고, 상기 출력 세트의 적어도 하나의 새로운 출력값은, 상기 로컬 값과 상기 초기 출력값 및/또는 초기 입력값을 입력으로 하는 함수를 평가함으로써 상기 계산 페이즈에서 계산되며, 상기 초기 출력값 및/또는 초기 입력값은 상기 하나의 포트를 통해 검색되고 상기 로컬 값은 상기 다른 하나의 포트를 통해 검색되는 것을 특징으로 하는 컴퓨터 프로그램을 실행하는 방법.
제6항에 있어서,
상기 제 2 작업 데이터는 제 1 및 제 2 로컬 값을 포함하고, 그리고 적어도 하나의 새로운 제 1 값은 합산의 비선형 함수(nonlinear function of a summation)로서 계산되며, 상기 합산(summation)은 적어도 상기 제 1 로컬 값과 상기 초기 출력값의 곱(product) 및 상기 제 2 로컬 값과 상기 초기 입력값의 곱(product)이며, 상기 초기값들은 상기 하나의 포트를 통해 검색되고 상기 로컬 값들은 상기 다른 하나의 포트를 통해 검색되는 것을 특징으로 하는 컴퓨터 프로그램을 실행하는 방법.
제1, 2, 3, 또는 4항에 있어서,
상기 새로운 출력값은 상기 출력 영역에서 검색 및 전송되고 그리고 상기 새로운 입력값은 상기 프로세싱 유닛 상에서 하나의 통신 명령을 실행함으로써 상기 입력 영역에 기입되는 것을 특징으로 하는 컴퓨터 프로그램을 실행하는 방법.
제8항에 있어서,
상기 하나의 통신 명령은, 상기 새로운 출력값이 유지되는 상기 출력 영역의 위치를 식별하는 출력 오퍼랜드 및 상기 수신된 새로운 입력값이 기입되는 상기 입력 영역의 위치를 식별하는 입력 오퍼랜드를 갖는 것을 특징으로 하는 컴퓨터 프로그램을 실행하는 방법.
제1항에 있어서,
상기 교환 페이즈는 다수의 서브-페이즈들을 차례로 수행함으로써 수행되고, 각각의 서브-페이즈에서, 각각의 계산 유닛은 기껏해야(at most) 하나의 각각의 다른 계산 유닛으로 데이터를 전송하고, 상기 각각의 다른 계산 유닛은 그 서브-페이즈에서 임의의 다른 계산 유닛으로부터 데이터를 수신하지 않으며, 그리고 그 계산 유닛은 상기 교환 페이즈의 임의의 다른 서브-페이즈에서 상기 각각의 다른 계산 유닛으로 데이터를 전송하지 않는 것을 특징으로 하는 컴퓨터 프로그램을 실행하는 방법.
제10항에 있어서,
상기 서브-페이즈들의 개수는 상기 프로세싱 유닛들의 개수보다 하나 적은 것을 특징으로 하는 컴퓨터 프로그램을 실행하는 방법.
제10항 또는 제11항에 있어서,
각각의 서브-페이즈에 대해, 상기 각각의 다른 계산 유닛을 식별하는 스케줄이 각각의 프로세싱 유닛에서 유지되는 것을 특징으로 하는 컴퓨터 프로그램을 실행하는 방법.
제12항에 있어서,
상기 스케줄은 라틴 스퀘어(Latin square)의 적어도 일부를 포함하는 것을 특징으로 하는 컴퓨터 프로그램을 실행하는 방법.
제7항에 있어서,
상기 교환 페이즈는 다수의 서브-페이즈들을 차례로 수행함으로써 수행되며, 각각의 서브-페이즈에서, 각각의 계산 유닛은 기껏해야(at most) 하나의 각각의 다른 계산 유닛으로 데이터를 전송하고, 상기 각각의 다른 계산 유닛은 그 서브-페이즈에서 임의의 다른 계산 유닛으로부터 데이터를 수신하지 않으며, 그리고 그 계산 유닛은 상기 교환 페이즈의 임의의 다른 서브-페이즈에서 상기 각각의 다른 계산 유닛으로 데이터를 전송하지 않으며;
상기 서브-페이즈들의 개수는 상기 프로세싱 유닛들의 개수보다 하나 적으며;
상기 스케줄은 라틴 스퀘어(Latin square)의 적어도 일부를 포함하며; 그리고
상기 하나의 통신 명령은 상기 서브-페이즈들 중 하나에서 실행되고 그리고 상기 다른 프로세싱 유닛을 식별하는 임의의 오퍼랜드를 포함하지 않는 것을 특징으로 하는 컴퓨터 프로그램을 실행하는 방법.
제1, 2, 3, 4, 10, 또는 11항 중 어느 한 항에 있어서,
각각의 계산 유닛은 개별 대역폭을 가지는 각각의 연결에 의해 인터커넥트에 연결되고, 상기 인터커넥트는 적어도 상기 개별 대역폭들의 총합만큼 큰 대역폭을 갖는 것을 특징으로 하는 컴퓨터 프로그램을 실행하는 방법.
제1, 2, 3, 4, 10, 또는 11항 중 어느 한 항에 있어서,
각각의 프로세싱 유닛은 하나 이상의 제어 레지스터들을 가지며, 상기 하나의 메모리 포트는 계산 페이즈 분할 데이터를 상기 제어 레지스터(들) 중 적어도 하나에 기입함으로써, 상기 계산 페이즈에서 상기 입력 및 출력 영역들 둘다에 할당되며, 그리고 상기 제 1 및 제 2 포트는 교환 페이즈 분할 데이터를 상기 제어 레지스터(들) 중 적어도 하나에 기입함으로써, 상기 교환 페이즈에서 상기 출력 및 입력 영역들에 각각 할당되는 것을 특징으로 하는 컴퓨터 프로그램을 실행하는 방법.
제16항에 있어서,
상기 계산 페이즈 분할 데이터는 상기 메모리 내의 단일 어드레스의 형태이며, 그리고 상기 교환 페이즈 분할 데이터는 상기 메모리 내의 다른 단일 어드레스의 형태인 것을 특징으로 하는 컴퓨터 프로그램을 실행하는 방법.
제1항에 있어서,
상기 프로세서는 각각의 계산 유닛에 연결된 동기화 로직을 포함하고, 각각의 계산 유닛에서:
상기 계산 페이즈의 말미에서, 그 계산 유닛은 교환 요청 신호를 상기 동기화 로직으로 발생시키고(instigate)하고, 상기 교환 요청 신호들이 모든 계산 유닛들로부터 수신된 때에만 상기 동기화 로직은 교환 진행 신호를 각각의 계산 유닛으로 발생시키며, 그리고
그 계산 유닛은 상기 교환 진행 신호를 수신함에 응답하여 교환 페이즈를 개시하는 것을 특징으로 하는 컴퓨터 프로그램을 실행하는 방법.
제18항에 있어서, 상기 각각의 계산 유닛에서:
상기 초기 입력값은 상기 초기 단계의 교환 페이즈에서 수신되고,
상기 교환 페이즈의 말미에서, 그 계산 유닛은 계산 요청 신호를 상기 동기화 로직으로 발생시키고(instigate)하고, 상기 계산 요청 신호들이 모든 계산 유닛들로부터 수신된 때에만 상기 동기화 로직은 계산 진행 신호를 각각의 계산 유닛으로 발생시키며, 그리고
그 계산 유닛은 상기 계산 진행 신호를 수신함에 응답하여 상기 후속 단계의 계산 페이즈를 개시하는 것을 특징으로 하는 컴퓨터 프로그램을 실행하는 방법.
제18항 또는 제19항에 있어서,
상기 동기화 로직은 전용 동기화 하드웨어인 것을 특징으로 하는 컴퓨터 프로그램을 실행하는 방법.
제1, 2, 3, 4, 10, 11, 18 또는 19항 중 어느 한 항에 있어서,
상기 후속 단계는 차례로 수행되는 다수의 후속 단계들 중 첫번째 후속 단계이고, 상기 다수의 후속 단계들 각각은 그 단계의 계산 페이즈에서 출력 영역에 기입되는 하나 이상의 각각의 새로운 출력값들의 각각의 출력 세트를 계산하고, 그리고 그 단계의 교환 페이즈에서 입력 영역에 기입되는 각각의 새로운 입력값을 수신함으로써 수행되며, 상기 각각의 출력 세트는, 선행 단계의 계산 페이즈에서 상기 출력 영역에 기입되었던 출력값 및/또는 선행 단계의 교환 페이즈에서 상기 입력 영역에 기입되었던 입력값으로부터 계산되는 것을 특징으로 하는 컴퓨터 프로그램을 실행하는 방법.
제6항에 있어서,
각각의 프로세싱 유닛은 하나 이상의 제어 레지스터들을 가지며, 상기 하나의 메모리 포트는 계산 위상 분할 데이터를 상기 제어 레지스터(들) 중 적어도 하나에 기입함으로써 상기 계산 페이즈에서 상기 입력 영역 및 출력 영역 모두에 할당되고, 상기 제 1 및 상기 제 2 메모리 포트는 교환 페이즈 분할 데이터를 상기 제어 레지스터(들) 중 적어도 하나에 기입함으로써 상기 교환 페이즈에서 상기 출력 영역 및 입력 영역에 각각 할당되고;
상기 계산 페이즈 분할 데이터는 상기 메모리 내의 단일 어드레스의 형태이며, 그리고 상기 교환 페이즈 분할 데이터는 상기 메모리 내의 다른 단일 어드레스의 형태이고;
각각의 후속 단계에 대해, 상기 로컬 값은 선행 단계의 계산 페이즈에서 상기 출력 영역에 기입되었던 출력값 및/또는 선행 단계의 교환 페이즈에서 상기 입력 영역에 기입되었던 입력값에 기초하여 업데이트되며; 그리고
그 단계를 위해 업데이트되는 로컬 변수(local variable)와 선행 단계의 계산 페이즈에서 상기 출력 영역에 기입되었던 출력값 및/또는 선행 단계의 교환 페이즈에서 상기 입력 영역에 기입되었던 입력값을 함수의 입력들로 하는 상기 함수를 평가함으로써, 적어도 하나의 각각의 새로운 출력값이 각 후속 단계의 계산 페이즈에서 계산되는 것을 특징으로 하는 컴퓨터 프로그램을 실행하는 방법.
컴퓨터 프로그램을 실행하는 프로세서로서, 상기 프로세서는 복수의 계산 유닛들과 상기 계산 유닛들에 연결된 인터커넥트를 포함하고, 각각의 계산 유닛은 프로세싱 유닛 및 적어도 2개의 메모리 포트들을 갖는 메모리를 포함하며, 각각의 메모리 포트는 상기 메모리의 하나 이상의 각 영역들에 할당될 수 있으며, 각각의 계산 유닛은,
상기 메모리의 출력 영역에 초기 출력값을 기입하고 상기 메모리의 입력 영역에 초기 입력값을 기입하도록 상기 프로그램의 초기 단계(initial step)를 수행하고; 그리고
상기 프로그램의 후속 단계(subsequent step)를 수행하도록 구성되되,
상기 프로그램의 후속 단계를 수행하는 것은,
계산 페이즈(computing phase)에서:
상기 2 개의 메모리 포트들 중 하나의 메모리 포트를 상기 입력 영역과 상기 출력 영역 둘다에 할당하고;
하나 이상의 새로운 출력값들의 출력 세트를 계산하도록 상기 프로세싱 유닛 상에서 코드 시퀀스들을 실행하고 그리고 상기 출력 세트를 상기 출력 영역에 기입하며, 상기 출력 세트는 상기 초기 출력값 및 초기 입력값으로부터 계산되고, 상기 초기 출력값 및 초기 입력값 각각은 상기 계산 페이즈에서 상기 하나의 메모리 포트를 통해 검색되며;
상기 계산 페이즈가 완료되면 교환 페이즈에서:
상기 2개의 메모리 포트들 중 제 1 메모리 포트를 상기 출력 영역에 할당하고 제 2 메모리 포트를 입력 영역에 할당하고; 그리고
상기 출력 세트의 새로운 출력값을 상기 제 1 메모리 포트를 통해 상기 출력 영역으로부터 검색하고 상기 검색된 값을 상기 인터커넥트를 통해 상이한 계산 유닛으로 전송하고, 그리고 상기 후속 단계에서 상기 상이한 계산 유닛에 의해 계산된 새로운 입력값을 상기 인터커넥트를 통해 수신하고 수신된 값을 상기 제 2 메모리 포트를 통해 상기 입력 영역에 기입하는 것을 포함하는, 컴퓨터 프로그램을 실행하는 프로세서.
실행가능한 명령들을 포함하는 컴퓨터 프로그램 제품으로서, 상기 명령들은 제23항의 프로세서 상에서 실행될 때, 제1, 2, 3, 4, 10, 11, 18 또는 19항 중 어느 한 항의 방법을 구현하는 것을 특징으로 하는 컴퓨터 프로그램 제품.
컴퓨터 프로그램을 실행하기 위해 프로세서에서 사용하기 위한 계산 유닛으로서, 상기 계산 유닛은 프로세싱 유닛 및 적어도 2개의 메모리 포트들을 갖는 메모리를 포함하며, 각각의 메모리 포트는 상기 메모리의 하나 이상의 각 영역들에 할당될 수 있으며, 상기 계산 유닛은,
상기 메모리의 출력 영역에 초기 출력값을 기입하고 상기 메모리의 입력 영역에 초기 입력값을 기입하도록 상기 프로그램의 초기 단계(initial step)를 수행하고; 그리고
상기 프로그램의 후속 단계(subsequent step)를 수행하도록 구성되되,
상기 프로그램의 후속 단계를 수행하는 것은,
계산 페이즈(computing phase)에서:
상기 2 개의 메모리 포트들 중 하나의 메모리 포트를 상기 입력 영역과 상기 출력 영역 둘다에 할당하고;
하나 이상의 새로운 출력값들의 출력 세트를 계산하도록 상기 프로세싱 유닛 상에서 코드 시퀀스들을 실행하고 그리고 상기 출력 세트를 상기 출력 영역에 기입하며, 상기 출력 세트는 상기 초기 출력값 및 초기 입력값으로부터 계산되고, 상기 초기 출력값 및 초기 입력값 각각은 상기 계산 페이즈에서 상기 하나의 메모리 포트를 통해 검색되며;
상기 계산 페이즈가 완료되면 교환 페이즈에서:
상기 2개의 메모리 포트들 중 제 1 메모리 포트를 상기 출력 영역에 할당하고 제 2 메모리 포트를 입력 영역에 할당하고; 그리고
상기 출력 세트의 새로운 출력값을 상기 제 1 메모리 포트를 통해 상기 출력 영역으로부터 검색하고 상기 검색된 값을 상기 프로세서의 인터커넥트를 통해 상이한 계산 유닛으로 전송하고, 그리고 상기 후속 단계에서 상기 상이한 계산 유닛에 의해 계산된 새로운 입력값을 상기 인터커넥트를 통해 수신하고 수신된 값을 상기 제 2 메모리 포트를 통해 상기 입력 영역에 기입하는 것을 포함하는, 프로세서에서 사용하기 위한 계산 유닛.