KR20230018361A - 벡터 연산들을 위한 회전식 누산기 - Google Patents

벡터 연산들을 위한 회전식 누산기 Download PDF

Info

Publication number
KR20230018361A
KR20230018361A KR1020227031431A KR20227031431A KR20230018361A KR 20230018361 A KR20230018361 A KR 20230018361A KR 1020227031431 A KR1020227031431 A KR 1020227031431A KR 20227031431 A KR20227031431 A KR 20227031431A KR 20230018361 A KR20230018361 A KR 20230018361A
Authority
KR
South Korea
Prior art keywords
vector
output
register
instruction
processing unit
Prior art date
Application number
KR1020227031431A
Other languages
English (en)
Inventor
헨드키크 람버투스 뮐러
Original Assignee
엑스모스 엘티디
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Application filed by 엑스모스 엘티디 filed Critical 엑스모스 엘티디
Publication of KR20230018361A publication Critical patent/KR20230018361A/ko

Links

Images

Classifications

    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00—Arrangements for program control, e.g. control units
    • G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/30—Arrangements for executing machine instructions, e.g. instruction decode
    • G06F9/38—Concurrent instruction execution, e.g. pipeline or look ahead
    • G06F9/3885—Concurrent instruction execution, e.g. pipeline or look ahead using a plurality of independent parallel functional units
    • G06F9/3893—Concurrent instruction execution, e.g. pipeline or look ahead using a plurality of independent parallel functional units controlled in tandem, e.g. multiplier-accumulator
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F17/00—Digital computing or data processing equipment or methods, specially adapted for specific functions
    • G06F17/10—Complex mathematical operations
    • G06F17/16—Matrix or vector computation, e.g. matrix-matrix or matrix-vector multiplication, matrix factorization
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F15/00—Digital computers in general; Data processing equipment in general
    • G06F15/76—Architectures of general purpose stored program computers
    • G06F15/80—Architectures of general purpose stored program computers comprising an array of processing units with common control, e.g. single instruction multiple data processors
    • G06F15/8007—Architectures of general purpose stored program computers comprising an array of processing units with common control, e.g. single instruction multiple data processors single instruction multiple data [SIMD] multiprocessors
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F15/00—Digital computers in general; Data processing equipment in general
    • G06F15/76—Architectures of general purpose stored program computers
    • G06F15/80—Architectures of general purpose stored program computers comprising an array of processing units with common control, e.g. single instruction multiple data processors
    • G06F15/8053—Vector processors
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00—Arrangements for program control, e.g. control units
    • G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/30—Arrangements for executing machine instructions, e.g. instruction decode
    • G06F9/30003—Arrangements for executing specific machine instructions
    • G06F9/30007—Arrangements for executing specific machine instructions to perform operations on data operands
    • G06F9/3001—Arithmetic instructions
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00—Arrangements for program control, e.g. control units
    • G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/30—Arrangements for executing machine instructions, e.g. instruction decode
    • G06F9/30003—Arrangements for executing specific machine instructions
    • G06F9/30007—Arrangements for executing specific machine instructions to perform operations on data operands
    • G06F9/30032—Movement instructions, e.g. MOVE, SHIFT, ROTATE, SHUFFLE
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00—Arrangements for program control, e.g. control units
    • G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/30—Arrangements for executing machine instructions, e.g. instruction decode
    • G06F9/30003—Arrangements for executing specific machine instructions
    • G06F9/30007—Arrangements for executing specific machine instructions to perform operations on data operands
    • G06F9/30036—Instructions to perform operations on packed data, e.g. vector, tile or matrix operations
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00—Arrangements for program control, e.g. control units
    • G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/30—Arrangements for executing machine instructions, e.g. instruction decode
    • G06F9/30098—Register arrangements
    • G06F9/30105—Register structure
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00—Arrangements for program control, e.g. control units
    • G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/30—Arrangements for executing machine instructions, e.g. instruction decode
    • G06F9/30098—Register arrangements
    • G06F9/3012—Organisation of register space, e.g. banked or distributed register file
    • G06F9/30134—Register stacks; shift registers
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00—Arrangements for program control, e.g. control units
    • G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/30—Arrangements for executing machine instructions, e.g. instruction decode
    • G06F9/30098—Register arrangements
    • G06F9/30141—Implementation provisions of register files, e.g. ports

Landscapes

  • Engineering & Computer Science (AREA)
  • Theoretical Computer Science (AREA)
  • Software Systems (AREA)
  • Physics & Mathematics (AREA)
  • General Physics & Mathematics (AREA)
  • General Engineering & Computer Science (AREA)
  • Computer Hardware Design (AREA)
  • Mathematical Physics (AREA)
  • Computing Systems (AREA)
  • Computational Mathematics (AREA)
  • Mathematical Analysis (AREA)
  • Mathematical Optimization (AREA)
  • Pure & Applied Mathematics (AREA)
  • Data Mining & Analysis (AREA)
  • Algebra (AREA)
  • Databases & Information Systems (AREA)
  • Complex Calculations (AREA)
  • Advance Control (AREA)
  • Executing Machine-Instructions (AREA)

Abstract

출력 벡터를 생성하기 위한 처리 유닛이 제공된다. 상기 처리 유닛은 출력 벡터 레지스터 및 벡터 유닛을 포함하고, 기계 코드 명령어들을 실행하도록 구성되고, 각각의 명령어는 상기 처리 유닛의 명령어 세트에서 사전 정의된 명령어 유형들의 세트의 인스턴스이다. 상기 명령어 세트는 대응하는 오피코드(opcode)에 의해 정의된 벡터 처리 명령어를 포함하며, 상기 벡터 처리 명령어는 상기 처리 유닛으로 하여금: i) 상기 벡터 유닛을 사용하여 적어도 2개의 입력 벡터들을 처리하여 결과 값을 생성하도록 하고; ii) 상기 출력 레지스터의 복수의 요소들에 대해 회전 연산을 수행하도록 하며, 상기 결과 값 또는 상기 결과 값에 기초한 값이 상기 출력 레지스터의 제1 단부 요소에 배치된다.

Description

벡터 연산들을 위한 회전식 누산기
본 발명은 행렬-벡터 연산과 같은 벡터 연산을 구현하기 위한 실행 유닛을 갖는 프로세서에 관한 것이다.
주어진 프로세서의 프로세서 아키텍처는 특정 명령어 세트 중에서 인스턴스화된 명령어들을 실행하도록 설계된다. 프로세서의 명령어 세트는 프로세서가 실행하도록 구성된 기계 코드 명령어 종류의 기본 정의 세트이다. 여기에는 여러 컴퓨팅 명령어, 예를 들어, 더하기, 곱하기 등과 같은 산술 명령어를 포함한다. 실행된 각 명령어는 명령어 세트의 명령어 유형 중 하나의 인스턴스이다. 명령어 세트에 정의된 각 명령어는 오피코드와 0개 이상의 피연산자 필드로 구성된 기계 코드 명령어이며, 여기서 오피코드는 수행될 연산을 지정하고 피연산자 필드(들)(있는 경우)는 지정된 연산에 의해 연산될 하나 이상의 피연산자를 지정하는 데 사용된다.
일부 프로세서는 명령어 세트의 일부로 벡터 처리 명령어로 구성된다. 이러한 유형의 일반적인 프로세서는 대응하는 기계 코드 명령어에 응답하여 벡터 연산들을 수행하기 위한 벡터 처리 유닛(VPU)을 포함한다. 예를 들어, VPU는 대응하는 기계 코드 명령어에 응답하여 2개의 입력 벡터들에 대해 곱셈 누산 연산을 수행할 수 있으며, 그 출력은 2개의 입력 벡터의 내적과 같다.
벡터 유닛은 더 큰 작업의 일부를 형성하는 벡터 연산을 수행하는 데 사용할 수 있다. 그러나, 이를 위해서는 각 개별 벡터 연산의 결과를 적절하게 저장하고 정렬해야 하므로 명령어에 추가 피연산자가 필요하거나 결과 값들을 이동하기 위한 메모리 사용량이 필요하거나 둘 다 필요할 수 있다. 보다 간소화된 구현 메커니즘을 제공하는 것이 바람직할 것이다.
본 명세서에 개시된 제1 양태에 따르면, 출력 벡터를 생성하기 위한 처리 유닛이 제공되고, 상기 처리 유닛은: 상기 출력 벡터의 상이한 성분들을 유지하기 위한 복수의 요소들을 갖는 출력 레지스터 - 상기 복수의 요소들은 제1 단부 요소 및 제2 단부 요소를 포함함 - 와; 그리고 각각의 결과 값을 생성하기 위해 적어도 두 개의 입력 벡터들을 처리하는 벡터 유닛을 포함하고, 상기 처리 유닛은 기계 코드 명령어들을 실행하도록 구성되고, 각각의 명령어는 상기 처리 유닛의 명령어 세트에서 사전 정의된 명령어 유형들의 세트의 인스턴스이고, 상기 명령어 세트는 대응하는 오피코드(opcode)에 의해 정의된 벡터 처리 명령어를 포함하며, 상기 벡터 처리 명령어는 상기 처리 유닛으로 하여금: i) 상기 벡터 유닛을 사용하여 제1 입력 벡터 및 제2 입력 벡터를 처리하여 결과 값을 생성하도록 하고; ii) 상기 출력 레지스터의 복수의 요소들에 대해 회전 연산을 수행하도록 하며, 상기 결과 값 또는 상기 결과 값에 기초한 값이 상기 출력 레지스터의 제1 단부 요소에 배치된다.
일 예에서, 상기 회전 연산의 일부로서 출력 레지스터의 제1 단부 요소에 배치된 값은 결과 값과 상기 회전 전에 제2 단부 요소에 존재하는 값의 합이다.
이 특정 예에는, 각각 메모리의 포인터만 조정하면 되는 명령어 시퀀스는 여러 패스들이 필요한 경우를 처리할 수 있는 이점이 있다. 이는, 예를 들어, 행렬 및/또는 벡터가 벡터 유닛에서 처리할 수 있는 (또는 입력 레지스터에 보관된) 것보다 큰 행렬-벡터 곱셈을 구현할 때 그렇다.
일 예에서, 상기 벡터 유닛은 i) 상기 입력 벡터들에 대해 곱셈-누산 연산을 수행함으로써 상기 제1 입력 벡터 및 상기 제2 입력 벡터의 처리를 수행하도록 구성되고, 상기 결과 값은 상기 곱셈-누산 연산의 결과인 스칼라 값이다.
일 예에서, 상기 벡터 유닛은 메모리로부터 직접적으로 적어도 상기 제2 입력 벡터에 액세스하도록 구성된다.
일 예에서, 상기 처리 유닛은 적어도 상기 제1 입력 벡터를 유지하기 위한 입력 레지스터를 포함하고, 상기 벡터 유닛은 상기 입력 레지스터로부터 상기 제1 입력 벡터에 액세스하도록 구성된다.
일 예에서, 상기 입력 레지스터는 상기 레지스터 파일 내의 복수의 레지스터들로부터 선택되고, 상기 벡터 처리 명령어는 상기 입력 레지스터를 지정하는 연산을 포함한다.
일 예에서, 상기 입력 레지스터는 상기 벡터 처리 명령어의 피연산자(operand)에 의해 지정되지 않은 상기 벡터 처리 명령어의 오피코드에 내재되어 있다.
일 예에서, 상기 출력 레지스터는 레지스터 파일 내의 복수의 레지스터들로부터 선택되고, 상기 벡터 처리 명령어는 상기 출력 레지스터를 지정하는 피연산자를 포함한다.
일 예에서, 상기 출력 레지스터는 벡터 처리 명령어의 피연산자에 의해 지정되지 않은 상기 벡터 처리 명령어의 오피코드에 내재되어 있다.
본 명세서에 개시된 제2 양태에 따르면, 출력 벡터의 상이한 성분들을 유지하기 위한 복수의 요소들을 갖는 출력 레지스터에서 출력 벡터를 생성하는 방법이 제공되고, 상기 방법은 처리 유닛에 의해 수행되며, 상기 복수의 요소들은 제1 단부 요소 및 제2 단부 요소를 포함하고, 상기 처리 유닛은 기계 코드 명령어들을 실행하도록 구성되고, 각각의 명령어는 상기 처리 유닛의 명령어 세트에서 사전 정의된 명령어 유형들의 세트의 인스턴스이고, 상기 명령어 세트는 대응하는 오피코드에 의해 정의된 벡터 처리 명령어를 포함하며, 상기 방법은, 상기 벡터 처리 명령어가 상기 처리 유닛으로 하여금: i) 상기 벡터 유닛을 사용하여 제1 입력 벡터 및 제2 입력 벡터를 처리하여 결과 값을 생성하고, 그리고 ii) 상기 출력 레지스터의 복수의 요소들에 대해 회전 연산을 수행하며, 상기 결과 값 또는 상기 결과 값에 기초한 값이 상기 출력 레지스터의 제1 단부 요소에 배치된다.
일 예에서, 상기 회전 연산의 일부로서 출력 레지스터의 제1 단부 요소에 배치된 값은 결과 값과 상기 회전 전에 제2 단부 요소에 존재하는 값의 합이다.
일 예에서, 상기 제1 입력 벡터는 레지스터에 저장되고, 그리고 상기 방법은 동일한 제1 입력 벡터를 사용하여 복수의 상기 벡터 처리 연산을 실행하는 단계를 포함한다. 예를 들어, 이것은 행렬 곱셈을 수행하는 데 사용될 수 있다.
일 예에서, 상기 방법은, 복수의 상기 벡터 처리 연산의 완료 후에, 상기 출력 레지스터에 존재하는 값들을 저장 위치에 출력하는 단계를 포함한다.
일 예에서, 상기 방법은, 상기 출력 레지스터의 요소들 수의 정수배와 같지 않은 복수의 벡터 처리 연산들을 완료한 후에, 총 회전 수가 출력 레지스터의 요소들 수의 정수 배수와 같도록 상기 출력 레지스터의 요소들에 존재하는 값을 변경하지 않고 상기 출력 레지스터에 대해 하나 이상의 회전 연산을 수행하는 단계를 포함한다.
본 명세서에 개시된 제3 양태에 따르면, 제2 양태에 따른 방법을 수행하도록 프로그래밍된, 제1 양태에 따른 처리 유닛을 포함하는 컴퓨터 시스템이 제공된다.
본 발명의 이해를 돕고 실시예들이 어떻게 실행될 수 있는지를 보여주기 위해, 예로서 첨부된 도면들을 참조한다.
도 1은 본 명세서에 서술된 예들에 따른 컴퓨터 시스템을 개략적으로 도시한다.
도 2는 벡터 처리 명령의 제1 구현예를 개략적으로 도시한다.
도 3a 및 도 3b는 회전 동작의 두 가지 예들을 더 자세히 개략적으로 도시한다.
도 4a 내지 도 4d는 행렬 및 벡터를 처리하기 위해 벡터 처리 명령을 사용하는 제1 예를 도시한다.
도 5a 및 도 5b는 행렬 및 벡터를 처리하기 위해 벡터 처리 명령을 사용하는 제2 예를 도시한다.
도 6은 벡터 처리 명령의 제2 구현예를 개략적으로 도시한다.
도 7은 처리 유닛에 의해 수행되는 예시적인 방법을 개략적으로 도시한다.
도 8은 처리 유닛에 의해 수행되는 또 다른 예시적인 방법을 개략적으로 도시한다.
본 발명은 행렬-벡터 연산들을 효율적으로 구현하기 위해 사용될 수 있는 명령어 및 마이크로 아키텍처 구조를 설계하는 것에 관한 것이다.
본 명세서에서 사용된 바와 같이, "명령어"라는 용어는 기계어 코드 명령어, 즉, 프로세서의 명령어 세트의 기본 명령어 유형들 중 하나를 나타내며, 각 명령어 유형은 단일 연산 코드 및 하나 이상의 피연산자 필드에 의해 정의된다. 피연산자는 즉시 피연산자가 될 수 있다. 즉, 연산할 값은 명령어에 직접 인코딩되거나, 또는 대안적으로 피연산자는 간접 피연산자의 형태, 즉, 연산될 값을 찾을 수 있는 어드레스를 취할 수 있다. 예를 들어, 추가 명령어는 피연산자들로 3개의 포인터를 사용할 수 있다. 2개는 추가할 값을 가져올 어드레스들을 지정하고 다른 하나는 결과를 쓸 대상 주소를 지정한다. 실제로, 벡터 곱셈 명령어 등의 소스 피연산자 필드에 있는 값은 일반적으로 직접 피연산자들과 달리 작업할 실제 벡터 값들을 보유하는 벡터 레지스터들에 대한 포인터들이다.
벡터 연산의 예는 행렬-벡터 연산이다. 행렬-벡터 연산은 많은 컴퓨팅 분야에서 사용된다. 예를 들어, 행렬-벡터 곱들을 사용하여 컨볼루션 신경망과 같은 딥 러닝 환경에서 컨볼루션 계층을 구현할 수 있다. 그러한 경우들에서, 값들의 입력 배열(예: 이미지에 대한 픽셀 값들의 배열)은 하나 이상의 필터(커널이라고도 함)로 컨볼루션될 수 있다. 이것은 필터의 내적과 수용 필드라고 하는 입력 배열의 하위 집합을 결정하는 것을 포함한다. 필터가 입력 배열을 통과할 때 각 수용 필드에 대해 내적이 결정된다. 그렇게 결정된 각 내적은 활성화 맵 또는 기능 맵이라고 하는 출력 배열에서 다른 값을 나타낸다. 따라서, 컨볼루션 계층은 벡터(필터를 나타냄)와 행렬(행렬의 각 행은 다른 수용 필드를 나타냄)을 곱한 것으로 간주될 수 있다. 이 연산은 두 번 이상, 예를 들어, RGB 이미지의 각 개별 색상 채널에서 수행될 수 있다.
일반적으로 벡터 V와 행렬 M의 곱을 결정하려면 출력 벡터 A의 각 요소가 입력 행렬 M의 (다른) 행과 입력 벡터 V의 내적에 대응하기 때문에 여러 내적들을 결정해야 한다.
기존 마이크로 프로세서에서, 내적을 산출하기 위한 계산은 각 항목을 차례로 곱하고 누적하는 루프로 구성된다. 예를 들어, 이는:
def vectorXvector(V1,V2):
sum = 0
for i in range (len(A)):
sum = sum + V1[i] * V2[i]
return sum
로서 표현될 수 있다.
여기서 "for" 루프는 요소별 곱셈과 누적을 구현하여 최종 내적 값("sum")을 산출한다.
행렬 계산의 경우, 다음과 같은 두 개의 루프들이 포함된다.
def matrixXvector (A, M, V):
for i in range(len(A)):
sum = 0
for j in range(lenV):
sum= sum + M[i,j] * V[j]
A[i] = sum
여기에서 내부 "for" 루프(인덱스 j 이상)는 이전과 같이 내적을 구현하고 외부 "for" 루프(인덱스 i 이상)는 행렬 M의 각 행에 대해 이 내적을 루프한다. n번째 내적의 결과는 출력 벡터 A의 n번째 요소 A[n]을 결정한다.
이것은 벡터 처리 유닛(간단히 벡터 유닛, VU라고도 함)을 사용하여 가속화될 수 있다. 벡터 유닛 자체는 당업계에 알려져 있다. 벡터 유닛은, 예를 들어, 다수의 VMA(다중 누산) 연산을 동시에 수행하여 두 입력 벡터들의 내적을 결정할 수 있다.
구체적인 예로, 벡터 유닛은 한 번에 16개의 곱셈을 계산한 후, 16개의 개별 곱셈 연산의 합계(합)를 결정하여 출력하는 누적 연산을 수행할 수 있다. 이러한 연산은 다음과 같은 형식을 취할 수 있다.
def vectorXvector (V1,V2):
sum = 0
for i in range(0, len(V1), 16): #step of 16
sum= VMA(sum, V1[i:i+16], V2[i:i+16])
return sum
이것은 16개의 승수(벡터 유닛)를 사용하는 대신 16배 더 빠르다. 이 연산은 다음과 같이 행렬에서도 사용할 수 있다.
def matrixXvector(A, M, V):
for i in range(len(A)):
sum = 0
for j in range(0, len(V), 16): #step of 16
sum = VMA(sum, M[i, j:j+16], V[j:j+16])
A[i] = sum
위와 유사하게 내부 "for" 루프(인덱스 j 이상)는 내적을 구현하고 외부 "for" 루프(인덱스 i 이상)는 행렬 M의 각 행에 대해 이 내적을 루프한다.
다시 말하지만, n번째 내적의 결과는 출력 벡터 A의 n번째 요소 A[n]을 결정한다. 즉, 위와 같은 과정을 수행할 때 벡터 유닛의 출력 값들을 이용하여 최종 출력 벡터를 구성하게 된다. 즉, 벡터 V와 행렬 M의 n번째 행을 벡터 유닛으로 전달한 결과는 출력 벡터의 n번째 요소(요소 0)에 해당하는 스칼라 값(내적)이 된다. 위의 예에서, 이것은 최종 출력 벡터의 올바른 각 요소에 기록되어야 하는 16개의 값으로 구성된다.
출력 벡터가 벡터 유닛의 개별 출력 값에서 올바르게 구성되도록 하기 위해, 일반적으로 두 가지 옵션들이 있다.
제1 옵션은 레지스터 파일의 작은 부분을 사용하여 단일 결과를 작성하는 것이다. 즉, 벡터 유닛의 출력 값들을 기존 스칼라 레지스터에 저장한 다음 이 값들을 스칼라 레지스터들에서 벡터 레지스터로 판독하여 벡터 레지스터에 최종 벡터를 구성한다. 이 방법의 단점은 값들을 반복적으로 로드해야 하기 때문에 더 많은 메모리 대역폭이 필요하다는 것이다.
제2 옵션은 결과를 누적할 위치에 대해 벡터 레지스터에서 명시적 인덱스를 사용하는 것이다. 즉, 벡터 유닛의 각 출력이 벡터 장치의 출력 시 벡터 레지스터의 올바른 요소에 기록되도록 한다. 이것의 단점은 출력이 기록될 벡터 레지스터의 위치를 지정하기 위해 추가 피연산자가 필요하다는 것이다.
본 발명은, 벡터 레지스터의 위치를 지정하기 위해(즉, 어떤 값이 출력 벡터의 어떤 요소에 해당하는지 지정하기 위해) 값들이나 추가 정보를 반복적으로 로드할 필요가 없이, 명령어의 반복적인 적용에 의해 출력 벡터가 자동으로 구성될 수 있도록 하는 명령어 및 대응하는 마이크로-아키텍처 구조를 제공함으로써 보다 효율적인 구현을 제공한다. 이것은 하나의 피연산자로 효율적인 행렬-벡터 곱셈 등을 가능하게 한다.
일반적으로 행렬과 벡터는 레지스터 집합이 보유할 수 있는 것보다 훨씬 크므로 입력 벡터는 벡터 유닛에 저장할 수 있는 요소들의 수보다 길 수 있다. 이러한 경우 여러 번 통과해야 한다. 그 결과 더 많은 출력 값이 생성된다. 따라서, 또 다른 문제는 레지스터 세트에서 올바른 데이터 비트를 로딩하고 메모리에서 나머지 데이터를 차례로 로딩하는 것이다. 본 발명은 이러한 복잡성을 처리하는 데 필요할 수 있는 모든 것이 메모리의 포인터를 조정할 필요가 있는 명령어 시퀀스를 차례로 생성하는 것이기 때문에 이에 대한 개선을 제공한다.
도 1은 프로세서(101)를 포함하는 예시적인 컴퓨터 시스템(100)을 도시한다. 프로세서(101)는 일련의 파이프라인 스테이지들을 포함하는 파이프라인(102)을 포함한다. 예를 들어, 파이프라인은 명령어를 인출하는 인출 스테이지(103), 명령어를 디코딩하는 디코딩 스테이지(104), 및 실행 유닛(105)을 포함할 수 있다. 실행 유닛(105)은 하나 이상의 스테이지, 예를 들어, 레지스터 파일(106)로부터 판독하는 레지스터 판독 스테이지, 계산들을 수행하는 계산 스테이지, 명령어에 따라 메모리에 어드레스할 수 있고, 데이터를 판독하고 데이터를 메모리에 기입할 수 있는 하나 이상의 메모리 액세스 스테이지를 포함할 수 있다. 도 1에 도시된 특정 파이프라인 스테이지들은 예시로서 여기에 설명되어 있지만 이것은 제한적이지 않으며, 당업자는 다른 가능한 파이프라인 변형들을 인식할 것이라는 점에 유의한다.
프로세서(101)는 인출 스테이지(103)에 연결된 스케줄러(미도시)를 포함할 수 있다. 실행 유닛(105)(예를 들어, 실행 유닛(105)의 메모리 액세스 스테이지)은 데이터 메모리(107)에 연결된다. 명령어 패치 스테이지(103)의 입력은 별도의 명령어 메모리(108)에 연결된다. 프로세서(101)는 적어도 하나의 레지스터 세트를 포함하는 레지스터 파일(106)을 포함한다. 또한, 가장 일반적으로, 여기에서 언급된 레지스터 파일은 프로세서상의 어드레스가능한 레지스터들의 전체 세트까지 레지스터들의 그룹을 참조할 수 있으며 레지스터 어드레스 공간의 특정 물리적 모듈 또는 하위 부분으로 제한되지 않는다. 특히, 레지스터 파일(106)은 후술하는 바와 같이 하나 이상의 벡터 레지스터를 포함한다.
데이터 메모리(107)는 연산들에 의해 계산될 데이터 및 연산 결과가 궁극적으로 저장될 수 있는 메모리이다. 데이터 메모리(107)는 프로세서(101)와 동일한 물리적 유닛에 저장될 수 있다. 대안적으로, 데이터 메모리(107)는 별도의 유닛, 예를 들어, 외부 메모리에 저장될 수 있다. 도 1에 도시된 것과 같은 실시예들에서, 명령어는 데이터 메모리(107)와 별개인 명령어 메모리(108)에 저장되고 그로부터 인출된다. 이들은 별도의 메모리 디바이스들 또는 동일한 메모리 디바이스의 별도 영역들일 수 있다. 어느 쪽이든, 명령어 메모리(108)와 데이터 메모리(107)는 겹치지 않는 어드레스 공간들을 갖기 때문에, 이것은 인출 스테이지(103)에 의해 수행된 명령어 인출들이 메모리 액세스 스테이지에 의해 수행되는 데이터 액세스(로드 또는 저장)와 경합할 위험이 없음을 의미한다. 데이터 메모리는 휘발성 저장소(예를 들어, 랜덤 액세스 메모리), 비휘발성 저장소(예를 들어, 읽기 전용 메모리), 플래시 메모리, 또는 이러한 메모리의 임의의 조합을 포함할 수 있지만 이에 제한되지 않는다.
실행 유닛(105)은 명령어 세트라고 하는 미리 정의된 세트로부터의 명령어에 응답하여 제한된 동작 세트를 수행할 수 있다. 전형적인 명령어 세트는, 예를 들어, 실행 유닛(105)이 각각의 명령어에 응답하여 이해하고 구현하도록 구성된 LOAD, ADD, STORE 등과 같은 명령어를 포함할 수 있다. 따라서, 실행 유닛(105)은 일반적으로 고정 소수점 산술 유닛(AU), 논리 유닛(LU), 산술 논리 유닛(ALU), 및 부동 소수점 유닛(FPU)과 같은 명령어들을 실행하기 위한 하나 이상의 산술 연산 유닛을 포함한다. 산술은 숫자에 대한 수학적 연산, 예를 들어, 곱하기, 더하기, 나누기, 빼기를 의미한다. 계산은 훨씬 더 넓은 세트를 구성할 수 있다. 예를 들어, 피연산자 0이 참이면 피연산자 1이 대상에 저장되고, 그렇지 않으면 피연산자 2가 대상에 저장된다. 도 1에 도시된 바와 같이, 실행 유닛(105)은 또한 벡터 유닛(201)을 포함하며, 이는 아래에서 더 상세히 논의된다.
본 명세서에 설명된 예에 따르면, 실행 유닛(105)은 본 명세서에서 예로서 VLMACCR(vector-load-multiply-accumulate-reduce)로 지칭되는 새로운 유형의 명령어를 구현하도록 구성된다.
도 2는 대응하는 명령어에 응답하여 VLMACCR 연산을 구현하도록 구성된 처리 유닛(200)을 사용하는 VLMACCR 연산의 예시적인 구현을 개략적으로 도시한다. VLMACCR 연산 자체는 도 3을 참조하여 아래에 서술된다.
처리 유닛(200)은 벡터 유닛(201) 및 출력 레지스터(rA)를 포함한다. 또한, 도 2에는 앞서 서술된 입력 레지스터 rV 및 메모리(107)가 도시되어 있다. 입력 레지스터 rV는 처리 유닛(201)의 일부를 형성하거나 형성하지 않을 수 있다. 유사하게, 메모리(107)는 처리 유닛(201)의 일부를 형성하거나 형성하지 않을 수 있다.
출력 레지스터 rA 및 입력 레지스터 rV는 벡터 레지스터들이다. 벡터 레지스터는 벡터의 서로 다른 성분들을 유지하기 위한 복수의 요소들을 포함하는 레지스터이다. 출력 레지스터 rA 및 입력 레지스터 rV는 앞서 서술된 레지스터 파일(106)의 일부로 구현될 수 있다(예를 들어, VLMACCR 명령어의 피연산자에 의해 지정됨). 대안적으로, 출력 레지스터 rA 및 입력 레지스터 rV 중 하나 이상은 벡터 유닛(201)에 의해 자동으로 사용되는 암시적 레지스터일 수 있다(피연산자에 의해 지정될 필요는 없음). 따라서, 특정 레지스터 rV, rA가 도면에 도시되어 있지만, 레지스터들 자체가 고정되지 않을 수 있음을 이해해야 한다. 즉, 프로세싱 유닛(200)에 의해 사용가능한 더 많은 레지스터가 있을 수 있고 rV 및 rA 중 하나 이상이 레지스터 세트로부터 (예를 들어, 레지스터 파일(106)에서) 선택될 수 있다. 사용할 벡터들은 VLMACCR 명령어의 피연산자들에 의해 (예를 들어, 벡터가 저장되는 레지스터 지정함으로써) 지정될 수 있다.
출력 레지스터 rA는 입력 레지스터 rV와 길이가 같을 필요는 없음을 알 수 있다. 출력 레지스터 rA의 2개의 단부 요소들은 여기에서 제1 단부 요소 및 제2 단부 요소로 지칭된다. 이는 상대적인 용어임을 이해해야 한다. 즉, 제1 단부 요소가 가장 왼쪽 요소이면(도 2 참조), 제2 단부 요소는 가장 오른쪽 요소이고 그 반대의 경우도 마찬가지이다. 마찬가지로, 제1 단부 요소가 최상부 요소이면 제2 단부 요소는 최하부 요소이다.
레지스터 rV 및 rA는 서로 다른 유형들 및/또는 너비들의 요소들을 저장할 수 있다. 일 예에서, rV는 8비트 정수들을 저장할 수 있고, rA는 32비트 정수들을 저장할 수 있다. 다른 형식들, 예를 들어, 32비트 부동 소수점, 16비트 부동 소수점이 가능하거나 또는 여러 유형들을 혼합할 수 있다.
벡터 유닛(201)은 위에서 서술된 실행 유닛(105)의 일부로서 구현될 수 있다. 또는 벡터 유닛(201)은 실행 유닛(105) 자체와 별도의 유닛으로 구현될 수 있다. 어느 경우든, 벡터 유닛(201)은 메모리(107)에 작동 가능하게 연결될 수 있다.
벡터 유닛(201)은 적어도 2개의 입력 벡터들에 대한 연산을 수행하여 결과 값을 생성하도록 구성된다. 도 2에 도시된 예에서, 벡터 유닛(201)은 제1 입력 벡터 V를 유지하는 입력 레지스터 rV 및 제2 입력 벡터 M을 유지하는 메모리(107)에 작동 가능하게 연결된다. 다른 예들에서, V 및 M 둘 모두는 벡터 유닛(201)에 의해 사용하기 위해 각각의 레지스터에 저장될 수 있다.
도 2에 도시된 예에서, 벡터 유닛(201)에 의해 수행되는 연산은 내적이고, 따라서, 입력 벡터 V 및 M으로부터 벡터 유닛(201)에 의해 생성된 결과 값은 V와 M의 내적과 동일한 스칼라 값이다. 1비트 숫자의 내적의 특정 구현에서 '0'은 -1을 나타내고 '1'은 +1(또는 그 반대)을 나타내는 데 사용될 수 있다. 이러한 경우, 곱들은 항상 +1 또는 -1(즉, NOT-XOR 연산)이고 값들의 합은 단순히 이러한 -1 및 +1 비트의 합이며, 이는 파퓰레이션 카운트(population count)이다. 이것은 매우 낮은 해상도이지만 고도로 평행한 내적의 예이다. 내적 이외의 연산은 벡터 유닛으로 수행될 수 있다. 예를 들어, 벡터 유닛은 포인트 방식으로 두 벡터를 함께 더할 수 있다(범위(len(V0)의 k에 대해): V2[k] = V0[k] + V1[k]). 곱하기, 빼기 또는 절대값이 다른 예이다.
도 3a는 VLMACCR 연산의 제1 예를 개략적으로 보여준다. 이 예에서 출력 레지스터 rA는 8개의 요소들로 구성된다. 출력 레지스터 rA의 초기 상태(301a) 및 최종 상태(301b)가 도시되어 있다. 초기 상태에서 출력 레지스터 rA의 8개 요소는 A0 내지 A7 값을 순서대로 유지한다. 이 값은 아래에서 더 자세히 논의되는 것처럼 0으로 초기화될 수 있다.
벡터 유닛(201)은 제1 입력 벡터(V)와 제2 입력 벡터(M)를 처리하여 결과 값(s)을 생성한다. 위에서 언급한 바와 같이, 이것은 V와 M의 내적을 결정하는 벡터 유닛(201)을 포함할 수 있다.
출력 레지스터 rA의 요소들의 값들은 도 3a와 같이 결과 값 s와 함께 초기 상태 값 A0 내지 A7을 사용하여 업데이트된다.
Figure pct00001
출력 레지스터 rA의 각 값은 왼쪽으로 1만큼 시프트한다(즉, 요소 n의 값이 요소 n-1로 이동).
Figure pct00002
가장 왼쪽 요소 A0의 값은 결과 값 s에 더해지고 합계는 출력 레지스터 rA의 가장 오른쪽(n번째) 요소에 배치된다.
도 3b는 제2 예시적인 VLMACCR 연산을 개략적으로 도시한다. 이 예는 출력 레지스터 rA의 값들이 오른쪽으로 이동한다는 점을 제외하고는 도 3a와 유사하다. 다시, 출력 레지스터 rA의 초기 상태(302a) 및 최종 상태(302b)가 도시된다. 초기 상태에서, 출력 레지스터 rA의 8개 요소들은 이전과 같이 값 A0 내지 A7을 유지한다.
다시, 출력 레지스터 rA의 요소들의 값들은 도 3a와 같이 결과 값 s와 함께 초기 상태 값 A0 내지 A7을 사용하여 업데이트된다. 그러나 이 예에서는 다음과 같다:
Figure pct00003
출력 레지스터 rA의 각 값은 1만큼 오른쪽으로 이동한다(즉, 요소 n의 값이 요소 n+1로 이동).
Figure pct00004
가장 오른쪽 요소 An-1의 값은 결과 값 s에 더해지고 합계는 출력 레지스터 rA의 가장 왼쪽(첫 번째) 요소에 배치된다.
위의 두 가지 예에서 볼 수 있듯이, 벡터 유닛(201)의 결과 값 s는 출력 벡터의 성분이 제1 단부 요소와 제2 단부 요소 사이에서 이동하는 모든 요소에 추가된다(이는 회전 방향에 따라 다름). 다른 값들(출력 레지스터 rA의 한쪽 끝에서 다른 쪽 끝으로 이동하지 않음)은 아무것도 추가하지 않고 단순히 한 요소를 왼쪽(또는 오른쪽)으로 이동한다.
따라서, 이 단계는 결과 값이 제1 단부 요소와 제2 단부 요소 사이에서 이동하는 출력 벡터의 성분에 추가되는 출력 레지스터의 복수 요소들에 대한 회전 연산(원형 시프트라고도 함)이다. 다른 예들에서 결과 값 및 제1 단부 요소와 제2 단부 요소 사이를 이동하는 출력 벡터의 성분에 대해 수행되는 연산은 다른 수학적 또는 논리 연산, 예를 들어, 곱하기, XOR, 빼기 등이다.
출력 레지스터 rA의 요소에 저장된 값들이 추가될 때(출력 레지스터 rA가 회전함에 따라 한 번에 하나씩), 요소들은 누산기들이라고 할 수 있다. 출력 레지스터 rA 자체도 비슷한 이유로 누산기라고 할 수 있다.
회전 동작은 플롭들을 사용하여 구현할 수 있다. 이러한 구현에서, 데이터는 (레지스터가 회전되는 방식에 따라) 마지막 요소에서 첫 번째 요소까지의 경로에 조합 요소(예: 가산기)를 포함하여 단순히 라우팅된다. 대안적인 구현에서, 캐리 레지스터는 다른 값들이 시프트되는 동안 하나의 값을 임시로 저장하는 데 사용될 수 있다.
위에서 서술된 VLMACCR 연산은 예를 들어 다음 의사 코드를 사용하여 나타낼 수 있다.
def vlmaccr(address):
sum = 0
for i in range(32):
sum = sum + rV[i] * memory[address+i]
sum = sum + rA[7]
for j in range(1,8):
rA[j] = rA[j-1]
rA[0] = sum
이 예에서 벡터 V와 M은 모두 32개의 성분들을 포함하고 출력 레지스터 rA는 출력 값들을 유지하기 위한 8개의 요소들(누산기들)을 포함한다. M은 메모리(107)에 저장되며, M의 제1 요소는 메모리 주소 "어드레스"에 있다. 첫 번째 "for" 루프는 곱하기 누산 연산(내적)을 구현한다. 두 번째 "for" 루프는 곱셈 누산 연산의 결과가 출력 레지스터 rA의 제1 요소에 기록되는 출력 레지스터 rA의 오른쪽 회전을 구현한다.
위에서 언급한 바와 같이, 처리 유닛(200) 및 VLMACCR 명령어는 행렬-벡터 곱셈을 효율적으로 구현하기 위해 사용될 수 있다.
def matrixXvector(A, M, V):
for i in range(0, len(A), 8):
rA[] = 0
for j in range(0, len(V), 16):
rV = V[j:j+16]
for k in range(8):
vlmaccr(address_of(M[i+k, j:j+16))
A[i:i+8] = rA
후술하는 도 8은 이 프로그램 코드를 흐름도로 보여준다.
예를 들어, 행렬의 연속적인 행들(예를 들어, 메모리(107)에 저장됨)은 차례로 판독되어 rV에 저장된 벡터 V가 곱해질 수 있다. 대안적인 구현에서, 매트릭스의 행들이 제2 입력 레지스터에 저장되는 것이 가능하다. 행렬의 각 행에 대해 VLMACCR 연산이 수행되고 출력 벡터 A는 출력 레지스터 rA에서 성분별로 자동으로 구성된다.
이제 처리 유닛(200)이 행렬 M과 벡터 V의 곱을 결정하는 데 사용되는 도 4a 내지 도 4d를 참조하여 예가 서술될 것이다. 이 예에서 행렬 M은 32개의 열들과 8개의 행들로 구성된다. 벡터 유닛(201)은 한 번에 16개의 요소들을 처리할 수 있다. 입력 레지스터 rV는 16개의 요소들로 구성된다. 일반적으로 입력 레지스터 rV는 벡터 유닛(201)이 한 번에 처리할 수 있는 것과 동일한 수의 요소를 포함해야 한다. 출력 레지스터 rA는 출력 벡터 A를 유지하기 위한 8개의 요소들로 구성된다.
도 4a에서 볼 수 있듯이 출력 레지스터 rA의 값은 먼저 0으로 초기화된다.
벡터 V의 처음 16개 성분들은 먼저 메모리(107)로부터 판독되고 입력 레지스터 rV에 저장된다.
그런 다음 제1 VLMACCR 명령에 대한 응답으로, 벡터 유닛(201)은 벡터 레지스터 rV에 저장된 벡터 V의 처음 16개 성분들과 메모리(107)로부터 판독된 행렬 M의 첫 번째 행의 처음 16개 성분들에 대해 연산하여 출력 값 s0을 생성한다. 즉, 처리 유닛(200)은 한 번에 2개의 벡터들에 대해 작동하도록 구성되며, 첫 번째는 벡터 V이고 두 번째는 행렬 M의 첫 번째(및 후속) 행이다. 이 예에서, 첫 번째 벡터 V는 레지스터 rV에 저장되지만 두 번째 벡터는 포인터를 사용하여 메모리(107)에서 직접 판독된다. 행렬 M의 후속 행들에 대해 작업하려면 포인터를 조정하기만 하면 된다. 다른 예들에서, 제2 벡터는 (제1 벡터 V와 유사하게) 프로세싱 유닛(200)에 의한 연산을 위해 벡터 레지스터에 저장될 수 있다. 그러한 경우들에서, 제2 벡터(또는 그 일부)는 별도의 로드 명령어를 사용하여 메모리(107)로부터 제2 입력 레지스터로 먼저 판독될 수 있다.
그런 다음 위에서 설명한 대로 회전 작업이 적용된다. 이 경우 s0은 출력 레지스터 rA의 제1 단부 요소(가장 왼쪽 요소)의 값에 더해지고 제2 단부 요소(가장 오른쪽 요소)에 배치된다. 출력 레지스터 rA의 다른 모든 값들은 왼쪽으로 한 요소 시프트된다.
다음 단계들은 도 4b에 나와 있다. 제2 VLMACCR 명령에 대한 응답으로, 벡터 유닛(201)은 벡터 레지스터 rV에 저장된 벡터 V의 처음 16개 성분들과 메모리(107)로부터 판독된 행렬 M의 두 번째 행의 처음 16개 성분들에 대해 연산하여 출력 값 s1을 생성한다. V는 재사용되므로 rV로 다시 로딩할 필요가 없다.
그런 다음 회전 작업이 적용된다. 이 경우 s1은 출력 레지스터 rA의 제1 단부 요소(가장 왼쪽 요소)의 값에 더해지고 제2 단부 요소(가장 오른쪽 요소)에 배치된다. 출력 레지스터 rA의 다른 모든 값들은 왼쪽으로 한 요소 시프트된다(이전에 작성한 s0 포함).
그런 다음 이 프로세스는 행렬 M의 8개 행 각각의 처음 16개 값이 처리될 때까지 계속된다. 다시 말해서, 행렬 M의 왼쪽은 벡터 유닛(201)에 의해 스윕되어 출력 레지스터 rA에 요소로 저장되는 "부분 합들"의 첫 번째 세트를 생성한다. 출력 벡터 레지스터 rA의 결과 상태는 [s0][s1][s2][s3][s4][s5][s6][s7]이다.
도 4c에 도시된 바와 같이, 벡터 V의 두 번째 16개 성분들은 메모리(107)에서 입력 레지스터 rV로 로딩된다.
제9 VLMACCR 명령에 대한 응답으로, 벡터 유닛(201)은 벡터 레지스터 rV에 저장된 벡터 V의 두 번째 16개 성분들과 메모리(107)로부터 판독된 행렬 M의 첫 번째 행의 두 번째 16개 성분들에 대해 연산하여 출력 값 s0'를 생성한다.
그런 다음 위에서 설명한 대로 회전 작업이 적용된다. 이 경우 출력 레지스터 rA의 제1 단부 요소(가장 왼쪽 요소)의 값 s0에 s0'이 더해지고 결과 s0'+s0은 제2 단부 요소(가장 오른쪽 요소)에 배치된다. 출력 레지스터 rA의 다른 모든 값들은 왼쪽으로 한 요소 시프트된다.
다음 단계는 도 4d에 도시된다. 다른 VLMACCR 명령어에 응답하여, 벡터 유닛(201)은 벡터 레지스터 rV에 저장된 벡터 V의 두 번째 16개 성분들과 메모리(107)로부터 판독된 행렬 M의 두 번째 행의 두 번째 16개 성분들에 대해 연산하여 출력 값 s1'을 생성한다. V는 재사용되므로 rV에 다시 로딩할 필요가 없다.
그런 다음 회전 작업이 적용된다. 이 경우, s1'은 출력 레지스터 rA의 제1 단부 요소(가장 왼쪽 요소)에서 값 s1에 더해지고 제2 단부 요소(가장 오른쪽 요소)에 배치된다. 출력 레지스터 rA의 다른 모든 값들은 왼쪽으로 한 요소 시프트된다.
그런 다음 이 프로세스는 행렬 M의 8개 행 각각에서 두 번째 16개 값들이 처리될 때까지 계속된다. 다시 말해, 행렬 M의 오른쪽은 벡터 유닛(201)에 의해 스윕되어 이전에 결정된 부분 합의 첫 번째 세트에 추가되고 출력 레지스터 rA의 요소로 저장되는 "부분 합들"의 두 번째 세트를 생성한다. 출력 벡터 레지스터 rA의 결과 상태는 [s0'+s0][s1'+s1][s2'+s2][s3'+s3][s4'+s4][s5'+s5][s6'+s6][s7'+s7]과 같다. 이것은 원하는 대로 최종 답변이다(즉, V와 M을 곱한 결과로 생성된 벡터).
물론, 위는 입력 레지스터 rV의 정확히 두 배(그리고 두 배의 길이는 벡터 유닛(201)에 의해 처리될 수 있음)인 행렬 M 및 벡터 V를 참조하여 서술되었지만, 그러나 동일한 VLMACCR 연산을 사용하여 모든 길이의 입력 벡터들에 대해 유사한 연산을 수행할 수 있다.
입력 벡터 길이(및 행렬 M의 너비)가 입력 레지스터 rV보다 짧으면 전체 내적(또는 다른 연산)을 한 번에 수행할 수 있다.
입력 벡터 길이가 rV 길이의 정수배 N이면 출력 벡터 rA가 N번 완전히 회전할 때까지 VLMACCR 명령어를 위에서 설명한 방식으로 사용할 수 있다.
입력 벡터 길이가 rV 길이의 정수배가 아닌 경우 위의 조합이 적용된다. 예를 들어, 42개 성분 벡터 연산을 처리하기 위해 16개 요소 벡터 유닛(201)을 사용하는 것은 16개 요소 모두가 사용되는 출력 레지스터 rA의 2회의 완전한 회전에 이어 10개의 요소만이 사용되는 세 번째 완전한 회전을 포함할 것이다.
도 5a 및 도 5b는 행렬이 16개의 열과 16개의 행으로 구성된 예를 보여준다. 입력 레지스터 rV는 16개의 요소들로 구성된다. 벡터 유닛(201)은 한 번에 16개의 요소를 처리하도록 구성된다. 출력 레지스터 rA는 8개의 요소로 구성된다.
VLMACCR 연산 자체의 구현은 위에서 설명한 것과 유사하므로 여기에서 반복하지 않는다.
이 경우, 벡터 유닛(201)은 행렬 M의 각 행과 벡터 V 사이의 전체 내적(또는 다른 연산)을 한 번에 처리할 수 있다. 따라서, 이전과 같이 부분합을 포함하는 반복적인 회전이 필요하지 않다. 그러나, 행렬은 16개의 행으로 구성되어 최종(원하는) 출력 벡터에 16개의 성분이 포함되며 이는 출력 레지스터 rA에 비해 너무 길다. 따라서, 처리 유닛(200)은 행렬 M의 처음 8개 행이 벡터 유닛(201)에 의해 처리되면 (예를 들어 프로그램 코드에 의해 지시됨), 출력 레지스터 rA의 요소에서 값을 저장 위치, 예를 들어, 도 5a에 도시된 바와 같이 메모리(107)에 출력하도록 구성된다. 위에 제공된 예제 코드에서, 이 작업을 수행하는 것은 외부 for 루프이다.
그 다음, 도 5b에 도시된 바와 같이, 처리 유닛(200)(출력 레지스터를 0으로 재설정한 후)은 유사한 방식으로 행렬 M의 다음(최종) 8행을 처리함으로써 계속된다. 그런 다음, 최종 결과 벡터는 두 번째 프로세스의 값을 저장 위치에 이미 저장된 첫 번째 프로세스의 값들 끝에 연결하여, 예를 들어, 도 5b와 같은 저장 위치에서 구성된다.
위의 모든 예들에서, 행렬 M의 행 수는 출력 레지스터 rA의 요소들의 수의 정수 배수와 같다. 행렬 M이 임의의 다른 수의 행을 포함하는 경우, 처리할 행 수가 출력 레지스터 rA의 요소 수보다 적을 때까지 프로세스는 동일하다. 이러한 "잔여" 행은 위에서 설명한 대로 VLMACCR 명령을 사용하여 계속 처리할 수 있다. 하지만, 첫 번째 값(위의 예에서 s0 및 a0)이 출력 레지스터 rA의 첫 번째 요소에 있도록 출력 레지스터 rA에 있는 값을 다시 정렬해야 한다. 따라서, 처리 유닛(200)은 추가적인 회전 동작을 적용하도록 구성될 수 있다. 이것은 표준 회전 연산을 구현하거나 메모리(107) 또는 입력 레지스터 rV에서 널 벡터(모두 0을 포함)에 대해 하나 이상의 "더미" VLMACCR 연산을 구현하여 수행할 수 있다.
다른 예시적인 구현에서, 벡터 유닛(201)으로부터의 출력은 단순히 출력 레지스터 rA에 기록되고 출력 레지스터 rA는 (왼쪽 또는 오른쪽으로) 회전된다. 이것은 도 6에서 도시된다.
이것은 여전히 벡터 레지스터의 위치를 지정하기 위해 값들이나 추가 정보를 반복적으로 로딩할 필요 없이, 명령어를 반복적으로 적용하여 출력 벡터를 자동으로 구성할 수 있다는 장점이 있지만, 출력 레지스터 rA의 한 번의 완전한 회전에만 사용될 수 있다. 입력 행렬이 출력 레지스터 rA의 요소보다 더 많은 행을 포함하는 경우 추가 작업이 필요하다. 이러한 것들은 아래에서 서술된다.
도 7은 도 6에 도시된 예에서 처리 유닛(200)에 의해 수행되는 예시적인 방법을 개략적으로 도시한다. 처리 유닛(200)은 여기에서 다시 VLMACCR 명령어로 지칭되는 단일 명령어에 응답하여 방법을 수행하도록 구성된다.
S701에서, 벡터 M 및 벡터 V의 각 성분에 벡터 유닛(201)을 곱한다. 즉, 벡터 유닛(201)은 rM의 n번째 요소의 값에 rV의 n번째 요소의 값을 곱한다. 각 개별 곱셈 연산은 스칼라 값을 생성한다.
S702에서, 스칼라 값은 벡터 유닛(201)에 의해 단일 결과 값 A1으로 누적된다. 즉, 벡터 유닛(201)은 각각의 곱셈 연산의 결과인 스칼라 값을 합산하여 결과 값 A1을 생성한다. 벡터 유닛(201)은 결과 값 A1을 레지스터 rA에 제공한다.
단계 S701 및 S702는 함께 두 입력 벡터들의 내적을 결정하는 벡터 유닛(201)에 대응한다. 따라서, 이 예에서 결과 값 A1은 스칼라 값이다. 앞서 언급한 바와 같이 내적 이외의 연산은 벡터 유닛으로 수행될 수 있다.
S703에서, 출력 레지스터 rA는 회전 연산(원형 시프트라고도 함)을 수행한다. 이것의 예는 도 6에서 점선 화살표로 개략적으로 설명되어 있다. 회전 연산은 곱셈 및 누산 연산과 병렬로(동시에) 수행될 수 있다. 일반적으로 작업은 파이프라인, 예를 들어, 메모리를 위한 하나의 스테이지, 곱셈을 위한 하나의 스테이지, 그리고 누산기를 구현하는 덧셈 트리를 위한 하나의 스테이지로 연결될 수 있다.
회전 연산 자체가 알려져 있다. 도 6에 표시된 예에서, 출력 레지스터 rA는 모든 값이 왼쪽으로 시프트되고, 제1 단부 요소의 값이 제2 단부 요소에 기록되는 "왼쪽 회전"을 수행한다. 즉, 제1 요소에 있는 값은 출력 레지스터 rA의 마지막 요소에 기록되고 다른 모든 요소 n에 있는 값은 rA의 n-1번째 요소에 기록된다. 다른 예에서, 출력 레지스터 rA는 값들이 반대 방향으로 이동하는 "오른쪽 회전"을 수행할 수 있다(즉, 제2 단부 요소에 있는 값이 제1 단부 요소에 기록되고 다른 모든 요소 n에 있는 값들은 n+1번째 요소에 기록된다). 이에 대해서는 아래에서 더 자세히 설명된다.
S704에서, 결과 값 A1이 출력 레지스터 rA의 제1 요소에 기록된다. 즉, 출력 레지스터 rA는 벡터 유닛(201)로부터 전달받은 결과 값을 출력 레지스터 rA의 제1 요소에 저장한다. 이 예에서, 출력 레지스터 rA의 제1 요소는 도 6과 같이 맨 왼쪽 요소이다.
위에서 설명한 예에서, 회전 연산은 결과 값 A1이 출력 레지스터 rA의 제1 요소에 기록되기 전에 수행된다. 다른 예들에서, 출력 레지스터 rA는 출력 값이 제1 요소에 기록된 후에 (어느 방향으로든) 회전될 수 있다.
따라서, 연산 순서(먼저 회전 또는 먼저 쓰기)와 회전 방향(왼쪽 또는 오른쪽)의 네 가지 가능한 조합들이 있다. 이것은 4x4 행렬 M이 VLMACCR 명령어의 반복된 인스턴스들에 의해 4 성분 벡터 V로 곱해지는 간단한 예를 참조하여 설명될 것이다. 예에서 VLMACCR 연산은 네 번 적용되어 네 개의 결과 값들 A1 내지 A4를 생성한다. 이 예에서, 출력 레지스터 rA도 크기가 4개 요소이다.
VLMACCR 연산이 먼저 출력 레지스터 rA를 오른쪽으로 회전시킨 다음, 벡터 유닛(201)의 결과를 출력 레지스터 rA의 제1 요소에 기록하는 것을 포함하는 첫 번째 예를 고려하자. 4번의 VLMACCR 연산 후에, 출력 레지스터 rA는 최종 벡터 A를 포함한다: 벡터 A의 각 요소 성분 A1 내지 A4는 출력 레지스터 rA의 서로 다른 요소에 존재한다. 중요한 것은 성분 A1 내지 A4의 순서가 정확하다는 것이다. 그러면 벡터 A가, 예를 들어, 메모리(107) 또는 어떤 다른 저장 위치로 출력될 수 있다.
VLMACCR 연산이 먼저 벡터 유닛(201)의 결과를 출력 레지스터 rA의 첫 번째 요소에 기록하고 출력 레지스터 rA를 왼쪽으로 회전시키는 것을 포함하는 두 번째 예를 고려하자. 이전과 유사하게 4번의 VLMACCR 연산 후에, 출력 레지스터 rA는 최종 벡터 A를 포함한다: 벡터 A의 각 요소 성분 A1 내지 A4는 출력 레지스터 rA의 서로 다른 요소에 존재한다. 중요한 것은 성분 A1 내지 A4의 순서가 정확하다는 것이다. 그러면 벡터 A가, 예를 들어, 메모리(107) 또는 어떤 다른 저장 위치로 출력될 수 있다. 이 예에서, 벡터 A의 요소 A1 내지 A4는 첫 번째 예와 반대 순서로 끝난다.
VLMACCR 연산이 먼저 출력 레지스터 rA를 왼쪽으로 회전시킨 다음, 벡터 유닛(201)의 결과를 출력 레지스터 rA의 첫 번째 요소에 기록하는 것을 포함하는 세 번째 예를 고려하자. 4번의 VLMACCR 연산 후에, 출력 레지스터 rA는 이전과 같이 벡터 A의 성분 A1 내지 A4를 포함한다. 그러나, 이전 예들과 달리, 성분 A1 내지 A4는 올바른 순서가 아니다. 이를 설명하기 위해 추가 수정 연산을 구현할 수 있다. 이 예에서 수정 연산은 왼쪽 회전을 포함한다. 세 개의 오른쪽 회전들도 사용할 수 있다.
VLMACCR 연산이 먼저 벡터 유닛(201)의 결과를 출력 레지스터 rA의 첫 번째 요소에 기록하고 출력 레지스터 rA를 오른쪽으로 회전시키는 것을 포함하는 네 번째 예를 고려하자. 세 번째 예와 유사하게 4번의 VLMACCR 연산 후에 출력 레지스터 rA는 벡터 A의 성분 A1 내지 A4를 포함하지만 올바른 순서는 아니다. 다시 말하지만, 이를 설명하기 위해 추가 수정 연산이 구현될 수 있다. 이 예에서, 수정 연산은 왼쪽 회전을 포함한다. 세 개의 오른쪽 회전도 사용할 수 있다.
위의 모든 예에서, 출력 레지스터 rA의 길이는 계산할 벡터 A와 동일한 길이로 가정하자. 그러나, 출력 레지스터 rA는 고정 크기(예: 32개 요소)를 갖는 반면 결정될 벡터 A는 이보다 작거나 더 큰 크기(예: 32개 성분들보다 작거나 더 큼)를 가질 수 있다. 벡터 A가 출력 레지스터 rA의 요소보다 더 많은 구성 요소를 포함하는 경우는 앞에서 논의했다.
벡터 A가 출력 레지스터 rA에 있는 요소보다 더 적은 수의 구성요소를 포함하는 경우, 벡터 A의 모든 요소는 VLMACCR 명령어가 완료되면 출력 레지스터 rA에 (어딘가) 존재할 것이다. 위에서 설명한 것과 유사하게 값을 "재정렬"하기 위해 추가 연산들이 필요할 수도 있고 필요하지 않을 수도 있다.
이러한 추가 연산들의 특성은 VLMACCR 명령어의 특정 구현에 따라 다르다. 이것은 위에서 논의된 네 가지 예를 고려하여 설명할 수 있지만, 처음 세 개의 VLMACCR 명령어들이 수행되는 유일한 명령어이다. 이것은 출력 레지스터 rA가 4개의 요소 길이이고 3개의 성분들만을 갖는 벡터 A를 계산하기 위한 연산의 일부로 사용되는 예에 해당한다.
첫 번째 예에서 3개의 VLMACCR 명령어들 후 출력 레지스터 rA의 상태는 [A3][A2][A1][0]과 같다. 추가 오른쪽 회전 연산을 사용하여 결과 벡터 A의 요소들을 재정렬할 수 있다.
두 번째 예에서 3개의 VLMACCR 명령어들 후 출력 레지스터 rA의 상태는 [0][A1][A2][A3]과 같다. 추가 왼쪽 회전 연산을 사용하여 결과 벡터 A의 요소들을 재정렬할 수 있다.
세 번째 예에서 3개의 VLMACCR 명령어들 후 출력 레지스터 rA의 상태는 [A3][0][A1][A2]와 같다. 두 개의 추가 왼쪽 회전 연산을 사용하여 결과 벡터 A의 요소를 재정렬할 수 있다.
네 번째 예에서 3개의 VLMACCR 명령어들 후 출력 레지스터 rA의 상태는 [0][A3][A2][A1]와 같다. 이 경우 추가 연산들이 필요하지 않다.
도 8은 처리 유닛(200)이 카운터를 사용하여 현재 사이클에서 얼마나 많은 VLMACCR 명령어들이 수행되었는지를 추적하도록 구성되는, 여기에 서술된 예에 따른 방법을 예시하는 흐름도이다. 카운터는 방법의 시작 시 재설정될 수 있다.
도 8에 서술된 방법은 아래에 표시된 코드의 가장 바깥쪽 for 루프를 제외한 모든 것을 나타낸다(위에서 또한 제시 및 설명).
def matrixXvector(A, M, V):
for i in range(0, len(A), 8):
rA[] = 0
for j in range(0, len(V), 16):
rV = V[j:j+16]
for k in range(8):
vlmaccr(address_of(M[i+k, j:j+16))
A[i:i+8] = rA
즉, 흐름도는 rV에서 벡터 V를 사용하여 행렬 M의 단일 행의 내적을 구현하는 예시적인 방법을 나타낸다.
이 예에서, 출력 벡터 A는 8 성분의 정수배를 포함하고, 입력 벡터 V는 16 성분의 정수배를 포함하며, 그리고 벡터 유닛(201)은 8개 요소들의 회전 누산기 rA에 동시에 16개의 곱셈-덧셈을 수행할 수 있다고 가정한다.
S800에서 처리 유닛(200)은 카운터 i를 0으로 재설정하여 출력 벡터 A의 첫 번째 부분을 계산하고 있음을 나타낸다.
S801에서, 처리 유닛(200)은 모든 누산기 값들을 0으로 재설정함으로써(즉, 출력 레지스터 rA의 각 요소에 존재하는 값이 0이 되도록) 출력 레지스터 rA를 재설정한다.
S802에서, 처리 유닛(200)은 카운터 j를 0으로 재설정하여, 행렬 M의 처음 16개 열(즉, M의 첫 번째 행에서 처음 16개 요소)을 처리하고 있음을 나타낸다.
S803에서 처리 유닛(200)은 행렬 M의 처음 16개 열과 곱할 입력 벡터 V의 처음 16개 값을 로딩한다. 후속 반복에서 j는 벡터의 후반부를 가리키도록 변경되고, S803에서 처리 유닛(200)은 행렬의 두 번째 16, 세 번째 16 등의 행과 곱할 벡터의 두 번째 16, 세 번째 16 등을 로딩한다.
S804에서, 처리 유닛(200)은 행렬의 행 i, i+1, i+2, …, i+7을 사용하여 8개의 VLMACCR 명령어들을 구현한다.
S805에서, 처리 유닛(200)은 벡터 V 및 행렬 M의 다음 부분에 대해 연산하도록 S803 및 S804를 진행하기 위해 카운터 j를 16만큼 증가시킨다.
S806에서, 처리 유닛(200)은 카운터 j가 입력 벡터 V의 길이와 동일한지 여부(즉, 그것이 행렬 M의 부분의 끝에 도달했는지 여부)를 결정한다. 그렇다면, 남은 VLMACCR 명령어는 없으며 방법은 S807로 진행한다. 그렇지 않으면, 행렬 M의 다음 16개 열을 반복하기 위해 단계 S803, S804 및 S805가 다시 처리된다.
S807에서, 처리 유닛(200)은 출력 레지스터 rA에 존재하는 값을 다른 저장 위치, 예를 들어, 메모리(107)에 출력한다. 이는, S806에서, 출력 레지스터 rA가 전체 회전 세트를 완료했다고 결정했기 때문이며, 출력 레지스터 rA의 모든 요소들이 현재 계산의 결과인 벡터 유닛(201)의 값들을 유지한다는 것을 의미한다.
S808에서, 처리 유닛(200)은 행렬 M의 다음 부분에서 동작하도록 S804에서 사용된 행 어드레스를 진행시키기 위해 카운터 i를 8만큼 증가시킨다.
S809에서, 처리 유닛(200)은 카운터 i의 값이 출력 벡터 V("n")의 요소들의 수와 동일한지를 결정한다. 즉, 처리 유닛(200)은 S800에서 방법이 시작된 이후 출력 레지스터 rA가 출력 벡터 V의 각 부분에 저장되었는지를 결정한다. 저장되면, 방법이 종료된다. 저장되지 않으면, 방법은 S801로 진행한다.
프로세서는 파이프라인 프로세서일 수 있다. 파이프라인 프로세서에서, 실행 유닛은 각각 특정 유형의 작업을 수행하기 위한 일련의 파이프라인 스테이지들로 나뉜다. 파이프라인은 일반적으로 인출 스테이지, 디코딩 스테이지, 레지스터 판독 스테이지, 적어도 하나의 계산 스테이지 및 하나 이상의 메모리 액세스 스테이지를 포함한다. 명령어 인출 스테이지는 메모리에서 제1 명령어를 인출하여 파이프라인의 제1 스테이지로 보낸다. 다음 프로세서 사이클에서, 디코딩된 명령어는 파이프라인의 다음 단계, 예를 들어, 레지스터 판독 스테이지로 전달된다. 동시에, 인출 스테이지는 명령어 메모리에서 디코딩 스테이지로 제2 명령어를 인출한다. 그 후의 다음 연속 프로세서 사이클에서, 제1 명령어는 제3 파이프라인 스테이지, 예를 들어, 계산 스테이지로 전달되는 반면, 제2 명령어는 제2 파이프라인 스테이지로 전달되고 제3 명령어는 제1 파이프라인 스테이지로 전달된다. 이렇게 하면 프로세서를 계속 바쁘게 유지하여 대기 시간을 줄이는 데 도움이 된다. 그렇지 않으면 프로세서가 다음 명령을 실행 유닛으로 보내기 전에 전체 명령어가 실행될 때까지 기다려야 하기 때문이다.
프로세서는 다중 스레드 프로세서일 수 있다. 다중 스레드 프로세서에서, 프로세서는 복수의 컨텍스트 레지스터 세트를 포함하고, 컨텍스트 레지스터의 각 세트는 현재 실행 중인 복수의 프로그램 스레드들의 각각의 컨텍스트(즉, 프로그램 상태)를 나타낸다. 프로그램 상태는 각각의 스레드에 대한 프로그램 카운터, 각 스레드의 피연산자, 및 선택적으로 스레드 또는 컨텍스트가 현재 활성 상태인지 여부와 같은 개별 상태 정보를 포함한다. 프로세서는, 예를 들어, 라운드 로빈 방식으로 파이프라인을 통해 명령어를 일시적으로 인터리브하기 위해 명령어 인출 스테이지를 제어하도록 구성된 스케줄러를 더 포함한다. 이러한 방식으로 인터리브된 스레드를 동시에 실행한다고 한다. 실행 유닛이 파이프라인되는 경우, 그때, 한 스레드의 명령이 파이프라인을 통해 한 파이프라인 스테이지에서 다음 스테이지로 진행하면 다른 스레드의 명령이 파이프라인을 한 스테이지 뒤로 진행하는 식이다. 이 인터리브 방식은 파이프라인 대기 시간을 숨길 수 있는 더 많은 기회를 제공하므로 유용하다. 인터리빙이 없으면 파이프라인은 파이프라인의 명령어 간의 종속성을 해결하기 위한 메커니즘이 필요하고(제2 명령어는 제1 명령어의 결과를 사용할 수 있으며 제 시간에 준비되지 않을 수 있음), 이는 제1 명령어가 실행을 완료할 때까지 제2 및 추가 명령어가 일시 중단되는 파이프라인 버블을 생성할 수 있다.
데이터를 저장하기 위한 데이터 저장 장치가 여기에서 참조된다. 이것은 단일 장치 또는 복수 장치에 의해 제공될 수 있다. 적합한 장치는 예를 들어 하드 디스크 및 비휘발성 반도체 메모리(예를 들어 솔리드 스테이트 드라이브 또는 SSD를 포함함)를 포함한다.
본 명세서에 기술된 예는 본 발명의 실시예의 예시적인 예로서 이해되어야 한다. 추가 실시예들 및 예시들이 예상된다. 임의의 하나의 예 또는 실시예와 관련하여 설명된 임의의 특징은 단독으로 또는 다른 특징과 조합하여 사용될 수 있다. 추가로, 임의의 하나의 예 또는 실시예와 관련하여 설명된 임의의 특징은 또한 임의의 다른 예 또는 실시예의 하나 이상의 특징, 또는 임의의 다른 예 또는 실시예의 임의의 조합과 조합하여 사용될 수 있다. 또한, 여기에 설명되지 않은 균등물 및 수정 사항이 특허청구범위에 정의된 본 발명의 범위 내에서 사용될 수도 있다.

Claims (13)

  1. 출력 벡터를 생성하기 위한 처리 유닛으로서,
    상기 출력 벡터의 상이한 성분들을 유지하기 위한 복수의 요소들을 갖는 출력 레지스터 - 상기 복수의 요소들은 제1 단부 요소 및 제2 단부 요소를 포함함 - 와; 그리고
    각각의 결과 값을 생성하기 위해 적어도 두 개의 입력 벡터들을 처리하는 벡터 유닛을 포함하고,
    상기 처리 유닛은 기계 코드 명령어들을 실행하도록 구성되고, 각각의 명령어는 상기 처리 유닛의 명령어 세트에서 사전 정의된 명령어 유형들의 세트의 인스턴스이고, 상기 명령어 세트는 대응하는 오피코드(opcode)에 의해 정의된 벡터 처리 명령어를 포함하며,
    상기 벡터 처리 명령어는 상기 처리 유닛으로 하여금:
    i) 상기 벡터 유닛을 사용하여 제1 입력 벡터 및 제2 입력 벡터를 처리하여 결과 값을 생성하도록 하고;
    ii) 상기 출력 레지스터의 복수의 요소들에 대해 회전 연산을 수행하도록 하며, 상기 결과 값과 상기 회전 이전의 제2 단부 요소에 존재하는 값의 합이 상기 출력 레지스터의 제1 단부 요소에 배치되는 것을 특징으로 하는
    출력 벡터를 생성하기 위한 처리 유닛.
  2. 제1항에 있어서,
    상기 벡터 유닛은 i) 상기 입력 벡터들에 대해 곱셈-누산 연산을 수행함으로써 상기 제1 입력 벡터 및 상기 제2 입력 벡터의 처리를 수행하도록 구성되고, 상기 결과 값은 상기 곱셈-누산 연산의 결과인 스칼라 값인 것을 특징으로 하는
    출력 벡터를 생성하기 위한 처리 유닛.
  3. 제1항 또는 제2항에 있어서,
    상기 벡터 유닛은 메모리로부터 직접적으로 적어도 상기 제2 입력 벡터에 액세스하도록 구성되는 것을 특징으로 하는
    출력 벡터를 생성하기 위한 처리 유닛.
  4. 제1항 내지 제3항 중 어느 한 항에 있어서,
    적어도 상기 제1 입력 벡터를 유지하기 위한 입력 레지스터를 포함하고, 상기 벡터 유닛은 상기 입력 레지스터로부터 상기 제1 입력 벡터에 액세스하도록 구성되는 것을 특징으로 하는
    출력 벡터를 생성하기 위한 처리 유닛.
  5. 제4항에 있어서,
    상기 입력 레지스터는 레지스터 파일 내의 복수의 레지스터들로부터 선택되고, 상기 벡터 처리 명령어는 상기 입력 레지스터를 지정하는 연산을 포함하는 것을 특징으로 하는
    출력 벡터를 생성하기 위한 처리 유닛.
  6. 제4항에 있어서,
    상기 입력 레지스터는 상기 벡터 처리 명령어의 피연산자(operand)에 의해 지정되지 않은 상기 벡터 처리 명령어의 오피코드에 내재되어 있는 것을 특징으로 하는
    출력 벡터를 생성하기 위한 처리 유닛.
  7. 제1항 내지 제6항 중 어느 한 항에 있어서,
    상기 출력 레지스터는 레지스터 파일 내의 복수의 레지스터들로부터 선택되고, 상기 벡터 처리 명령어는 상기 출력 레지스터를 지정하는 피연산자를 포함하는 것을 특징으로 하는
    출력 벡터를 생성하기 위한 처리 유닛.
  8. 제1항 내지 제6항 중 어느 한 항에 있어서,
    상기 출력 레지스터는 벡터 처리 명령어의 피연산자에 의해 지정되지 않은 상기 벡터 처리 명령어의 오피코드에 내재되어 있는 것을 특징으로 하는
    출력 벡터를 생성하기 위한 처리 유닛.
  9. 출력 벡터의 상이한 성분들을 유지하기 위한 복수의 요소들을 갖는 출력 레지스터에서 출력 벡터를 생성하는 방법으로서,
    상기 방법은 처리 유닛에 의해 수행되고, 상기 복수의 요소들은 제1 단부 요소 및 제2 단부 요소를 포함하고, 상기 처리 유닛은 기계 코드 명령어들을 실행하도록 구성되고, 각각의 명령어는 상기 처리 유닛의 명령어 세트에서 사전 정의된 명령어 유형들의 세트의 인스턴스이고, 상기 명령어 세트는 대응하는 오피코드에 의해 정의된 벡터 처리 명령어를 포함하며,
    상기 방법은, 상기 벡터 처리 명령어가 상기 처리 유닛으로 하여금:
    i) 상기 벡터 유닛을 사용하여 제1 입력 벡터 및 제2 입력 벡터를 처리하여 결과 값을 생성하고, 그리고
    ii) 상기 출력 레지스터의 복수의 요소들에 대해 회전 연산을 수행하며, 상기 결과 값과 상기 회전 이전의 제2 단부 요소에 존재하는 값의 합이 상기 출력 레지스터의 제1 단부 요소에 배치되는
    벡터 처리 연산을 구현하도록 하는 단계를 포함하는 것을 특징으로 하는
    출력 벡터를 생성하는 방법.
  10. 제9항에 있어서,
    상기 제1 입력 벡터는 레지스터에 저장되고, 그리고
    상기 방법은 동일한 제1 입력 벡터를 사용하여 복수의 상기 벡터 처리 연산을 실행하는 단계를 포함하는 것을 특징으로 하는
    출력 벡터를 생성하는 방법.
  11. 제10항에 있어서,
    복수의 상기 벡터 처리 연산의 완료 후에, 상기 출력 레지스터에 존재하는 값들을 저장 위치에 출력하는 단계를 포함하는 것을 특징으로 하는
    출력 벡터를 생성하는 방법.
  12. 제10항 또는 제11항에 있어서,
    상기 출력 레지스터의 요소들 수의 정수배와 같지 않은 복수의 벡터 처리 연산들을 완료한 후에, 총 회전 수가 출력 레지스터의 요소들 수의 정수 배수와 같도록 상기 출력 레지스터의 요소들에 존재하는 값을 변경하지 않고 상기 출력 레지스터에 대해 하나 이상의 회전 연산을 수행하는 단계를 포함하는 것을 특징으로 하는
    출력 벡터를 생성하는 방법.
  13. 제10항 내지 제12항 중 어느 한 항에 따른 방법을 수행하도록 프로그래밍된, 제1항 내지 제9항 중 어느 한 항에 따른 처리 유닛을 포함하는 컴퓨터 시스템.
KR1020227031431A 2020-02-10 2020-10-12 벡터 연산들을 위한 회전식 누산기 KR20230018361A (ko)

Applications Claiming Priority (3)

Application Number Priority Date Filing Date Title
GB2001789.3 2020-02-10
GB2001789.3A GB2601466A (en) 2020-02-10 2020-02-10 Rotating accumulator
PCT/EP2020/078580 WO2021160300A1 (en) 2020-02-10 2020-10-12 Rotating accumulator for vector operations

Publications (1)

Publication Number Publication Date
KR20230018361A true KR20230018361A (ko) 2023-02-07

Family

ID=69897132

Family Applications (1)

Application Number Title Priority Date Filing Date
KR1020227031431A KR20230018361A (ko) 2020-02-10 2020-10-12 벡터 연산들을 위한 회전식 누산기

Country Status (7)

Country Link
US (1) US20230116419A1 (ko)
EP (1) EP4073632B1 (ko)
JP (1) JP7439276B2 (ko)
KR (1) KR20230018361A (ko)
CN (1) CN115039070A (ko)
GB (1) GB2601466A (ko)
WO (1) WO2021160300A1 (ko)

Families Citing this family (2)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
GB2614875A (en) 2022-01-12 2023-07-26 Xmos Ltd Processor implementation
US20230350640A1 (en) * 2022-05-02 2023-11-02 Qualcomm Incorporated System and method of rotating vector input

Family Cites Families (7)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US5862067A (en) * 1995-12-29 1999-01-19 Intel Corporation Method and apparatus for providing high numerical accuracy with packed multiply-add or multiply-subtract operations
US7797363B2 (en) * 2004-04-07 2010-09-14 Sandbridge Technologies, Inc. Processor having parallel vector multiply and reduce operations with sequential semantics
US8407456B2 (en) * 2007-12-05 2013-03-26 Qualcomm Incorporated Method and instruction set including register shifts and rotates for data processing
US20090248769A1 (en) * 2008-03-26 2009-10-01 Teck-Kuen Chua Multiply and accumulate digital filter operations
US20150052330A1 (en) * 2013-08-14 2015-02-19 Qualcomm Incorporated Vector arithmetic reduction
JP6616608B2 (ja) * 2015-07-16 2019-12-04 ルネサスエレクトロニクス株式会社 半導体装置
US11775313B2 (en) * 2017-05-26 2023-10-03 Purdue Research Foundation Hardware accelerator for convolutional neural networks and method of operation thereof

Also Published As

Publication number Publication date
US20230116419A1 (en) 2023-04-13
GB2601466A (en) 2022-06-08
WO2021160300A1 (en) 2021-08-19
CN115039070A (zh) 2022-09-09
JP7439276B2 (ja) 2024-02-27
EP4073632A1 (en) 2022-10-19
JP2023515348A (ja) 2023-04-13
GB202001789D0 (en) 2020-03-25
EP4073632B1 (en) 2024-01-24

Similar Documents

Publication Publication Date Title
CN111213125B (zh) 使用simd指令进行高效的直接卷积
KR102311010B1 (ko) 하나 또는 그 초과의 복소수 산술 명령들을 사용하여 가변 길이 벡터들에 대해 연산하도록 구성된 벡터 프로세서
KR102413832B1 (ko) 벡터 곱셈 덧셈 명령
CN111381880B (zh) 一种处理器、介质和处理器的操作方法
CA3040896C (en) Register files in a multi-threaded processor
US7308559B2 (en) Digital signal processor with cascaded SIMD organization
US20120072704A1 (en) "or" bit matrix multiply vector instruction
JP7439276B2 (ja) ベクトル演算の回転累算器
US20080288756A1 (en) "or" bit matrix multiply vector instruction
US6915411B2 (en) SIMD processor with concurrent operation of vector pointer datapath and vector computation datapath
JP6712052B2 (ja) 演算処理装置及び演算処理装置の制御方法
KR102591988B1 (ko) 데이터 처리장치에서의 벡터 인터리빙
EP3336691B1 (en) Replicate elements instruction
JP7495194B2 (ja) 積和演算用のプロセッサ・ユニット
GB2616037A (en) Looping instruction
GB2616036A (en) Sparse matrix multiplication
JP3547316B2 (ja) プロセッサ

Legal Events

Date Code Title Description
A201 Request for examination