KR102355990B1 - 그래픽 처리 유닛에 대한 고성능 희소 삼각 풀이 - Google Patents

Abstract

방법은 희소 삼각 행렬을 압축 희소 로우(CSR) 데이터세트로 저장하는 것을 포함한다. 제1 벡터의 복수 인자들의 각 인자에 대해, 제1 벡터의 하나 이상의 선행 인자들의 세트를 식별함으로써 인자에 대해 인자의 값은 계산되며, 인자의 값은 하나 이상의 선행 인자들 각각에 종속한다. 하나 이상의 선행 인자 값들이 모두 해결되었음을 나타내는 완료 어레이에 응답하여, 인자의 값은 행렬의 로우의 하나 이상의 요소들과 로우에 대응하는 산출 값을 기반으로 계산된다. 완료 어레이에서, 인자에 대한 제1 완료 플래그가 어서션되어, 인자가 해결되었음을 나타낸다.

Description

그래픽 처리 유닛에 대한 고성능 희소 삼각 풀이

삼각 행렬은 행렬의 주 대각선 위 또는 아래에 0의 요소들만을 갖는 정사각형 행렬 유형이다. 하부 삼각 행렬은 주 대각선 위의 0의 요소들만을 갖고, 행렬의 0이 아닌 요소들은 주 대각선 또는 그 아래에 있는 하부 삼각형에 있다. 상부 삼각형 행렬은 주 대각선 아래에 0의 요소들만을 갖고, 행렬의 0이 아닌 요소들은 주 대각선 또는 그 위의 상부 삼각형에 있다. 삼각 행렬은 선형 대수학 분야에서 연립 방정식을 나타내는 데 사용될 수 있다.

희소 삼각 행렬(sparse triangular matrix)은 채워진 삼각형에 많은 수의 0의 요소들이 있는 삼각 행렬이며, 예를 들어, 희소 하부 삼각 행렬은 그 하부 삼각형에 하나 이상의 0 값들을 갖는다. 희소 삼각 풀이(sparse triangular solve, SpTS)는 방정식 Ax = y에서 벡터 x를 구하는 과정이며, 여기서 A는 N 개의 로우들(rows)과 N 개의 컬럼들(columns)이 있는 희소 삼각 행렬이고, x는 N 개의 알 수 없는 값들을 가진 벡터이고, y는 N 개의 알려진 값들의 벡터이다. 행렬 A에서 0이 아닌 값이 주 대각선과 해당 대각선의 일 측에만 있는 경우, 대입(substitution)을 사용하여 벡터 x를 구할 수 있습니다. 벡터 항목 x[n]에 대한 풀이는 하위 삼각형 행렬에서 전진 대입(forward substitution)의 경우 모든 이전 벡터 항목들(예를 들어, x[0] - x[n-1])을 풀었는지에 의존한다. 그러나 희소 행렬의 경우, 삼각 행렬 값들 중 일부도 0이 되고 병렬 프로세서들 상에서 다수의 로우들을 병렬로 풀 수 있다.

본 개시는 첨부 도면에서 제한이 아닌 예로서 예시된다.
도 1은 일 실시예에 따른 희소 삼각 풀이(SpTS)를 수행하기 위한 병렬 컴퓨팅 시스템의 일 실시예를 도시한다.
도 2는 일 실시예에 따른 컴퓨팅 디바이스를 도시한다.
도 3은 일 실시예에 따른 컴퓨팅 디바이스의 다중 처리 유닛 및 메모리를 도시한다.
도 4a는 일 실시예에 따른 희소 삼각 행렬과 벡터의 행렬 곱을 도시한다.
도 4b는 일 실시예에 따른 SpTS에 대한 종속성 그래프를 도시한다.
도 4c는 일 실시예에 따른 압축 희소 로우(compressed sparse row, CSR) 데이터세트 및 완료 어레이를 도시한다.
도 5는 일 실시예에 따른 벡터의 각 인자에 대한 완료 플래그들(completion flags)을 식별하기 위한 CSR 데이터세트의 요소들을 예시한다.
도 6은 일 실시예에 따른 SpTS의 이벤트들의 타임라인을 도시한다.
도 7은 일 실시예에 따른 SpTS의 이벤트들의 타임라인을 도시한다.
도 8은 일 실시예에 따른 처리 코어에서 SpTS를 수행하기 위한 모듈을 예시하는 블록도이다.
도 9a 및 9b는 일 실시예에 따른 SpTS를 수행하기 위한 프로세스를 예시하는 흐름도들이다.

다음의 설명은 실시예들의 좋은 이해를 제공하기 위해 특정 시스템, 구성 요소, 방법 등의 예시들과 같은 수 많은 특정 세부 사항을 설명한다. 그러나, 적어도 일부 실시예들이 이러한 특정 세부 사항 없이 실시될 수 있다는 것은 당업자에게 명백할 것이다. 다른 예시에서, 잘 알려진 구성 요소 또는 방법은 실시예를 불필요하게 모호하게 하는 것을 피하기 위해 상세하게 설명되지 않거나 간단한 블록 다이어그램 형식으로 제공된다. 따라서, 설명된 특정 세부 사항은 단지 예시 일뿐이다. 특정 구현은 이러한 예시적인 세부 사항과 다를 수 있으며 여전히 실시예의 범위 내에 있는 것으로 고려된다.

희소 삼각 풀이(SpTS)는 방정식 Ax = y 에서 벡터 x의 알려지지 않은 값을 해결하려고 하며, 여기서 A는 희소 삼각 행렬이고 y는 알려진 값들로 구성된 벡터이다. 희소 삼각 행렬의 로우들을 병렬로 해결하는 것은 일련의 데이터 종속성을 초래한다; 벡터 x의 각 인자 x[n]의 해는 풀이된 이전 인자 x[0] - x[n-1]에 의존한다. 해는 일련의 레벨들로 나눌 수 있고, 동일한 레벨의 인자들이 직접적으로 또는 전이적으로 서로 의존하지 않으므로 서로 병렬로 해결될 수 있다. 병렬 SpTS를 신속하게 수행하는 데있어 가장 큰 어려움 중 하나는 특히 입력 행렬에 수천 또는 수백만 개의 로우들과 컬럼들이 포함된 경우 특정 입력 행렬에 대해 이러한 데이터 종속성 그래프를 찾는 것이다. 따라서 희소 삼각 풀이는 GPU(그래픽 처리 유닛) 기반 병렬 컴퓨팅 시스템과 같은 고도의 병렬 아키텍처에서 여전히 성능이 저하될 수 있다. 병렬 컴퓨팅 시스템은 계산을 시작하기 전에 결정된 종속성 그래프를 기반으로 또는 이전에 계산된 결과를 사용할 수 있는 경우 병렬 작업자간에 통신하여 특정 인자에 대한 풀이를 시작할 시기를 결정할 수 있다.

병렬 컴퓨팅 시스템에서 SpTS를 수행하는 한 가지 방법은 먼저 입력 행렬을 분석하여 병렬로 풀 수 있는 로우와 인자를 결정하고, 그런 다음 레벨의 각 로우를 병렬로 해결하기 위한 스레드를 포함하는 각 레벨에 대한 새 커널을 런칭하는 것을 포함한다. 그러나 SpTS를 분석 및 솔루션 단계로 나누면 사용자가 원하는 솔루션을 얻기 전에 분석(구현 레벨-세부 정보)을 추가로 호출하는 더 번거로운 어플리케이션 프로그래밍 인터페이스(application programming interface, API)가 생성된다. 또한 분석을 수행하는 데 걸리는 시간이 해의 계산에 걸리는 시간을 초과할 수 있다. 수행된 분석에 따라, 분석은 솔루션 단계보다 최대 수천 배 더 오래 걸릴 수 있다. 행렬을 반복적으로 사용하지 않으면 분석을 수행하는 데 소요된 시간이 상각되지 않을 수 있다.

어떤 경우에는 주어진 레벨의 인자가 이미 해결된 이전 레벨의 인자들의 하위 집합에 종속할 수 있고; 따라서 인자의 해결이 진행될 수 있어야 한다. 그러나 이전 레벨에서 해결되지 않은 다른 인자로 인해 이전 레벨이 완료되지 않는 동안 인자의 풀이가 진행되지 않는다. 따라서 SpTS 계산을 레벨들로 나눌 때 일부 병렬성이 손실될 수 있다.

별도의 분석 단계가 필요하지 않은 하나의 접근 방식에서, 압축 희소 컬럼(Compressed Sparse Column, CSC) 형식에 따라 저장된 희소 삼각형 행렬에서 작동하여 풀이 단계에서 병렬 작업자를 동적으로 관리하는 SpTS를 수행할 수 있다. 그러나, 많은 어플리케이션들은 희소 삼각 행렬을 압축 희소 로우(Compressed Sparse Row, CSR) 형식으로 저장하고 CSR 데이터세트를 CSC 형식으로 전치하면 상당한 시간과 메모리 리소스를 소비할 수 있다.

일 실시예에서, 병렬 컴퓨팅 시스템은 벡터 x의 인자들이 풀리고 후속 계산에 사용할 수 있는 시기를 나타내는 완료 어레이를 업데이트하여 CSR 형식으로 저장된 행렬에 대해 SpTS를 수행할 수 있다. 컴퓨팅 시스템에 의해 런칭된 커널은 행렬의 해당 로우 n의 요소들을 사용하여 벡터 x의 각 인자 x[n]을 계산하기 위한 스레드를 실행한다. 각 스레드에서, 스핀 루프가 실행되어 완료 어레이의 완료 플래그를 반복적으로 모니터링하여 인자 x[n]가 의존하는 선행 인자(로우 n에 대한 입력 변수를 나타냄)가 해결되었는지 여부를 결정한다. 선행 인자가 풀리면, 인자 x[n] 값의 일부를 계산하는 데 사용된다.

완료 어레이의 값들에 대한 스핀 루프로 인한 메모리 경합을 줄이기 위해, 스핀 루프의 반복 횟수 또는 스핀 루프에 소요된 시간이 제한을 초과하는 경우, 스레드는 현재 커널이 완료된 후 시작하도록 대기열에 추가된 종속 자식 커널을 런칭한다. 나머지 스레드들이 완료된 후(즉, 더 많은 인자들이 해결됨) 종속 자식 커널은 새 스레드를 시작하여 완료 어레이의 동일한 값에 대한 스핀 루프를 재개한다.

따라서 이러한 고-성능 SpTS 메커니즘을 사용하면 병렬 컴퓨팅 시스템이 CSC와 같은 다른 형식으로 변환하기 위해 값 비싼 전치 작업을 수행하지 않고도 CSR 형식으로 저장된 희소 삼각 행렬에 대해 SpTS를 수행할 수 있다. 로우들과 그들의 대응하는 인자들을 레벨들로 그룹화하지 않기 때문에, 메커니즘은 잘못된 종속성을 생성하지 않고 SpTS를 수행할 때보다 동적인 병렬 처리를 찾을 수 있다. 고-성능 SpTS 메커니즘은 별도의 분석 단계가 필요하지 않고; 각 병렬 작업자는 선행 인자가 이미 알려져 있거나 이전 로우를 해결하여 사용할 수 있게 되면 해당 인자에 대한 값을 계산하기 위해 로우를 풀이하기 시작한다. 자식 커널을 런칭하여 스핀 루프가 시간 초과되고 나중에 다시 재개되도록 하는 메커니즘은 완료 어레이의 여러 완료 플래그에 대한 스핀 루프로 인한 메모리 경합을 줄인다. 일 실시예에서, 이 고-성능 SpTS 메커니즘은 일부 경우에 별도의 단계에서 분석 및 솔루션을 수행하는 SpTS 메커니즘보다 수천 배 더 빠르게 수행된다.

도 1은 병렬 컴퓨팅 시스템(100)의 실시예를 도시한다. 컴퓨팅 시스템(100)은 통신 네트워크(110)를 통해 서로 연결된 다수의 컴퓨팅 디바이스들(101-103)을 포함한다. 컴퓨팅 디바이스들(101-103) 각각은 처리 및 메모리 저장 능력을 갖는다. 일 실시예에서, 컴퓨팅 시스템(100)은 단일 물리적 인클로저 내에 포함되고, 통신 네트워크(110)는 인클로저 내에서 컴퓨팅 디바이스들(101-103)을 연결하는 버스 또는 시스템 상호 접속이다. 예를 들어, 컴퓨팅 디바이스들(101-103)은, 동일한 보드 또는 백플레인을 통해 서로 연결된 별도의 캐리어 보드들 상의, GPU, 중앙 처리 유닛(CPU), 필드 프로그램 가능 게이트 어레이(FPGA) 등과 같은 처리 유닛을 포함 할 수 있다. 일 실시예에서, 컴퓨팅 시스템(100)의 구성 요소들은 별도의 물리적 인클로저에 포함되고 지리적으로 분산되어 있다. 예를 들어, 컴퓨팅 디바이스들(101-103)은 인터넷과 같은 광역 네트워크(wide-area network, WAN), 근거리 통신망(local-area network, LAN), 무선 네트워크, 또는 다른 통신 네트워크(110)를 통해 서로 연결된 개별 서버, 개인용 컴퓨터, 모바일 디바이스 등을 나타낼 수 있다. 일 실시예에서, 컴퓨팅 디바이스들(101-103)은 동일한 유형 또는 유사한 유형의 디바이스를 나타내고; 대안적으로, 컴퓨팅 디바이스들(101-103)은 상이한 유형의 디바이스이다.

도 2는 고성능 병렬 SpTS 메커니즘이 구현되는 컴퓨팅 디바이스(101)의 실시예를 도시한다. 일반적으로, 컴퓨팅 디바이스(101)는 랩톱 또는 데스크톱 컴퓨터, 모바일 디바이스, 서버 등을 포함하지만 이에 제한되지 않는 다수의 상이한 유형의 디바이스들 중 임의의 것으로 구현된다. 컴퓨팅 디바이스(101)는 버스(201)를 통해 서로 통신하는 다수의 구성 요소들(202-208)을 포함한다. 컴퓨팅 디바이스(101)에서, 구성 요소들(202-208) 각각은 버스(201)를 통해 직접적으로 또는 하나 이상의 다른 구성 요소들(202-208)을 통해 다른 구성 요소들(202-208) 중 임의의 것과 통신할 수 있다. 컴퓨팅 디바이스(101)의 구성 요소들(201-208)은 랩탑 또는 데스크탑 섀시, 또는 휴대폰 케이스와 같은 단일 물리적 인클로저 내에 포함된다. 대안적인 실시예에서, 컴퓨팅 디바이스(101)의 일부 구성 요소들은 전체 컴퓨팅 디바이스(101)가 단일 물리적 인클로저 내에 상주하지 않도록 주변 디바이스로서 구현된다.

컴퓨팅 디바이스(101)는 또한 사용자로부터 정보를 수신하거나 사용자에게 정보를 제공하기 위한 사용자 인터페이스 디바이스를 포함한다. 구체적으로, 컴퓨팅 디바이스(101)는 키보드, 마우스, 터치 스크린, 또는 사용자로부터 정보를 수신하기 위한 다른 디바이스와 같은 입력 디바이스(202)를 포함한다. 컴퓨팅 디바이스(101)는 모니터, 발광 다이오드(LED) 디스플레이, 액정 디스플레이, 또는 다른 출력 디바이스와 같은 디스플레이(205)를 통해 사용자에게 정보를 표시한다.

컴퓨팅 디바이스(101)는 유선 또는 무선 네트워크를 통해 데이터를 송수신하기 위한 네트워크 어댑터(207)를 추가로 포함한다. 컴퓨팅 디바이스(101)는 또한 하나 이상의 주변 디바이스(208)를 포함한다. 주변 디바이스(208)는 대용량 저장 장치, 위치 검출 장치, 센서, 입력 장치, 또는 컴퓨팅 디바이스(101)에 의해 사용되는 다른 유형의 디바이스를 포함할 수 있다.

컴퓨팅 디바이스(101)는, 다수의 처리 유닛들(204)의 경우 병렬로 동작할 수 있는, 하나 이상의 처리 유닛들(204)을 포함한다. 처리 유닛(들)(204)은 메모리 서브 시스템(206)에 저장된 명령(209)을 수신하고 실행하도록 구성된다. 일 실시예에서, 각각의 처리 유닛(들)(204)은 공통 집적 회로 기판 상에 상주하는 다수의 처리 코어들을 포함한다. 메모리 서브 시스템(206)은 랜덤 액세스 메모리(RAM) 모듈, 판독 전용 메모리(ROM) 모듈, 하드 디스크 및 기타 비-일시적 컴퓨터 판독 가능 매체와 같은 컴퓨팅 디바이스(101)에 의해 사용되는 메모리 디바이스를 포함한다.

컴퓨팅 디바이스(101)의 일부 실시예는 도 2에 도시된 실시예보다 더 적거나 많은 구성 요소를 포함할 수 있다. 예를 들어, 특정 실시예는 디스플레이(205) 또는 입력 디바이스(202)없이 구현된다. 다른 실시예는 하나 이상의 특정 구성 요소를 갖는다; 예를 들어, 컴퓨팅 디바이스(101)의 실시예는 다수의 버스들(201), 네트워크 어댑터들(207), 메모리 디바이스들(206) 등을 가질 수 있다.

도 3은 일 실시예에 따른 컴퓨팅 디바이스(101)의 선택된 구성 요소들을 포함하는 블록도를 도시한다. 도 3은 버스(201)를 통해 메모리(206)에 각각 연결된 처리 유닛들(204)을 도시한다. 도 3은 컴퓨팅 디바이스들(101)의 하나를 예시하지만, 컴퓨팅 시스템(100)의 다른 컴퓨팅 디바이스들(예를 들어, 102-103)은 유사한 구성 요소들을 포함한다.

일 실시예에서, 각각의 처리 유닛(204)은 GPU, CPU, FPGA 또는 다른 처리 디바이스이고, 처리 유닛들(204)의 세트 내의 다른 처리 유닛과 별개의 집적 회로 다이에 위치된다. 각각의 처리 유닛(204)은 단일 집적 회로 다이 상의 처리 코어들의 세트를 포함한다. 처리 유닛(204(1))은 처리 코어들(301-303)을 포함하고, 처리 유닛(204(2))은 처리 코어들(304-306)을 포함하고, 처리 유닛(204(3))은 처리 코어들(307-309)을 포함한다. 각각의 처리 코어는, 명령어(209)에 의해 지시된 바와 같이, 컴퓨터 프로그램에서 스레드를 실행하도록 구성된다. 처리 코어들(301-309)은 서로 독립적으로 명령을 실행할 수 있으므로 SpTS 프로세스에서 병렬 스레드를 실행할 수 있으며, 여기서 각각의 병렬 스레드는 처리 코어들(301-309) 중 하나에서 실행되고 벡터 x의 인자들(factors) 중 하나에 대한 값을 계산한다.

방정식 Ax=y의 고성능 SpTS를 수행하기 위한 명령어들의 세트(209)에 추가하여, 메모리(206)는 또한 CSR 데이터세트(321)의 형태로 희소 삼각 행렬 A 및 입력 데이터(322)를 저장하고, 여기에는 풀어야 할 알려지지 않은 인자의 벡터 x와 알려진 제품 값의 벡터 y가 포함된다. 메모리(206)는 또한 벡터 x의 각 인자에 대한 완료 플래그(completion flag)를 포함하는 완료 어레이(323)를 저장하고, 각 완료 플래그는 대응하는 인자가 해결되었는지 여부를 표시한다. 일 실시예에서, 메모리(206)의 정보는 컴퓨팅 디바이스(101)의 단일 메모리 디바이스 또는 서브 시스템에 저장된다. 대안적인 실시예에서, 정보는 동일한 컴퓨팅 디바이스(101) 또는 다수의 컴퓨팅 디바이스들(예를 들어, 101-103)에서 다수의 메모리 디바이스들에 걸쳐 분산된다. 따라서, 더 넓은 컴퓨팅 시스템(100)을 위한 메모리 시스템은 다수의 컴퓨팅 디바이스들(101-103)에 걸쳐 분산된 메모리 디바이스들을 포함할 수 있다.

도 4a는 일 실시예에 따른 곱 벡터 y(430)을 생성하는 희소 삼각 행렬(410)의 벡터 x(420)와의 곱(즉, Ax=y)을 도시한다. 행렬 A(410)는 SpTS에 대한 입력으로 사용되며, 0이 아닌 10 개의 요소들을 포함하는 하위 삼각 행렬이다. 행렬 A(410)의 주 대각선은 요소들 a, c, e, g 및 j를 포함한다. 행렬 A(410)는 하부 삼각 행렬이기 때문에 전진-대입(forward-substitution)으로 풀 수 있다. 이는 이전에 해결된 상위 로우들의 결과를 입력으로 사용하여 일부 로우들이 해결됨을 의미한다. 따라서, 화살표들(411-415)는 전진-대입 프로세스에서 이러한 종속성을 나타낸다. 예를 들어, 각 로우들 1, 2, 3에 대응되는 x[1], x[2] 및 x[3] 인자들을 해결하는 것은 해결되는 로우 0과 연관된 x[0] 인자에 의존한다. 이러한 종속성은 각각 화살표들(411, 412 및 413)로 표시된다. 예를 들어, 종속성 화살표(411)는 로우 1에서 용어 bx[0]의 값을 계산하는 것은 로우 0에서 용어 ax[0]을 사용하여 x[0]을 푸는 것에 의존함을 나타낸다. 종속성 화살표(414 및 415)는 로우 4를 통한 인자 x[4]가 각각 0이 아닌 요소 c 및 g에 대응하는 x[1] 및 x[3] 인자를 푸는 것에 의존함을 나타낸다. 해결된 x[1] 및 x[3] 인자들은 x[4] 인자를 풀 때 용어들 hx[1] 및 ix[3]를 계산하는 데 사용된다. 여기에서는 고성능 SpTS 메커니즘이 하부 삼각 행렬을 해결하기 위해 수행되는 것으로 설명되지만, 메커니즘은 상부 삼각 행렬을 해결하기 위해 역-대입(backwards-substitution)를 수행하는 데 유사하게 사용될 수 있다.

도 4b는 행렬 A(410)의 SpTS를 수행하기 위한 종속성 그래프(450)를 도시한다. 그래프의 각 노드들은 풀어야 할 벡터 x의 인자들 중 하나를 나타낸다. 도 4b의 종속성들(411-415)은 각각 도 4a의 유사하게 넘버링된 종속성들(411-415)에 대응된다. 인자들 x[0] -x[4] 각각의 계산은 별도의 스레드에 의해 수행되며, 각각의 개별 스레드는 별도의 처리 코어(예를 들어, 처리 코어들(301 - 309) 중 하나)에서 실행된다.

종속성 그래프(450)에서, 인자 x[0]에 대한 값의 계산은 종속성이 없고, 다른 인자들이 해결될 때까지 기다리지 않고 먼저 계산된다. x[1], x[2], x[3] 인자들 각각의 풀이는 종속성들(411, 412, 413) 각각을 통해 x[0]에 의존한다; 따라서 이러한 계산들은 x[0]이 풀리고 사용 가능해질 때 시작된다. x[1], x[2] 및 x[3]을 풀기 위해 각각의 개별 스레드에서 실행되는 계산은 적어도 부분적으로 병렬로 수행되지만 각 인자 계산을 완료하는 데 다른 시간이 걸릴 수 있다. x[4]의 풀이는 종속성들(414 및 415) 각각을 통해 x[1] 및 x[3]에 종속된다. 따라서 x[1]과 x[3]을 모두 사용할 수 있을 때 x[4]의 전체 계산이 수행된다. 일 실시예에서, 다중 스레드들 각각은 인자들 x[0] - x[4] 중 하나를 해결한다. 대안적인 실시예에서, 다중 스레드를 포함하는 병렬 작업 그룹은 하나의 인자를 해결하고, 단일 스레드는 다중 인자들을 해결하거나, 다중 스레드는 벡터 x(420)의 여러 인자들을 해결한다.

도 4c는 일 실시예에 따른 희소 삼각 행렬 A(410)를 나타내는 압축 희소 로우(Compressed Sparse Row, CSR) 데이터세트(321)를 도시한다. CSR 데이터세트(321)는 3 개의 어레이들을 포함한다: 값 어레이(값[]), 컬럼 어레이(컬럼[]) 및 로우 포인터 어레이(로우_포인터[])을 포함한다. 값 어레이는 행렬 A(410)의 0이 아닌 요소들을 저장한다. 요소들은 행렬에서 왼쪽에서 오른쪽(각 로우의 컬럼 0에서 컬럼 4까지) 및 위에서 아래(로우 0에서 로우 4)의 순서로 저장된다. 컬럼 어레이는, 값 어레이의 요소들 각각에 대해, 요소가 위치된 행렬의 컬럼을 식별한다. 컬럼 어레이는 값 어레이와 동일한 수의 엔트리를 갖는다; 컬럼 어레이의 각각의 요소는 동일한 어레이 인덱스를 갖는 값 어레이의 대응되는 요소에 대한 컬럼을 식별한다. 로우 포인터 어레이는 행렬의 각 로우에 있는 요소들을 식별한다. 특히, 로우 포인터 어레이의 각 값은 각 로우의 첫 번째 값에서 컬럼 어레이 및 값 에러이를 나타내는 인덱스이다. 로우 포인터 어레이의 최종 값은 값 어레이 또는 컬럼 어레이에서 가장 높은 인덱스보다 하나 더 많다.

CSR 형식으로 저장된 행렬에 대해 SpTS를 수행하는 한 가지 접근 방식에 따르면, x[0]을 풀기 위한 스레드 0은 x[0]이 풀릴 때 종속 스레드들 1, 2 및 3(각각 x[1], x[2] 및 x[3]을 풀기 위한)에 통지한다. 그러나 CSR 형식을 사용하는 경우, 이러한 통지는 '0'을 포함하는 모든 항목들을 찾기 위해 컬럼 어레이를 살펴보아야 하며, 이는 로우가 컬럼 0에 0이 아닌 값을 갖고, 따라서 x[0]에 대한 데이터 종속성이 있음을 나타낸다. 컬럼 어레이에서 '0' 항목을 찾은 후, 스레드 0은 또한 로우 포인터 어레이의 검색을 수행하여 컬럼 어레이의 '0'항목이 사이에 있는 로우 포인터 어레이의 두 인덱스를 결정하여 깨울 종속 스레드를 결정한다. 컬럼 어레이를 살펴보고 로우 포인터 어레이를 검색하는 것은 계산 비용이 많이 들고 고성능 SpTS에 대해 실행 불가능한 속도 저하를 초래한다.

도 4c는 일 실시예에 따른 계산적으로 많은 비용이 드는 컬럼 어레이의 탐색 및 로우 포인터 어레이의 검색을 피하는데 사용되는 완료 어레이(completion array)(323)를 추가로 도시한다. 완료된 각 스레드가 종속 스레드를 깨우는 대신, 대기중인 종속 스레드 각각은 완료 어레이(323)를 검사하여 선행 인자가 해결되었는지 여부를 결정한다. 완료 어레이(323)는 벡터 x(420)의 각 인자에 대한(따라서 행렬 A(410)의 각 로우에 대한) 완료 플래그를 저장한다. 벡터 x(420)의 각 인자는 동일한 인덱스를 갖는 완료 어레이의 플래그에 대응된다(즉, x[n]은 완료[n]에 대응). SpTS를 시작하기 전에, 완료 어레이의 모든 플래그들이 '0'으로 초기화되어, 아직 해결된 인자가 없음을 나타낸다. 스레드가 벡터 x(420)의 인자들 중 하나에 대해 해결된 값의 기록을 완료 할 때마다, 스레드는 또한 그 해결된 값이 후속 계산에서 사용 가능하다는 것을 나타내기 위해 완료 어레이(323)에서 대응되는 완료 플래그를 어서션(assertion)한다. 일 실시예에서, 완료 플래그는 그 값이 0 일 때 디어어션(deassertion)되고, 그 값이 0이 아닌 값일 때 어서션된다.

도 5는 일 실시예에 따른 해결되는 벡터 x(420)의 각 인자에 대해 모니터링할 완료 어레이(323)의 완료 플래그를 결정하기 위해 CSR 데이터세트 어레이의 요소들을 사용하는 것을 도시한다. 벡터 x(420)에서, 인자들 x[0] - x[4] 각각은 행렬 A(410)의 로우들 중 하나에 대응되므로 로우 포인터 어레이의 로우 포인터 요소들 중 하나에 대응된다. 따라서, 인자들 중 하나를 해결하기 위해 실행되는 스레드는 해결해야 할 인자와 로우 포인터 어레이에서 동일한 인덱스를 갖는 로우 포인터 요소를 식별한다. 로우 포인터 요소는 컬럼 어레이에서 컬럼 요소를 찾기 위한 인덱스로 사용되며, 이는 행렬 A(410)의 대응되는 로우에서 0이 아닌 첫 번째 값을 식별한다. 스레드는 컬럼 요소를 인덱스로 사용하여 완료 어레이(323)에서 완료 플래그를 찾는다.

완료 플래그를 식별한 후, 스레드는 완료 플래그가 어서션될 때까지 완료 플래그를 반복적으로 확인하는 스핀 루프(spin loop)를 실행한다. 완료 플래그가 어서션되면, 스레드는 컬럼 어레이에서 다음 컬럼 요소를 찾아(예를 들어, 인덱스를 1씩 증가시켜) 모니터링할 다음 완료 플래그를 식별한다. 스레드는 스핀 루프를 실행하여 다음 완료 플래그를 모니터링한다. 이 프로세스는 다음 컬럼 요소가 인자의 인덱스와 같고 따라서 행렬 A(410)의 주 대각선에 있는 요소에 대응될 때까지 반복된다. 모니터링되는 각 완료 플래그는 선행 인자들 중 하나(인자의 해가 의존하는)가 해결되었는지 여부를 나타낸다. 따라서 주 대각선이 도달되면, 로우에 대한 모든 선행 인자들이 해결되고 스레드가 그의 자체 인자를 해결할 수 있다.

인자 x[0]에 대해 이 프로세스를 수행할 때, 값이 '0'인 대응되는 컬럼 요소는 이미 주 대각선 상의 요소를 나타낸다. 따라서, 스레드는 임의의 완료 플래그를 확인하지 않고도 x[0]을 이미 풀 수 있다.

도 6은 일 실시예에 따른 SpTS의 이벤트 타임라인(timeline)을 도시한다. 도 6에서 볼 수 있듯이, 벡터 x의 각 인자는 병렬 스레드들 0-4 중 하나에 의해 해결된다. 일 실시예에서, 스레드들 0-4는 하나 이상의 처리 유닛(예를 들어, 처리 유닛(들)(204))에서 실행되고, 각 스레드는 처리 코어들 중 하나(예를 들어, 코어들(301-309) 중 하나)에서 실행된다. 대안적인 실시예에서, 각 인자는 작업그룹의 다중 스레드에 의해 해결될 수 있거나, 작업 그룹은 다중 인자들을 해결할 수 있다. 도 6의 타임라인에서, 시간은 위에서 아래로 진행된다. 다이어그램의 오른쪽 부분은 SpTS 프로세스 동안 다른 시간에 완료 어레이(323)의 완료 플래그의 값들을 보여준다.

시간(601)에서, 완료 어레이(323)는 모든 완료 플래그들이 '0'으로 설정된 상태로 초기화되어 아직 해결된 인자가 없음을 나타낸다. 스레드 0, 1, 2, 3 및 4는 각각 벡터 y(430)로부터의 y[0], y[1], y[2], y[3] 및 y[4]와 행렬의 주 대각선으로부터의 요소들 a, c, e, g 및 j의 산출 값(product value)을 판독한다. 벡터 y(430) 및 주 대각선 요소들로부터의 산출 값은 각 스레드에서 벡터 x(420)로부터의 그 인자를 해결하는 데 사용될 이미 알려진 값이다.

시간(602)에서, 각각의 스레드들 1-3(각각 인자들 x[1]-x[3]에 대응)은, 도 5에 도시된 결정에 기초하여, 완료 어레이의 인덱스 0(즉, 완료[0])에서 완료 플래그의 상태를 모니터링하기 위하여 스핀 루프를 실행한다. 인자 x[4]에 대응되는 스레드 4는 스핀 루프를 실행하여 도 5에 도시된 것과 같은 그의 결정에 따라 완료[1] 상태를 모니터링한다. 이 시간(602) 동안, 스레드 0은 종속성이 없으며(이전에 도 5를 참조하여 설명한 것처럼) x[0]에 대한 해결을 진행한다. 스레드 0은 y[0]을 a로 나누고 그 결과를 벡터 x(420)에 x[0]으로 저장한다. 결과를 저장 한 후, 스레드 0은 완료[0]에 0이 아닌 값을 기록하여 완료[0]를 어서션한다.

시간(603)에서, 완료[0]에서 완료 플래그는 어서션된 상태에 있다. 스레드들 1-3 각각에 대해, 컬럼 어레이의 다음 컬럼 요소는 주 대각선에 있다(도 5 참조); 따라서, 스레드들 1-3에 대한 모든 선행 인자 값들이 해결되었다. 스레드들 1-3은 각각의 스핀 루프를 종료하고 각각의 인자를 해결하는 과정을 진행한다. 스레드들 1-3 각각은 방정식 Ax=y에서 x[0]에 곱해지는 행렬 요소들(예를 들어, b, d, f)과 함께 x[0]에 대해 새로 계산된 값을 판독한다. 시간(604)에서 스레드들 1-3은 x[0], 행렬 요소(b, d, f) 및 로우 대한 산출 값(y[1] - y[3])을 각각 기반으로 x[1] - x[3] 인자들을 구한다. 스레드들 1-3은 벡터 x(420)의 x[1] - x[3]의 계산된 결과 값을 저장한다.

계산된 값을 저장 한 후, 스레드들 1-3 각각은 인자들 x[1] - x[3]에 대응되는 완료 플래그를 어서션하여 이러한 인자들이 해결되었음을 나타낸다. 따라서, 스레드들 1, 2 및 3은 이러한 위치에 0이 아닌 값을 저장하여 각각 완료[1], 완료[2] 및 완료[3]를 어서션한다.

시간(605)에서, 완료[1]는 어서션된 상태에 있다; 따라서, 스레드 4는 완료[1]에 대한 스핀 루프를 중지하고, 방정식 Ax=y에서 x[1]에 곱해지는 행렬 요소 h와 함께, x[1]에 대해 새로 계산된 값을 판독한다. 시간(606)에서, 스레드 4는 0이 아닌 요소를 포함하는 행렬 로우의 다음 컬럼을 식별한다. 컬럼 어레이에서, 위치 컬럼[8](로우 4의 초기 위치 컬럼[7]에 인접)은 로우 4의 0이 아닌 다음 요소가 컬럼 3의 대각선을 벗어난 요소임을 나타낸다. 따라서, 스레드 4는, 컬럼 3에 대응되는, 완료[3]에서 완료 플래그의 상태를 모니터링하기 위해 스핀 루프를 시작한다.

시간(607)에서 x[3]은 이전에 해결되었으며 시간(603)에서 스레드 3에 의해 그의 완료 플래그가 어서션되었다. 또한, 0이 아닌 값을 갖는 로우 4의 다음 컬럼(컬럼[9]에 의해 지정된 바와 같이)은 행렬 A(410)의 주 대각선에 있다. 따라서, 완료 어레이(323)는 모든 선행 인자들이 해결되었음을 나타낸다. 이에 대한 응답으로, 스레드 4는 스핀 루프를 종료하고 x[4] 인자 값을 계산하는 데 사용할 i 및 값 x[3]를 판독하기 시작한다. 시간(608)에서, 스레드 4는 선행 인자들 x[1] 및 x[2], 행렬 요소들 h, i 및 j, 그리고 산출 값 y[4]를 기반으로 인자 x[4]의 값을 계산한다. x[4]에 대해 해결한 스레드 4는 완료[4]에서 0이 아닌 값을 저장하여 완료[4]에서 완료 플래그를 어서션한다.

일 실시예에서, 스레드들 0-4는 0이 아닌 값으로서 '1' 또는 다른 고정된 수를 기록함으로써 완료 어레이(323)의 그들의 각각의 완료 플래그를 어서션한다. 대안적으로, 도 6에 도시된 바와 같이, 완료 어레이(323)의 업데이트는 레벨 세트 정보를 생성하는데 사용된다. 단순히 '1'값으로 완료 플래그를 어서션하는 대신에, 어서션 스레드는 선행 인자들의 완료 플래그들 중 가장 높은 값을 증가시켜 해결된 인자에 대한 완료 플래그의 값을 결정한다. 그 다음 스레드는 완료 플래그의 결정된 값을 인자에 대응되는 위치에서 완료 어레이(323)에 저장함으로써 인자에 대한 완료 플래그를 어서션한다.

예를 들어, 이러한 스레드들 1-3 각각에 대해 선행 인자(즉, x[0])에 대한 가장 높은 완료 플래그 값은 1이다. 이 값을 늘리면 새 완료된 플래그 값 '2'가 생성된다. 따라서 시간(604)에서 스레드들 1, 2 및 3은 그들의 각각의 인자들 x[1], x[2] 및 x[3]에 대해 값 '2'를 사용하여 완료 플래그를 어서션한다. 스레드 4가 시간(608)에서 해결된 인자 x[4]에 대한 완료 플래그를 어서션할 때, 선행 인자들 x[1] 및 x[2]에 대응되는 완료 플래그들 중 가장 높은 완료 플래그는 '2'의 값을 갖는다. 따라서, 스레드 4는 증가된 값 '3'을 사용하여 x[4]에 대한 완료 플래그를 어서션한다.

SpTS의 종료에서(시간(609)), 그의 모든 완료 플래그 요소들이 어서션된 완료 어레이(323)는 새로운 벡터 x의 인자들을 후속적으로 해결하기 위한 순서를 결정하기 위해 선택적으로 사용될 수 있는 레벨 세트를 표시한다. 이전 예를 계속하여, 요소들[1, 2, 2, 2, 3]을 포함하는 완료 어레이는 x[0]이 레벨 1에서 먼저 해결되었고, 다음으로 x[1], x[2] 및 x[3]가 레벨 2에서 병렬로 해결되었으며, 마지막으로 레벨 3에서 x[4]가 해결되었다는 것을 나타낸다. 따라서, 완료 어레이(323)는 동일한 행렬 A(410)에 대한 후속 계산에서 사용될 수 있는 레벨 세트 정보를 효율적으로 생성하는 데 사용된다.

도 7은 스핀 루프를 실행하는 스레드들이 시간 초과되고 자식 커널들(child kernels)을 런칭하여 스핀 루프로 인한 메모리 경합(contention)을 줄일 수 있는 SpTS의 실시예를 수행하기 위한 이벤트의 타임라인을 보여준다. 특히 행렬 A가 많은 수의 로우들 및/또는 긴 종속성 체인을 갖는 경우, 큰 수의 대응 인자들의 완료 상태를 반복적으로 확인하기 위한 스핀 루핑은 완료 어레이(323)를 판독하기 위한 반복된 메모리 액세스로 인해 상당한 양의 메모리 경합을 유발할 수 있다. 메모리 경합은 그들의 인자들을 풀고 SpTS에서 앞으로 진행하려는 스레드의 속도를 늦추고 스핀 루핑에 소요되는 시간을 더욱 연장시킨다. 전체적이 스핀 루핑 사이클을 줄이기 위해, 스핀 루프를 수행하는 각 스레드는 반복 횟수 또는 스핀 루핑에 소요된 시간이 미리 결정된 임계 값을 초과하는 경우 스핀 루프를 종료한다. 스핀 루핑은 SpTS에서 더 많은 진행이 이루어진 후(즉, 더 많은 인자들이 해결됨) 자식 커널의 대응되는 스레드에서 다시 재개된다.

도 7에 도시된 바와 같이, 스레드들 0-4 각각은 벡터 x(420)의 인자들 x[0] - x[4] 중 하나를 풀기 위해 제1 커널(711)에서 실행된다. 각 스레드 0-4는 완료 어레이를 확인하여 그의 해당 인자 x[0] - x[4]가 이미 이전 스레드에 의해 해결되었는지 여부를 확인하는 것으로 시작한다. 인자가 이미 해결 된 경우, 스레드가 즉시 종료된다. 시간(702)에서, 완료 어레이(323)는 '0' 요소만을 포함하고 따라서 벡터 x(420)의 인자들 중 어느 것도 해결되지 않았음을 나타낸다. 따라서 스레드들 1-3은 스핀 루프를 실행하여 x[0]의 해결에 대한 완료[0]을 모니터링하며, 반면에 스레드 4는 스핀 루프를 실행하여 x[1]의 해결에 대한 완료[1]을 모니터링한다. 스레드 0은 x[0]을 해결하고 완료[0]에서 연관된 완료 플래그를 어서션한다.

스레드들 1-3 각각은 스핀 루프에 의해 모니터링되는 완료 플래그가 어서션되거나 또는 스핀 루프의 반복 횟수가 미리 결정된 제한을 초과 할 때까지 그의 스핀 루프를 계속 실행한다. 시간(703)에서, 완료[0]에서 x[0]에 대한 완료 플래그는 어서션된 상태에 있다. 따라서 스레드들 1-3은 그들의 스핀 루프 반복이 미리 결정된 제한을 초과하기 전에 그들의 각각의 인자들 x[1]-x[3]을 풀기 시작한다. 그러나, 스레드 4는 x[1]이 해결되기 전에 미리 결정된 반복 제한을 초과하는 x[1]에 대한 완료 플래그에서 스핀 루프를 실행한다. 스레드 4는 스핀 루프를 종료하여 포기하고 자식 커널이 이미 다른 스레드에 의해 런칭되었는지 여부를 나타내는 전역(global) "자식_런칭(child_launched)" 변수를 확인한다. "자식_런칭" 변수가 어서션되면, 자식 커널이 이미 다른 스레드에 의해 런칭되었으며, 그리고 스레드 4는 자식 커널을 런칭하지 않고 종료된다. "자식_런칭" 변수가 어서션되지 않으면, 이전에 자식 커널이 런칭되지 않았고 스레드 4가 제2 커널(712)을 런칭하며, 이는 제1 커널(711)이 완료된 후 시작되도록 대기열에 추가된다(즉, 커널(711)의 다른 모든 스레드가 완료된 경우). 커널(712)의 런칭과 관련하여, 스레드 4는 제1 커널(711)의 다른 스레드가 이러한 방식으로 자식 커널을 런칭하려고 시도하는 것을 방지하기 위해 "자식_런칭" 변수를 어서션한다. 스레드 4가 종료된다. 이 메커니즘에 의해, 너무 많은 반복을 실행하거나 스핀 루핑에 너무 많은 시간을 소비하는 스레드는 더 많은 진행이 이루어질 때까지 일시적으로 메모리 시스템 액세스를 중지한다.

시간(703)의 종료에서, 모든 병렬 스레드들 0-4이 완료되면, 제1 커널(711)이 종료된다. 시간(704)에서, 제2 커널(712)이 런칭되고, 병렬 스레드들 0-4이 각각 동일한 인자들 x[0] - x[4]에 대해 다시 호출된다(invoked). 전역 "자식_런칭" 변수는 자식 커널(712)의 런칭과 관련하여 디어서션 상태로 초기화된다. 스레드들 0-4는 그들의 각 인자들 x[0]-x[4]에 대한 완료 플래그를 확인한다. 완료 어레이(323)가 인자들 x[0] - x[3]이 이미 해결되었음을 표시한 이후, 스레드들 0-3은 종료된다.

그러나, 완료[4]에서 완료 플래그가 디어서션되고 인자 x[4]가 해결되지 않았음을 표시한다. 스레드 4는 스핀 루프를 실행하여 x[1](완료[1]에서) 및 x[3](완료[3]에서)에 대한 완료 플래그들을 확인하여 선행 인자들 x[1] 및 x[3]이 해결되었는지 여부를 결정한다. 시간(705)에서, 스레드 4는 완료[1]에서 그의 완료 플래그를 기반으로 x[1]이 이미 해결되었다고 결정한다. 시간(706)에서, 스레드 4는 완료[3]에서 그의 완료 플래그를 기반으로 x[3]이 이미 해결되었다고 결정한다. 인자 x[4]의 풀이가 의존하는 모든 선행 인자들이 풀렸으므로, 스레드 4는 시간(707)에서 x[4] 풀이를 진행한다. 인자들 x[0] - x[4]가 모두 해결되면, 더 이상 자식 커널이 런칭되지 않고 SpTS가 완료된다.

도 8은 일 실시예에 따른 CSR 데이터세트(321)에서 고성능 SpTS를 실행하기 위한 처리 코어(301)의 모듈의 블록도를 도시한다. 일 실시예에서, 처리 코어(301)의 모듈들(801-805)은 강화된 회로 모듈을 사용하여 구현된다; 대안적인 실시예에서, 모듈들(801-805)은 프로그래밍 가능 논리 회로(예를 들어, 처리 코어(301)가 FPGA 또는 기타 프로그램 가능한 디바이스를 사용하여 구현되는 경우), 소프트웨어 모듈 또는 하드웨어, 소프트웨어, 프로그래밍 가능 논리 등의 조합을 사용하여 구현된다. 일 실시예에서, 모듈들(801-805)은 벡터 x의 n 번째 요소를 나타내는 인자 x[n]을 해결하기 위해 스레드(800)에서 실행되는 연산을 수행한다. 일 실시예에서, 스레드(800)는 도 6 또는 도 7을 참조하여 설명된 바와 같이 스레드들 0-4과 유사한 방식으로 기능한다.

스핀 루프 모듈(801)은, 도 5를 참조하여 앞서 설명한 바와 같이, 완료 어레이(323)에서 모니터링할 적절한 완료 플래그를 결정하기 위해 포인터(811)를 판독하며(로우 포인터 어레이 및 컬럼 어레이에서) 스핀 루프를 실행하여 완료 어레이(323)로부터 완료 플래그(810)를 반복적으로 확인한다. 따라서 스핀 루프 모듈(801)은 풀어야 할 인자 x[n]이 종속하는 임의의 선행 인자의 가용성을 결정한다.

일 실시예에서, 스레드(800)는 스핀 루핑이 너무 많은 시간이 걸리거나 너무 많은 반복으로 실행되었을 때 자식 커널을 종료하고 런칭함으로써 메모리 경합을 감소시킨다. 모듈(801)에 의해 실행되는 스핀 루프의 각 반복은 카운터(802)에 의해 카운트된다. 반복 횟수(또는 스핀 루핑에 소요된 시간)는 미리 정해진 제한(803)과 비교되며, 스핀 루프의 반복 횟수(또는 스핀 루핑에 소요된 시간)가 제한(803)을 초과하면 자식 런처(804)는 "자식_런칭" 변수(817)를 확인한다. "자식_런칭" 변수(817)가 자식 커널이 다른 스레드에 의해 런칭되지 않았음을 나타내는 경우, 자식 런처(804)는 현재 커널(711)의 모든 스레드들이 완료된 후 시작하도록 대기열에 추가된 자식 커널(712)을 런칭한다. 따라서 스레드(800)는 제한(803)를 초과하는 것에 응답하여 스핀 루핑을 중단하고, SpTS에서 더 많은 진행이 이루어진 후(즉, 더 많은 인자들이 해결됨) 자식 커널(712)에서 스핀 루핑을 다시 시작한다.

솔버 모듈(solver module)(805)은, 완료 어레이(323)에서 그들의 연관된 완료 플래그에 의해 표시되는 바와 같이, 스핀 루프 모듈(801)이 x[n]에 대한 모든 선행 인자들이 해결되었다고 결정한 것에 응답하여 인자 x[n]에 대한 값을 계산한다. 솔버(805)는 CSR 데이터세트(321)로부터 x[n]에 대응되는 로우의 행렬 요소(812)를, x[n]에 대응되는 산출 벡터 y(430)로부터 산출 값 y[n]을, 그리고 벡터 x(420)으로부터 해결된 선행 인자들(814)을 판독한다. 솔버(805)는 선행 인자들(814), 산출 y[n] 813 및 행렬 요소(812)를 Ax=y로 정의된 로우에 대한 방정식에 대입하여 인자 x[n]의 값을 계산하여 그런 다음 인자 x[n]을 대수적으로 풀이한다.

솔버(805)는 x[n]의 풀이 값(815)을 인자 벡터 x(420)에 저장하며, 여기서 이는 다른 스레드들의 인자들을 풀기 위해 이용 가능하게 된다. 솔버(805)는 또한 x[n]에 대한 완료 플래그(816)에 대해 0이 아닌 값을 결정하고 완료 어레이(323)에 값을 저장함으로써 완료 어레이(323)에서 완료 플래그를 어서션한다. 일 실시예에서, 솔버(805)는 인자 x[n]에 대한 레벨을 계산하기 위해 선행 인자들의 완료 플래그들 중 가장 높은 값을 증가시킴으로써 완료 플래그의 값을 결정한다. 대안적으로, 솔버(805)는 완료 플래그에 대해 '1' 또는 다른 고정 값을 사용한다.

도 9a 및 9b는 CSR 포맷으로 저장된 희소 삼각 행렬에 대해 고성능 SpTS를 수행하기 위한 프로세스(900)를 도시한다. 프로세스(900)의 동작들은 메모리 시스템(206), 처리 코어(301)의 모듈들(801-805) 등과 같은 컴퓨팅 시스템(100)의 구성 요소에 의해 수행된다.

블록(901)에서, 메모리 시스템(206)은 CSR 데이터세트(321)로서 희소 삼각 행렬 A(410)를 저장한다. CSR 데이터세트(321) 내에서, 값 어레이는 행렬 A(410)의 요소들을 저장하고, 컬럼 어레이는 값 어레이에 저장된 각 요소들에 대해 행렬 A(410)의 컬럼을 식별하고, 로우 포인터 어레이는 행렬 A(410)의 각 로우의 요소들을 식별한다. CSR 데이터세트(321)의 이러한 어레이는 도 4c에 예시되어 있다.

메모리 시스템(206)은 또한 벡터 x(420) 내의 인자들 x[0] - x[4] 각각에 대한 완료 플래그를 포함하는 완료 어레이(323)(완료[])를 저장한다. 블록(903)에서, 완료 어레이(323)의 완료 플래그들 각각은 '0'으로 초기화되어, 어떤 인자도 해결되지 않았음을 표시한다. 블록(905)에서, 다수의 병렬 스레드들이 시작되고, 각 스레드는 벡터 x(420)의 인자들 중 하나를 계산한다. 병렬 스레드들(800) 중 하나는 인자 x[n]의 값을 계산하기 위해 시작되며, n은 일반적으로 벡터 x(420)에서 인자 x[n]의 인덱스를 나타낸다.

블록(907)에서, 스레드(800)는 완료[n]에서 완료 플래그를 판독함으로써 인자 x[n]이 이전 프로세스에 의해 이미 해결되었는지 여부를 결정한다. 완료[n]이 0이 아닌 값이면(즉, 어서션됨), 스레드(800)는 x[n]이 이미 해결 되었기 때문에 블록(933)에서 종료된다. 완료[n]이 0이면(즉, 디어서션됨), 프로세스(900)는 블록(909)에서 계속된다.

x[n]의 값은 벡터 x(420)의 하나 이상의 선행 인자들 세트 각각에 의존하는 데이터이다; 즉, x[n]의 값을 계산하기 위해 선행 인자들의 값들이 사용된다. 따라서 블록(909)에서, 스핀 루프 모듈(801)은 CSR 데이터세트(321)의 로우 포인터 어레이 및 컬럼 어레이에 기초하여 모니터링을 위한 다음 선행 인자를 식별한다. 인자 x[n] 인수와 동일한 인덱스 n을 갖는 로우 포인터는 컬럼 어레이에서 위치를 식별하는 인덱스로 사용된다. 컬럼 어레이에서 식별된 위치는 인자 x[n]에 대응되는 행렬 A(410)의 로우 n에서 0이 아닌 요소의 컬럼을 식별한다. 도 5를 참조한 예로서, 인자 x[4]의 경우, 로우_포인터[4]의 값은 '7'이고 컬럼[7]의 값은 '1'이다. 이것은 행렬 A(410)의 로우 4에서 0이 아닌 요소가 컬럼 1에 있음을 나타낸다. 도 4a에서 볼 수 있듯이, 이 0이 아닌 요소는 'h'이다.

블록(910)에서, 컬럼에서 식별 된 위치의 인덱스가 로우_포인터[n+1]과 같지 않은 경우, 로우 n에서 0이 아닌 요소를 포함하는 모든 컬럼들이 순회되지 않았으며, 모든 선행 인자들에 대해 스핀 루핑이 수행되지 않았다. 로우 4에 대한 이전 예를 계속하면, 로우_포인터[4+1]은 '10'이다. 선행 인자 x[1]에 대응되는 0이 아닌 식별된 요소 'h'에 대한 컬럼 어레이의 현재 인덱스는 '7'이다. 이러한 값들이 같지 않기 때문에, 로우 4에 대한 모든 컬럼이 순회되지 않았으며, 프로세스(900)는 블록(911)에서 계속된다.

블록(911)에서, 스핀 루프 모듈(801)은 식별된 0이 아닌 요소가 행렬 A(410)의 주 대각선에 위치하는지 여부를 결정한다. 일 실시예에서, 컬럼 번호가 인자의 인덱스(즉, 'n')와 같으면 0이 아닌 요소는 주 대각선에 있다. 요소가 주 대각선에 위치하면, 프로세스(900)는 스핀 루핑을 수행하지 않고 블록(909)로 돌아 간다. 주 대각선 상의 요소에 대응되는 인자는 스레드(800)가 풀어야 할 인자 x[n]이다; 따라서 그의 완료 플래그를 모니터링하기 위해 스핀 루핑이 수행되지 않는다. 대신에 프로세스(900)는 블록(910)에서 다음 선행 인자로 계속된다. 블록(911)에서, 요소가 대각선을 벗어난 곳에 위치하면(주 대각선이 아닌), 요소는 선행 인자에 대응하고 프로세스(900)는 블록(913)에서 계속된다.

블록(913)에서, 스핀 루프 모듈(801)은 메모리(206)의 완료 어레이(323)로부터 완료 플래그(810)를 판독함으로써 제1 선행 인자에 대한 완료 플래그를 확인한다. 도 5를 참조하여 앞의 예를 계속하면, 컬럼 어레이에서 식별된 요소는 완료 어레이(323)의 선행 인자에 대한 완료 플래그의 인덱스를 저장한다. 따라서, 스핀 루프 모듈(801)은, 선행 인자 x[1]이 해결되었는지 여부를 나타내는, 완료[1]에서 완료 플래그를 판독한다. 블록(915)에서, 완료 플래그가 어서션되지 않으면, 선행 인자가 해결되지 않았고 프로세스(900)는 블록(917)에서 계속된다.

블록(917)에서, 스핀 루프 모듈(801)은 수행된 스핀 루프의 반복 횟수를 카운팅하는 스핀 루프 카운터(802)를 증가시킨다. 카운트된 반복 횟수는 제한(803)와 비교되고, 블록(919)에서, 카운트된 반복 횟수가 제한(803)를 초과하지 않으면, 프로세스(900)는 블록(913)으로 계속 돌아간다. 따라서, 프로세스(900)는 완료 플래그가 어서션될 때까지 또는 제한(803)이 초과될 때까지 제1 선행 인자의 완료 플래그를 모니터링하기 위한 스핀 루프를 수행하기 위해 블록들(913-919)를 통해 루프한다.

스핀 루프 동안, 완료 플래그가 어서션되면, 프로세스는 블록(915)에서 블록(909)으로 진행한다. 블록(909)에서, 스핀 루프 모듈(801)은 인자 x[n]에 대한 해가 의존하는 다음 선행 인자를 식별한다. 컬럼 어레이는 로우 n에서 0이 아닌 요소를 식별한다; 따라서, 로우에서 0이 아닌 다음 요소는 가장 최근에 식별된 0이 아닌 컬럼에 인접한 컬럼 어레이에 표시된다. 따라서 가장 최근에 식별된 컬럼의 인덱스가 1씩 증가한다. 도 5를 참조하여 앞의 예를 계속하면, 0이 아닌 값을 저장하는 로우 4에서 가장 최근에 식별된 컬럼은 컬럼[7]에서 표시된다; 따라서, 로우 4에서 0이 아닌 다음 요소는 컬럼[7+1] 또는 컬럼[8]에 표시된다. 컬럼 어레이의 이 위치는 로우 4가 컬럼 3에서 0이 아닌 값이 갖는 것을 나타낸다. 도 4a에서 볼 수 있듯이 이 값은 'i'이다.

로우 4의 컬럼 3은 컬럼 어레이에서 인덱스 '8'을 가지며, 이는 로우_포인터[4+1]과 같지 않다; 따라서, 프로세스(900)는 블록(910)에서 블록(911)으로 계속된다. 로우 4의 컬럼 3은 행렬 A(410)의 비 대각선 요소이다. 따라서, 블록(911)로부터, 프로세스(900)은 블록(913)에서 계속된다. 블록(913)에서, 스핀 루프 모듈(801)은 컬럼 어레이의 현재 위치에 지정된 완료 플래그를 판독한다. 이전 예를 계속하면, 컬럼[8]은 컬럼 3을 지정한다. 따라서, x[3]이 풀렸는지 여부를 나타내는, 완료[3]에서 완료 플래그를 모니터링하기 위해 스핀 루프가 수행된다. 따라서 블록들(909-919)은 반복되어 인자 x[n]에 대한 다수의 선행 인자들(예를 들어, x[1] 및 x[3])의 완료 플래그를 차례로 모니터링하기 위한 스핀 루프를 실행한다.

블록(910)에서, 컬럼 어레이의 0이 아닌 요소의 인덱스가 로우_포인터[n+1]과 같으면, 로우 n에 0이 아닌 요소들을 포함하는 모든 컬럼들이 순회되었다. 이는 스핀 루핑 프로세스가 모든 선행 인자들에 대해 어서션된 완료 플래그를 검출했음을 의미한다. 이전 예를 계속하면, 로우 4는 컬럼들 1, 3 및 4에 0이 아닌 요소들을 포함한다. 마지막 컬럼 '4'의 인덱스는 컬럼 어레이에서 '9'이다. 로우 4의 경우, 로우_포인터[n+1]은 '10'과 같다. 따라서, 컬럼 어레이에 대한 인덱스가 '10'으로 증가할 때까지, 0이 아닌 요소들을 갖는 모든 컬럼들('7'에서 '9'까지의 인덱스를 갖는)은 스핀 루프 모듈(801)에 의해 순회되었다; 즉, 스핀 루핑 프로세스는 모든 선행 인자들 x[1] 및 x[3]에 대한 완료 플래그가 어서션되었음을 확인하였다. 이때, 모든 선행 인자들이 해결되었다; 따라서, 블록(921)에서, 솔버(805)는 해결된 선행 인자(814), x[n]에 대응하는 행렬 A(410)의 로우 n의 요소들(812) 및 x[n]에 대응하는 산출 값 y[n](813)에 기초하여 인자 x[n]의 값을 계산한다. x[n](815)에 대한 계산된 값은 메모리 시스템(206)의 벡터 x(420)에 기록된다. n이 '4'인 이전 예를 계속하면, 솔버(805)는(y[4] - hx[1] - ix[3])/j에서 x[4]를 계산한 다음, 그 결과를 벡터 x(420)에 기록한다.

블록(923)에서, 솔버(805)는 x[n]의 완료 플래그를 어서션하기 위해 0이 아닌 값을 계산한다. 솔버(805)는 x[n]의 풀이가 종속하는 선행 인자들의 완료 플래그들 중 가장 높은 값의 완료 플래그를 증가시킨다. x[4]의 경우, 시간(605)에서 도 6에 도시된 것처럼, 선행 인자들 x[1] 및 x[3]에 대한 완료 플래그들은 각각 '2' 및 '2'이다. 가장 높은 값의 완료 플래그가 '2'이므로, x[4]에 대한 완료 플래그는 3이다. 블록(925)에서, 솔버(805)는 인자에 대응하는 위치에서 완료 플래그(816)를 완료 어레이(323)에 기록한다. 일 실시예에서, 완료 플래그는 벡터 x(420)의 인자 x[n]과 완료 어레이에서 동일한 인덱스 n을 갖는다(예를 들어, 완료[n]은 인자 x[n]에 대응함). 완료 플래그는 x[n]이 해결되었음을 나타낸다; 따라서, 스레드는 블록(933)에서 종료된다.

블록(919)에서, 카운터(802)에 의해 카운팅된 스핀 루프의 반복 횟수가 제한(803)을 초과하면, 프로세스(900)는 블록(927)에서 계속된다. 블록(927)에서, 자식 런처(804)는, 현재 커널의 자식 커널이 이전에 런칭되었는지 여부를 나타내는, 자식_시작(child_started) 전역 변수(817)를 확인한다. 자식_시작 변수(817)가 어서션되면, 스레드는 자식 커널을 런칭하지 않고 블록(933)에서 종료되고, 따라서 스핀 루프가 종료된다. 블록(927)에서, 자식_시작 변수(817)가 디어선션되면, 자식 커널은 이전에 런칭되지 않았으며, 프로세스(900)는 블록(929)에서 계속된다. 블록(929)에서, 자식 런처(804)는 자식 커널을 런칭하고 현재 커널의 완료 후 시작하도록 자식 커널을 대기열에 넣는다. 따라서 자식 커널은 현재 실행중인 커널의 모든 병렬 스레드들이 종료 된 후 새로운 병렬 스레드 집합을 시작하기 위해 대기열에 넣어진다.

블록(931)에서, 자식 런처(804)는 자식 커널 및 그 병렬 스레드들을 런칭하고 대기열에 넣는 것과 관련하여 자식 시작된 플래그를 어서션한다. 이는 스핀 루프에 대한 제한(803)을 초과하는 현재 실행중인 다른 스레드들이 다른 자식 커널을 런칭하고 대기열에 넣는 것을 방지한다. 자식 커널이 이미 대기열에 넣어진 경우, 스핀 루프 제한(803)으로 인해 종료된 현재 커널의 임의의 스레드는 동일한 자식 커널의 대응되는 스레드에서 계속된다. 블록(933)에서 스레드가 종료된다.

블록(935)에서, 처리 코어(301)는 현재 커널의 나머지 병렬 스레드들이 종료될 때까지 대기한다. 병렬 스레드들 각각은 그 인자의 풀이를 완료하거나, 또는 스핀 루프 제한(803)을 초과하여 종료된다. 모든 스레드들이 종료되면, 커널이 완료되고 프로세스(900)는 블록(937)에서 계속된다.

블록(937)에서, 자식 커널이 대기열에 추가되었다면(즉, 블록(929)에서), 프로세스는 블록(939)에서 계속된다. 블록(939)에서 대기열에 넣어진 자식 커널이 시작된다. 자식 커널은 벡터 x(420)의 각 인자 x[n]에 대한 스레드를 시작한다. 이전 스레드들에서 이미 해결된 인자들을 해결하기 위한 스레드들(완료 어레이에 의해 표시됨)은 블록들(907 및 933)을 통해 종료된다. 나머지 미해결 인자들은 이전에 설명된 바와 같이 해결된다. 새 스레드들은 스핀 루프(즉, 블록들(909-919))를 실행하여 언제 그들의 각 인자들에 대한 모든 선행 인자들을 사용할 수 있는지 확인하고 선행 인자들이 해결된 후 그들의 인자들을 해결한다. 스핀 루프 제한(803)을 초과하는 그의 스레드들 중 하나를 통해, 각 자식 커널은 벡터 x(420)의 모든 인자들이 해결되고 전체 SpTS가 완료될 때까지 블록들(919 및 927-933)을 통해 자체 자식 커널을 런칭하고 대기열에 넣을 수도 있다.

벡터 x(420)의 모든 인자들이 풀리면, 모든 스레드들이 블록(907) 또는 블록(925)으로부터 블록(933)에서 종료되고 자식 커널이 대기열에 추가되지 않는다. 따라서, 블록(937)으로부터, 프로세스(900)는 SpTS가 완료되는 블록(941)에서 계속된다.

일 실시예에서, 블록들(901-941)은 행렬 A(410)의 첫 번째 SpTS를 수행하기 위한 동작을 나타내는 반면, 블록들(943-947)은, 도 9b에 도시된 바와 같이, 행렬 A(410)의 제2 SpTS를 수행하기 위한 동작을 나타낸다. 제2 SpTS의 경우, 제1 SpTS를 수행하는 것으로부터 생성된 완료 어레이는 방정식 Ax'=y'에서 제2 벡터 x'를 풀 때 사용되고, 여기서 A는 제1 SpTS의 동일한 행렬 A(410)이고, x'는 벡터 x(420)와 다른 알려지지 않은 인자들로 구성된 제2 벡터이고, y'는 벡터 y(430)와 다른 알려진 산출 값의 제2 벡터이다.

블록(943)에서, 처리 유닛(예를 들어, 처리 유닛들(204) 중 하나)은 벡터 x'에서 해결될 인자에 대한 레벨을 결정한다. 벡터 x'의 각 인자에 대한 레벨은 이전에 생성된 완료 어레이의 인자와 동일한 인덱스를 갖는 대응되는 완료 플래그로 표시된다. 예를 들면, 이전에 생성된 완료 어레이에 완료 플래그들[1, 2, 2, 2, 3]이 포함되어 있으면, 레벨 1에는 x'[0]이 포함되고, 레벨 2에는 x'[1], x'[2] 및 x'3가 포함되고, 레벨 3에는 x'[4]가 포함된다. 같은 레벨의 인자들은 병렬로 해결될 수 있다.

블록(945)에서 처리 유닛은 결정된 레벨에 대응하는 순서로 벡터 x'의 인자들 x'[n] 각각에 대한 값을 계산하고, 더 높은 레벨의 인자들보다 먼저 더 낮은 레벨의 인자들이 해결되고 같은 레벨의 인자들이 병렬로 해결된다. 각 인자 x'[n]은 그의 선행 인자, 행렬 A(410)의 대응되는 로우의 요소들 및 대응되는 산출 값 y'[n]에 기초하여 해결된다. 인자들 x'[n]이 레벨에 따라 순서대로 풀이되면, 각 인자는 그의 선행 인자들이 이미 풀린 후에 풀린다. 모든 인자들이 해결된 후, 제2 SpTS가 블록(947)에서 완료된다.

따라서 프로세스(900)는 병렬 컴퓨팅 시스템(예를 들어, 컴퓨팅 시스템(100))이 CSR 데이터세트를 다른 형식(CSC와 같은)으로 비용이 많이 드는 변환없이, 그리고 비용이 많이 드는 종속성 분석을 수행하지 않고, CSR 형식으로 저장된 행렬에 대해 SpTS를 수행할 수 있게 한다. 따라서 이러한 접근 방식을 채용하는 병렬 컴퓨팅 시스템은 동일한 결과를 얻기 위해 다른 접근 방식에 비해 더 적은 전력을 소비하고 더 적은 컴퓨팅 리소스를 사용하며 더 짧은 시간에 해를 계산한다.

방법은 희소 삼각 행렬을 압축 희소 로우(compressed sparse row, CSR) 데이터세트로 저장하는 단계 및 제1 벡터의 복수의 인자들의 각 인자에 대해, 인자의 값을 계산하는 단계를 포함한다. 인자의 값을 계산하는 단계는 인자에 대해 제1 벡터에서 하나 이상의 선행 인자들의 세트를 식별하는 것을 포함하는 단계, 여기서 인자의 값은 하나 이상의 선행 인자들 각각에 종속되며, 하나 이상의 선행 인자 값들이 모두 해결되었음을 나타내는 완료 어레이에 대한 응답으로, 행렬의 로우에서 하나 이상의 요소들 및 로우에 대응하는 산출 값에 기초하여 인자의 값을 계산하는 단계; 및 완료 어레이에서, 인자가 해결되었음을 나타내는 인자에 대한 제1 완료 플래그를 어서션하는 단계를 포함한다.

방법은 CSR 데이터세트의 값 에레이, CSR 데이터세트의 컬럼 어레이에 행렬의 요소들을 저장하는 단계, 값 어레이에 저장된 요소들 각각에 대한 행렬의 컬럼을 식별하는 단계, 및 CSR 데이터세트의 로우 포인터 어레이의, 행렬의 각 로우의 요소들을 식별하는 단계를 더 포함한다.

방법은, 복수의 인자들의 각각의 인자에 대해 인자의 값을 계산하기 위한 스레드를 시작하는 단계를 더 포함하며, 여기서 스레드는 병렬로 실행되는 복수의 스레드들 중 하나이다.

방법은 복수의 스레드들의 각 스레드에 대해, 완료 어레이의 제2 완료 플래그를 모니터링하기 위해 스레드에서 실행된 스핀 루프의 반복 횟수를 계산하는 단계, 여기서 제2 완료 플래그는 선행 인자들 중 하나와 연관되며, 제한을 초과하는 반복 횟수에 응답하여 스핀 루프를 종료하는 단계, 복수의 병렬 처리 스레드들이 모두 완료되면 실행할 새 스레드를 대기열에 넣는 단계, 그리고 새 스레드에서 완료 플래그를 모니터링하는 단계를 더 포함한다.

방법은 자식 시작 플래그를 확인하는 단계, 여기서 자식 시작 플래그가 디어어션될 때 새 스레드를 대기열에 넣는 것이 수행되며, 새 스레드를 대기열에 넣는 것과 관련하여 자식 시작 플래그를 어서션하는 단계를 더 포함한다.

방법은, 복수의 인자들의 각 인자에 대해, 제1 스핀 루프를 실행하여 완료 어레이의 제1 완료 플래그를 모니터링하는 단계로, 여기서 제1 완료 플래그는 CSR 데이터세트의 컬럼 어레이의 제1 위치에 지정되고, 컬럼 어레이의 제1 위치는 인자에 대응하는 로우 포인터로 표시되며, 제1 완료 플래그가 어서션되고 컬럼 어레이의 제2 위치가 희소 삼각 행렬의 비-대각선 요소에 대응한다는 결정에 응답하여 완료 어레이의 제2 완료 플래그를 모니터링하기 위해 제2 스핀 루프를 실행하는 단계를 더 포함하고, 여기서 제2 완료 플래그는 컬럼 어레이의 제2 위치에 지정된다.

방법에서, 로우 포인터 어레이 로우 포인터의 위치는 벡터의 인자 위치에 해당하고, 로우 포인터는 컬럼 어레이의 제1 위치의 인덱스이며, 컬럼 어레이의 제1 위치는 완료 어레이의 완료 플래그의 인덱스를 저장한다.

방법은, 복수의 인자들의 각 인자에 대해, 선행 인자들 각각에 대한 완료 플래그를 저장하는 단계, 선행 인자들의 완료 플래그들 중 가장 높은 값을 갖는 완료 플래그를 증가시켜 인자에 대한 완료 플래그의 값을 결정하는 단계, 및 인자에 대응하는 위치에서 완료 어레이의 인자에 대한 완료 플래그의 결정된 값을 저장함으로써 인자에 대한 완료 플래그를 어어션하는 단계를 더 포함한다.

방법은, 제2 벡터의 여러 인자들의 각 인자에 대해, 완료 어레이의 인자에 대응하는 완료 플래그의 값에 기초하여 인자에 대한 레벨을 결정하는 단계, 및 결정된 레벨에 따른 순서로 제2 벡터의 각 인자에 대한 값을 계산하는 단계를 더 포함하고, 여기서 동일한 레벨에 있는 복수의 인자들 중 적어도 2 개에 대한 값들이 병렬로 계산된다.

방법에서, CSR 데이터세트는 메모리 시스템에 저장되고, 복수의 인자들의 각 인자에 대해, 인자의 값은 메모리 시스템과 결합된 솔버 회로에서 계산된다.

방법은 스핀 루프 회로를 사용하여 완료 어레이로부터 제1 완료 플래그를 판독하는 단계를 더 포함하고, 완료 어레이는 메모리 시스템에 저장되고 완료 어레이의 제1 완료 플래그를 어어션하는 단계는 스핀 루프 회로 및 메모리 시스템과 결합된 솔버 회로에 의해 수행된다.

컴퓨팅 디바이스는 압축 희소 로우(CSR) 데이터세트로서 희소 삼각 행렬을 저장하기 위한 메모리 및 메모리와 결합된 처리 유닛을 포함한다. 처리 유닛은, 제1 벡터의 복수의 인자들의 각 인자에 대해, 인자에 대해 제1 벡터의 하나 이상의 선행 인자들의 세트를 식별함으로써 인자의 값을 계산하고, 여기서 인자의 값은 하나 이상의 선행 인자들 각각에 종속하고, 하나 이상의 선행 인자 값들이 모두 해결되었음을 나타내는 완료 어레이에 대한 응답으로, 행렬의 로우의 하나 이상의 요소들 로우에 대응하는 산출 값을 기반으로 인자의 값을 계산하고, 완료 어레이에서, 인자가 해결되었음을 나타내는 인자에 대한 완료 플래그를 어서션하기 위한 것이다.

컴퓨팅 디바이스에서, CSR 데이터세트는 행렬의 요소들을 저장하기 위한 값 어레이, 값 어레이에 저장된 요소들 각각에 대한 행렬의 컬럼을 식별하기 위한 컬럼 어레이, 및 행렬의 각 로우에서 요소들을 식별하기 위한 로우 포인터 어레이를 더 포함한다.

컴퓨팅 디바이스에서, 처리 유닛은 복수의 처리 코어들을 포함하고 각각의 처리 코어는 벡터의 인자들 중 하나의 값을 계산하기 위해 복수의 병렬 스레드들의 스레드를 각각 실행한다.

컴퓨팅 디바이스에서, 복수의 처리 코어들 각각은 스레드에서 스핀 루프를 실행하여 완료 어레이의 완료 플래그를 모니터링하고, 미리 결정된 제한을 초과하는 스핀 루프의 반복 횟수에 응답하여 스핀 루프를 종료하고, 복수의 병렬 처리 스레드들이 모두 완료되면, 완료 플래그를 모니터링하기 위해 새 스레드를 실행하기 위한 것이다.

컴퓨팅 디바이스에서, 처리 유닛은 복수의 처리 코어들을 포함하고, 각각의 처리 코어는 완료 어레이의 제1 완료 플래그를 모니터링하기 위해 제1 스핀 루프를 실행하고, 여기서 제1 완료 플래그는 CSR 데이터세트의 컬럼 어레이의 제1 위치에서 지정되고, 컬럼 어레이의 제1 위치는 제1 벡터의 복수 인자들 중 하나에 대응하는 로우 포인터로 표시되며, 제1 완료 플래그가 어서션되고 컬럼 어레이의 제2 위치가 희소 삼각형 행렬의 대각선을 벗어난 요소에 해당한다는 결정에 응답하여 완료 어레이의 제2 완료 플래그를 모니터링하기 위해 제2 스핀 루프를 실행하고, 여기서 제2 완료 플래그는 컬럼 어레이의 제2 위치에 지정된다.

컴퓨팅 디바이스는 메모리의 완료 어레이를 더 포함하고, 완료 어레이는 복수의 인자들 각각에 대한 완료 플래그를 저장하기 위한 것이고, 처리 유닛은 또한, 복수의 인자들의 각 인자에 대해, 선행 인자들의 완료 플래그들 중 가장 높은 값을 증가시킴으로써 인자에 대한 완료 플래그의 값을 결정하고, 인자에 대응하는 위치에서 완료 어레이의 인자에 대한 완료 플래그의 결정된 값을 저장하여 인자에 대한 완료 플래그를 어서션하기 위한 것이다.

컴퓨팅 디바이스에서, 처리 유닛은 또한, 제2 벡터의 복수의 인자들의 각 인자에 대해, 완료 어레이의 인자에 대응하는 완료 플래그의 값에 기초한 인자에 대한 레벨을 결정하고, 결정된 레벨의 순서에 따라 제2 벡터의 각 인자에 대한 값을 계산하기 위한 것이며, 여기서 동일한 레벨에 있는 복수의 인자들 중 적어도 2 개에 대한 값이 병렬로 계산된다.

컴퓨팅 시스템은 압축 희소 로우(CSR) 데이터세트로서 희소 삼각 행렬을 저장하기 위한 메모리 시스템 및 메모리 시스템과 결합된 하나 이상의 처리 유닛들의 세트를 포함한다. 처리 유닛들의 세트의 각 처리 유닛은, 제 1 벡터에서 복수의 인자들의 각 인자에 대해, 인자에 대해 제1 벡터에서 하나 이상의 선행 인자들의 세트를 식별함으로써 인자의 값을 계산하고, 여기서 인자의 값은 하나 이상의 선행 인자들 각각에 종속하며, 하나 이상의 선행 인자 값들이 모두 해결되었음을 나타내는 완료 어레이에 응답하여, 행렬의 로우에 있는 하나 이상의 인자의 로우에 대응하는 산출 값을 기반으로 인자의 값을 계산하고, 완료 어레이에서, 인자가 해결되었음을 나타내는 인자에 대한 완료 플래그를 어서션하기 위한 것이다.

컴퓨팅 시스템에서, 처리 유닛들의 세트의 각 처리 유닛은 또한 복수의 병렬 스레드들 중 적어도 하나를 실행하기 위한 것이며, 여기서 복수의 병렬 스레드들 각각은 복수의 인자들 중 하나에 대한 값을 계산한다.

컴퓨팅 시스템에서, 처리 유닛들의 세트의 각 처리 유닛은 단일 집적 회로 다이 상의 복수의 처리 코어들을 더 포함하고, 여기서 복수의 처리 코어들 각각은 복수의 병렬 스레드들 중 하나를 실행하기 위한 것이다.

컴퓨팅 시스템에서, 처리 유닛들의 세트의 각 처리 유닛은 처리 유닛들의 세트의 다른 처리 유닛들과는 별개의 집적 회로 다이에 있는 그래픽 처리 유닛(GPU)이다.

본 명세서에서 사용되는 바와 같이, "결합된(coupled to)"이라는 용어는 하나 이상의 개재 구성 요소를 통해 직접 또는 간접적으로 결합되는 것을 의미할 수 있다. 본 명세서에 설명된 다양한 버스들을 통해 제공되는 임의의 신호들은 다른 신호들과 시간 다중화되고 하나 이상의 공통 버스들을 통해 제공될 수 있다. 또한, 회로 구성 요소들 또는 블록들 간의 상호 연결은 버스 또는 단일 신호 라인으로 표시될 수 있다. 각각의 버스는 대안적으로 하나 이상의 단일 신호 라인일 수 있고 각각의 단일 신호 라인은 대안적으로 버스일 수 있다.

특정 실시예들은 비-일시적 컴퓨터-판독 가능 매체에 저장된 명령어를 포함할 수 있는 컴퓨터 프로그램 제품으로 구현될 수 있다. 이러한 명령어는 설명된 동작들을 수행하기 위해 범용 또는 특수 목적 프로세서를 프로그래밍하는 데 사용될 수 있다. 컴퓨터-판독 가능 매체는 기계(예를 들어, 컴퓨터)에 의해 판독 가능한 형태(예를 들어, 소프트웨어, 처리 어플리케이션)로 정보를 저장하거나 전송하기 위한 임의의 메커니즘을 포함한다. 비-일시적 컴퓨터-판독 가능 저장 매체는 자기 저장 매체(예를 들어, 플로피 디스켓); 광학 저장 매체(예를 들어, CD-ROM); 광-자기 저장 매체; 판독 전용 메모리(ROM); 랜덤 액세스 메모리(RAM); 지울 수 있는 프로그래밍 가능 메모리(예를 들어, EPROM 및 EEPROM); 플래쉬 메모리, 또는 전자 명령을 저장하는 데 적합한 다른 유형의 매체를 포함할 수 있지만 이에 제한되지 않는다.

추가적으로, 일부 실시예는 컴퓨터 판독 가능 매체가 하나 이상의 컴퓨터 시스템에 저장 및/또는 실행되는 분산 컴퓨팅 환경에서 실행될 수 있다. 또한, 컴퓨터 시스템들 간에 전송되는 정보는 컴퓨터 시스템들을 연결하는 전송 매체를 통해 가져 오거나 푸시될 수 있다.

일반적으로, 컴퓨터 판독 가능 저장 매체에 운반되는 컴퓨팅 장치(101) 및/또는 그 일부를 나타내는 데이터 구조는 데이터베이스 또는 기타 데이터 구조일 수 있고, 이것은 프로그램에 의해 판독될 수 있고, 컴퓨팅 디바이스(101)를 포함하는 하드웨어를 제조하기 위해 직접 또는 간접적으로 사용될 수 있다. 예를 들어, 데이터 구조는 Verilog 또는 VHDL과 같은 고 레벨 설계 언어(High Level Design Language, HDL)의 하드웨어 기능에 대한 동작 레벨 디스크립션(description) 또는 RTL(Register-Transfer Level) 디스크립션일 수 있다. 디스크립션은 합성 라이브러리에서 게이트 목록을 포함하는 넷리스트를 생성하기 위해 디스크립션을 합성할 수 있는 합성 도구에 의해 판독될 수 있다. 넷리스트는 컴퓨팅 디바이스(101)를 포함하는 하드웨어의 기능을 나타내는 게이트 세트를 포함한다. 넷리스트는 마스크에 적용될 기하학적 모양을 설명하는 데이터세트를 생성하기 위해 배치되고 라우팅될 수 있다. 그 다음, 마스크는 컴퓨팅 디바이스(101)에 대응하는 반도체 회로 또는 회로들을 생성하기 위해 다양한 반도체 제조 단계에서 사용될 수 있다. 대안적으로, 컴퓨터-판독 가능 저장 매체 상의 데이터베이스는 넷리스트(합성 라이브러리 포함 또는 제외) 또는 데이터세트, 바람직하게는, 또는 그래픽 데이터 시스템(GDS) II 데이터 일 수 있다.

여기에서 방법(들)의 동작들이 특정 순서로 표시되고 설명되었지만, 각 방법의 동작들의 순서는 특정 동작들이 역순으로 수행될 수 있도록 변경되거나, 특정 동작들이 적어도 부분적으로 다른 동작과 동시에 수행될 수 있도록 변경될 수 있다. 다른 실시예에서, 별개의 동작들의 명령어 또는 하위 동작들은 간헐적 및/또는 교대 방식일 수 있다.

전술한 명세서에서 실시예들은 구체적인 예시적인 실시예들을 참조하여 설명되었다. 그러나, 첨부된 청구 범위에 기재된 실시예의 더 넓은 범위를 벗어나지 않고 다양한 수정 및 변경이 이루어질 수 있음이 명백할 것이다. 따라서, 명세서 및 도면은 제한적인 의미가 아니라 예시적인 의미로 간주되어야 한다.

Claims (22)

1. 방법에 있어서,
   메모리 디바이스에서, 희소 삼각 행렬(sparse triangular matrix)을 압축 희소 로우(compressed sparse row, CSR) 데이터세트로 저장하는 단계;
   복수의 처리 코어들을 포함하는 처리 유닛에서, 제1 벡터의 인자들의 서브세트의 각 인자에 대해,
   상기 제1 벡터의 하나 이상의 선행 인자들의 세트를 상기 인자에 대해 식별하고-여기서, 상기 인자의 값은 상기 하나 이상의 선행 인자들 각각에 종속함-;
   상기 하나 이상의 선행 인자 값들에 대한 계산들이 모두 완료되었음을 나타내는 완료 어레이에 응답하여, 상기 인자의 값을 계산하기 위해 상기 복수의 처리 코어들 중 하나에서 스레드를 개시하고-여기서, 상기 스레드는,
   상기 행렬의 로우에 있는 하나 이상의 요소들; 및
   하나 이상의 선행 인자 값들, 상기 인자의 상기 값, 및 상기 로우의 상기 하나 이상의 요소들에 대응하는 산출 값(product value)에 기초하여 상기 복수의 처리 코어들 중 하나에서 실행됨-; 및
   상기 완료 어레이에서, 상기 인자에 대한 계산이 완료되었음을 나타내는 상기 인자에 대한 완료 플래그를 어서션(assertion)함으로써, 상기 인자의 상기 값을 계산함으로써, 상기 제1 벡터의 상기 인자들의 상기 서브세트의 각각에 대한 상기 값을 계산하는 단계를 포함하는, 방법.
2. 제1항에 있어서, 상기 희소 삼각 행렬을 상기 CSR 데이터세트로 저장하는 단계는,
   상기 CSR 데이터세트의 값 어레이에 상기 행렬의 요소들을 저장하는 단계;
   상기 CSR 데이터세트의 컬럼 어레이에서, 상기 값 어레이에 저장된 요소들 각각에 대한 상기 행렬의 컬럼(column)을 식별하는 단계; 및
   상기 CSR 데이터세트의 로우 포인터 어레이(row pointers array)에서, 상기 행렬의 각 로우에 있는 상기 요소들을 식별하는 단계를 더 포함하는, 방법.
3. 제1항에 있어서, 상기 인자들의 서브세트의 각 인자에 대해,
   상기 스레드는 서로 병렬로 실행되는 복수의 병렬 스레드들 중 하나이고, 상기 복수의 병렬 스레드들 각각은 상기 복수의 인자들 중 하나를 계산하기 위한 것인, 방법.
4. 제3항에 있어서, 상기 복수의 스레드들의 각각의 스레드에 대해,
   상기 완료 어레이의 제2 완료 플래그를 모니터링하기 위해 상기 스레드에서 실행된 스핀 루프(spin loop)의 반복 횟수를 카운팅하는 단계로, 상기 제2 완료 플래그는 상기 선행 인자들 중 하나와 연관되는, 상기 스핀 루프의 반복 횟수를 카운팅하는 단계; 및
   제한(limit)을 초과하는 상기 반복 횟수에 대한 응답으로,
   상기 스핀 루프를 종료하는 단계,
   상기 복수의 병렬 처리 스레드들이 모두 완료되었을 때 실행을 위해 자식 커널(child kernel)을 대기열에 넣는 단계(enqueueing), 및
   상기 자식 커널의 새 스레드의 상기 제2 완료 플래그를 모니터링하는 단계를, 더 포함하는 방법.
5. 제4항에 있어서,
   자식 시작 플래그(child started flag)를 검사하는 단계로, 상기 자식 시작 플래그가 디어어션(deassertion)될 때 상기 자식 커널을 대기열에 넣는 단계가 수행되는, 상기 자식 시작 플래그를 검사하는 단계; 및
   상기 자식 커널을 대기열에 넣는 단계와 관련하여 상기 자식 시작 플래그를 어서션(assertion)하는 단계를 더 포함하는, 방법.
6. 제1항에 있어서, 상기 인자들의 서브세트의 각 인자에 대해,
   상기 완료 어레이의 제1 완료 플래그를 모니터링하기 위해 제1 스핀 루프를 실행하는 단계-여기서, 상기 제1 완료 플래그는 상기 CSR 데이터세트의 컬럼 어레이의 제1 위치에서 지정되고, 상기 컬럼 어레이의 상기 제1 위치는 상기 인자에 대응하는 로우 포인터에 의해 표시됨-; 및
   상기 제1 완료 플래그가 어서션되고 상기 컬럼 어레이의 제2 위치가 상기 희소 삼각 행렬의 비-대각선 요소에 대응한다는 결정에 응답하여 상기 완료 어레이의 제2 완료 플래그를 모니터링하기 위해 제2 스핀 루프를 실행하는 단계-여기서, 상기 제2 완료 플래그는 상기 컬럼 어레이의 상기 제2 위치에서 지정됨-를 더 포함하는, 방법.
7. 제6항에 있어서, 상기 인자들의 서브세트의 각 인자에 대해,
   로우 포인터 어레이에서 상기 로우 포인터의 위치는 상기 벡터에서 상기 인자의 위치에 대응하고;
   상기 로우 포인터는 상기 컬럼 어레이에서 상기 제1 위치의 인덱스이고; 그리고
   상기 컬럼 어레이의 상기 제1 위치는 상기 완료 어레이의 상기 인자의 상기 완료 플래그의 인덱스를 저장하는, 방법.
8. 제1항에 있어서, 상기 인자들의 서브세트의 각 인자에 대해,
   상기 선행 인자들 각각에 대한 완료 플래그를 저장하는 단계;
   상기 선행 인자들의 상기 완료 플래그들 중 가장 높은 값을 갖는 완료 플래그를 증가시킴으로써 상기 인자에 대한 상기 완료 플래그의 값을 결정하는 단계; 및
   상기 인자에 대응하는 위치에서 상기 완료 어레이의 상기 인자에 대한 상기 완료 플래그의 상기 결정된 값을 저장함으로써 상기 인자에 대한 상기 완료 플래그를 어서션하는 단계를 더 포함하는, 방법.
9. 제8항에 있어서,
   제2 벡터의 복수의 인자들의 각 인자에 대해, 상기 완료 어레이의 상기 인자에 대응하는 상기 완료 플래그의 값에 기초하여 상기 인자에 대한 레벨을 결정하는 단계; 및
   상기 결정된 레벨에 따른 순서로 상기 제2 벡터의 상기 인자들 각각에 대한 값을 계산하는 단계를 더 포함하고, 동일한 레벨의 상기 복수의 인자들 중 적어도 2 개에 대한 값들은 병렬로 계산되는, 방법.
10. 제1항에 있어서,
    상기 CSR 데이터세트는 메모리 시스템에 저장되고, 그리고
    상기 인자들의 서브세트의 각 인자에 대해, 상기 인자의 상기 값은 상기 메모리 시스템과 결합된 솔버 회로(solver circuit)에서 계산되는, 방법.
11. 제1항에 있어서,
    상기 완료 어레이를 생성하는 단계; 및
    스핀 루프 회로를 사용하여 상기 완료 어레이로부터 상기 완료 플래그를 판독하는 단계를 더 포함하고, 여기서:
    상기 완료 어레이는 메모리 시스템에 저장되고, 그리고
    상기 완료 어레이에서 상기 완료 플래그를 어서션하는 단계는 상기 스핀 루프 회로 및 상기 메모리 시스템과 결합된 솔버 회로에 의해 수행되는, 방법.
12. 컴퓨팅 디바이스에 있어서,
    희소 삼각 행렬을 압축 희소 로우(CSR) 데이터세트로 저장하도록 구성된 메모리; 및
    복수의 처리 코어들을 포함하는 처리 유닛을 포함하고, 상기 처리 코어는 상기 메모리와 결합되고, 제1 벡터의 인자들의 서브세트의 각 인자에 대해,
    제1 벡터의 하나 이상의 선행 인자들의 세트를 상기 인자에 대해 식별하고-여기서 상기 인자의 값은 상기 하나 이상의 선행 인자들 각각에 종속함-;
    상기 하나 이상의 선행 인자 값들에 대한 계산들이 모두 완료되었음을 나타내는 완료 어레이에 응답하여, 상기 인자의 상기 값의 계산을 위해 상기 복수의 처리 코어들 중 하나에서 스레드를 개시하고-여기서 상기 스레드는,
    상기 행렬의 로우의 하나 이상의 요소들, 및
    상기 선행 인자 값들, 상기 인자의 상기 값, 및 로우의 상기 하나 이상의 요소들에 대응하는 산출 값을 기초로, 상기 복수의 처리 코어들 중 하나에서 실행됨-; 그리고
    상기 완료 어레이에서, 상기 인자에 대한 계산이 완료되었음을 나타내는 상기 인자에 대한 완료 플래그를 어서션함으로써, 상기 인자의 값을 계산하도록 구성된, 컴퓨팅 디바이스.
13. 제12항에 있어서, 상기 CSR 데이터세트는,
    상기 행렬의 요소들을 저장하도록 구성된 값 어레이;
    상기 값 어레이에 저장된 상기 요소들 각각에 대해 상기 행렬의 컬럼을 식별하도록 구성된 컬럼 어레이; 및
    상기 행렬의 각 로우의 요소들을 식별하도록 구성된 로우 포인터 어레이를 더 포함하는, 컴퓨팅 디바이스.
14. 제12항에 있어서, 상기 처리 유닛은 복수의 처리 코어들을 포함하고, 각각의 처리 코어는,
    상기 벡터의 상기 인자들 중 하나의 상기 값을 계산하기 위해 복수의 병렬 스레드들의 스레드를 실행하도록 구성된, 컴퓨팅 디바이스.
15. 제14항에 있어서, 상기 복수의 처리 코어들 각각은,
    상기 스레드에서 스핀 루프를 실행하여 상기 완료 어레이의 상기 완료 플래그를 모니터링하고; 그리고
    미리 정해진 제한을 초과하는 상기 스핀 루프의 반복 횟수에 응답하여,
    상기 스핀 루프를 종료하고, 그리고
    상기 복수의 병렬 처리 스레드들이 모두 완료되면, 상기 완료 플래그를 모니터링하기 위해 새 스레드를 실행하도록 더 구성된, 컴퓨팅 디바이스.
16. 제12항에 있어서, 상기 처리 유닛은 복수의 처리 코어들을 포함하고, 각각의 처리 코어는,
    제1 스핀 루프를 실행하여 상기 완료 어레이의 제1 완료 플래그를 모니터링하고-여기서 상기 제1 완료 플래그는 상기 CSR 데이터세트의 컬럼 어레이의 제1 위치에 지정되고, 상기 컬럼 어레이의 상기 제1 위치는 상기 제1 벡터의 상기 인자들의 서브세트 중 하나에 대응하는 로우 포인터에 의해 표시됨-; 그리고
    상기 제1 완료 플래그가 어서션되고 상기 컬럼 어레이의 제2 위치가 상기 희소 삼각 행렬의 비-대각선 요소에 대응된다는 결정에 응답하여 상기 완료 어레이의 제2 완료 플래그를 모니터링하기 위해 제2 스핀 루프를 실행하도록 구성되며, 상기 제2 완료 플래그는 상기 컬럼 어레이의 상기 제2 위치에 지정된, 컴퓨팅 디바이스.
17. 제12항에 있어서,
    상기 메모리의 완료 어레이를 더 포함하고, 상기 완료 어레이는 상기 인자들의 서브세트 각각에 대한 완료 플래그를 저장하도록 구성되고,
    상기 처리 유닛은, 상기 인자들의 서브세트의 각 인자에 대해,
    상기 선행 인자들의 상기 완료 플래그들 중 가장 높은 값을 증가시켜 상기 인자에 대한 상기 완료 플래그의 값을 결정하고, 그리고
    상기 인자에 대응하는 위치에서 상기 완료 어레이의 상기 인자에 대한 상기 완료 플래그의 상기 결정된 값을 저장하여 상기 인자에 대한 완료 플래그를 어서션하도록 더 구성된, 컴퓨팅 디바이스.
18. 제17항에 있어서, 상기 처리 유닛은,
    제2 벡터의 복수의 인자들의 각 인자에 대해, 상기 완료 어레이의 상기 인자에 대응하는 상기 완료 플래그의 값에 기초하여 상기 인자에 대한 레벨을 결정하고; 그리고
    상기 결정된 레벨에 따른 순서로 상기 제2 벡터의 상기 인자들 각각에 대한 값을 계산하도록 더 구성되며, 동일한 레벨의 복수의 인자들 중 적어도 2 개에 대한 값들은 병렬로 계산되는, 컴퓨팅 디바이스.
19. 컴퓨팅 시스템에 있어서,
    희소 삼각 행렬을 압축 희소 로우(CSR) 데이터세트로 저장하도록 구성된 메모리;
    상기 메모리에 결합된 하나 이상의 처리 유닛들의 세트를 포함하고, 상기 처리 유닛들의 세트의 각각의 처리 유닛은 복수의 처리 코어들을 포함하고, 제1 벡터의 인자들의 서브세트의 각 인자에 대해,
    상기 제1 벡터의 하나 이상의 선행 인자들의 세트를 상기 인자에 대해 식별하고-여기서 상기 인자의 값은 상기 하나 이상의 선행 인자들 각각에 종속함-;
    상기 하나 이상의 선행 인자 값들예 대한 계산들이 모두 완료되었음을 나타내는 완료 어레이에 응답하여, 상기 인자에 대한 상기 값의 계산을 위해 상기 복수의 처리 코어들 중 하나에서 스레드를 개시하고-여기서 상기 스레드는,
    상기 행렬의 로우의 하나 이상의 요소들, 및
    상기 선행 인자 값들, 상기 인자의 상기 값, 및 로우의 상기 하나 이상의 요소들에 대응하는 산출 값을 기초로, 상기 복수의 처리 코어들 중 하나에서 실행됨-; 그리고
    상기 완료 어레이에서, 상기 인자에 대한 계산이 완료되었음을 나타내는 상기 인자에 대한 완료 플래그를 어서션함으로써, 상기 인자의 상기 값을 계산하도록 구성된, 컴퓨팅 시스템.
20. 제19항에 있어서, 상기 처리 유닛들의 세트의 각각의 처리 유닛은,
    복수의 병렬 스레드들 중 적어도 하나를 실행하도록 더 구성되고, 상기 복수의 병렬 스레드들 각각은 상기 인자들의 서브세트 중 하나에 대한 값을 계산하는, 컴퓨팅 시스템.
21. 제20항에 있어서, 상기 처리 유닛들의 세트의 각 처리 유닛은 단일 집적 회로 다이 상의 복수의 처리 코어들을 더 포함하고, 상기 복수의 처리 코어들 각각은 상기 복수의 병렬 스레드들 중 하나를 실행하도록 구성된, 컴퓨팅 시스템.
22. 제19항에 있어서, 상기 처리 유닛들의 세트의 각 처리 유닛은 상기 처리 유닛들의 세트의 다른 처리 유닛들과는 별개의 집적 회로 다이 상의 그래픽 처리 유닛(graphics processing unit, GPU)인, 컴퓨팅 시스템.

Images