KR101997325B1 - 라스트 레벨 캐시 성분 또는 신경망 유닛 메모리로서 동작 가능한 메모리 어레이를 가지는 프로세서 - Google Patents

라스트 레벨 캐시 성분 또는 신경망 유닛 메모리로서 동작 가능한 메모리 어레이를 가지는 프로세서 Download PDF

Info

Publication number
KR101997325B1
KR101997325B1 KR1020160183877A KR20160183877A KR101997325B1 KR 101997325 B1 KR101997325 B1 KR 101997325B1 KR 1020160183877 A KR1020160183877 A KR 1020160183877A KR 20160183877 A KR20160183877 A KR 20160183877A KR 101997325 B1 KR101997325 B1 KR 101997325B1
Authority
KR
South Korea
Prior art keywords
data
mode
nnu
memory array
llc
Prior art date
Application number
KR1020160183877A
Other languages
English (en)
Other versions
KR20180062913A (ko
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 KR20180062913A publication Critical patent/KR20180062913A/ko
Application granted granted Critical
Publication of KR101997325B1 publication Critical patent/KR101997325B1/ko

Links

Images

Classifications

    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06N—COMPUTING ARRANGEMENTS BASED ON SPECIFIC COMPUTATIONAL MODELS
    • G06N3/00—Computing arrangements based on biological models
    • G06N3/02—Neural networks
    • G06N3/06—Physical realisation, i.e. hardware implementation of neural networks, neurons or parts of neurons
    • G06N3/063—Physical realisation, i.e. hardware implementation of neural networks, neurons or parts of neurons using electronic means
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F12/00—Accessing, addressing or allocating within memory systems or architectures
    • G06F12/02—Addressing or allocation; Relocation
    • G06F12/08—Addressing or allocation; Relocation in hierarchically structured memory systems, e.g. virtual memory systems
    • G06F12/0802—Addressing of a memory level in which the access to the desired data or data block requires associative addressing means, e.g. caches
    • G06F12/0806—Multiuser, multiprocessor or multiprocessing cache systems
    • G06F12/0811—Multiuser, multiprocessor or multiprocessing cache systems with multilevel cache hierarchies
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F12/00—Accessing, addressing or allocating within memory systems or architectures
    • G06F12/02—Addressing or allocation; Relocation
    • G06F12/08—Addressing or allocation; Relocation in hierarchically structured memory systems, e.g. virtual memory systems
    • G06F12/0802—Addressing of a memory level in which the access to the desired data or data block requires associative addressing means, e.g. caches
    • G06F12/0806—Multiuser, multiprocessor or multiprocessing cache systems
    • G06F12/084—Multiuser, multiprocessor or multiprocessing cache systems with a shared cache
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F12/00—Accessing, addressing or allocating within memory systems or architectures
    • G06F12/02—Addressing or allocation; Relocation
    • G06F12/08—Addressing or allocation; Relocation in hierarchically structured memory systems, e.g. virtual memory systems
    • G06F12/0802—Addressing of a memory level in which the access to the desired data or data block requires associative addressing means, e.g. caches
    • G06F12/0864—Addressing of a memory level in which the access to the desired data or data block requires associative addressing means, e.g. caches using pseudo-associative means, e.g. set-associative or hashing
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F13/00—Interconnection of, or transfer of information or other signals between, memories, input/output devices or central processing units
    • G06F13/14—Handling requests for interconnection or transfer
    • G06F13/16—Handling requests for interconnection or transfer for access to memory bus
    • G06F13/1668—Details of memory controller
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F3/00—Input arrangements for transferring data to be processed into a form capable of being handled by the computer; Output arrangements for transferring data from processing unit to output unit, e.g. interface arrangements
    • G06F3/06—Digital input from, or digital output to, record carriers, e.g. RAID, emulated record carriers or networked record carriers
    • G06F3/0601—Interfaces specially adapted for storage systems
    • G06F3/0602—Interfaces specially adapted for storage systems specifically adapted to achieve a particular effect
    • G06F3/0604—Improving or facilitating administration, e.g. storage management
    • G06F3/0607—Improving or facilitating administration, e.g. storage management by facilitating the process of upgrading existing storage systems, e.g. for improving compatibility between host and storage device
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F3/00—Input arrangements for transferring data to be processed into a form capable of being handled by the computer; Output arrangements for transferring data from processing unit to output unit, e.g. interface arrangements
    • G06F3/06—Digital input from, or digital output to, record carriers, e.g. RAID, emulated record carriers or networked record carriers
    • G06F3/0601—Interfaces specially adapted for storage systems
    • G06F3/0628—Interfaces specially adapted for storage systems making use of a particular technique
    • G06F3/0629—Configuration or reconfiguration of storage systems
    • G06F3/0634—Configuration or reconfiguration of storage systems by changing the state or mode of one or more devices
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F3/00—Input arrangements for transferring data to be processed into a form capable of being handled by the computer; Output arrangements for transferring data from processing unit to output unit, e.g. interface arrangements
    • G06F3/06—Digital input from, or digital output to, record carriers, e.g. RAID, emulated record carriers or networked record carriers
    • G06F3/0601—Interfaces specially adapted for storage systems
    • G06F3/0628—Interfaces specially adapted for storage systems making use of a particular technique
    • G06F3/0655—Vertical data movement, i.e. input-output transfer; data movement between one or more hosts and one or more storage devices
    • G06F3/0656—Data buffering arrangements
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F3/00—Input arrangements for transferring data to be processed into a form capable of being handled by the computer; Output arrangements for transferring data from processing unit to output unit, e.g. interface arrangements
    • G06F3/06—Digital input from, or digital output to, record carriers, e.g. RAID, emulated record carriers or networked record carriers
    • G06F3/0601—Interfaces specially adapted for storage systems
    • G06F3/0628—Interfaces specially adapted for storage systems making use of a particular technique
    • G06F3/0655—Vertical data movement, i.e. input-output transfer; data movement between one or more hosts and one or more storage devices
    • G06F3/0658—Controller construction arrangements
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F3/00—Input arrangements for transferring data to be processed into a form capable of being handled by the computer; Output arrangements for transferring data from processing unit to output unit, e.g. interface arrangements
    • G06F3/06—Digital input from, or digital output to, record carriers, e.g. RAID, emulated record carriers or networked record carriers
    • G06F3/0601—Interfaces specially adapted for storage systems
    • G06F3/0668—Interfaces specially adapted for storage systems adopting a particular infrastructure
    • G06F3/0671—In-line storage system
    • G06F3/0683—Plurality of storage devices
    • G06F3/0689—Disk arrays, e.g. RAID, JBOD
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06N—COMPUTING ARRANGEMENTS BASED ON SPECIFIC COMPUTATIONAL MODELS
    • G06N3/00—Computing arrangements based on biological models
    • G06N3/02—Neural networks
    • G06N3/04—Architecture, e.g. interconnection topology
    • G06N3/044—Recurrent networks, e.g. Hopfield networks
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06N—COMPUTING ARRANGEMENTS BASED ON SPECIFIC COMPUTATIONAL MODELS
    • G06N3/00—Computing arrangements based on biological models
    • G06N3/02—Neural networks
    • G06N3/04—Architecture, e.g. interconnection topology
    • G06N3/045—Combinations of networks
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F2212/00—Indexing scheme relating to accessing, addressing or allocation within memory systems or architectures
    • G06F2212/10—Providing a specific technical effect
    • G06F2212/1041—Resource optimization

Landscapes

  • Engineering & Computer Science (AREA)
  • Theoretical Computer Science (AREA)
  • Physics & Mathematics (AREA)
  • General Physics & Mathematics (AREA)
  • General Engineering & Computer Science (AREA)
  • Health & Medical Sciences (AREA)
  • Life Sciences & Earth Sciences (AREA)
  • Biomedical Technology (AREA)
  • Biophysics (AREA)
  • General Health & Medical Sciences (AREA)
  • Software Systems (AREA)
  • Molecular Biology (AREA)
  • Computing Systems (AREA)
  • Data Mining & Analysis (AREA)
  • Computational Linguistics (AREA)
  • Mathematical Physics (AREA)
  • Evolutionary Computation (AREA)
  • Artificial Intelligence (AREA)
  • Human Computer Interaction (AREA)
  • Neurology (AREA)
  • Memory System Of A Hierarchy Structure (AREA)
  • Memory System (AREA)
  • Advance Control (AREA)

Abstract

프로세서는 복수의 프로세스 코어들, 복수의 프로세스 코어들에 의해 공유된 라스트 레벨 캐시 메모리(LLC), 신경 프로세스 유닛들(NPU)의 어레이 및 메모리 어레이를 포함하는 신경망 유닛(NNU)을 포함한다. LLU는 복수의 성분들로 구성된다. 메모리 어레이가 복수의 N개의 PU들에 의해 판독된 신경망 웨이트들을 저장하기 위하여 동작하는 제1 모드로부터 메모리 어레이가 복수의 성분들뿐만 아니라 LLC의 성분으로 동작하는 제2 모드로 천이하기 위하여, 프로세서는 LLC를 재기입-실효화시키고 그리고 메모리 어레이를 복수의 성분들뿐만 아니라 LLC의 성분으로 포함하기 위하여 해싱 알고리즘을 경신한다. 제2 모드로부터 제1 모드로 천이하기 위하여, 프로세서는 LLC를 재기입-실효화시키고 그리고 LLC로부터 메모리 어레이를 제외하기 위하여 해싱 알고리즘을 경신한다.

Description

라스트 레벨 캐시 성분 또는 신경망 유닛 메모리로서 동작 가능한 메모리 어레이를 가지는 프로세서{PROCESSOR WITH MEMORY ARRAY OPERABLE AS EITHER LAST LEVEL CACHE SLICE OR NEURAL NETWORK UNIT MEMORY}
본 발명은 라스트 레벨 캐시 성분 또는 신경망 유닛 메모리로서 동작 가능한 메모리 어레이를 가지는 프로세서에 관한 것이다.
관련 출원(들)에 대한 교차 참조
본 출원은 다음의 미국 정규 출원들에 관한 것이고, 이들 각각은 본 명세서에서 그 전체가 참조로서 통합된다.
일련번호 출원일 발명의 명칭
15090665 2016년 4월 5일 신경 메모리 및 신경 메모리로부터 수신된 데이터의 행의 멀티-워드 거리의 회전을 집단적으로 수행하는 신경 처리 유닛들의 어레이를 갖는 신경망 유닛(NEURAL NETWORK UNIT WITH NEURAL MEMORY AND ARRAY OF NEURAL PROCESSING UNITS THAT COLLECTIVELY SHIFT ROW OF DATA RECEIVED FROM NEURAL MEMORY)
15090666 2016년 4월 5일 3-구성 신경망 유닛(TRI-CONFIGURATION NEURAL NETWORK UNIT)
15090669 2016년 4월 5일 아키텍쳐 신경망 실행 유닛을 갖는 프로세서(PROCESSOR WITH ARCHITECTURAL NEURAL NETWORK EXECUTION UNIT)
15090672 2016년 4월 5일 복수의 데이터 크기들을 처리하도록 동적으로 구성 가능한 신경 처리 유닛들을 갖는 신경망 유닛(NEURAL NETWORK UNIT WITH NEURAL PROCESSING UNITS DYNAMICALLY CONFIGURABLE TO PROCESS MULTIPLE DATA SIZES)
15090678 2016년 4월 5일 신경 메모리에 활성함수 출력 또는 누산기 값을 선택적으로 다시 기입하는 신경 처리 유닛(NEURAL PROCESSING UNIT THAT SELECTIVELY WRITES BACK TO NEURAL MEMORY EITHER ACTIVATION FUNCTION OUTPUT OR ACCUMULATOR VALUE)
15090691 2016년 4월 5일 공유된 활성함수 유닛들을 갖는 신경망 유닛(NEURAL NETWORK UNIT WITH SHARED ACTIVATION FUNCTION UNITS)
15090696 2016년 4월 5일 누적된 값을 정규화하기 위한 사용자-공급 역수를 채용하는 신경망 유닛(NEURAL NETWORK UNIT EMPLOYING USER-SUPPLIED RECIPROCAL FOR NORMALIZING AN ACCUMULATED VALUE)
15090701 2016년 4월 5일 가변 속도의 실행 유닛을 갖는 프로세서(PROCESSOR WITH VARIABLE RATE EXECUTION UNIT)
15090705 2016년 4월 5일 공유된 자원에 관한 프로세서 상에서 실행중이 아키텍쳐 프로그램 및 프로세서의 실행 유닛 상에서 실행중인 비-아키텍쳐 프로그램 사이의 통신을 위한 메커니즘(MECHANISM FOR COMMUNICATION BETWEEN ARCHITECTURAL PROGRAM RUNNING ON PROCESSOR AND NON-ARCHITECTURAL PROGRAM RUNNING ON EXECUTION UNIT OF THE PROCESSOR REGARDING SHARED RESOURCE)
15090708 2016년 4월 5일 프로세서의 아키텍쳐 명령에 의해 아키텍쳐 레지스터 파일에 로딩된 마이크로-동작의 실행 유닛에 의해 직접 실행(DIRECT EXECUTION BY AN EXECUTION UNIT OF A MICRO-OPERATION LOADED INTO AN ARCHITECTURAL REGISTER FILE BY AN ARCHITECTURAL INSTRUCTION OF A PROCESSOR)
15090712 2016년 4월 5일 멀티-동작의 신경망 유닛(MULTI-OPERATION NEURAL NETWORK UNIT)
15090722 2016년 4월 5일 신경 처리 유닛들의 어레이 중 집단적인 시프트 레지스터를 사용하여 컨벌루션을 수행하는 신경망 유닛(NEURAL NETWORK UNIT THAT PERFORMS CONVOLUTIONS USING COLLECTIVE SHIFT REGISTER AMONG ARRAY OF NEURAL PROCESSING UNITS)
15090727 2016년 4월 5일 복수의 선택 가능한 출력 함수들을 갖는 신경망 유닛(NEURAL NETWORK UNIT WITH PLURALITY OF SELECTABLE OUTPUT FUNCTIONS)
15090794 2016년 4월 5일 확률론적인 반올림을 수행하는 신경망 유닛(NEURAL NETWORK UNIT THAT PERFORMS STOCHASTIC ROUNDING)
15090796 2016년 4월 5일 사용자-지정 이진 포인트의 고정 포인트 산술을 채용하는 장치(APPARATUS EMPLOYING USER-SPECIFIED BINARY POINT FIXED POINT ARITHMETIC)
15090798 2016년 4월 5일 하이브리드 코프로세서/실행 유닛 신경망 유닛을 갖는 프로세서(PROCESSOR WITH HYBRID COPROCESSOR/EXECUTION UNIT NEURAL NETWORK UNIT)
15090801 2016년 4월 5일 출력 버퍼 피드백 및 마스킹 성능을 갖는 신경망 유닛(NEURAL NETWORK UNIT WITH OUTPUT BUFFER FEEDBACK AND MASKING CAPABILITY)
15090807 2016년 4월 5일 동시의 LSTM 셀 계산들을 수행하는 신경망 유닛(NEURAL NETWORK UNIT THAT PERFORMS CONCURRENT LSTM CELL CALCULATIONS)
15090814 2016년 4월 5일 회귀 신경망 계산들을 수행하기 위한 출력 버퍼 피드백을 갖는 신경망 유닛(NEURAL NETWORK UNIT WITH OUTPUT BUFFER FEEDBACK FOR PERFORMING RECURRENT NEURAL NETWORK COMPUTATIONS)
15090823 2016년 4월 5일 신경 메모리 및 신경 메모리로부터 수신된 데이터의 행을 집단적으로 이동시키는 신경 처리 유닛들 및 시퀀서의 어레이를 갖는 신경망 유닛(NEURAL NETWORK UNIT WITH NEURAL MEMORY AND ARRAY OF NEURAL PROCESSING UNITS AND SEQUENCER THAT COLLECTIVELY SHIFT ROW OF DATA RECEIVED FROM NEURAL MEMORY)
15090829 2016년 4월 5일 회귀 신경망 LSTM 셀들로서 동작하는 처리 유닛 그룹들을 통한 출력 버퍼 피드백 및 마스킹 성능을 갖는 신경망 유닛(NEURAL NETWORK UNIT WITH OUTPUT BUFFER FEEDBACK AND MASKING CAPABILITY WITH PROCESSING UNIT GROUPS THAT OPERATE AS RECURRENT NEURAL NETWORK LSTM CELLS)
위의 정규 출원들 각각은 다음의 미국 가특허 출원들에 기초하여 우선권을 주장하고, 이들 각각은 본 명세서에서 그 전체가 참조로서 통합된다.
일련번호 출원일 발명의 명칭
62239254 2015년 10월 8일 신경망 유닛을 갖는 프로세서(PROCESSOR WITH NEURAL NETWORK UNIT)
62262104 2015년 12월 2일 가변 속도의 실행 유닛을 갖는 프로세서(PROCESSOR WITH VARIABLE RATE EXECUTION UNIT)
62299191 2016년 2월 4일 공유된 자원에 관한 프로세서 상에서 실행중이 아키텍쳐 프로그램 및 프로세서의 실행 유닛 상에서 실행중인 비-아키텍쳐 프로그램 사이의 통신을 위한 메커니즘; 출력 버퍼 피드백 및 마스킹 성능을 갖고, 동시 LSTM 셀 계산을 수행하고, 회귀 신경망 계산들을 수행하기 위한 출력 버퍼 피드백을 갖는 신경망 유닛(ARCHITECTURAL PROGRAM RUNNING ON PROCESSOR AND NON-ARCHITECTURAL PROGRAM RUNNING ON EXECUTION UNIT OF THE PROCESSOR REGARDING SHARED RESOURCE; NEURAL NETWORK UNIT WITH OUTPUT BUFFER FEEDBACK AND MASKING CAPABILITY, AND THAT PERFORMS CONCURRENT LSTM CELL CALCULATIONS, AND WITH OUTPUT BUFFER FEEDBACK FOR PERFORMING RECURRENT NEURAL NETWORK COMPUTATIONS)
본 출원은 또한 다음의 동시 출원된 미국 정규 출원들에 관한 것이고, 이들 각각은 본 명세서에서 그 전체가 참조로서 통합된다.
일련번호 발명의 명칭
VAS.3085 캐시 메모리 또는 신경망 유닛 메모리로서 동작 가능한 메모리 어레이를 갖는 프로세서(PROCESSOR WITH MEMORY ARRAY OPERABLE AS EITHER CACHE MEMORY OR NEURAL NETWORK UNIT MEMORY)
VAS.3095 최종 레벨의 캐시 성분 또는 신경망 유닛 메모리로서 동작 가능한 메모리 어레이를 갖는 프로세서(PROCESSOR WITH MEMORY ARRAY OPERABLE AS EITHER LAST LEVEL CACHE SLICE OR NEURAL NETWORK UNIT MEMORY)
VAS.3099 희생 캐시 또는 신경망 유닛 메모리로서 동작 가능한 메모리 어레이를 갖는 프로세서(PROCESSOR WITH MEMORY ARRAY OPERABLE AS EITHER VICTIM CACHE OR NEURAL NETWORK UNIT MEMORY)
VAS.3087 효율적인 3-차원 컨벌루션들을 수행하는 신경망 유닛(NEURAL NETWORK UNIT THAT PERFORMS EFFICIENT 3-DIMENSIONAL CONVOLUTIONS)
VAS.3094 효율적인 3-차원 컨벌루션들을 수행하기 위한 메모리 배치를 갖는 신경망 유닛(NEURAL NETWORK UNIT WITH MEMORY LAYOUT TO PERFORM EFFICIENT 3-DIMENSIONAL CONVOLUTIONS)
VAS.3071 신경 메모리 및 신경 메모리로부터 수신된 데이터 행의 멀티-워드 거리의 회전을 집단적으로 수행하는 신경 처리 유닛의 어레이를 갖는 신경망 유닛(NEURAL NETWORK UNIT WITH NEURAL MEMORY AND ARRAY OF NEURAL PROCESSING UNITS THAT COLLECTIVELY PERFORM MULTI-WORD DISTANCE ROTATES OF ROW OF DATA RECEIVED FROM NEURAL MEMORY)
최근에, 인공 신경망들(Artificial Neural Network, ANN)에서의 관심의 재유행이 있어 왔고, 이러한 연구는 공통적으로 딥 러닝(deep learning), 컴퓨터 러닝(computer learning) 및 유사한 용어로 불려왔다. 범용 프로세서의 연산력 증가는 수십년 전에 쇠약해졌던 새로워진 관심을 일으키고 있다. ANN들의 최근의 출원들은 다른 것들과 함께 음성 및 이미지 인식을 포함해 왔다. ANN들과 관련된 계산들의 개선된 성능 및 효율에 대한 증가하는 요구가 출현하고 있다.
본 발명의 목적은 ANN들과 관련된 연산들의 개선된 성능 및 효율에 대한 증가하는 요구가 충족하기 위하여, 캐시 메모리 또는 신경망 유닛 메모리로서 동작 가능한 메모리 어레이를 가지는 프로세서를 제공하는 것이다.
상기와 같은 목적을 달성하기 위하여, 모드 표시기; 복수의 프로세스 코어들; 및 메모리 어레이; 신경처리 유닛(NPU)들의 어레이; 캐시 제어 로직; 및 복수의 NPU들 및 캐시 제어 로직을 상기 메모리 어레이에 선택적으로 결합하도록 구성된 선택 로직;을 포함하는 신경망 유닛(NNU)을 포함하며, 모드 표시기가 제1 모드를 표시할 때, 선택 로직은 웨이트를 이용하여 계산을 수행하도록 상기 메모리 어레이로부터의 신경망 웨이트를 복수의 NPU들이 판독할 수 있도록 하고; 그리고 모드 표시기가 제2 모드를 표시할 때, 선택 로직은 복수의 프로세스 코어들이 캐시 메모리로서의 캐시 제어 로직을 통해 상기 메모리 어레이에 접속할 수 있도록 하는 것을 특징으로 하는 프로세서가 제공된다.
본 발명의 일 실시예에 따르면 NNU(121)의 뉴런들에 대한 연결 입력들의 수에 대해 유연성 및 효율성의 장점을 갖고, 극히 높은 성능을 제공한다.
도 1은 신경망 유닛(NNU)을 포함하는 프로세서를 도시하는 블록도.
도 2는 도 1의 NPU를 도시하는 블록도.
도 3은 도 1의 데이터 RAM으로부터 수신된 데이터 워드들의 한 행에 대해, 도 1의 NNU의 N개의 NPU들의 N개의 mux-reg들의 배열의 실시예를 도시하여 이들의 동작을 N-워드 회전자, 또는 순환 시프터로서 도시하는 블록도.
도 4는 도 1의 NNU의 프로그램 메모리 내의 저장 및 도 1의 NNU에 의한 실행을 위한 프로그램을 도시하는 테이블.
도 5는 NNU에 의해 도 4의 프로그램의 실행을 도시하는 타이밍도.
도 6a는 도 4의 프로그램을 실행하기 위한 도 1의 NNU를 도시하는 블록도.
도 6b는 NNU를 사용하는 아키텍쳐 프로그램을 수행하여, 도 4의 프로그램에 의해 수행되는 것과 같은 인공 신경망의 숨겨진 층들의 뉴런들과 고전적으로 관련된 곱-누산-활성 함수의 계산들을 수행하기 위한 도 1의 프로세서의 동작을 도시하는 흐름도.
도 7은 다른 실시예에 따른 도 1의 NPU를 도시하는 블록도.
도 8은 다른 실시예에 따른 도 1의 NPU를 도시하는 블록도.
도 9는 도 1의 NNU의 프로그램 메모리에서의 저장 및 도 1의 NNU에 의한 실행을 위한 프로그램을 도시하는 테이블.
도 10은 NNU에 의한 도 9의 프로그램의 실행을 도시하는 타이밍도.
도 11은 도 1의 NNU의 실시예를 도시하는 블록도. 도 11의 실시예에서, 뉴런은 2개의 성분(Slice)들, 활성 함수 유닛 성분 및 ALU 부분(시프트 레지스터 부분을 또한 포함하는)으로 분리되고, 각 활성 함수 유닛 부분은 다수의 ALU 부분들에 의해 공유된다.
도 12는 도 11의 NNU에 의한 도 4의 프로그램의 실행을 도시하는 타이밍도.
도 13은 도 11의 NNU에 의한 도 4의 프로그램의 실행을 도시하는 타이밍도.
도 14는 신경망으로의 이동(MTNN)의 아키텍쳐 명령 및 도 1의 NNU의 성분들에 대한 이의 동작을 도시하는 블록도.
도 15는 신경망으로부터의 이동(MFNN)의 아키텍쳐 명령 및 도 1의 NNU의 성분들에 대한 이의 동작을 도시하는 블록도.
도 16은 도 1의 데이터 RAM의 실시예를 도시하는 블록도.
도 17은 도 1의 웨이트 RAM 및 버퍼의 실시예를 도시하는 블록도.
도 18은 도 1의 동적으로 구성 가능한 NPU를 도시하는 블록도.
도 19는 도 18의 실시예에 따라 도 1의 NNU의 N개의 NPU들의 2N개의 mux-reg들의 배열의 실시예를 도시하여, 도 1의 데이터 RAM으로부터 수신된 데이터 워드의 한 행에 대한 회전자로서 이들의 동작을 도시하는 블록도.
도 20은 도 18의 실시예에 따른 NPU들을 갖는 도 1의 NNU의 프로그램 메모리에서의 저장 및 도 1의 NNU에 의한 실행을 위한 프로그램을 도시하는 테이블.
도 21은 좁은 구성으로 동작하는 도 18의 NPU들을 포함하는 NNU에 의한 도 20의 프로그램의 실행을 도시하는 타이밍도.
도 22는 도 20의 프로그램을 실행하기 위한 도 18의 NPU들을 포함하는 도 1의 NNU를 도시하는 블록도.
도 23은 다른 실시예에 따라 도 1의 동적으로 구성 가능한 NPU를 도시하는 블록도.
도 24는 컨벌루션 동작을 수행하기 위해 도 1의 NNU에 의해 사용된 데이터 구조의 예를 도시하는 블록도.
도 25는 NNU를 사용하는 아키텍쳐 프로그램을 수행하여 도 24의 데이터 어레이를 통한 컨벌루션 커넬의 컨벌루션을 수행하기 위한 도 1의 프로세서의 동작을 도시하는 흐름도.
도 26a는 도 24의 컨벌루션 커넬을 통해 데이터 매트릭스의 컨벌루션을 수행하고 이를 다시 웨이트 RAM에 기입하는 NNU 프로그램의 프로그램 목록.
도 26b는 일 실시예에 따라 도 1의 NNU의 제어 레지스터의 특정 필드들을 도시하는 블록도.
도 27은 풀링(pooling) 동작이 도 1의 NNU에 의해 수행되는 입력 데이터로 채워진 도 1의 웨이트 RAM의 예를 도시하는 블록도.
도 28은 도 27의 입력 데이터 매트릭스의 풀링 동작을 수행하고 이를 다시 웨이트 RAM에 기입하는 NNU 프로그램의 프로그램 목록.
도 29a는 도 1의 제어 레지스터의 실시예를 도시하는 블록도.
도 29b는 다른 실시예에 따라 도 1의 제어 레지스터의 실시예를 도시하는 블록도.
도 29c는 일 실시예에 따라 2개의 성분들로서 저장된 도 29a의 역수의 실시예를 도시하는 블록도.
도 30은 도 2의 AFU의 실시예를 더 상세하게 도시하는 블록도.
도 31은 도 30의 AFU의 동작의 예를 도시하는 도면.
도 32는 도 30의 AFU의 동작의 제 2의 예를 도시하는 도면.
도 33은 도 30의 AFU의 동작의 제 3의 예를 도시하는 도면.
도 34는 도 1의 프로세서를 도시하고, 도 1의 NNU의 성분들을 더 상세하게 도시하는 블록도.
도 35는 가변 속도의 NNU를 포함하는 프로세서를 도시하는 블록도.
도 36a는 정상 모드, 즉 기본 클록 속도로 동작하는 NNU를 갖는 프로세서의 동작의 예를 도시하는 타이밍도.
도 36b는 완화된 모드, 즉 기본 클록 속도보다 낮은 속도로 동작하는 NNU를 갖는 프로세서의 동작의 예를 도시하는 타이밍도.
도 37은 도 35의 프로세서의 동작을 도시하는 흐름도.
도 38은 NNU의 시퀀스를 더 상세하게 도시하는 블록도.
도 39는 NNU의 제어 및 상태 레지스터의 특정 필드를 도시하는 블록도.
도 40은 프로세서를 나타내는 블록도.
도 41은 도 40의 NNU를 보다 상세하게 그리고 도 40의 링 스톱을 나타내는 블록도,
도 42는 도 41의 메모리 어레이가 LLC 성분으로 사용될 때의 캐시 메모리 모드로부터 NNU의 웨이트/데이터 RAM으로 사용될 때의 NNU 모드로 이전될 때 도 40의 프로세서의 동작을 나타내는 블록도,
도 43은 도 41의 메모리 어레이가 NNU의 웨이트/데이터 RAM으로 사용될 때의 NNU 모드로부터 LLC 성분으로 사용될 때의 캐시 메모리 모드로 이전될 때 도 40의 프로세서의 동작을 나타내는 블록도,
도 44는 도 41의 메모리 어레이가 NNU의 웨이트/데이터 RAM으로 사용될 때의 NNU 모드로부터 희생 캐시로서 사용될 때의 캐시 메모리 모드로 이전될 때 도 40의 프로세서의 동작을 나타내는 흐름도,
도 45는 도 41의 메모리 어레이가 희생 캐시로서 사용될 때의 캐시 메모리 모드로부터 NNU의 웨이트/데이터 RAM으로 사용될 때의 NNU 모드로 이전될 때 도 40의 프로세서의 동작을 나타내는 흐름도이다.
아키텍쳐 신경망 유닛을 갖는 프로세서
이제 도 1을 참조하면, 신경망 유닛(NNU)(121)을 포함하는 프로세서(100)를 도시하는 블록도가 도시된다. 프로세서(100)는 명령 인출(fetch) 유닛(101), 명령 캐시(102), 명령 변환기(104), 재명명 유닛(106), 예약 스테이션들(108), 미디어 레지스터들(118), 범용 레지스터들(GPR)(116), NNU(121) 이외의 실행 유닛들(112), 및 메모리 하위시스템(114)을 포함한다.
프로세서(100)는 집적회로 상에서 중앙 처리 유닛(CPU)로서 기능하는 전자 디바이스이다. 프로세서(100)는 입력으로 디지털 데이터를 수신하고, 메모리로부터 인출된 명령들에 따라 데이터를 처리하고, 명령들에 의해 지정된 동작들의 결과들을 출력으로 생성한다. 프로세서(100)는 데스크탑, 모바일, 또는 태블릿 컴퓨터 내에서 채용될 수 있고, 계산, 텍스트 편집, 멀티미디어 디스플레이, 및 인터넷 브라우징과 같은 용도들을 위하여 채용된다. 프로세서(100)는 또한 가전제품들, 모바일 전화기들, 스마트폰들, 자동차들 및 산업용 제어 디바이스들을 포함하는 폭넓은 다양한 디바이스들을 제어하기 위한 내장형 시스템 내에 배치될 수 있다. CPU는 산술 동작들, 로직 동작들, 및 입력/출력 동작들을 포함하는 데이터에 대한 동작들을 수행함으로써 컴퓨터 프로그램(또한 "컴퓨터 어플리케이션" 또는 "어플리케이션"으로 알려진)의 명령들을 실행하는 전자 회로(즉, "하드웨어")이다. 집적회로(IC)는 반도체 재료, 전형적으로 실리콘의 작은 성분 상에 제작된 한 세트의 전자 회로들이다. IC는 또한 칩, 마이크로칩 또는 다이로 언급된다.
명령 인출 유닛(101)은 시스템 메모리(미도시)로부터 명령 캐시(102)로 아키텍쳐 명령들(103)의 인출을 제어한다. 명령 인출 유닛(101)은 인출 어드레스를 명령 캐시(102)에 제공하고, 명령 캐시(102)는 프로세서(100)가 아키텍쳐 명령 바이트들의 캐시 라인을 명령 캐시(102)로 인출하는 메모리 어드레스를 지정한다. 인출 어드레스는 프로세서(100)의 명령 포인터(미도시), 또는 프로그램 카운터의 현재 값에 기초한다. 프로그램 카운터가 분기 타깃 어드레스, 복귀 어드레스, 또는 예외 벡터와 같은 비순차적인 어드레스로 경신되는, 분기, 호출 또는 복귀 명령과 같은 제어 명령이 명령 스트림에서 발생하지 않거나, 인터럽트, 트랩, 예외 또는 장애와 같은 예외 조건이 발생하지 않는다면, 프로그램 카운터는 정상적으로 명령의 크기만큼 순차적으로 증가된다. 일반적으로 말해, 프로그램 카운터는 실행 유닛들(112/121)에 의한 명령들의 실행에 따라 경신된다. 프로그램 카운터는 또한 명령 변환기(104)가 프로세서(100)의 명령 세트 구조에 의해 지정되지 않은 명령(103)을 직면하는 것과 같은 예외 조건의 검출에 응답하여 경신될 수 있다.
명령 캐시(102)는 프로세서(100)에 결합된 시스템 메모리로부터 인출된 아키텍쳐 명령들(103)을 저장한다. 아키텍쳐 명령들(103)은 신경망으로의 이동(MTNN) 명령 및 신경망으로부터의 이동(MFNN) 명령을 포함하고, 이들은 아래에서 보다 상세하게 기술된다. 일 실시예에 있어서, 아키텍쳐 명령들(103)은 MTNN 및 MFNN 명령들이 추가된 x86 명령 세트 아키텍쳐(ISA)의 명령들이다. 본 개시사항의 내용에서, 프로세서로서 x86 ISA 프로세서는 명령 세트 구조 레벨에서, Intel® 80386® 프로세서가 동일한 기계 언어 명령들을 실행할 때 생성하는 것과 동일한 결과를 생성한다. 그러나, 다른 실시예들은 진보된 RISC Machine(ARM)®, Sun SPARC®, 또는 PowerPC®와 같은 다른 명령 세트 구조들을 고려한다. 명령 캐시(102)는 아키텍쳐 명령들(103)을 명령 변환기(104)에 제공하고, 명령 변환기는 아키텍쳐 명령들(103)을 마이크로 명령들(105)로 변환한다.
마이크로 명령들(105)은 재명명 유닛(106)에 제공되고, 궁극적으로 실행 유닛(112/121)에 의해 실행된다. 마이크로 명령들(105)은 아키텍쳐 명령들을 구현한다. 바람직하게, 명령 변환기(104)는 자주 실행되는 및/또는 상대적으로 덜 복잡한 아키텍쳐 명령들(103)을 마이크로 명령들(105)로 변환하는 제1 부분을 포함한다. 명령 변환기(104)는 또한 마이크로코드 유닛(미도시)을 포함하는 제 2 부분을 포함한다. 마이크로코드 유닛은 아키텍쳐 명령 세트의 복합 및/또는 드물게 사용된 명령들을 구현하는 마이크로코드 명령들을 유지하는 마이크로코드 메모리를 포함한다. 마이크로코드 유닛은 또한 비-아키텍쳐 마이크로-프로그램 카운터(마이크로-PC)를 마이크로코드 메모리로 제공하는 마이크로 시퀀서를 포함한다. 바람직하게 마이크로코드 명령들은 마이크로변환기(미도시)에 의해 마이크로명령들(105)로 변환된다. 선택기는 마이크로코드 유닛이 현재 제어를 갖는지의 여부에 따라, 재명명 유닛(106)으로의 공급을 위해 제1 부분 또는 제 2 부분으로부터 마이크로명령들(105)을 선택한다.
재명명 유닛(106)은 아키텍쳐 명령들(103)에 지정된 아키텍쳐 레지스터들을 프로세서(100)의 물리적인 레지스터들로 재명명한다. 바람직하게 프로세서(100)는 재배열 버퍼(미도시)를 포함한다. 재명명 유닛(106)은 각 마이크로명령(105)에 대한 재배열 버퍼의 입력을 프로그램 순서로 할당한다. 이것은 프로세서(100)가 마이크로명령들(105), 및 이들의 대응하는 아키텍쳐 명령들(103)을 프로그램 순서로 만료시킬 수 있게 한다. 일 실시예에 있어서, 미디어 레지스터들(118)은 256 비트의 폭이고, GPR(116)은 64 비트 폭이다. 일 실시예에 있어서, 미디어 레지스터들(118)은 진보된 벡터 확장(AVX) 레지스터들과 같은 x86 미디어 레지스터이다.
일 실시예에 있어서, 재배열 버퍼의 각 입력은 마이크로명령들(105)의 결과를 위한 저장을 포함하고; 추가적으로 프로세서(100)는, 아키텍쳐 레지스터들, 예컨대 미디어 레지스터들(118) 및 GPR(116), 및 다른 아키텍쳐 레지스터들의 각각에 대한 물리적인 레지스터를 포함하는 아키텍쳐 레지스터 파일을 포함한다. (바람직하게, 미디어 레지스터들(118) 및 GPR(116)이 예컨대 상이한 크기들을 갖기 때문에 이들에 대한 별도의 레지스터 파일들이 존재한다). 아키텍쳐 레지스터를 지정하는 마이크로명령(105)의 각 소스 피연산자(operand)에 대해, 재명명 유닛은 마이크로명령(105) 내의 소스 피연산자 필드를, 아키텍쳐 레지스터에 기입하는 가장 새로운 오래된 마이크로명령(105)의 재배열 버퍼 색인으로 채운다. 실행 유닛(112/121)이 마이크로명령(105)의 실행을 완성할 때, 그 결과를 마이크로명령(105)의 재배열 버퍼 입력에 기입한다. 마이크로명령(105)이 만료될 때, 만료 유닛(미도시)는 마이크로명령의 재배열 버퍼 입력으로부터 그 결과를, 만료 마이크로명령(105)에 의해 지정된 아키텍쳐 목적지 레지스터와 관련된 물리적인 레지스터 파일의 레지스터에 기입한다.
다른 실시예에 있어서, 프로세서(100)는 아키텍쳐 레지스터들의 수보다 더 많은 물리적인 레지스터들을 포함하는 물리적인 레지스터 파일을 포함하지만, 아키텍쳐 레지스터 파일을 포함하지 않고, 재배열 버퍼 입력들은 결과의 저장을 포함하지 않는다. (바람직하게, 미디어 레지스터들(118) 및 GPR(116)이 예컨대 상이한 크기들을 갖기 때문에 이들에 대한 별도의 레지스터 파일들이 존재한다). 프로세서(100)는 또한 각 아키텍쳐 레지스터에 대해 관련된 포인터를 갖는 포인터 테이블을 포함한다. 아키텍쳐 레지스터를 지정하는 마이크로명령(105)의 피연산자에 대해, 재명명 유닛은 마이크로명령(105) 내의 목적지 피연산자 필드를 물리적인 레지스터 파일 내의 자유 레지스터에 대한 포인터로 채운다. 물리적인 레지스터 파일 내에서 어떠한 레지스터도 자유롭지 않으면, 재명명 유닛(106)은 파이프라인을 지연시킨다. 아키텍쳐 레지스터를 지정하는 마이크로명령(105)의 각 소스 피연산자에 대해, 재명명 유닛은 마이크로명령(105) 내의 소스 피연산자 필드를 아키텍쳐 레지스터에 기입하는 가장 새로운 오래된 마이크로명령(105)에 할당된 물리적인 레지스터 파일 내의 레지스터에 대한 포인터로 채운다. 실행 유닛(112/121)이 마이크로명령(105)의 실행을 완성할 때, 마이크로명령(105)의 목적지 피연산자 필드에 의해 지시된 물리적인 레지스터 파일의 레지스터에 그 결과를 기입한다. 마이크로명령(105)이 만료될 때, 만료 유닛은 마이크로명령(105)의 목적지 피연산자 필드 값을, 만료 마이크로명령(105)에 의해 지정된 아키텍쳐 목적지 레지스터와 관련된 포인터 테이블 내의 포인터에 복사한다.
예약 스테이션들(108)은 마이크로명령들(105)이 실행을 위해 실행 유닛(112/121)으로 배출될 준비가 될 까지 마이크로명령들(105)을 유지한다. 마이크로명령(105)의 소스 피연산자들 모두가 사용 가능하고, 실행 유닛(112/121)이 마이크로명령을 실행하기 위하여 사용 가능할 때, 마이크로명령(105)은 배출될 준비가 된다. 실행 유닛들(112/121)은 제1 실시예에서 재배열 버퍼 또는 아키텍쳐 레지스터 파일로부터, 또는 상술한 제 2 실시예에서 물리적인 레지스터 파일로부터 레지스터 소스 피연산자들을 수신한다. 추가적으로, 실행 유닛들(112/121)은 결과 전달 버스들(미도시)을 통해 실행 유닛들(112/121)로부터 직접 레지스터 소스 피연산자들을 수신할 수 있다. 추가적으로, 실행 유닛들(112/121)은 마이크로명령들(105)에 의해 지정된 즉시 피연산자들을 예약 스테이션들(108)로부터 수신할 수 있다. 아래에서 더 상세하게 논의되는 바와 같이, MTNN 및 MFNN 아키텍쳐 명령들(103)은 하나 이상의 마이크로명령들(105) 중 하나에서 제공된 NNU(121)에 의해 수행될 기능을 지정하는 즉시 피연산자를 포함하고, MTNN 및 MFNN 아키텍쳐 명령들(103)은 하나 이상의 마이크로명령들(105)로 변환된다.
실행 유닛들(112)은 메모리 하위시스템(114)으로부터 데이터를 로딩하고 데이터를 메모리 하위시스템(114)에 저장하는 하나 이상의 로드/저장 유닛(미도시)을 포함한다. 바람직하게, 메모리 하위시스템(114)은 메모리 관리 유닛(미도시)을 포함하고, 이는 예컨대 변환 참조 버퍼들, 테이블 워크(tablewalk) 유닛, 레벨-1 캐시(및 명령 캐시(102)), 레벨-2 통합 캐시, 및 프로세서(100)를 시스템 메모리에 인터페이스시키는 버스 인터페이스 유닛을 포함한다. 일 실시예에 있어서, 도 1의 프로세서(100)는 최종-레벨의 캐시 메모리를 공유하는 멀티-코어 프로세서 내의 다수의 프로세스 코어들 중 하나인 프로세스 코어를 나타낸다. 실행 유닛들(112)은 또한 정수 유닛들, 미디어 유닛들, 부동소수점 유닛들, 및 분기 유닛들을 포함할 수 있다.
NNU(121)는 웨이트 RAM(124), 데이터 RAM(122), N개의 신경망 유닛들(NPUs)(126), 프로그램 메모리(129), 시퀀서(128) 및 제어 및 상태 레지스터(127)를 포함한다. NPUs(126)은 개념적으로 신경망 내의 뉴런들로서 기능한다. 웨이트 RAM(124), 데이터 RAM(122) 및 프로그램 RAM(129)은 모두 MTNN 및 MFNN 아키텍쳐 명령들(103)을 통해 각각 기입 및 판독 가능하다. 웨이트 RAM(124)은 N개의 웨이트 워드들의 W개의 행들로 배열되고, 데이터 RAM(122)은 N개의 데이터 워드들의 D개의 행들로 배열된다. 각 데이터 워드 및 각 웨이트 워드는 복수의 비트들, 바람직하게는 8 비트들, 9 비트들, 12 비트들 또는 16 비트들이다. 각 데이터 워드는 망 내에서 이전 층의 뉴런의 출력값(간혹 활성으로도 언급된다)으로 기능하고, 각 웨이트 워드는 망의 인스턴트 층의 뉴런으로 들어오는 연결과 관련된 웨이트로서 기능한다. NNU(121)의 많은 사용들에서 웨이트 RAM(124)에 유지된 워드들 또는 피연산자들은 실제 뉴런으로 들어오는 연결과 관련된 웨이트들이지만, NNU(121)의 다른 사용들에서 웨이트 RAM(124)에 유지된 워드들은 웨이트가 아니지만, 그럼에도 불구하고 이들이 웨이트 RAM(124)에 저장되기 때문에 "웨이트 워드들"로 언급됨을 이해하여야 한다. 예컨대, NNU(121)의 일부 사용들, 예컨대 도 24 내지 도 26a의 컨벌루션 예 또는 도 27 내지 도 28의 풀링 예에서, 웨이트 RAM(124)은 데이터 매트릭스, 예컨대 이미지 픽셀 데이터의 요소들과 같은 웨이트들을 유지할 수 있다. 유사하게, NNU(121)의 많은 사용들에서, 데이터 RAM(122)에 유지된 워드들 또는 피연산자들이 실제 신경의 출력값, 또는 활성이지만, NNU(121)의 다른 사용들에서 데이터 RAM(122) 내에 유지된 워드들은 이러한 것이 아니지만, 그럼에도 불구하고 이들이 데이터 RAM(122)에 저장되기 때문에 "데이터 워드들"로 언급됨을 이해하여야 한다. 예컨대, NNU(121)의 일부 사용들, 예컨대 도 24 내지 도 26a의 컨벌루션 예에서, 데이터 RAM(122)은 컨벌루션 커넬의 요소들과 같은 비-뉴런 출력들을 유지할 수 있다.
일 실시예에 있어서, NPU들(126) 및 시퀀서(128)는 조합 로직, 순차 로직, 상태 머신들, 또는 이들의 조합을 포함한다. 아키텍쳐 명령(예, MFNN 명령(1500))은 상태 레지스터(127)의 내용들을 GPR(116) 중 하나에 로드하여, NNU(121)가 명령을 완료하였다는 또는 NNU(121)가 프로그램 메모리(129)로부터 실행하였던 프로그램을 완료하였다는, 또는 NNU(121)가 새로운 명령을 수신하기 위하여 자유롭다는, 또는 새로운 NNU 프로그램을 시작하였다는, NNU(121)의 상태를 결정한다.
유리하게, NPU들(126)의 수는 필요에 따라 증가될 수 있고, 웨이트 RAM(124) 및 데이터 RAM(122)의 크기는 폭 및 깊이에서 적절하게 확장될 수 있다. 웨이트 RAM(124)은 큰 것이 바람직한데, 왜냐하면 종래의 신경망 층에서 많은 연결, 따라서 각 신경과 관련된 많은 웨이트들이 존재하기 때문이다. 다양한 실시예들은 본 명세서에서 데이터 및 웨이트 워드들의 크기, 웨이트 RAM(124) 및 데이터 RAM(122)의 크기들 및 NPU들(126)의 수에 관해 기술되었다. 일 실시예에 있어서, 64KB(8192비트들×64 행들)의 데이터 RAM(122), 2MB(8192비트들×2048 행들)의 웨이트 RAM(124), 및 512개의 NPU들(126)를 갖는 NNU(121)는 Taiwan Semiconductor Manufacturing Company, Limited (TSMC)의 16nm 공정으로 구현되었고, 대략 3.3 mm2의 면적을 점유한다.
시퀀서(128)는 프로그램 메모리(129)로부터 명령들을 인출하고, 이들을 실행하고, 명령들은 특히 데이터 RAM(122), 웨이트 RAM(124) 및 NPU들(126)에 제공을 위한 생성 어드레스 및 제어 신호들을 포함한다. 시퀀서(128)는 데이터 RAM(122)에 제공하기 위한 메모리 어드레스(123) 및 판독 명령을 생성하여, N개의 NPU들(126)에 제공하기 위한 N개의 데이터 워드들의 D개 행들 중 하나를 선택한다. 시퀀서(128)는 또한 웨이트 RAM(124)에 제공하기 위한 메모리 어드레스(125) 및 판독 명령을 생성하여, N개의 NPU들(126)에 제공하기 위한 N개의 웨이트 워드들의 W개 행들 중 하나를 선택한다. NPU들(126)에 제공을 위해 시퀀서(128)에 의해 생성된 어드레스들(123 및 125)의 시퀀스는 뉴런들 사이의 "연결들"을 결정한다. 시퀀서(128)는 또한 데이터 RAM(122)에 제공하기 위한 메모리 어드레스(123) 및 기입 명령을 생성하여, N개의 NPU들(126)로부터 기입을 위한 N개의 데이터 워드들의 D개 행들 중 하나를 선택한다. 시퀀서(128)는 또한 웨이트 RAM(124)에 제공하기 위한 메모리 어드레스(125) 및 판독 명령을 생성하여, N개의 NPU들(126)로부터 기입하기 위한 N개의 웨이트 워드들의 W개 행들 중 하나를 선택한다. 시퀀서(128)는 또한 아래에서 기술되는 바와 같이, 프로그램 메모리(129)에 대한 메모리 어드레스(131)를 생성하여, 시퀀서(128)에 제공되는 NNU 명령을 선택한다. 메모리 어드레스(131)는 프로그램 카운터(미도시)에 대응하고, 시퀀서(128)가 프로그램 카운터를 제어 명령의 타깃 어드레스로 경신하는 루프 명령(예컨대, 도 26a를 참조)과 같은 제어 명령을 시퀀스(128)가 만나지 않는다면, 시퀀서(128)는 프로그램 메모리(129)의 순차적인 위치를 통해 프로그램 카운터를 일반적으로 증가시킨다. 시퀀서(128)는 또한 NPU들(126)에 대한 제어 신호들을 생성하여, 이들이 초기화, 산술/로직 동작들, 회전 및 이동 동작들, 활성함수들, 재기입 동작들과 같은 동작들 및 함수들을 수행하도록 명령하고, 이들 예들은 아래에서 더 상세하게 기술된다(예컨대, 도 34의 마이크로-동작들(3418)을 참조).
N개의 NPU들(126)은 웨이트 RAM(124)의 한 행 또는 데이터 RAM(122)에 기입될 수 있는 N개의 결과 워드들(133)을 생성한다. 바람직하게, 웨이트 RAM(124) 및 데이터 RAM(122)은 N개의 NPU들(126)에 직접 결합된다. 더 특별하게, 웨이트 RAM(124) 및 데이터 RAM(122)은 NPU들(126)에 전용되고, 프로세서(100)의 다른 실행 유닛들(112)에 의해 공유되지 않고, NPU들(126)은 지속되는 방식으로, 바람직하게는 파이프라인 방식으로 매 클록 사이클마다 웨이트 RAM(124) 및 데이터 RAM(122) 중 하나 또는 모두로부터 한 행을 소비할 수 있다. 일 실시예에 있어서, 데이터 RAM(122) 및 웨이트 RAM(124) 각각은 각 클록 사이클마다 8192개의 비트들을 NPU들(126)에 제공할 수 있다. 8192개의 비트들은 아래에서 더 상세하게 기술되는 바와 같이 512개의 16-비트 워드들로서 또는 1024개의 8-비트 워드들로서 소비될 수 있다.
유리하게, NNU(121)에 의해 처리될 수 있는 데이터 세트의 크기는 웨이트 RAM(124) 및 데이터 RAM(122)의 크기에 국한되지 않고, 데이터 및 웨이트들이 MTNN 및 MFNN 명령들(예, 미디어 레지스터들(118)을 통해)을 사용하여 시스템 메모리와 웨이트 RAM(124) 및 데이터 RAM(122) 사이에서 이동될 수 있기 때문에, 오히려 시스템 메모리의 크기에 의해 오로지 국한된다. 일 실시예에 있어서, 데이터 워드들이 동시에 데이터 RAM(122)으로부터 판독 또는 이에 기입되는 동안, 데이터 워드들이 데이터 RAM(122)에 기입되는 것을 가능하게 하기 위하여, 데이터 RAM(122)은 이중-포트로 이루어진다. 더욱이, 캐시 메모리들을 포함하는, 메모리 하위 시스템(114)의 대형 메모리 계층은 시스템 메모리 및 NNU(121) 사이의 전송을 위한 매우 높은 데이터 대역폭을 제공한다. 또한, 바람직하게 메모리 하위시스템(114)은 시스템 메모리로부터 신경 데이터 및 웨이트들의 로딩과 같은 메모리 접속 패턴들을 추적하고, 웨이트 RAM(124) 및 데이터 RAM(122)에 대한 높은 대역폭 및 낮은 지연의 전송들을 용이하게 하기 위하여 캐시 계층으로의 데이터 인출을 수행하는 하드웨어 데이터 인출을 포함한다.
비록 각 NPU(126)에 제공되는 피연산자들 중 하나가 웨이트 메모리로부터 제공되어 웨이트로 표시되고, 신경망들에서 공통적으로 사용되는 실시예들이 기술되었지만, 피연산자들은, 계산 속도가 기술된 장치들에 의해 개선될 수 있는 계산들과 관련된 다른 유형들의 데이터일 수 있음을 이해해야 한다.
이제 도 2를 참조하면, 도 1의 NPU(126)를 도시하는 블록도가 도시된다. NPU(126)는 많은 기능들 또는 동작들을 수행하도록 동작한다. 특히, 유리하게 NPU(126)는 뉴런, 또는 노드로서 동작하도록, 인공 신경망에서 종래의 곱-누적 기능, 또는 동작을 수행하도록 구성될 수 있다. 즉, 일반적으로 말해, NPU(126)(뉴런)는: (1) 연결을 갖는 각 뉴런으로부터, 반드시 그런 것은 아니지만 전형적으로 인공 신경망의 바로 이전의 층으로부터 입력값을 수신하고; (2) 연결과 관련된 대응하는 웨이트 값으로 각 입력을 곱해 곱을 생성하고; (3) 모든 곱들을 더해 합을 생성하고; 및 (4) 합에 활성함수를 수행하여 뉴런의 출력을 생성하도록 구성된다. 그러나, 종래의 방식에서와 같이, 모든 연결 입력들과 관련된 모든 곱셈들을 수행하고 이후 모든 곱들을 함께 더하는 것이 아니라, 유리하게 각 뉴런은 주어진 클록 사이클에서 연결 입력들 중 하나와 관련된 웨이트 곱셈 동작을 수행하고, 이후 곱을 그 지점까지의 이전 클록 사이클들에서 처리된 연결 입력들과 관련된 곱들의 누적된 값들에 가산(누적) 하도록 구성된다. 뉴런에 대한 M개의 연결들이 존재하는 것을 가정하여, 모든 M개의 곱들이 누적된 후(대략 M개의 클록 사이클들이 소요됨), 뉴런은 누적된 값에 대한 활성함수를 수행하여 출력 또는 결과를 생성한다. 이는 모든 연결 입력들과 관련된 곱들의 모두 또는 심지어 서브세트를 더하는 것을 필요로 할 가산기보다, 뉴런에서 더 적은 곱셈기들, 및 더 작고, 더 단순하며 더 빠른 가산기 회로(예, 2-입력 가산기)를 필요로 하는 장점을 갖는다. 이는 차례로, 대략 M개의 클록 사이클들 이후, NNU(121)가 큰 수(N)의 뉴런들의 모두에 대해 출력을 생성하도록, NNU(121) 내에서 매우 많은 수(N)의 뉴런들(NPU들(126))을 촉진하는 장점을 갖는다. 최종적으로, 이러한 뉴런들로 구성된 NNU(121)는 상이한 연결 입력들의 큰 수에 대해 인공 신경망의 층으로서 효율적으로 수행하는 장점을 갖는다. 즉, 상이한 층들에 대해 M이 증가하거나 감소할 때, 뉴런 출력들을 생성하는데 요구되는 클록 사이클들의 수는 증가하거나 감소하고, 자원들(예, 곱셈기들 및 누산기들)은 완전히 사용된다; 반면에 더 종래의 설계에서 곱셈기들의 일부 및 가산기의 일부는 M의 더 작은 값들에 대해 사용되지 않을 수도 있다. 따라서, 본 명세서에서 기술된 실시예들은 NNU(121)의 뉴런들에 대한 연결 입력들의 수에 대해 유연성 및 효율성의 장점을 갖고, 극히 높은 성능을 제공한다.
NPU(126)는 레지스터(205), 2-입력 다중 레지스터(mux-reg)(208), 연산 로직유닛(ALU)(204), 누산기(202) 및 활성함수 유닛(AFU)(212)을 포함한다. 레지스터(205)는 웨이트 RAM(124)로부터 웨이트 워드(206)를 수신하고, 후속 클록 사이클에 그 출력(203)을 제공한다. mux-reg(208)는 그 입력들(207 또는 211) 중 하나를 선택하여, 레지스터에 저장하고, 이후 후속 클록 사이클의 출력(209) 상에 제공한다. 하나의 입력(207)은 데이터 RAM(122)으로부터 데이터 워드를 수신한다. 다른 입력(211)은 인접한 NPU(126)의 출력(209)을 수신한다. 도 2에 도시된 NPU(126)는 도 1의 N개의 NPU들(126) 중에서 NPU J로 표시된다. 즉, NPU J는 N개의 NPU들(126) 중 대표적인 예이다. 바람직하게, NPU J의 mux-reg(208)의 입력(211)은 NPU(126)의 예 J-1의 mux-reg(208)의 출력(209)을 수신하고, NPU J의 mux-reg(208)의 출력(209)은 NPU(126)의 예 J+1의 mux-reg(208)의 입력(211)에 제공된다. 이러한 방식으로, N개의 NPU들(126)의 mux-reg들(208)은 도 3에 관해 아래에서 더 상세하게 기술되는 바와 같이, 집단적으로 N-워드 회전자, 또는 순환 시프터로서 동작한다. 제어 입력(213)은 mux-reg(208)가 그 레지스터에 저장하기 위해 2개 입력들 중 어느 것을 선택할 지를 제어하고, 이는 후속적으로 출력(209)에 제공된다.
ALU(204)는 3개의 입력을 갖는다. 하나의 입력은 레지스터(205)로부터 웨이트 워드(203)를 수신한다. 다른 입력은 mux-reg(208)의 출력(209)을 수신한다. 또 다른 입력은 누산기(202)의 출력(217)을 수신한다. ALU(204)는 그 입력들에 대한 연산 및/또는 로직 동작들을 수행하여 그 출력에 제공되는 결과를 생성한다. 바람직하게, ALU(204)에 의해 수행될 연산 및/또는 로직 동작들은 프로그램 메모리(129)에 저장된 명령들에 의해 지정된다. 예컨대, 도 4의 곱-누산 명령은 곱-누산 동작을 지정한다, 즉, 결과(215)는 누산기(202)의 값(217)과, 웨이트 워드(203)와 mux-reg(208)의 출력(209)의 데이터 워드의 곱의 합이다. 지정될 수 있는 다른 동작들은, 결과(215)가 mux-reg의 출력(209)의 패스쓰루(passed-through) 값이고; 결과(215)가 웨이트 워드(203)의 패스쓰루 값이고; 결과(215)가 0이고; 결과(215)가 웨이트 워드(203)의 패스쓰루 값이고; 결과(215)가 누산기(202)의 값(217)과 웨이트 워드(203)의 합이고; 결과(215)가 누산기(202)의 값(217)과 mux-reg의 출력(209)의 합이고; 결과(215)가 누산기(202)의 값(217)과 웨이트 워드(203)의 최대값이고; 결과(215)가 누산기(202)의 값(217)과 mux-reg의 출력(209) 중 최대값인 것을 포함하지만, 이에 제한되는 것은 아니다.
ALU(204)는 그 출력(215)을 누산기(202)에서의 저장을 위해 누산기(202)에 제공한다. ALU(204)는 웨이트 워드(203)와 mux-reg(208) 출력(209)의 데이터를 곱하여 곱(246)을 생성하는 곱셈기(242)를 포함한다. 일 실시예에 있어서, 곱셈기(242)는 2개의 16-비트 피연산자들을 곱하여 32-비트 결과를 생성한다. ALU(204)는 또한 곱(246)을 누산기(202)의 출력(217)에 더하여 합을 생성하는 가산기(244)를 포함하고, 이 합은 누산기(202)에 저장을 위해 누산기(202)에서 누적되는 결과(215)이다. 일 실시예에 있어서, 가산기(244)는 곱셈기(242)의 32-비트 결과를 누산기(202)의 41-비트 값(217)에 더하여 41-비트 결과를 생성한다. 이러한 방식으로, 다수의 클록 사이클들에 걸쳐 mux-reg(208)의 회전자 양상을 사용하여, NPU(126)는 신경망들에 의해 요구되는 뉴런에 대한 곱들의 합을 달성한다. ALU(204)는 또한 상술한 것과 같은 다른 연산/로직 동작들을 수행하기 위한 다른 회로 요소들을 포함할 수 있다. 일 실시예에 있어서, 제 2 가산기는 mux-reg(208)의 출력(209)의 데이터 워드로부터 웨이트 워드(203)를 감산하여 차이를 생성하고, 가산기(244)는 이후 이 차이를 누산기(202)의 출력(217)에 더하여 합(215)을 생성하고, 이 합은 누산기(202)에 누적되는 결과이다. 이러한 방식으로, 다수의 클록 사이클들에 걸쳐, NPU(126)는 차이들의 합을 달성할 수 있다. 바람직하게, 웨이트 워드(203)와 데이터 워드(209)가 (비트수에서) 동일한 크기이지만, 이들은 아래에서 더 상세하게 기술되는 바와 같이 상이한 2진 점 위치들을 가질 수 있다. 바람직하게, 곱셈기(242) 및 가산기(244)는 아래에서 더 상세하게 기술되는 바와 같이 정수 곱셈기들 및 가산기들이어서, 부동 소수점의 ALU들보다 덜 복합하고, 더 작고, 더 빠르며, 낮은 전력을 소비하는 ALU들(204)를 달성한다. 그러나, 다른 실시예들에서 ALU(204)이 부동 소수점 동작들을 수행하는 것을 이해하여야 한다.
도 2가 ALU(204) 내에서 오로지 곱셈기(242) 및 가산기(244)를 도시하지만, 바람직하게 ALU(204)는 상술한 다른 동작들을 수행하기 위한 다른 요소를 포함한다. 예컨대, 바람직하게 ALU(204)는 누산기(202)를 데이터/웨이트 워드 및 mux(미도시)와 비교하기 위한 비교기(미도시)를 포함하고, mux는 누산기(202)에 저장을 위해 비교기에 의해 표시된 2개의 값들 중 더 큰(최대) 것을 선택한다. 다른 예에 대해, ALU(204)는 바람직하게, 가산기(244)가 데이터/웨이트 워드를 누산기(202)의 값(217)에 가산하여 누산기(202)에 저장을 위한 합을 생성할 수 있게 하기 위하여, 데이터/웨이트 워드를 갖는 곱셈기(242)를 우회하는 선택 로직(미도시)을 포함한다. 이들 추가적인 동작들은 예컨대 도 18 내지 도 29a에 관해 아래에서 더 상세하게 기술되고, 예컨대 컨벌루션 및 풀링 동작을 수행하기 위해 유용할 수 있다.
AFU(212)는 누산기(202)의 출력(217)을 수신한다. AFU(212)는 도 1의 결과(133)를 생성하기 위하여 누산기(202)의 출력(217)에 대한 활성함수를 수행한다. 일반적으로 말하여, 인공 신경망의 중간층의 뉴런에서 활성함수는 바람직하게는 비선형 방식으로 곱들의 누적된 합을 정상화하도록 작용할 수 있다. 누적된 합을 "정상화"하기 위하여, 인스턴트 뉴런의 활성함수는 인스턴트 뉴런에 연결된 뉴런들이 입력으로서 수신할 것으로 기대되는 값들의 범위 내에서 최종 값을 생성한다. (정상화된 결과는 간혹 "활성"으로 언급되고, 이러한 활성은 본 명세서에서 기술되는 바와 같이 인스턴트 노드의 출력이고, 수신중인 노드는 인스턴트 노드의 출력을 출력중인 노드와 수신중인 노드 사이의 연결과 관련된 웨이트로 곱하여, 수신중인 노드에 대한 다른 입력 연결들과 관련된 다른 곱들과 함께 누적되는 곱을 생성한다.) 예컨대, 수신중인/연결된 뉴런들은 0과 1 사이의 값을 입력으로 수신하는 것을 예상할 수 있고, 이 경우 출력중인 뉴런은 0 내지 1의 범위 밖의 누적된 합을 예상된 범위 내의 값으로 비선형적으로 압축 및/또는 조정하는 것(예, 음의 값을 양의 값으로 변환하는 상향 이동)을 필요로 할 수 있다. 따라서, AFU(212)는 누산기(202)의 값(217)에 대한 동작을 수행하여 결과(133)를 알려진 범위 내에 들게 한다. N개의 NPU들(126)의 모두의 결과(133)들은 다시 동시에 데이터 RAM(122) 또는 웨이트 RAM(124)에 기입될 수 있다. 바람직하게, AFU(212)는 다수의 활성함수들을 수행하도록 구성되고, 예컨대 제어 레지스터(127)로부터의 입력은 누산기(202)의 출력(217)에 대해 수행하기 위한 활성함수들 중 하나를 선택한다. 활성함수들은 계단 함수, 정류 함수, 시그모이드(Signoid) 함수, 쌍곡 탄젠트(tanh) 함수, 소프트플러스(softplus) 함수(평활 정류로도 언급됨)을 포함할 수 있지만, 이에 국한되는 것은 아니다. 소프트플러스 함수는 분석 함수(f(x)=Ln(1+ex), 즉 1과 ex의 합의 자연로그이고, "e"는 오일러의 수이고, x는 함수에 대한 입력(217)이다. 바람직하게, 활성함수들은 또한 아래에서 더 상세하게 기술되는 바와 같이 누산기(202)의 값(217) 또는 이들의 일부를 통과시키는 패스쓰루 함수를 포함할 수 있다. 일 실시예에 있어서, AFU(212)의 회로는 단일 클록 사이클에서 활성함수를 수행한다. 일 실시예에 있어서, AFU(212)는 테이블들을 포함하고, 이러한 테이블은 누적된 값을 수신하고, 활성함수들의 일부, 예컨대, 시그모이드, 쌍곡 탄젠트, 소프트플러스에 대해 실제 활성함수가 제공할 값에 밀접하게 근사하는 값을 출력한다.
바람직하게 누산기(202)의 폭(비트수)은 AFU(212)의 출력(133)의 폭보다 크다. 예컨대, 일 실시예에 있어서, 누산기는 41비트 폭이어서, 512개의 32비트 곱들(예, 도 30에 대해 아래에서 더 상세하게 기술되는 바와 같이)까지의 누적에서 정확성의 손실을 피하고, 결과(133)은 16비트 폭이다. 일 실시예에 있어서, 연속적인 클록 사이클들 동안 "미처리" 누산기(202)의 출력(217) 값의 상이한 부분들이 AFU(212)를 통과하여, 데이터 RAM(122) 또는 웨이트 RAM(124)에 다시 기입되는 실시예의 일 예가 도 8에 관해 아래에서 더 상세하게 기술된다. 이 예는 미처리 누산기(202)의 값들이 MFNN 명령을 통해 미디어 레지스터들(118)에 다시 적재될 수 있게 하여, 프로세서(100)의 다른 실행 유닛(112) 상에서 실행중인 명령들은 정상화된 지수 함수로서 또한 언급되는 잘 알려진 소프트맥스 활성함수와 같은, AFU(212)가 수행할 수 없는 복잡한 활성함수들을 수행할 수 있게 된다. 일 실시예에 있어서, 프로세서(100)의 명령 세트 구조는 ex 또는 exp(x)로 일반적으로 언급되는 지수 함수를 수행하는 명령을 포함하고, 이는 프로세서(100)의 다른 실행 유닛들(112)에 의한 소프트맥스 활성함수의 성능의 속도를 높이는데 사용될 수 있다.
일 실시예에 있어서, NPU(126)는 파이프라인 방식으로 이루어진다. 예컨대, NPU(126)는 ALU(204)의 곱셈기와 가산기 및/또는 다른 회로 사이의 레지스터와 같은 ALU(204)의 레지스터들, 및 AFU(212)의 출력을 유지하는 레지스터를 포함할 수 있다. NPU(126)의 다른 실시예들은 아래에서 기술된다.
이제 도 3을 참조하면, 도 1의 NNU(121)의 N개의 NPU들(126)의 N개의 mux-reg들(208)의 배열의 일 실시예를 도시하여, 도 1의 데이터 RAM(122)으로부터 수신된 데이터 워드들(207)의 한 행에 대해, N-워드 회전자, 또는 순환 시프터로서 이들의 동작을 도시하기 위한 블록도가 도시된다. 도 3의 실시예에서, NNU(121)가 도시된 바와 같이 512개의 NPU들(126)에 대응하는 0 내지 511로 표시된 512개의 mux-reg들(208)을 갖도록, N은 512이다. 각 mux-reg(208)는 데이터 RAM(122)의 D개 행들의 한 행의 대응하는 데이터 워드(207)를 수신한다. 즉, mux-reg 0은 데이터 RAM(122) 행의 데이터 워드 0을 수신하고, mux-reg 1은 데이터 RAM(122) 행의 데이터 워드 1을 수신하고, mux-reg 2는 데이터 RAM(122) 행의 데이터 워드 2를 수신하는, 등의 방식으로 mux-reg 511은 데이터 RAM(122) 행의 데이터 워드 511을 수신한다. mux-reg 1은 그의 다른 입력(211) 상에서 mux-reg 0의 출력(209)을 수신하고, mux-reg 2는 그의 다른 입력(211) 상에서 mux-reg 1의 출력(209)을 수신하고, mux-reg 3은 그의 다른 입력(211) 상에서 mux-reg 2의 출력(209)을 수신하는, 등의 방식으로 mux-reg 511은 그의 다른 입력(211) 상에서 mux-reg 510의 출력(209)을 수신하고, mux-reg 0은 그의 다른 입력(211) 상에서 mux-reg 511의 출력(209)을 수신한다. mux-reg들(208)의 각각은 데이터 워드(207) 또는 회전된 입력(211)을 선택할 지를 제어하는 제어 입력(213)을 수신한다. 아래에서 더 상세하게 기술되는 바와 같이, 동작의 한 모드에서, 제1 클록 사이클에서, 제어 입력(213)은 각 mux-reg들(208)이 레지스터 내의 저장을 위해 그리고 ALU(204)에 대한 후속 제공을 위해 데이터 워드(207)를 선택하도록 제어하고; 후속 클록 사이클들(예, 상술한 M-1 클록 사이클들)에서, 제어 입력(213)은 각 mux-reg들(208)이 레지스터 내의 저장을 위해 그리고 ALU(204)에 대한 후속 제공을 위해 회전된 입력(211)을 선택하도록 제어한다.
비록 도 3(및 아래의 도 7 및 도 19)이 NPU들(126)이 mux-reg들(208/705)의 값들을 오른쪽으로, 즉 NPU J로부터 MPU J+1로 회전시키도록 구성되는 일 실시예를 기술하지만, NPU들(126)이 mux-reg들(208/705)의 값들을 왼쪽으로, 즉 NPU J로부터 MPU J-1로 회전시키도록 구성되는 (도 24 내지 도 26의 실시예에 관한 것과 같은)실시예들이 고려된다. 더욱이, NPU들(126)이 mux-reg들(208/705)의 값들을 예컨대 NNU 명령들에 의해 지정된 바와 같이, 선택적으로 왼쪽 또는 오른쪽으로 회전시키도록 구성되는 실시예들이 고려된다.
이제 도 4를 참조하면, 도 1의 NNU(121)의 프로그램 메모리(129)에 저장을 위한 및 NNU(121)에 의한 실행을 위한 프로그램을 도시하는 테이블이 도시된다. 예시적인 프로그램은 상술한 바와 같이 인공 신경망의 층과 관련된 계산들을 수행한다. 도 4의 테이블에서, 4개의 행들 및 3개의 열들이 도시된다. 각 행은 제1 열에서 지시된 프로그램 메모리(129)의 어드레스에 대응한다. 제 2 열은 명령을 지정하고, 제 3 열은 명령과 관련된 클록 사이클들의 수를 나타낸다. 바람직하게, 클록 사이클들의 수는 명령의 지연보다는, 파이프라인으로 이루어진 실시예에서 명령당-클록수 유형의 값에서 클록들의 유효 수를 나타낸다. 도시된 바와 같이, 각 명령들은 NNU(121)의 파이프라인으로 이루어진 성질에 인해 관련된 하나의 클록 사이클를 갖고, 예외로서 어드레스 2에서 명령은 아래에서 더 상세하게 기술되는 바와 같이 자신을 511회 효과적으로 반복하기 때문에 511개의 클록들을 필요로 한다.
프로그램의 각 명령에 대해, NPU들(126)의 모두는 명령을 병렬로 수행한다. 즉, 모든 N개의 NPU들(126)은 동일한 클록 사이클(들)에서 제1 행의 명령을 수행하고, 모든 N개의 NPU들(126)은 동일한 클록 사이클(들)에서 제 2 행의 명령을 수행하는, 등의 방식이다. 그러나, 명령들의 일부가 부분적으로는 병렬로 그리고 부분적으로는 순차적으로 수행되는 다른 예들이 아래에 기술된다, 예컨대 도 11의 실시예에 관해 NPU들(126)이 활성함수 유닛을 공유하는 실시예에서 어드레스들 3 및 4에서 활성함수 및 출력 명령들. 도 4의 예는 한 층의 514개의 뉴런(NPU들(126))을 간주하고, 이들 각각은 총 256K 연결들에 대해, 512개의 뉴런의 이전 층으로부터 512개의 연결 입력들을 갖는다. 각 뉴런은 각 연결 입력으로부터 16-비트 데이터 값을 수신하고, 16-비트 데이터 값을 적절한 16-비트 웨이트 값으로 곱한다.
어드레스 0(다른 어드레스들이 지정된다 할지라도)에서 제1 행은 초기화 NPU 명령을 지정한다. 초기화 명령은 누산기(202)의 값을 0으로 소거한다. 일 실시예에 있어서, 초기화 명령은 또한 명령에 의해 어드레스가 지정된 데이터 RAM(122) 또는 웨이트 RAM(124)의 한 행의 대응하는 워드를 누산기(202)에 로딩하는 것을 지정할 수 있다. 초기화 명령은 또한 도 29a 및 도 29b에 관해 아래에서 더 상세하게 기술되는 바와 같이 구성 값들을 제어 레지스터(127)에 로딩한다. 예컨대, 데이터 워드(207) 및 웨이트 워드(209)의 폭이 로딩될 수 있고, 이는 회로들에 의해 수행되는 동작들의 크기를 결정하기 위하여 ALU(204)에 의해 사용될 수 있고, 누산기(202)에 저장된 결과(215)에 영향을 미칠 수 있다. 일 실시예에 있어서, NPU(126)는 누산기(202)에 저장되기 전에 ALU(204)의 출력(215)을 포화시키는 회로를 포함하고, 초기화 명령은 포화에 영향을 미치기 위하여 구성 값을 회로에 로딩한다. 일 실시예에 있어서, 누산기(202)는 또한, ALU 함수 명령(예, 어드레스 1에서 곱-누산 명령)에서 또는 어드레스 4에서 AFU 출력 기입 명령과 같은 출력 명령에서 그렇게 지정함으로써, 0의 값으로 소거될 수 있다.
어드레스 1에서 제 2 행은 512개의 NPU들(126)이 데이터 RAM(122)의 한 행으로부터 각 데이터 워드를 로딩하고, 웨이트 RAM(124)의 한 행으로부터 각 웨이트 워드를 로딩하고, 데이터 워드 입력(207) 및 웨이트 워드 입력(206)에 대한 제1 곱-누산 동작을 수행하도록 명령하는 곱-누산 명령을 지정하고, 이러한 누적은 0의 값으로 초기화된 누산기(202)를 통해 누적된다. 보다 구체적으로, 이 명령은 시퀀서(128)가 제어 입력(213)에 대한 값을 생성하여 데이터 워드 입력(207)을 선택하도록 명령한다. 도 4의 예에서, 지정된 데이터 RAM(122)의 행은 행 17이고, 지정된 웨이트 RAM(124)의 행은 행 0이고, 이것은 시퀀서(128)가 데이터 RAM(122)에 어드레스(123)의 값 17을 출력하고, 웨이트 RAM에 어드레스(125)의 값 0을 출력하도록 명령한다. 결과적으로, 데이터 RAM(122)의 행 17로부터 512개의 데이터 워드들은 512개의 NPU들(126)의 대응하는 데이터 입력(207)에 제공되고, 웨이트 RAM(124)의 행 0으로부터 512개의 웨이트 워드들은 512개의 NPU들(126)의 대응하는 웨이트 입력(206)에 제공된다.
어드레스 2에서 제 3 행은 511의 카운트값으로 곱-누산 회전 명령을 지정하고, 이것은 512개의 NPU들(126) 각각이 511회의 곱-누산 동작들을 수행하도록 명령한다. 이 명령은 512개의 NPU들(126)에, 511회의 곱-누산 동작들의 각각에 대해 ALU(204)에 대한 데이터 워드(209) 입력이 인접한 NPU(126)로부터 회전된 값(211)이 되도록 명령한다. 즉, 이 명령은 시퀀서(128)가 회전된 값(211)을 선택하기 위하여 제어 입력(213)에 대한 값을 생성하도록 명령한다. 추가적으로, 이 명령은 512개의 NPU들(126)이 웨이트 RAM(124)의 "다음" 행으로부터 511회의 곱-누산 동작들의 각각에 대해 각 웨이트 워드를 로딩하도록 명령한다. 즉, 이 명령은 시퀀서(128)가 이전 클록 사이클에서 그 값에 대해 1만큼 웨이트 RAM의 어드레스(125)를 증가시키도록 명령한다, 본 예에서 이것은 명령의 제1 클록 사이클에서 행 1이 될 것이고, 다음 클록 사이클에서 행 2가 될 것이고, 다음 클록 사이클에서 행 3이 되는 방식으로, 511번째 클록 사이클에서 행 511이 될 것이다. 511회의 곱-누산 동작들의 각각에 대해 회전된 입력(211) 및 웨이트 워드 입력(206)의 곱은 누산기(202) 내의 이전 값과 함께 누적된다. 512개의 NPU들(126)은 511개의 클록 사이클들에서 511회의 곱-누산 동작들을 수행하고, 각 NPU(126)는 데이터 RAM(122)의 행 17로부터의 상이한 데이터 워드-즉, 이전 사이클에서 인접한 NPU(126)에 의해 조작된 데이터 워드- 및 뉴런에 대해 개념적으로 상이한 연결 입력인 데이터 워드와 관련된 상이한 웨이트 워드에 대해 곱-누산 동작을 수행한다. 이 예에서, 각 NPU(126)(뉴런)에 대한 연결 입력의 수는 512인 것으로, 따라서 512개의 데이터 워드들 및 512개의 웨이트 워드들을 포함하는 것으로 간주된다. 행 2의 곱-누산 회전 명령의 마지막 반복이 일단 수행되면, 누산기(202)는 모든 512개의 연결 입력들에 대해 곱들의 합을 포함한다. 일 실시예에 있어서, 각 유형의 ALU 동작(예, 상술한 바와 같은 곱-누산, 누산기 및 웨이트 워드의 최대값, 등)에 대해 별도의 명령을 갖는 것이 아니라, NPU(126) 명령 세트는 ALU(204)가 도 29a의 ALU 함수(2926)에 지정된 것과 같은, 초기화 NPU 명령에 의해 지정된 ALU 동작을 수행하도록 명령하는 "실행" 명령을 포함한다.
어드레스 3에서 제 4 행은 활성함수 명령을 지정한다. 활성함수 명령은 AFU(212)가 누산기(202)의 값(217)에 대한 지정된 활성함수를 수행하여 결과(133)를 생성하도록 명령한다. 일 실시예에 따른 활성함수들은 아래에서 더 상세하게 기술된다.
어드레스 4에서 제 5 행은 512개의 NPU들(126)이 결과들(133)로서 그들의 AFU(212) 출력을 데이터 RAM(122)의 한 행, 이 예에서는 행 16에 다시 기입하도록 명령하는 기입 AFU 출력 명령을 지정한다. 즉, 이 명령은 시퀀서(128)가 데이터 RAM의 어드레스(123)의 값 16과 기입 명령(어드레스 1에서 곱-누적 명령의 경우의 판독 명령과는 대조적으로)을 출력하도록 명령한다. 바람직하게, 기입 AFU 출력 명령의 실행은, 파이프라인 방식의 특징에서 다른 명령들의 실행과 중첩될 수 있어서, 기입 AFU 출력 명령은 단일 클록 사이클에서 효과적으로 실행된다.
바람직하게, 각 NPU(126)는 다양한 기능 요소들, 예컨대 mux-reg(208)(및 도 7의 mux-reg(705)), ALU(204), 누산기(202), AFU(212), mux(802)(도 8의), 행 버퍼(1104) 및 AFU(1112)(도 11의), 등을 포함하는 파이프라인으로서 구성되고, 이들 중 일부는 그들 자체가 파이프라인 방식으로 이루어질 수 있다. 데이터 워드(207) 및 웨이트 워드(206)에 덧붙여, 파이프라인은 프로그램 메모리(129)로부터 명령들을 수신한다. 명령들은 파이프라인 아래로 흐르고, 다양한 기능 유닛들을 제어한다. 다른 실시예에서, 활성함수 명령은 프로그램에 포함되지 않는다. 오히려, 초기화 NPU 명령은 누산기(202)의 값(217) 상에서 수행될 활성함수를 지정하고, 지정된 활성함수를 나타내는 값은, 일단 최종 누산기(202)의 값(217)이 생성되면, 즉 일단 어드레스 2에서 곱-누산 회전 명령의 마지막 반복이 완료되면, 파이프라인의 AFU(212) 부분에 의한 이후의 사용을 위해 구성 레지스터에 저장된다. 바람직하게, 전력 절감의 목적들을 위해, 파이프라인의 AFU(212) 부분은 기입 AFU 출력 명령이 이에 도달할 때까지 비활성이고, 명령이 도달할 때 AFU(212)는 전력을 공급받아, 초기화 명령에 의해 지정된 누산기(202)의 출력(217)에 대한 활성 기능을 수행한다.
이제 도 5를 참조하면, NNU(121)에 의한 도 4의 프로그램의 실행을 도시하는 타이밍도가 도시된다. 타이밍도의 각 행은 제1 열에서 표시된 연속적인 클록 사이클에 대응한다. 다른 열들의 각각은 512개의 NPU들(126)의 상이한 하나에 대응하고 그 동작을 나타낸다. 도시의 단순화 및 명확성을 위해, NPU 0, 1 및 511에 대해서만 동작들이 도시된다.
클록 0에서, 512개의 NPU들(126)의 각각은 도 4의 초기화 명령을 수행하고, 이는 누산기(202)에 0 값의 할당에 의해 도 5에 도시된다.
클록 1에서, 512개의 NPU들(126)의 각각은 도 4의 어드레스 1에서의 곱-누산 명령을 수행한다. NPU 0은 누산기(202)의 값(0인)을 데이터 RAM(122)의 행 17의 워드 0 및 웨이트 RAM(124)의 행 0의 워드 0의 곱과 함께 누적시키고; NPU 1은 누산기(202)의 값(0인)을 데이터 RAM(122)의 행 17의 워드 1 및 웨이트 RAM(124)의 행 0의 워드 1의 곱과 함께 누적시키는; 등의 방식으로 도시된 바와 같이 NPU 511은 누산기(202)의 값(0인)을 데이터 RAM(122)의 행 17의 워드 511 및 웨이트 RAM(124)의 행 0의 워드 511의 곱과 함께 누적시킨다.
클록 2에서, 512개의 NPU들(126)의 각각은 도 4의 어드레스 2에서의 곱-누산 회전 명령의 제1 반복을 수행한다. NPU 0은 누산기(202)의 값을 NPU 511의 mux-reg(208)의 출력(209)으로부터 수신된 회전된 데이터 워드(211)(데이터 RAM(122)으로부터 수신된 데이터 워드 511이었던) 및 웨이트 RAM(124)의 행 1의 워드 0의 곱과 함께 누적시키고; NPU 1은 누산기(202)의 값을 NPU 0의 mux-reg(208)의 출력(209)으로부터 수신된 회전된 데이터 워드(211)(데이터 RAM(122)으로부터 수신된 데이터 워드 0이었던) 및 웨이트 RAM(124)의 행 1의 워드 1의 곱과 함께 누적시키는; 등의 방식으로 도시된 바와 같이, NPU 511은 누산기(202)의 값을 NPU 510의 mux-reg(208)의 출력(209)으로부터 수신된 회전된 데이터 워드(211)(데이터 RAM(122)으로부터 수신된 데이터 워드 510이었던) 및 웨이트 RAM(124)의 행 1의 워드 511의 곱과 함께 누적시킨다.
클록 3에서, 512개의 NPU들(126)의 각각은 도 4의 어드레스 2에서의 곱-누산 회전 명령의 제 2 반복을 수행한다. NPU 0은 누산기(202)의 값을 NPU 511의 mux-reg(208)의 출력(209)으로부터 수신된 회전된 데이터 워드(211)(데이터 RAM(122)으로부터 수신된 데이터 워드 510이었던) 및 웨이트 RAM(124)의 행 2의 워드 0의 곱과 함께 누적시키고; NPU 1은 누산기(202)의 값을 NPU 0의 mux-reg(208)의 출력(209)으로부터 수신된 회전된 데이터 워드(211)(데이터 RAM(122)으로부터 수신된 데이터 워드 511이었던) 및 웨이트 RAM(124)의 행 2의 워드 1의 곱과 함께 누적시키는; 등의 방식으로 도시된 바와 같이, NPU 511은 누산기(202)의 값을 NPU 510의 mux-reg(208)의 출력(209)으로부터 수신된 회전된 데이터 워드(211)(데이터 RAM(122)으로부터 수신된 데이터 워드 509이었던) 및 웨이트 RAM(124)의 행 2의 워드 511의 곱과 함께 누적시킨다. 도 5의 생략으로 표시된 바와 같이, 이는 다음의 509개의 클록 사이클들의 각각에 대해 계속된다.
클록 512에서, 512개의 NPU들(126)의 각각은 도 4의 어드레스 2에서의 곱-누산 회전 명령의 제 511번째 반복을 수행한다. NPU 0은 누산기(202)의 값을 NPU 511의 mux-reg(208)의 출력(209)으로부터 수신된 회전된 데이터 워드(211)(데이터 RAM(122)으로부터 수신된 데이터 워드 1이었던) 및 웨이트 RAM(124)의 행 511의 워드 0의 곱과 함께 누적시키고; NPU 1은 누산기(202)의 값을 NPU 0의 mux-reg(208)의 출력(209)으로부터 수신된 회전된 데이터 워드(211)(데이터 RAM(122)으로부터 수신된 데이터 워드 2이었던) 및 웨이트 RAM(124)의 행 511의 워드 1의 곱과 함께 누적시키는; 등의 방식으로 도시된 바와 같이, NPU 511은 누산기(202)의 값을 NPU 510의 mux-reg(208)의 출력(209)으로부터 수신된 회전된 데이터 워드(211)(데이터 RAM(122)으로부터 수신된 데이터 워드 0이었던) 및 웨이트 RAM(124)의 행 511의 워드 511의 곱과 함께 누적시킨다. 일 실시예에 있어서, 다수의 클록 사이클들은, 데이터 RAM(122) 및 웨이트 RAM(124)으로부터 데이터 워드들 및 웨이트 워드들을 판독하여, 도 4의 어드레스 1에서 곱-누적 명령을 수행하는데 필요하지만; 데이터 RAM(122) 및 웨이트 RAM(124) 및 NPU들(126)은 파이프라인 방식으로 이루어져, 일단 제1 곱-누산 명령이 시작되면(예, 도 5의 클록 1의 동안 도시된 바와 같이), 후속 곱-누산 동작들(예, 클록들 2 내지 512 동안 도시된 바와 같이) 연속적인 클록 사이클들에서 시작된다. 바람직하게, NPU들(126)은 MTNN 또는 MFNN 명령(도 14 및 도 15에 관해 아래에서 기술되는)과 같은 아키텍쳐 명령 또는 아키텍쳐 명령이 변환된 마이크로명령에 의해 데이터 RAM(122) 및/또는 웨이트 RAM(124)의 접속에 응답하여 간단히 지연시킬 수 있다.
클록 513에서, 512개의 NPU들(126) 각각의 AFU(212)는 도 4의 어드레스 3에서의 활성함수 명령을 수행한다. 최종적으로, 클록 514에서, 512개의 NPU들(126) 각각은 그 결과(133)를 데이터 RAM(122)의 행 16의 대응하는 워드에 기입함으로써 도 4의 어드레스 4에서의 AFU 출력 명령을 수행한다, 즉 NPU 0의 결과(133)는 데이터 RAM(122)의 워드 0에 기입되고, NPU 1의 결과(133)는 데이터 RAM(122)의 워드 1에 기입되는, 등의 방식으로, NPU 511의 결과(133)는 데이터 RAM(122)의 워드 511에 기입된다. 도 5에 관해 상술된 동작은 또한 도 6a에서 블록도의 형태로 도시되었다.
이제, 도 6a를 참조하면, 도 4의 프로그램을 실행하기 위하여, 도 1의 NNU(121)를 도시하는 블록도가 도시된다. NNU(121)는 512개의 NPU들(126), 그 어드레스 입력(123)을 수신하는 데이터 RAM(122), 및 그 어드레스 입력(125)을 수신하는 웨이트 RAM(124)을 포함한다. 도시되지는 않았지만, 클록 0에서, 512개의 NPU들(126)은 초기화 명령을 수행한다. 도시된 바와 같이, 클록 1에서, 행 17의 512개의 16-비트 데이터 워드들은 데이터 RAM(122)으로부터 판독되고, 512개의 NPU들(126)에 제공된다. 클록 1 내지 클록 512에서, 행 0 내지 행 511의 512개의 16-비트 데이터 워드들은 각각 웨이트 RAM(124)으로부터 판독되고, 512개의 NPU들(126)에 제공된다. 도시되지는 않았지만, 클록 1에서, 512개의 NPU들(126)은 로딩된 데이터 워드들 및 웨이트 워드들에 대한 각 곱-누산 동작들을 수행한다. 클록 2 내지 클록 512에서, 512개의 NPU들(126)의 mux-reg(208)는 데이터 RAM(122)의 행 17의 이전에 로딩된 데이터 워드들을 인접한 NPU(126)로 회전시키기 위하여 512개의 16-비트 워드 회전자로서 동작하고, NPU들(126)은 웨이트 RAM(124)으로부터 로딩된 각 회전된 데이터 워드 및 각 웨이트 워드에 대한 곱-누산 동작을 수행한다. 도시되지는 않았지만, 클록 513에서, 512개의 AFU들(212)은 활성 명령을 수행한다. 클록 514에서, 512개의 NPU들(126)은 그들의 각 512개의 16-비트 결과들(133)을 데이터 RAM(122)의 행 16에 다시 기입한다.
관찰되는 바와 같이, 생성되어 데이터 RAM(122) 또는 웨이트 RAM(124)에 다시 기입되는 결과 워드들(뉴런 출력들)을 생성하기 위하여 필요한 클록들의 수는 대략 신경망의 현재 층에 의해 수신된 데이터 입력들(연결들)의 수의 제곱이다. 예컨대, 현재의 층이 512개의 뉴런들을 갖고 각 뉴런이 이전 층으로부터 512개의 연결을 갖는다면, 연결의 총 수는 256K이고, 현재의 층에 대한 결과들을 생성하기 위해 요구되는 클록들의 수는 512를 약간 초과한다. 따라서, NNU(121)는 신경망 계산들을 위한 극히 높은 성능을 제공한다.
이제, 도 6b를 참조하면, 흐름도는 예컨대, NNU(121)를 사용하는 아키텍쳐 프로그램을 수행하여, 도 4의 프로그램에 의해 수행되는 것과 같은 인공 신경망의 숨겨진 층과 관련된 곱-누산-활성함수의 계산들을 수행하기 위한 도 1의 프로세서의 동작을 도시한다. 도 6b의 예는 4개의 숨겨진 층들(블록(602)에서 NUM_LAYERS 변수의 초기화로 표시된)에 대한 계산들을 간주하고, 각 층은 512개의 뉴런들을 갖고, 각 뉴런은 (도 4의 프로그램의 사용을 통해) 이전 층의 512개의 뉴런들에 완전히 연결된다. 그러나, 층들 및 뉴런들의 이들 수는 예시 목적들을 위해 선택되었고, NNU(121)가 상이한 수의 숨겨진 층들 및 층마다 상이한 수의 뉴런들에 대해 및 완전히 연결되지 않은 뉴런들에 대해 유사한 계산들을 수행하기 위하여 채용될 수 있음을 이해해야 한다. 일 실시예에 있어서, 웨이트들은 한 층 내에서 존재하지 않는 뉴런들에 대해 또는 뉴런에 대해 존재하지 않는 연결들에 대해 0으로 설정될 수 있다. 바람직하게, 아키텍쳐 프로그램은 제1 세트의 웨이트들을 웨이트 RAM(124)에 기입하며, NNU(121)를 개시하고, NNU(121)가 제1 층과 관련된 계산들을 수행하는 동안, 아키텍쳐 프로그램은 제 2 세트의 웨이트들을 웨이트 RAM(124)에 기입하여, NNU(121)가 제1 숨겨진 층에 대한 계산들을 종료하자마자, NNU(121)는 제 2 층에 대한 계산들을 시작할 수 있게된다. 이러한 방식으로, 아키텍쳐 프로그램은 NNU(121)가 완전히 사용된 채로 유지하기 위하여 웨이트 RAM(124)의 2개의 영역들 사이에서 앞뒤로 반복한다. 흐름은 블록(602)에서 시작한다.
블록(602)에서, 프로세서(100), 즉 프로세서(100) 상에서 실행중인 아키텍쳐 프로그램은, 도 6a에 관해 도시되고 기술된 바와 같이, 뉴런들의 현재의 숨겨진 층에 대한 입력값들을 데이터 RAM(122)에, 예컨대 데이터 RAM(122)의 행 17에 입력한다. 대안적으로, 값들은 이전 층(예, 컨벌루션, 풀링 또는 입력 층)에 대한 NNU(121)의 동작의 결과들(133)로서 데이터 RAM(122)의 행 17 내에 이미 존재할 수 있다. 덧붙여, 아키텍쳐 프로그램은 변수 N을 1의 값으로 초기화한다. 변수 N은 NNU(121)에 의해 처리되고 있는 숨겨진 층들의 현재의 층을 나타낸다. 추가적으로, 이 예에서 4개의 숨겨진 층들이 존재하기 때문에, 아키텍쳐 프로그램은 변수 NUM_LAYERS를 4의 값으로 초기화한다. 흐름은 블록(604)으로 진행한다.
블록(604)에서, 프로세서(100)는 층 1에 대한 웨이트 워드들을 도 6a에 도시된 바와 같이 웨이트 RAM(124)에, 예컨대 행 0 내지 행 511에 기입한다. 흐름은 블록(606)으로 진행한다.
블록(606)에서, 프로세서(100)는, 프로그램 메모리(129)를 기입하기 위한 함수(1432)를 지정하는 MTNN(1400)의 명령을 사용하여, 곱-누산-활성함수 프로그램(예, 도 4의)을 NNU(121) 프로그램 메모리(129)에 기입한다. 프로세서(100)는 이후 프로그램의 실행을 시작하기 위한 함수(1432)를 지정하는 MTNN(1400) 명령을 사용하여 NNU 프로그램을 시작한다. 흐름은 결정 블록(608)으로 진행한다.
결정 블록(608)에서, 아키텍쳐 프로그램은 변수 N의 값이 NUM_LAYERS보다 작은지의 여부를 결정한다. 만약 작다면, 흐름은 블록(612)으로 진행하고; 그렇지 않을 경우 흐름은 블록(614)으로 진행한다.
블록(612)에서, 프로세서(100)는 층 N+1에 대한 웨이트 워드들을 웨이트 RAM(124)에, 예컨대 행 512 내지 행 1023에 기입한다. 따라서, 유리하게 아키텍쳐 프로그램은, NNU(121)가 현재 층에 대한 숨겨진 층의 계산을 수행하고 있는 동안, 다음 층에 대한 웨이트 워드들을 웨이트 RAM(124)에 기입하여, 현재의 층에 대한 계산들이 일단 종료되면, 즉 데이터 RAM(122)에 기입되면, NNU(121)가 다음 층에 대한 숨겨진 층의 계산을 수행하는 것을 즉시 시작할 수 있게 된다. 흐름은 블록(614)으로 진행한다.
블록(614)에서, 프로세서(100)는 현재 실행중인 NNU 프로그램(층 1의 경우 블록(606)에서 시작되고, 층 2 내지 층 4의 경우 블록(618)에서 시작되는)이 종료된 것을 결정한다. 바람직하게, 프로세서(100)는 NNU(121) 상태 레지스터(127)를 판독하기 위하여 MFNN(1500)의 명령을 실행함으로써 이것을 결정한다. 다른 실시예에 있어서, NNU(121)는 곱-누산-활성함수 층 프로그램을 완료하였음을 나타내기 위한 인터럽트를 생성한다. 흐름은 결정 블록(616)으로 진행한다.
결정 블록(616)에서, 아키텍쳐 프로그램은 변수 N의 값이 NUM_LAYERS보다 작은지를 결정한다. 만약 작다면, 흐름은 블록(618)으로 진행하고; 그렇지 않을 경우, 흐름은 블록(622)으로 진행한다.
블록(618)에서, 프로세서(100)는 층 N+1에 대한 숨겨진 층의 계산들을 수행할 수 있도록, 곱-누산-활성함수 프로그램을 경신한다. 더 구체적으로, 프로세서(100)는 도 4의 어드레스 1에서 곱-누산 명령의 데이터 RAM(122)의 행 값을 이전 층이 그 결과를 기입한 데이터 RAM(122)의 행(예컨대 행 16)으로 경신하고, 또한 출력 행을 경신한다(예, 행 15으로). 프로세서(100)는 이후 경신된 NNU 프로그램을 시작한다. 대안적으로, 도 4의 프로그램은 어드레스 1에서 곱-누산 명령에서 지정된 행과 어드레스 4의 출력 명령에서 동일한 행(즉, 데이터 RAM(122)으로부터 판독된 행)을 지정한다. 본 실시예에 있어서, 입력 데이터 워드의 현재의 행은 덮어쓰여진다(이는 데이터 워드들의 행이 일부 다른 목적을 위해 필요하지 않는 한 허용 가능한데, 왜냐하면 데이터 워드들의 행이 이미 mux-reg(208) 안으로 판독되었고, N-워드의 회전자를 통해 NPU들(126) 중에서 회전되고 있기 때문이다). 본 경우에 있어서, 블록(618)에서 NNU 프로그램의 어떠한 경신도 필요하지 않고, 오로지 이의 재시작만이 필요하다. 흐름은 블록(622)으로 진행한다.
블록(622)에서, 프로세서(100)는 층 N에 대해 데이터 RAM(122)으로부터 NNU 프로그램의 결과를 판독한다. 그러나, 결과들이 다음 층에 의해 단순히 사용되어야 한다면, 아키텍쳐 프로그램은 데이터 RAM(122)으로부터 결과들을 판독할 필요는 없을 것이지만, 대신에 다음의 숨겨진 층의 계산들을 위해 데이터 RAM(122)에서 그들을 남겨둘 수 있다. 흐름은 결정 블록(624)으로 진행한다.
결정 블록(624)에서, 아키텍쳐 프로그램은 변수 N의 값이 NUM_LAYERS보다 작은지를 결정한다. 만약 작다면, 흐름은 블록(626)으로 진행하고; 그렇지 않을 경우, 흐름은 종료된다.
블록(626)에서, 아키텍쳐 프로그램은 1만큼 N을 증가시킨다. 흐름은 결정 블록(608)으로 진행한다.
도 6b의 예로부터 결정될 수 있는 바와 같이, 대략 매 512 클록 사이클들에서 NPU들(126)은 데이터 RAM(122)으로부터 한 번 판독되고, 데이터 RAM(122)에 한 번 기입된다(도 4의 NNU 프로그램의 동작 때문에). 추가적으로, NPU들(126)은 웨이트 워드들의 한 행을 판독하기 위하여 대략 매 클록 사이클마다 웨이트 RAM(124)을 판독한다. 따라서, 웨이트 RAM(124)의 전체 대역폭은 NNU(121)가 숨겨진 층의 동작을 수행하는 하이브리드 방식에 의해 소비된다. 추가적으로, 도 17의 버퍼(1704)와 같은 기입 및 판독 버퍼를 포함하는 실시예를 가정하면, NPU(126)가 판독하는 것과 동시에, 프로세서(100)가 웨이트 RAM(124)에 기입하여, 버퍼(1704)는 웨이트 워드들을 판독하기 위하여 대략 매 16개의 클록 사이클들마다 웨이트 RAM(124)에 한 번의 기입을 수행하게 된다. 따라서, 웨이트 RAM(124)의 단일 포트로 이루어진 실시예(도 17에 대해 기술된 것과 같은)에서, 대략 매 16개 클록 사이클들마다, NPU들(126)은 버퍼(1704)가 웨이트 RAM(124)에 기입하는 것이 가능하도록 웨이트 RAM(124)을 판독하는 것으로부터 지연되어야 한다. 그러나, 웨이트 RAM(124)이 이중-포트로 이루어진 실시예에서, NPU들(126)은 지연될 필요가 없다.
이제, 도 7을 참조하면, 다른 실시예에 따른 도 1의 NPU(126)를 도시하는 블록도가 도시된다. 도 7의 NPU(126)는 많은 관점에서 도 2의 NPU(126)와 유사하다. 그러나, 도 7의 NPU(126)는 추가적으로 제 2의 2-입력 mux-reg(705)를 포함한다. mux-reg(705)는 그 입력들(206 또는 711) 중 하나를 선택하여, 그 레지스터에 저장하고 이후 후속 클록 사이클에 그 출력(203)에 제공한다. 입력(206)은 웨이트 RAM(124)으로부터 웨이트 워드를 수신한다. 다른 입력(711)은 인접한 NPU(126)의 제 2 mux-reg(705)의 출력(203)을 수신한다. 바람직하게, NPU J의 mux-reg(705)의 입력(711)은 NPU(126)의 예 J-1의 mux-reg(705)의 출력(203)을 수신하고, NPU J의 출력은 NPU(126)의 예 J+1의 mux-reg(705)의 입력(711)에 제공된다. 이러한 방식으로, N개의 NPU들(126)의 mux-reg들(705)은 도 3에 관해 상술한 방식과 유사하게, 하지만 데이터 워드들이 아니라 웨이트 워드들에 대해, 집단적으로 N-워드 회전자로서 동작한다. 제어 입력(713)은 mux-reg(705)가 그 레지스터에 저장하기 위해 2개의 입력들 중 어느 것을 선택할지를 제어하고, 이는 후속적으로 출력(203)에 제공된다.
데이터 RAM(122) 및/또는 웨이트 RAM(124)으로부터 수신된 행의 데이터/웨이트들을 회전시키는 대형 회전자를 효과적으로 형성하기 위하여 mux-reg(208) 및/또는 mux-reg(705)(도 18 및 도 23의 것과 같은 다른 실시예들의 mux-reg들과 함께)를 포함하는 것은, NNU(121)가 필요한 데이터/웨이트 워드들을 적절한 NNU(121)에 제공하기 위하여, 그렇지 않을 경우 데이터 RAM(122) 및/또는 웨이트 RAM(124) 사이에서 요구될 극히 큰 mux를 필요로 하지 않는다는 장점을 갖는다.
활성함수 결과에 추가한 누산기 값들의 재기입
일부 출원들에 있어서, 프로세서(100)가 미처리 누산기(202)의 값(217)을 다시 (예, 도 15의 MFNN 명령을 통해 미디어 레지스터들(118)로) 수신하는 것이 유용하고, 다른 실행 유닛(112) 상에서 실행중인 명령들은 이러한 미처리 누산기(202)의 값(217)에 대한 계산들을 수행할 수 있다. 예컨대, 일 실시예에 있어서, AFU(212)의 복잡성을 감소시키기 위하여, 소프트맥스 활성 기능을 수행하는 것이 구성되지 않는다. 결과적으로, NNU(121)는 미처리 누산기(202)의 값(217), 또는 이의 서브세트를 데이터 RAM(122) 또는 웨이트 RAM(124)에 출력할 수 있고, 아키텍쳐 프로그램이 후속적으로 미처리 값을 데이터 RAM(122) 또는 웨이트 RAM(124)으로부터 판독하고, 미처리 값들에 대한 계산들을 수행한다. 그러나, 미처리 누산기(202)의 값(217)의 사용은 소프트맥스의 성능에 국한되지 않고, 다른 용도들이 고려된다.
이제 도 8을 참조하면, 다른 실시예에 따른 도 1의 NPU(126)를 도시하는 블록도가 도시된다. 도 8의 NPU(126)는 많은 관점에서 도 2의 NPU(126)와 유사하다. 그러나, 도 8의 NPU(126)는 제어 입력(803)을 갖는 AFU(212) 내에 멀티플렉서(mux)(802)를 포함한다. 누산기(202)의 폭(비트수)은 데이터 워드의 폭보다 크다. mux(802)는 누산기(202)의 출력(217) 중 데이터 워드-폭 부분들을 수신하는 다수의 입력들을 갖는다. 일 실시예에 있어서, 누산기(202)의 폭은 41 비트이고, NPU(126)는 16비트인 결과 워드(133)를 출력하도록 구성된다, 따라서 예컨대 mux(802)(또는 도 30의 mux(3032) 및/또는 mux(3037))는 누산기(202)의 출력(217) 중 비트들[15:0], 비트들[31:16] 및 비트들[47:32]을 각각 수신하는 3개의 입력을 갖는다. 바람직하게, 누산기(202)에 의해 제공되지 않는 출력 비트들(예, 비트들[47:41])은 0값의 비트들로 강제된다.
시퀀서(128)는 제어 입력(803) 상의 값을 생성하고, 이 값은 mux(802)가 아래에서 기술되는 도 9의 어드레스 3 내지 어드레스 5에서 기입 ACC 명령들과 같은 기입 ACC 명령에 응답하여 누산기(202)의 워드들(예, 16비트들) 중 하나를 선택하도록 제어한다. 바람직하게, mux(80)는 또한, 데이터 워드의 폭인 출력들을 생성하는 활성함수 회로들(예, 도 30의 요소들(3022, 3024, 3026, 3018, 3014, 및 3016))의 출력을 수신하는 하나 이상의 입력들을 갖는다. 시퀀서(128)는, 도 4의 어드레스 4에서의 기입 AFU 출력 명령과 같은 명령에 응답하여, 누산기(202)의 워드들 중 하나가 아니라, 활성함수 회로 출력들 중 하나를 mux(802)가 선택하도록 제어하기 위한 제어 입력(803) 상의 값을 생성한다.
이제 도 9를 참조하면, 도 1의 NNU(121)의 프로그램 메모리(129)에 저장을 위한, 및 NNU(121)에 의한 실행을 위한 프로그램을 도시하는 테이블이 도시된다. 도 9의 예시적인 프로그램은 많은 양상에서 도 4의 프로그램과 유사하다. 특별히, 어드레스 0 내지 어드레스 2에서의 명령들은 동일하다. 그러나, 도 4의 어드레스 3 및 어드레스 4에서의 명령들은 도 9에서 기입 ACC 명령들로 대체되고, 이러한 기입 ACC 명령들은 512개의 NPU들(126)이 다시 그들의 누산기(202)의 출력(217)을 결과들(133)로서 데이터 RAM(122)의 3개의 행들(본 예에서, 행 16 내지 행 18)에 기입하도록 명령한다. 즉, 기입 ACC 명령은 시퀀서(128)가, 제1 클록 사이클에서 데이터 RAM의 어드레스(123)의 값 16과 기입 명령을 출력하고, 제 2 클록 사이클에서 데이터 RAM의 어드레스(123)의 값 17과 기입 명령을 출력하고, 제 3 클록 사이클에서 데이터 RAM의 어드레스(123)의 값 18과 기입 명령을 출력하도록 명령한다. 바람직하게, 기입 ACC 명령의 실행은 다른 명령의 실행과 중첩될 수 있어서, 기입 ACC 명령은 데이터 RAM(122)에 기입된 각 행에 대해 하나씩, 3개의 클록 사이클들에서 효과적으로 실행된다. 일 실시예에 있어서, 사용자는 데이터 RAM(122) 또는 웨이트 RAM(124)에 대한 누산기(202)의 원하는 부분들의 기입을 달성하기 위하여, (도 29a)의 제어 레지스터(127) 내의 활성함수(2934) 및 출력 명령(2956)의 필드들의 값들을 지정한다. 대안적으로, 누산기(202)의 전체 내용들을 다시 기입하는 것보다, 기입 ACC 명령은 선택적으로 누산기(202)의 서브세트를 다시 기입할 수 있다. 일 실시예에 있어서, 누산기(202)의 규정형(canonical form)은 도 29 내지 도 31에 관해 아래에서 더 상세하게 기술되는 바와 같이, 다시 기입될 수 있다.
이제 도 10을 참조하면, NNU(121)에 의한 도 9의 프로그램의 실행을 도시하는 타이밍도가 도시된다. 도 10의 타이밍도는 도 5의 타이밍도와 유사하고, 클록 0 내지 클록 512는 동일하다. 그러나, 클록들(513-515)에서, 512개의 NPU들(126)의 각각의 AFU(212)는 도 9의 어드레스 3 내지 어드레스 9에서의 기입 ACC 명령들 중 하나를 수행한다. 특히, 클록 513에서, 512개의 NPU들(126)의 각각은 데이터 RAM(122)의 행 16의 대응하는 워드에 그 결과(133)로서 누산기(202)의 출력(217)의 비트들[15:0]을 다시 기입하고, 클록 514에서, 512개의 NPU들(126)의 각각은 데이터 RAM(122)의 행 17의 대응하는 워드에 그 결과(133)로서 누산기(202)의 출력(217)의 비트들[31:16]을 다시 기입하고, 클록 515에서, 512개의 NPU들(126)의 각각은 데이터 RAM(122)의 행 18의 대응하는 워드에 그 결과(133)로서 누산기(202)의 출력(217)의 비트들[40:32]을 다시 기입한다. 바람직하게, 비트들[47:41]은 0의 값들로 강요된다.
공유된 AFU들
이제 도 11을 참조하면, 도 1의 NNU(121)의 실시예를 도시하는 블록도가 도시된다. 도 11의 실시예에서, 뉴런은 2개의 부분들, 활성함수 유닛 부분과 ALU 부분(또한 시프트 레지스터 부분을 포함하는)로 분할되고, 각 활성함수 유닛 부분은 다수의 ALU 부분들에 의해 공유된다. 도 11에서, ALU 부분들은 NPU들(126)로서 언급되고, 공유된 활성함수 유닛 부분들은 AFU들(212)로 언급된다. 이것은 예컨대 각 뉴런이 자신의 AFU(212)를 포함하는 도 2의 실시예와 대비된다. 따라서, 예컨대 일 실시예에서, 도 11의 실시예의 NPU들(126)(ALU 부분들)은 도 2의 누산기(202), ALU(204), mux-reg(208) 및 레지스터(205)를 포함하지만, AFU(212)를 포함하지는 않는다. 도 11의 실시예에서, NNU(121)는 일 예로서 512개의 NPU들(126)을 포함하지만; 다른 수의 NPU들(126)을 갖는 다른 실시예들이 고려된다. 도 11의 예에서, 512개의 NPU들(126)은 각각 8개의 NPU들(126)로 이루어진 64개의 그룹으로 구분되어지고, 이들은 도 11에서 그룹 0 내지 그룹 63으로 언급된다.
NNU(121)는 또한 하나의 행 버퍼(1104), 및 NPU들(126)과 행 버퍼(1104) 사이에 결합된 복수의 공유된 AFU들(1112)을 포함한다. 행 버퍼(1104)는 데이터 RAM(122) 또는 웨이트 RAM(124)의 한 행과 동일한 폭(비트수), 예컨대 512 워드이다. NPU(126) 그룹 당 하나의 AFU(212)가 존재하고, 각 AFU(1112)는 대응하는 NPU(126) 그룹을 갖는다; 따라서 도 11의 실시예에서, 64개의 NPU(126) 그룹들에 대응하는 64개의 AFU들(1112)이 존재한다. 한 그룹 내의 8개의 NPU들(126)의 각각은 대응하는 AFU(1112)를 공유한다. 그룹당 상이한 수의 AFU들(1112) 및 NPU들(126)을 갖는 다른 실시예들이 고려된다. 예컨대, 한 그룹 내에서 2개, 또는 4개 또는 16개의 NPU들(126)이 하나의 AFU(1112)를 공유하는 다른 실시예가 고려된다.
AFU들(1112)을 공유하는 것에 대한 동기부여는 NNU(121)의 크기를 감소시키는 것이다. 크기 감소는 성능 축소의 비용으로 얻어진다. 즉, 이것은 도 12에서 설명되는 바와 같이, NPU들(126)의 전체 어레이에 대해 결과들(133)을 생성하기 위하여, 공유 비율에 따라 수 개의 클록들을 더 필요로 할 수 있다, 예컨대 8:1의 공유 비율로 인해 7개의 추가적인 클록 사이클들이 요구된다. 그러나, 일반적으로 말해, 추가적인 수의 클록들(예, 7)은, 생성된 누적 합에 필요한 클록들의 수(예, 뉴런당 512개의 연결들을 갖는 한 층에 대해 512개의 클록들)에 비해 상대적으로 작다. 따라서, 상대적으로 작은 성능 충격(예, 계산 시간에서 1% 증가)은 NNU(121)의 감소된 크기에 대해 가치있는 교환이다.
일 실시예에 있어서, NPU들(126)의 각각은 상대적으로 단순한 활성함수들을 수행하는 AFU(212)를 포함하고, 따라서 단순한 AFU들(212)이 상대적으로 작아지고, 따라서 각 NPU(126)에 포함되는 것을 가능케 하고; 반면, 공유된 또는 복잡한 AFU들(212)은 상대적으로 복잡한 활성함수들을 수행하고, 따라서 단순한 AFU들(212)보다 상대적으로 상당히 크다. 이러한 실시예에 있어서, 추가적인 클록 사이클들은 복잡한 AFU(1112)의 공유를 필요로 하는 복합한 활성함수가 지정될 때 오로지 필요하지만, 단순한 AFU(212)가 수행되도록 구성되는 활성함수가 지정될 때에는 필요하지 않는다.
이제 도 12 및 도 13을 참조하면, 도 11의 NNU(121)에 의한 도 4의 프로그램의 실행을 도시하는 2개의 타이밍도가 도시된다. 도 12의 타이밍도는 도 5의 타이밍도와 유사하고, 클록 0 내지 클록 512는 동일하다. 그러나, 클록 513에서 동작은 도 5의 타이밍도에서 기술된 것과 상이한데, 왜냐하면 도 11의 NPU들(126)이 AFU들(1112)을 공유하기 때문이다, 즉 한 그룹의 NPU들(126)은 그 그룹과 관련된 AFU(1112)를 공유하고, 도 11은 이러한 공유를 도시한다.
도 13의 타이밍도의 각 행은 제1 열에서 표시된 연속적인 클록 사이클에 대응한다. 다른 열들의 각각은 64개의 AFU들(1112)의 상이한 하나에 대응하고, 그 동작을 표시한다. 도시의 단순화 및 명확성을 위해, 오로지 AFU들 0, 1 및 63을 위한 동작들만이 도시된다. 도 13의 클록 사이클들은 도 12의 클록 사이클들에 대응하지만, NPU들(126)에 의한 AFU들(1112)의 공유를 상이한 방식으로 도시한다. 클록들 0-512에서, 64개의 AFU들(1112)의 각각은 도 13에 도시된 바와 같이 비활성이고, 반면에 NPU들(126)은 초기화 NPU 및 곱-누산 및 곱-누산 회전 명령들을 수행한다.
도 12 및 도 13 모두에서 도시된 바와 같이, 클록 513에서, AFU 0(그룹 0과 관련된 AFU(1112))은 그룹 0에서 첫 번째 NPU(126)인 NPU 0의 누산기(202)의 값(217)에 대해 지정된 활성함수를 수행하기 시작하고, AFU 0의 출력은 행 버퍼(1104)의 워드 0에 저장될 것이다. 또한, 클록 513에서, AFU들(1112)의 각각은 NPU들(126)의 대응하는 그룹 내의 첫 번째 NPU(126)의 누산기(202)에 대해 지정된 활성함수를 수행하기 시작한다. 따라서, 클록 513 내에서, 도 13에 도시된 바와 같이, AFU 0은 NPU 0의 누산기(202)에 대해 지정된 활성함수를 수행하기 시작하여 행 버퍼(1104)의 워드 0에 저장될 결과를 생성하고; AFU 1은 NPU 8의 누산기(202)에 대해 지정된 활성함수를 수행하기 시작하여 행 버퍼(1104)의 워드 8에 저장될 결과를 생성하고; 이와 같은 방식으로 AFU 63은 NPU 504의 누산기(202)에 대해 지정된 활성함수를 수행하기 시작하여 행 버퍼(1104)의 워드 504에 저장될 결과를 생성한다.
클록 514에서, AFU 0(그룹 0과 관련된 AFU(1112))은 그룹 0에서 두 번째 NPU(126)인 NPU 1의 누산기(202)의 값(217)에 대해 지정된 활성함수를 수행하기 시작하고, 도시된 바와 같이 AFU 0의 출력은 행 버퍼(1104)의 워드 1에 저장될 것이다. 또한, 클록 514에서, AFU들(1112)의 각각은 NPU들(126)의 대응하는 그룹 내의 두 번째 NPU(126)의 누산기(202)에 대해 지정된 활성함수를 수행하기 시작한다. 따라서, 클록 514 내에서, 도 13에 도시된 바와 같이, AFU 0은 NPU 1의 누산기(202)에 대해 지정된 활성함수를 수행하기 시작하여 행 버퍼(1104)의 워드 1에 저장될 결과를 생성하고; AFU 1은 NPU 9의 누산기(202)에 대해 지정된 활성함수를 수행하기 시작하여 행 버퍼(1104)의 워드 9에 저장될 결과를 생성하고; 이와 같은 방식으로 AFU 63은 NPU 505의 누산기(202)에 대해 지정된 활성함수를 수행하기 시작하여 행 버퍼(1104)의 워드 505에 저장될 결과를 생성한다. 이러한 패턴은, 클록 사이클 520에서, AFU 0(그룹 0과 관련된 AFU(1112))이 그룹 0에서 여덟번째(마지막) NPU(126)인 NPU 7의 누산기(202)의 값(217)에 대해 지정된 활성함수를 수행하기 시작하고, AFU 0의 출력이 도시된 바와 같이 행 버퍼(1104)의 워드 7에 저장될 때까지 지속된다. 또한, 클록 520에서, AFU들(1112)의 각각은 NPU들(126)의 대응하는 그룹 내의 여덟번째 NPU(126)의 누산기(202)에 대해 지정된 활성함수를 수행하기 시작한다. 따라서, 클록 520 내에서, 도 13에 도시된 바와 같이, AFU 0은 NPU 7의 누산기(202) 지정된 활성함수를 수행하기 시작하여 행 버퍼(1104)의 워드 7에 저장될 결과를 생성하고; AFU 1은 NPU 15의 누산기(202)에 대해 지정된 활성함수를 수행하기 시작하여 행 버퍼(1104)의 워드 15에 저장될 결과를 생성하고; 이와 같은 방식으로 AFU 63은 NPU 511의 누산기(202)에 대해 지정된 활성함수를 수행하기 시작하여 행 버퍼(1104)의 워드 511에 저장될 결과를 생성한다.
클록 521에서, 일단 512개의 NPU들(126)과 관련된 모든 512개의 결과가 생성되어 행 버퍼(1104)에 기입되면, 행 버퍼(1104)는 그 내용을 데이터 RAM(122) 또는 웨이트 RAM(124)에 기입하기 시작한다. 이러한 방식으로, NPU들(126)의 64개의 그룹들의 각각의 AFU(1112)는 도 4의 어드레스 3에서 활성함수 명령의 일부를 수행한다.
ALU들(204)의 그룹들 중에서 AFU들(1112)을 공유하는 도 11의 실시예와 같은 실시예들은, 예컨대 도 29a 내지 도 33에 관해 아래에서 더 상세하게 기술되는 바와 같이 내부 ALU들(204)와 관련하여 특히 유리할 수 있다.
MTNN 및 MFNN 의 아키텍쳐 명령들
이제 도 14를 참조하면, 신경망으로의 이동(MTNN)의 아키텍쳐 명령(1400) 및 도 1의 NNU(121)의 부분들에 관한 그 동작을 도시하는 블록도가 도시된다. MTNN 명령(1400)은 연산코드(opcode) 필드(1402), src1 필드(1404), src2 필드(1406), gpr 필드(1408), 및 즉시(immediate) 필드(1412)를 포함한다. MTNN 명령(1400)은 아키텍쳐 명령이다, 즉 이것은 프로세서(100)의 명령 세트 구조에 포함된다. 바람직하게, 명령 세트 구조는 연산코드 필드(1402)의 미리 결정된 값을 MTNN 명령(1400)과 관련시켜, 이를 명령 세트 구조 내의 다른 명령들과 구별한다. MTNN 명령(1400)의 연산코드(1402)는 예컨대 x86 구조 내에서 공통인 프리픽스(prefix)들을 포함할 수 있거나 포함하지 않을 수 있다.
즉시 필드(1412)는 NNU(121)의 로직(1434)을 제어하는 함수(1432)를 지정하는 값을 제공한다. 바람직하게, 함수(1432)는 도 1의 마이크로명령(105)의 즉시 피연산자로서 제공된다. NNU(121)에 의해 수행될 수 있는 함수들(1432)은, 데이터 RAM(122)에 기입, 웨이트 RAM(124)에 기입, 프로그램 메모리(129)에 기입, 제어 레지스터(127)에 기입, 프로그램 메모리(129) 내의 프로그램의 실행의 시작, 프로그램 메모리(129) 내의 프로그램의 실행의 중지, 프로그램 메모리(129) 내의 프로그램의 실행의 종료의 요청 통보(예, 인터럽트), 및 NNU(121)의 리세팅을 포함하지만, 이에 국한되지는 않는다. 바람직하게, NNU 명령 세트는 NNU 프로그램이 종료되었음을 나타내는 결과를 갖는 명령을 포함한다. 대안적으로, NNU 명령 세트는 명시적인 생성 인터럽트 명령을 포함한다. 바람직하게, NNU(121)의 리세팅은 데이터 RAM(122), 웨이트 RAM(124), 및 프로그램 메모리(129)의 내용들이 본래대로 남겨지는 것을 제외하고, NNU(121)를 다시 리셋 상태로 유효하게 강제하는 것(예, 내부 상태 머신이 소거되어, 휴지(Idle) 상태로 설정된다)을 포함한다. 추가적으로, 누산기(202)와 같은 내부 레지스터들은 리셋 함수에 의해 영향을 받지 않고, 예컨대 도 4의 어드레스 0에서 초기화 NPU 명령에 의해 명시적으로 소거되어야 한다. 일 실시예에 있어서, 함수(1432)는 제1 소스 레지스터가 마이크로-동작(예컨대 도 34의 마이크로-동작(3418)을 참조)를 포함하는 직접 실행 함수를 포함할 수 있다. 직접 실행 함수는 NNU(121)가 지정된 마이크로-동작을 직접 실행하도록 명령한다. 이러한 방식으로, 아키텍쳐 프로그램은, 명령들을 프로그램 메모리(129)에 기입한 후 NNU(121)가 MTNN 명령(1400)(또는 도 15의 MFNN 명령(1500))을 실행함으로써 프로그램 메모리 내의 명령들을 실행하도록 명령하는 것이 아니라, NNU(121)가 동작들을 수행하도록 직접 제어할 수 있다. 도 14는 데이터 RAM(122)에 기입하는 함수(1432)의 예를 도시한다.
gpr 필드(1408)는 범용 레지스터 파일(116) 내의 GPR(General Purpose Register) 중 하나를 지정한다. 일 실시예에 있어서, 각 GPR은 64비트이다. 범용 레지스터 파일(116)은 선택된 GPR로부터의 값을 NNU(121)에 제공하고, 도시된 바와 같이 NNU(121)는 이 값을 어드레스(1422)로서 사용한다. 어드레스(1422)는 함수(1432)에서 지정된 메모리의 한 행을 선택한다. 데이터 RAM(122) 및 웨이트 RAM(124)의 경우, 어드레스(1422)는 선택된 행 내에서 미디어 레지스터 위치의 크기(예, 512비트)의 두 배인 청크(chunk)를 추가적으로 선택한다. 바람직하게, 이러한 위치는 512-비트 경계상에 놓인다. 일 실시예에 있어서, 멀티플렉서는 어드레스(1422)(또는 아래에서 기술되는 MFNN 명령(1400)의 경우 어드레스(1422)) 또는 데이터 RAM(122)/웨이트 RAM(124)/프로그램 메모리(129)로의 제공을 위한 시퀀서(128)로부터의 어드레스(123/125/131)를 선택한다. 일 실시예에 있어서, 아래에서 더 상세하게 기술되는 바와 같이, 데이터 RAM(122)은 NPU들(126)이, 미디어 레지스터들(118)이 데이터 RAM(122)을 판독/기입하는 것과 동시에 데이터 RAM(122)을 판독/기입하는 것을 허용하기 위하여 2중-포트로 이루어진다. 일 실시예에 있어서, 웨이트 RAM(124)은 유사한 목적을 위해 또한 2중-포트로 이루어진다.
src1 필드(1404) 및 src2 필드(1406) 각각은 미디어 레지스터 파일(118) 내의 미디어 레지스터를 지정한다. 일 실시예에 있어서, 각 미디어 레지스터(118)는 256 비트이다. 미디어 레지스터 파일(118)은 선택된 미디어 레지스터들로부터의 연결된 데이터(예, 512 비트들)를, 도시된 바와 같이 어드레스(1422)에 의해 지정된 선택된 행(1428)에 및 선택된 행(1428) 내의 어드레스(1422)에 의해 지정된 위치에 기입하기 위해, 데이터 RAM(122)(또는 웨이트 RAM(124) 또는 프로그램 메모리(129))에 제공한다. 유리하게, 일련의 MTNN 명령들(1400)(및 아래에서 기술된 MFNN 명령들(1400))을 실행함으로써, 프로세서(100) 상에서 실행중인 아키텍쳐 프로그램은 데이터 RAM(122)의 행들 및 웨이트 RAM(124)의 행들을 채울 수 있고, NNU(121)로 하여금 데이터 및 웨이트들에 대한 동작을 극히 높은 속도들로 수행하여 인공 신경망을 달성하게 하기 위하여 본 명세서에서 기술된 프로그램들(예, 도 4 및 도 9의)과 같은 프로그램을 프로그램 메모리(129)에 기입할 수 있다. 일 실시예에 있어서, 아키텍쳐 프로그램은, 프로그램을 프로그램 메모리(129)에 기입하는 것이 아니라 NNU(121)를 직접 제어한다.
일 실시예에 있어서, 2개의 소스 레지스터들(예, 1404 및 1406)을 지정하는 것이 아니라, NTNN 명령(1400)은 시작 소스 레지스터 및 소스 레지스터들의 수, Q를 지정한다. 이러한 형태의 MTNN 명령(1400)은 프로세서(100)로 하여금 시작 소스 레지스터로 지정된 미디어 레지스터(118) 및 다음의 Q-1개의 순차적인 미디어 레지스터들(118)을 NNU(121)에, 즉 지정된 데이터 RAM(122) 또는 웨이트 RAM(124)에 기입하도록 명령한다. 바람직하게, 명령 변환기(104)는 MTNN 명령(1400)을, 모든 Q개의 지정된 미디어 레지스터들(118)을 기입하기 위해 필요한 만큼 많은 마이크로명령들로 변환한다. 예컨대, 일 실시예에 있어서, MTNN 명령(1400)은 시작 소스 레지스터를 MR4로 지정하고, Q가 8일 때, 명령 변환기(104)는 MTNN 명령(1400)을 4개의 마이크로명령들로 변환하고, 이들 중 제1의 마이크로명령은 MR4 및 MR5를 기입하고, 이들 중 제 2의 마이크로명령은 MR6 및 MR7을 기입하고, 이들 중 제 3의 마이크로명령은 MR8 및 MR9를 기입하고, 이들 중 제 4의 마이크로명령은 MR10 및 MR11을 기입한다. 미디어 레지스터들(118)로부터 NNU(121)까지의 데이터 경로가 512 비트가 아니라 1024 비트인 다른 실시예에서, 명령 변환기(104)는 MTNN 명령(1400)을 2개의 마이크로명령들로 변환하고, 이들 중 제1 마이크로명령은 MR4 내지 MR7을 기입하고, 이들 중 제 2의 마이크로명령은 MR8 내지 MR11을 기입한다. 단일 미디어 레지스터(118)보다는 MFNN 명령(1500) 마다 데이터 RAM(122) 또는 웨이트 RAM(124)의 한 행의 더 큰 청크들의 판독을 가능케 하기 위하여, MFTN 명령(1500)이 시작 목적지 레지스터 및 목적지 레지스터들의 수를 지정하는 유사한 실시예가 고려된다.
이제, 도 15를 참조하면, 신경망으로부터의 이동(MFNN)의 아키텍쳐 명령(1500) 및 도 1의 NNU(121)의 부분들에 대한 이의 동작을 도시하는 블록도가 도시된다. MFNN 명령(1500)은 연산코드 필드(1502), dst 필드(1504), gpr 필드(1508), 및 즉시 필드(1512)를 포함한다. MFNN 명령(1500)은 아키텍쳐 명령이다, 즉 이 명령은 프로세서(100)의 명령 세트 구조에 포함된다. 바람직하게, 명령 세트 구조는 연산코드 필드(1502)의 미리 결정된 값을 MFNN 명령(1500)과 관련시켜, 이를 명령 세트 구조 내의 다른 명령과 구별한다. MFNN 명령(1500)의 연산코드(1502)는 예컨대 x86 구조에서 공통인 프리픽스들을 포함할 수 있거나 포함하지 않을 수 있다.
즉시 필드(1512)는 NNU(121)의 제어 로직(1434)에 함수(1532)를 지정하는 값을 제공한다. 바람직하게, 함수(1532)는 도 1의 마이크로명령(105)의 즉시 피연산자로서 제공된다. NNU(121)에 의해 수행될 수 있는 함수들(1532)은 데이터 RAM(122)으로부터 판독, 웨이트 RAM(124)으로부터 판독, 프로그램 메모리(129)로부터 판독, 및 상태 레지스터(127)로부터 판독을 포함하지만 이에 제한되지는 않는다. 도 15는 데이터 RAM(122)으로부터 판독하는 함수(1532)의 일 예를 도시한다.
gpr 필드(1508)는 범용 레지스터 파일(116) 내의 GPR 중 하나를 지정한다. 범용 레지스터 파일(116)은 선택된 GPR로부터의 값을 NNU(121)에 제공하고, 도시된 바와 같이 NNU(121)는 이 값을 어드레스(1522)로서 사용하고, 어드레스(1522)는 함수(1532)에서 지정된 메모리의 한 행을 선택하기 위하여 도 14의 어드레스(1422)와 유사한 방식으로 동작하고, 데이터 RAM(122) 및 웨이트 RAM(124)의 경우, 어드레스(1522)는 선택된 행 내에서 미디어 레지스터 위치의 크기(예, 256비트)인 청크를 추가적으로 선택한다. 바람직하게, 이러한 위치는 256-비트 경계상에 놓인다.
dst 필드(1504)는 미디어 레지스터 파일(118) 내의 미디어 레지스터를 지정한다. 미디어 레지스터 파일(118)은, 도시된 바와 같이 어드레스(1522)에 의해 지정된 선택된 행(1528)으로부터 및 선택된 행(1528) 내의 어드레스(1522)에 의해 지정된 위치로부터 판독된 데이터 RAM(122)(또는 웨이트 RAM(124) 또는 프로그램 메모리(129))로부터 선태된 미디어 레지스터 안으로 데이터(예, 256 비트)를 수신한다.
NNU 내부 RAM 포트 구성들
이제, 도 16을 참조하면, 도 1의 데이터 RAM(122)의 실시예를 도시하는 블록도가 도시된다. 데이터 RAM(122)은 메모리 어레이(1606), 판독 포트(1602), 및 기입 포트(1604)를 포함한다. 메모리 어레이(1606)는 데이터 워드들을 유지하고, 상술한 바와 같이 바람직하게 N개 워드들의 D개 열들로 구성된다. 일 실시예에 있어서, 메모리 어레이(1606)는 각 셀들이 128 비트 폭 및 64 비트 높이인 64개의 수평으로 배열된 정적 RAM 셀들의 어레이를 포함하여, 8192 비트 폭이고 64개 행들을 갖는 64KB 데이터 RAM(122)을 제공하고, 데이터 RAM(122)은 다이 영역의 대략 0.2 제곱 밀리미터를 점유한다. 그러나, 다른 실시예들이 고려된다.
판독 포트(1602)는 바람직하게는 다중화된 방식으로 NPU들(126) 및 미디어 레지스터들(118)에 결합된다. (보다 정확하게 미디어 레지스터들(118)는, 또한 데이터를 재배열 버퍼에 제공할 수 있는 결과 버스들 및/또는 다른 실행 유닛들(112)에 대한 결과 전달 버스들을 통해, 판독 포트(1602)에 결합될 수 있다). NPU들(126) 및 미디어 레지스터들(118)은 데이터 RAM(122)을 판독하기 위해 판독 포트(1602)를 공유한다. 기입 포트(1604)는 또한 바람직하게는 다중화된 방식으로 NPU들(126)에 및 미디어 레지스터들(118)에 결합된다. NPU들(126) 및 미디어 레지스터들(118)은 데이터 RAM(122)에 기입하기 위하여 기입 포트(1604)를 공유한다. 따라서, 유리하게 미디어 레지스터들(118)은, NPU들(126)이 또한 데이터 RAM(122)으로부터 판독하는 동안, 동시에 데이터 RAM(122)에 기입할 수 있거나, 또는 NPU들(126)은, 미디어 레지스터들(118)이 데이터 RAM(122)으로부터 판독하는 동안, 동시에 데이터 RAM(122)에 기입할 수 있다. 이것은 유리하게 개선된 성능을 제공한다. 예컨대, NPU들(126)은, 미디어 레지스터들(118)이 더 많은 데이터 워드들을 데이터 RAM(122)에 기입하는 동안, (예, 계산들의 수행을 지속하기 위하여) 데이터 RAM(122)을 판독할 수 있다. 다른 예로서, NPU들(126)은, 미디어 레지스터들(118)이 데이터 RAM(122)으로부터 계산 결과들을 판독하는 동안, 계산 결과들을 데이터 RAM(122)에 기입할 수 있다. 일 실시예에 있어서, NPU들(126)은, NPU들(126)이 또한 데이터 RAM(122)으로부터 한 행의 데이터 워드들을 판독하는 동안, 한 행의 계산 결과들을 데이터 RAM(122)에 기입할 수 있다. 일 실시예에 있어서, 메모리 어레이(606)는 뱅크들로 구성된다. NPU들(126)이 데이터 RAM(122)을 접속할 때, 뱅크들 모두는 메모리 어레이(1606)의 전체 행을 접속하기 위하여 활성화되고; 반면에 미디어 레지스터들(118)이 데이터 RAM(122)을 접속할 때, 오로지 지정된 뱅크들만이 활성화된다. 일 실시예에 있어서, 각 뱅크는 128 비트폭이며, 미디어 레지스터들(118)은 256 비트폭이고, 따라서 2개의 뱅크들은 예컨대 미디어 레지스터들(118)의 접속마다 활성화된다. 일 실시예에 있어서, 포트들(1602/1604) 중 하나는 판독/기입 포트이다. 일 실시예에 있어서, 포트들(1602 및 1604) 모두는 판독/기입 포트들이다.
본 명세서에서 기술된 NPU들(126)의 회전자 성능의 장점은, 데이터 RAM(122)의 메모리 어레이(1606)가 상당히 적은 행들을 갖는 능력, 따라서 그렇지 않을 경우 NPU들(126)이 높게 이용되는 것을 보장하기 위하여 요구될 수 있는 것보다 상대적으로 훨씬 더 작아질 수 있는 능력을 촉진한다는 점이고, 이는 아키텍쳐 프로그램(미디어 레지스터(118)를 통해)이, NPU들(126)이 계산들을 수행하는 동안, 데이터를 데이터 RAM(122)에 계속 제공할 수 있어야 하고, 이로부터 결과들을 검색할 수 있는 것을 필요로 한다.
내부 RAM 버퍼
이제, 도 17을 참조하면, 도 1의 웨이트 RAM(124) 및 버퍼(1704)의 실시예를 도시하는 블록도가 도시된다. 웨이트 RAM(124)은 메모리 어레이(1706) 및 포트(1702)를 포함한다. 메모리 어레이(1706)는 웨이트 워드들을 유지하고, 상술한 바와 같이 N개 워드들의 W개 행들로 바람직하게 배열된다. 일 실시예에 있어서, 메모리 어레이(1706)는 각 셀들이 64 비트 폭 및 2048 비트 높이인 128개의 수평으로 배열된 정적 RAM 셀들의 어레이를 포함하여, 8192 비트 폭이고 2048개 행들을 갖는 2MB 웨이트 RAM(124)을 제공하고, 웨이트 RAM(124)은 다이 영역의 대략 2.4 제곱 밀리미터를 점유한다. 그러나, 다른 실시예들이 고려된다.
포트(1702)는 바람직하게는 다중화된 방식으로 NPU들(126) 및 버퍼(1704)에 결합된다. NPU들(126) 및 버퍼(1704)은 포트(1702)를 통해 웨이트 RAM(124)을 판독 및 기입한다. 버퍼(1704)는 또한 도 1의 미디어 레지스터들(118)에 결합되어, 미디어 레지스터들(118)은 버퍼(1704)를 통해 웨이트 RAM(124)을 판독 및 기입한다. 따라서, 유리하게, 미디어 레지스터들(118)은, NPU들(126)이 또한 웨이트 RAM(124)으로부터 판독 및 이에 기입하는 동안(버퍼(1704)가 웨이트 RAM(124)에 접속하는 동안 웨이트 RAM(124)에 대한 접속을 회피하기 위하여, 이들이 동시에 실행중이라면, 바람직하게 NPU들(126)이 지연하지만), 동시에 버퍼(1704)에 기입 및 이로부터 판독할 수 있다. 특히 미디어 레지스터들(118)에 의한 웨이트 RAM(124)에 대한 판독들/기입들이 NPU들(126)에 의한 웨이트 RAM(124)에 기입들/판독들보다 상대적으로 훨씬 적기 때문에, 이것은 유리하게 개선된 성능을 제공한다. 예컨대, 일 실시예에 있어서, NPU들(126)은 한 번에 8192 비트들(한 행)을 판독/기입하고, 반면에 미디어 레지스터(118)는 256 비트 폭이고, 각 MTNN 명령들(1400)은 2개의 미디어 레지스터들(118), 즉 512 비트들을 기입한다. 따라서, 아키텍쳐 프로그램이 버퍼(1704)를 채우기 위하여 16개의 MTNN 명령(1400)을 수행하는 경우, 웨이트 RAM(124)에 대한 접속를 위한 NPU(126) 및 아키텍쳐 프로그램 사이의 충돌은 오로지 시간의 대략 6% 이하로 발생한다. 다른 실시예에 있어서, 명령 변환기(104)는 MTNN 명령(1400)을 2개의 마이크로명령(105)들로 변환시키고, 이들 각각은 단일 미디어 레지스터(118)를 버퍼(1704)에 기입하고, 이 경우 웨이트 RAM(124)에 대한 접속을 위한 NPU(126)들 및 아키텍쳐 프로그램 사이의 충돌은 덜 빈번하게 발생한다.
버퍼(1704)를 포함하는 일 실시예에 있어서, 아키텍쳐 프로그램에 의한 웨이트 RAM(124)에의 기입은 다수의 MTNN 명령(1400)을 필요로 한다. 하나 이상의 MTNN 명령(1400)은 버퍼(1704)의 지정된 청크들에 기입하기 위한 함수(1432)를 지정하고, 뒤이어 NNU(121)로 하여금 버퍼(1704)의 내용을 웨이트 RAM(124)의 지정된 행에 기입하도록 명령하는 함수(1432)를 지정하는 MTNN 명령(1400)이 후속하는데, 청크의 크기는 미디어 레지스터(118)의 비트 수의 두 배이고, 청크들은 자연적으로 버퍼(1704) 내에서 정렬된다. 일 실시예에 있어서, 버퍼(1704)의 지정된 청크들에 기입하기 위한 함수(1432)를 지정하는 MTNN 명령(1400)의 각각에, 버퍼(1704)의 각 청크에 대응하는 비트를 갖는 비트마스크(bitmask)가 포함된다. 2개의 지정된 소스 레지스터(118)로부터의 데이터는, 설정된 비트마스크 내의 대응 비트를 갖는 버퍼(1704)의 각 청크에 기입된다. 이것은 웨이트 RAM(124)의 한 행 내에서 반복된 데이터 값을 위해 유용할 수 있다. 예컨대, 버퍼(1704)(및 후속적으로 웨이트 RAM(124)의 한 행)을 소거하기 위하여, 프로그래머는 소스 레지스터들을 0으로 로딩하여, 비트마스크의 모든 비트들을 설정할 수 있다. 추가적으로, 비트마스크는 프로그래머가 버퍼(1704)의 선택된 청크들에 오로지 기입하고, 이에 의해 다른 청크들 내의 이전 데이터를 유지하는 것을 가능케 한다.
버퍼(1704)를 포함하는 일 실시예에 있어서, 아키텍쳐 프로그램에 의한 웨이트 RAM(124)으로부터 판독은 다수의 MTNN 명령(1400)을 필요로 한다. 초기 MFNN 명령(1500)은 웨이트 RAM(124)의 지정된 행으로부터 버퍼(1704)를 로딩하기 위한 함수(1532)를 지정하고, 뒤이어 버퍼(1704)의 지정된 청크를 목적지 레지스터 안으로 판독하는 함수(1532)를 지정하는 하나 이상의 MFNN 명령(1500)이 후속하는데, 청크의 크기는 미디어 레지스터(118)의 비트 수이고, 청크들은 자연적으로 버퍼(1704) 내에서 정렬된다. NPU(126)이 실행중인 동안 아키텍쳐 프로그램에 의해 이루어질 수 있는 접속들의 수를 증가시킴으로써 웨이트 RAM(124)으로의 접속을 위한 NPU들(126) 및 아키텍쳐 프로그램 사이의 회선 쟁탈을 추가로 줄이기 위한 다수의 버퍼(1704)들을 웨이트 RAM(124)이 포함하는 다른 실시예들이 고려되는데, 이는 버퍼(1704)들에 의한 접속들이 NPU(126)들이 웨이트 RAM(124)을 접속하는 것을 필요로 하지 않는 클록 사이클 동안 수행될 수 있는 가능성을 증가시킬 수 있다.
도 16이 2중 포트의 데이터 RAM(122)를 기술하지만, 웨이트 RAM(124) 또한 2중 포트로 이루어진 다른 실시예들이 고려될 수 있다. 또한, 도 17이 웨이트 RAM(124)과 함께 사용하기 위한 버퍼를 기술하지만, 데이터 RAM(122)이 또한 버퍼(1704)와 유사한 관련된 버퍼를 갖는 다른 실시예들이 고려될 수 있다.
동적으로 구성 가능한 NPU 들
이제, 도 18을 참조하면, 도 1의 동적으로 구성 가능한 NPU(126)를 도시하는 블록도가 도시된다. 도 18의 NPU(126)는 많은 면에서 도 2의 NPU(126)와 유사하다. 그러나, 도 18의 NPU(126)는 2가지 상이한 구성들 중 하나로 동작하기 위하여 동적으로 구성 가능하다. 제1 구성에서, 도 18의 NPU(126)는 도 2의 NPU(126)와 유사하게 동작한다. 즉, 본 명세서에서 "넓은(wide)" 구성 또는 "단일" 구성으로 언급되는 제1 구성에서, NPU(126)의 ALU(204)는 단일의 넓은 결과를 생성하기 위하여 단일의 넓은 데이터 워드 및 단일의 넓은 웨이트 워드(예, 16 비트)에 대한 동작들을 수행한다. 대조적으로, 본 명세서에서 "좁은(narrow)" 구성 또는 "이중" 구성으로 언급되는 제 2 구성에서, NPU(126)는 2개의 각각의 좁은 결과들을 생성하기 위하여 2개의 좁은 데이터 워드들 및 2개의 각각의 좁은 웨이트 워드(예, 8 비트)들에 대한 동작들을 수행한다. 일 실시예에 있어서, NPU(126)의 구성(넓거나 좁은)은 초기화 NPU 명령(예, 아래에서 기술되는 도 20의 어드레스 0에서)에 의해 이루어진다. 대안적으로, 이러한 구성은 NPU(126)를 그 구성(넓거나 좁은)으로 구성하도록 지정하는 함수(1432)를 갖는 MTNN 명령에 의해 이루어진다. 바람직하게, 구성 레지스터들은 구성(넓거나 좁은)을 결정하는 프로그램 메모리(129) 명령 또는 MTNN 명령으로 채워진다. 예컨대, 구성 레지스터 출력들은 ALU(204), AFU(212), 및 mux-reg 제어 신호(213)를 생성하는 로직에 제공된다. 일반적으로 말해, 도 18의 NPU(126)들의 요소들은 도 2의 그 유사한 번호의 요소들과 유사한 기능들을 수행하고, 도 18의 이해를 위해 이들에 대한 참조가 이루어져야 한다. 그러나, 도 18의 실시예들은 도 2와의 차이점을 포함하여 이제 기술될 것이다.
도 18의 NPU(126)는 2개의 레지스터(205A 및 205B)들, 2개의 3-입력 mux-reg(280A 및 208B)들, ALU(204), 2개의 누산기(202A 및 202B)들, 및 2개의 AFU(212A 및 212B)들을 포함한다. 레지스터(205A/205B)들의 각각은 도 2의 레지스터(205)의 절반의 폭(예, 8 비트)이다. 레지스터(205A/205B)들의 각각은 웨이트 RAM(124)으로부터 각 좁은 웨이트 워드(206A/206B)(예, 8 비트)를 수신하고, 후속 클록 사이클에서 그 출력(203A/203B)을 ALU(204)의 피연산자 선택 로직(1898)에 제공한다. NPU(126)가 넓은 구성일 때, 레지스터(205A/205B)들은 도 2의 실시예의 레지스터(205)의 방식과 유사하게, 웨이트 RAM(124)으로부터 넓은 웨이트 워드(206A/206B)(예, 16 비트)를 수신하기 위하여 유효하게 함께 기능하고; NPU(126)가 좁은 구성일 때, 레지스터(205A/205B)들은 웨이트 RAM(124)으로부터 좁은 웨이트 워드(206A/206B)(예, 8 비트)를 각각 수신하기 위하여 유효하게 개별적으로 기능하여, NPU(126)는 유효하게 2개의 별도의 좁은 NPU들이 된다. 그럼에도 불구하고, 웨이트 RAM(124)의 동일한 출력 비트들은, NPU(126)의 구성에 관계없이, 레지스터(205A/205B)들에 결합되어 이들에 제공된다. 예컨대, NPU 0의 레지스터(205A)는 바이트 0을 수신하고, NPU 0의 레지스터(205B)는 바이트 1을 수신하고, NPU 1의 레지스터(205A)는 바이트 2을 수신하고, NPU 1의 레지스터(205B)는 바이트 3을 수신하고, 이와 같은 방식으로, NPU 511의 레지스터(205B)는 바이트 1023을 수신한다.
mux-reg(208A/208B)들의 각각은 도 2의 레지스터(208)의 폭(예, 8비트)의 절반이다. mux-reg(208A)는 자신의 입력(207A 또는 211A 또는 1811A)들 중 하나를 선택하여 자신의 레지스터에 저장하고 이후 후속 클록 사이클에서 그 출력(209A)에 제공하고, mux-reg(208B)는 자신의 입력(207B 또는 211B 또는 1811B)들 중 하나를 선택하여 자신의 레지스터에 저장하고 이후 후속 클록 사이클에서 그 출력(209A)에 그리고 피연산자 선택 로직(1898)에 제공한다. 입력(207A)은 데이터 RAM(122)으로부터 좁은 데이터 워드(예, 8비트)를 수신하고, 입력(207B)은 데이터 RAM(122)으로부터 좁은 데이터 워드를 수신한다. NPU(126)가 넓은 구성일 때, mux-reg(208A/208B)들은 도 2의 실시예의 mux-reg(208)의 방식과 유사하게, 데이터 RAM(122)으로부터 넓은 데이터 워드(207A/207B)(예, 16비트)를 수신하도록 함께 유효하게 기능하고, NPU(126)가 좁은 구성일 때, mux-reg(208A/208B)들은 데이터 RAM(122)으로부터 좁은 데이터 워드(207A/207B)(예, 8비트)를 수신하도록 유효하게 개별적으로 기능하여 NPU(126)는 유효하게 2개의 개별적인 좁은 NPU들이 된다. 그럼에도 불구하고, 데이터 RAM(122)의 동일한 출력 비트들은 NPU(126)의 구성에 상관없이 mux-reg(208A/208B)들에 결합되어, 이들에 제공된다. 예컨대, NPU 0의 mux-reg(208A)는 바이트 0을 수신하고, NPU 0의 mux-reg(208B)는 바이트 1을 수신하고, NPU 1의 mux-reg(208A)는 바이트 2를 수신하고, NPU 1의 mux-reg(208B)는 바이트 3을 수신하고, 이와 같은 방식으로, NPU 511의 mux-reg(208B)는 바이트 1023을 수신한다.
입력(211A)은 인접한 NPU(126)의 mux-reg(208A)의 출력(209A)을 수신하고, 입력(211B)은 인접한 NPU(126)의 mux-reg(208B)의 출력(209B)을 수신한다. 입력(1811A)은 인접한 NPU(126)의 mux-reg(208B)의 출력(209B)을 수신하고, 입력(1811B)은 도시된 바와 같이 인스턴트 NPU(126)의 mux-reg(208A)의 출력(209A)을 수신한다. 도 18에 도시된 NPU(126)는 도 1의 N개의 NPU(126)들 중에서 NPU J로 언급된다. 즉, NPU J는 N개의 NPU(126)들 중 대표적인 예이다. 바람직하게, NPU J의 mux-reg(208A)의 입력(211A)은 NPU(126) 예 J-1의 mux-reg(208A)의 출력(209A)을 수신하고, NPU J의 mux-reg(208A)의 입력(1811A)은 NPU(126)의 예 J-1의 mux-reg(208B)의 출력(209B)을 수신하고, NPU J의 mux-reg(208A)의 출력(209A)은 NPU(126)의 예 J+1의 mux-reg(208A)의 입력(211A) 및 NPU(126)의 예 J의 mux-reg(208B)의 입력(211B) 모두에 제공되고; NPU J의 mux-reg(208B)의 입력(211B)은 NPU(126)의 예 J-1의 mux-reg(208B)의 출력(209B)을 수신하고, NPU J의 mux-reg(208B)의 입력(1811B)은 NPU(126)의 예 J의 mux-reg(208A)의 출력(209A)을 수신하고, NPU J의 mux-reg(208B)의 출력(209B)은 NPU(126)의 예 J+1의 mux-reg(208A)의 입력(1811A) 및 NPU(126)의 예 J+1의 mux-reg(208B)의 입력(211B) 모두에 제공된다.
제어 입력(213)은 mux-reg(208A/208B)들의 각각이 자신의 각 레지스터에 저장하기 위해 3개의 입력들 중 어느 것을 선택할지를 제어하고, 이는 후속적으로 각 출력(209A/209B)들에 제공된다. NPU(126)가 데이터 RAM(122)으로부터 한 행 (예, 아래에서 기술되는 도 20의 어드레스 1에서의 곱-누적 명령에 의해)을 로딩하도록 명령받을 때, NPU(126)가 넓거나 좁은 구성인지에 관계없이, 제어 입력(213)은 mux-reg(208A/208B)들의 각각이 데이터 RAM(122)의 선택된 행의 대응하는 좁은 워드로부터 각 좁은 데이터 워드(207A/207B)(예, 8비트)를 선택하도록 제어한다.
NPU(126)가 이전에 수신된 데이터 행 값들을 (예, 아래에서 기술되는 도 20의 어드레스 2에서의 곱-누적 회전 명령에 의해) 회전시키도록 명령받을 때, NPU(126)가 좁은 구성이라면, 제어 입력(213)은 mux-reg(208A/208B)들의 각각이 각 입력(1811A/1811B)을 선택하도록 제어한다. 이 경우, mux-reg(208A/208B)들은, NPU(126)가 유효하게 2개의 별도의 좁은 NPU들이 되도록, 개별적으로 유효하게 기능한다. 이러한 방식으로, N개의 NPU(126)들의 mux-reg(208A 및 208B)들은 도 19에 관해 아래에서 더 상세하게 기술되는 바와 같이, 집단적으로 2N-좁은-워드 회전자로서 동작한다.
NPU(126)가 이전에 수신된 데이터 행 값들을 회전시키도록 명령받을 때, NPU(126)가 넓은 구성이라면, 제어 입력(213)은 mux-reg(208A/208B)들의 각각이 각 입력(211A/211B)을 선택하도록 제어한다. 이 경우, mux-reg(208A/208B)들은 마치 NPU(126)가 단일의 넓은 NPU(126)인 것처럼 함께 유효하게 기능한다. 이러한 방식으로, N개의 NPU(126)들의 mux-reg(208A 및 208B)들은 도 3에 관해 기술된 방식과 유사하게, 집단적으로 N-넓은-워드 회전자로서 동작한다.
ALU(204)는 피연산자 선택 로직(1898), 넓은 곱셈기(242A), 좁은 곱셈기(242B), 넓은 2-입력 mux(1896A), 좁은 2-입력 mux(1896B), 넓은 가산기(244A) 및 좁은 가산기(244B)를 포함한다. 효과적으로, ALU(204)는 피연산자 선택 로직(1898), 넓은 ALU(204)(240A)(넓은 곱셈기(242A), 넓은 mux(1896A), 넓은 가산기(244A)를 포함) 및 좁은 ALU(204B)(좁은 곱셈기(242B), 좁은 mux(1896B), 좁은 가산기(244B)를 포함)를 포함한다. 바람직하게, 넓은 곱셈기(242A)는 2개의 넓은 워드들을 곱하고, 도 2의 곱셈기(242), 예컨대 16비트×16비트 곱셈기와 유사하다. 좁은 곱셈기(242B)는 2개의 좁은 워드들을 곱한다, 예컨대 16비트 결과를 생성하는 8비트×8비트 곱셈기이다. NPU(126)가 좁은 구성일 때, 넓은 곱셈기(242A)는 2개의 좁은 워드들을 곱하기 위하여 피연산자 선택 로직(1898)의 도움으로 좁은 곱셈기로서 유효하게 사용되어, NPU(126)는 2개의 좁은 NPU들로서 유효하게 기능한다. 바람직하게, 넓은 가산기(244A)는 넓은 mux(1986A)의 출력과 넓은 누산기(202A)의 출력(217A)를 더하여, 넓은 누산기(202A)에 제공하기 위한 합(215A)을 생성하고, 도 2의 가산기(244)와 유사하다. 좁은 가산기(244B)는 좁은 mux(1986B)의 출력과 좁은 누산기(202B)의 출력(217B)을 더하여, 좁은 누산기(202B)에 제공을 위한 합(215B)을 생성한다. 일 실시예에 있어서, 좁은 누산기(202B)는 1024개까지의 16비트 곱들의 누적에서 정확도의 손실을 회피하기 위하여 28비트 폭이다. NPU(126)가 넓은 구성일 때, 좁은 곱셈기(242B), 좁은 mux(1896B), 좁은 가산기(244B), 좁은 누산기(202B) 및 좁은 AFU(212B)는 바람직하게 비활성이 되어 전력 소모를 줄인다.
피연산자 선택 로직(1898)은 아래에서 더 상세하게 기술되는 바와 같이 ALU(204)의 다른 요소들에 제공하기 위하여 209A, 209B, 203A 및 203B로부터 피연산자들을 선택한다. 바람직하게, 피연산자 선택 로직(1898)은 또한 부호값의 데이터 워드들 및 웨이트 워드들의 부호 확장을 수행하는 것과 같은 다른 기능을 수행한다. 예컨대, NPU(126)가 좁은 구성일 때, 피연산자 선택 로직(1898)은 좁은 데이터 워드 및 웨이트 워드를 넓은 곱셈기(242A)에 제공하기 전에 이들을 넓은 워드의 폭으로 부호 확장시킨다. 유사하게, ALU(204)가 좁은 데이터/웨이트 워드를 통과하도록(넓은 mux(1896A)를 통한 넓은 곱셈기(242A)를 우회하도록) 명령을 받는다면, 피연산자 선택 로직(1898)은 좁은 데이터/웨이트 워드를 넓은 가산기(244A)에 제공하기 전에 이를 넓은 워드의 폭으로 부호 확장시킨다. 바람직하게, 부호-확장 기능을 수행하기 위한 로직은 또한 도 2의 NPU(126)의 ALU(204) 내에 존재한다.
넓은 mux(1896A)는 넓은 곱셈기(242A)의 출력과 피연산자 선택 로직(1898)으로부터의 피연산자를 수신하고 넓은 가산기(244A)에 제공을 위해 입력들 중 하나를 선택하고, 좁은 mux(1896B)는 좁은 곱셈기(242B)의 출력과 피연산자 선택 로직(1898)으로부터의 피연산자를 수신하고 좁은 가산기(244B)에 제공을 위해 입력들 중 하나를 선택한다.
피연산자 선택 로직(1898)에 의해 제공된 피연산자들은, NPU(126)에 의해 실행되는 명령에 의해 지정되는 함수에 기초하여, NPU(126)의 구성 및 ALU(204)에 의해 수행될 연산 및/또는 로직 동작들에 의존한다. 예컨대, 명령이 ALU(204)가 곱-누산을 수행하도록 명령하고, NPU(126)가 넓은 구성이라면, 피연산자 선택 로직(1898)은 하나의 입력상에 출력(209A 및 209B)들의 연결인 넓은 워드를, 다른 입력상에 출력(203A 및 203B)들의 연결인 넓은 워드를 넓은 곱셈기(242A)에 제공하고, 좁은 곱셈기(242B)는 비활성이 되어, NPU(126)는 도 2의 NPU(126)와 유사한 단일의 넓은 NPU(126)로서 기능한다. 반면, 명령이 ALU(204)가 곱-누산을 수행하도록 명령하고, NPU(126)가 좁은 구성이라면, 피연산자 선택 로직(1898)은 하나의 입력상에 좁은 데이터 워드(209A)의 확장되거나 넓어진 형태를, 다른 입력상에 좁은 웨이트 워드(203A)의 확장된 형태를 넓은 곱셈기(242A)에 제공하고; 추가적으로, 피연산자 선택 로직(1898)은 하나의 입력상에 좁은 데이터 워드(209B)들을 및 다른 입력상에 좁은 웨이트 워드(203B)를 좁은 곱셈기(242B)에 제공한다. 좁은 워드를 확장 또는 넓히기 위하여, 좁은 워드가 부호가 붙는다면, 피연산자 선택 로직(1898)은 좁은 워드를 부호 확장시키고, 반면에 좁은 워드가 부호가 없다면, 피연산자 선택 로직(1898)은 좁은 워드에 0값의 상위 비트들을 덧붙인다.
다른 예로서, NPU(126)가 넓은 구성이고, 명령이 ALU(204)로 하여금 웨이트 워드의 누적을 수행하도록 명령하면, 넓은 곱셈기(242A)는 우회되고, 피연산자 선택 로직(1898)은 출력(203A 및 203B)들의 연결을 넓은 가산기(244A)에 제공하기 위해 넓은 mux(1896A)에 제공한다. 반면에, NPU(126)가 좁은 구성이고, 명령이 ALU(204)로 하여금 웨이트 워드의 누산을 수행하도록 명령하면, 넓은 곱셈기(242A)는 우회되고, 피연산자 선택 로직(1898)은 출력(203A)의 확장된 형태를 넓은 가산기(244A)에 제공하기 위해 넓은 mux(1896A)에 제공하고; 좁은 곱셈기(242B)는 우회되고, 피연산자 선택 로직(1898)은 출력(203B)의 확장된 형태를 좁은 가산기(244B)에 제공하기 위해 좁은 mux(1896B)에 제공한다.
다른 예로서, NPU(126)가 넓은 구성이고, 명령이 ALU(204)로 하여금 데이터 워드의 누적을 수행하도록 명령하면, 넓은 곱셈기(242A)는 우회되고, 피연산자 선택 로직(1898)은 출력(209A 및 209B)들의 연결을 넓은 가산기(244A)에 제공하기 위해 넓은 mux(1896A)에 제공한다. 반면에, NPU(126)가 좁은 구성이고, 명령이 ALU(204)로 하여금 데이터 워드의 누산을 수행하도록 명령하면, 넓은 곱셈기(242A)는 우회되고, 피연산자 선택 로직(1898)은 출력(209A)의 확장된 형태를 넓은 가산기(244A)에 제공하기 위해 넓은 mux(1896A)에 제공하고; 좁은 곱셈기(242B)는 우회되고, 피연산자 선택 로직(1898)은 출력(209B)의 확장된 형태를 좁은 가산기(244B)에 제공하기 위해 좁은 mux(1896B)에 제공한다. 웨이트/데이터 워드들의 누산은, 예컨대 이미지 처리와 같은, 일부 인공 신경망 응용들의 풀링 층에서 사용되는 평균화 동작들을 수행하기 위하여 유용할 수 있다.
바람직하게, NPU(126)는 또한, 넓은 가산기(244A)를 우회하여 넓은 누산기(202A)에 넓은 구성의 넓은 데이터/웨이트 워드 또는 좁은 구성의 확장된 좁은 데이터/웨이트 워드의 로딩을 용이하게 하기 위한 제 2 넓은 mux(미도시), 및 좁은 가산기(244B)를 우회하여 좁은 누산기(202B)에 좁은 구성의 좁은 데이터/웨이트 워드의 로딩을 용이하게 하기 위한 제 2 좁은 mux(미도시)를 포함한다. 바람직하게, ALU(204)는 또한, 각 누산기 값(217A/217B) 및 각 mux(1896A/1896B)의 출력을 수신하여 누산기 값(217A/217B)과 데이터/웨이트 워드(209A/B/203A/B) 사이의 최대값을 선택하는 넓은 및 좁은 비교기/mux 조합(미도시)을 포함하고, 동작은 도 27 및 도 18에 관해 아래에서 더 상세하게 기술되는 바와 같이 일부 인공 신경망 응용들의 풀링 층들에서 사용된다. 추가적으로, 피연산자 선택 로직(1898)은 (0으로 첨가를 위해, 또는 누산기의 소거를 위해) 0값의 피연산자를 제공하고, (1에 의한 곱셈을 위해) 1값의 피연산자를 제공하도록 구성된다.
좁은 AFU(212B)는 좁은 누산기(202B)의 출력(217B)을 수신하고, 이에 대한 활성함수를 수행하여 좁은 결과(133B)를 생성하고, 넓은 AFU(212A)는 넓은 누산기(202A)의 출력(217A)을 수신하고, 이에 대한 활성함수를 수행하여 넓은 결과(133A)를 생성한다. NPU(126)가 좁은 구성일 때, 넓은 AFU(212A)는 넓은 누산기(202A)의 출력(217A)을 적절히 고려하고, 이에 대한 활성함수를 수행하여, 예컨대 도 29a 내지 도 30에 관해 아래에서 더 상세하게 기술되는 바와 같이, 좁은 결과, 예컨대 8비트를 생성한다.
위의 설명으로부터 알 수 있는 바와 같이, 유리하게 단일 NPU(126)는 좁은 구성일 때 2개의 좁은 NPU들로서 효과적으로 동작하고, 따라서 더 작은 워드들에 대해 넓은 구성일 때의 처리량의 대략 2배까지 제공한다. 예컨대, 각각 이전 층으로부터 1024개의 좁은 입력들을 수신하는 (그리고 좁은 웨이트 워드들을 갖는) 1024개의 뉴런들을 갖는 신경망을 고려하면, 1 메가-연결들을 초래한다. 좁은 구성의 512개의 NPU(126)(1024개의 좁은 NPU)들을 갖는 NNU(121)는, 넓은 구성의 512개의 NPU(126)들을 갖는 NNU(121)와 비교하여, 넓은 워드들이 아니라 좁은 워드들에 대한 것이지만, 대략 절반의 시간(대략 1026 클록들에 대해 514클록들)에 연결들의 수의 4배(256K 연결들에 대해 1 메가-연결들)를 처리할 수 있다.
일 실시예에 있어서, 도 18의 동적으로 구성 가능한 NPU(126)는, 도 7의 실시예에 대해 기술된 방식과 어느 정도 유사하지만 도 18에 관해 기술된 동적으로 구성 가능한 방식으로, 레지스터(205A 및 205B)들 대신에 mux-reg(208A 및 208B)들과 유사한 3-입력 다중화된 레지스터들을 포함하여 웨이트 RAM(124)으로부터 수신된 웨이트 워드들의 한 행에 대한 회전자를 달성한다.
이제, 도 19를 참조하면, 도 18의 실시예에 따라 도 1의 NNU(121)의 N개의 NPU(126)들의 2N개의 mux-reg(208A/208B)들의 배열의 실시예를 도시하여, 도 1의 데이터 RAM(122)으로부터 수신된 데이터 워드(207)의 한 행에 대한 회전자로서 이들의 동작을 도시하는 블록도가 도시된다. 도 19의 실시예에서, NNU(121)가 1024개의 mux-reg(208A/208B)들을 갖도록, N은0 내지 511로 표시되는 512이고, 도시된 바와 같이, 512개의 NPU(126)들, 효과적으로 1024개의 좁은 NPU들에 대응한다. NPU(126) 내의 2개의 좁은 NPU들은 A 및 B로 표시되고, mux-reg(208)들의 각각 내에서 대응하는 좁은 NPU의 지정이 도시된다. 더 특별하게, NPU(126) 0의 mux-reg(208A)는 0-A로 지정되고, NPU(126) 0의 mux-reg(208B)는 0-B로 지정되고, NPU(126) 1의 mux-reg(208A)는 1-A로 지정되고, NPU(126) 1의 mux-reg(208B)는 1-B로 지정되고, NPU(126) 511의 mux-reg(208A)는 511-A로 지정되고, NPU(126) 511의 mux-reg(208B)는 0-B로 지정되고, 이들 값들은 또한 아래에 기술된 도 21의 좁은 NPU들에 대응한다.
각 mux-reg(208A)는 데이터 RAM(122)의 D개 행들 중 한 행의 대응하는 좁은 데이터 워드(207A)를 수신하고, 각 mux-reg(208B)는 데이터 RAM(122)의 D개 행들 중 한 행의 대응하는 좁은 데이터 워드(207B)를 수신한다. 즉, mux-reg 0A는 데이터 RAM(122) 행의 좁은 데이터 워드 0을 수신하고, mux-reg 0B는 데이터 RAM(122) 행의 좁은 데이터 워드 1을 수신하고, mux-reg 1A는 데이터 RAM(122) 행의 좁은 데이터 워드 2을 수신하고, mux-reg 1B는 데이터 RAM(122) 행의 좁은 데이터 워드 3을 수신하고, 이와 같은 방식으로, mux-reg 511A는 데이터 RAM(122) 행의 좁은 데이터 워드 1022를 수신하고, mux-reg 511B는 데이터 RAM(122) 행의 좁은 데이터 워드 1023을 수신한다. 추가적으로, mux-reg 1A는 그 입력(211A) 상에서 mux-reg 0A의 출력(209A)을 수신하고, mux-reg 1B는 그 입력(211B) 상에서 mux-reg 0B의 출력(209B)을 수신하고, 이와 같은 방식으로, mux-reg 511A는 그 입력(211A) 상에서 mux-reg 510A의 출력(209A)을 수신하고, mux-reg 511B는 그 입력(211B) 상에서 mux-reg 510B의 출력(209B)을 수신하고, mux-reg 0A는 그 입력(211A) 상에서 mux-reg 511A의 출력(209A)을 수신하고, mux-reg 0B는 그 입력(211B) 상에서 mux-reg 511B의 출력(209B)을 수신한다. mux-reg(208A/208B)들의 각각은 데이터 워드(207A/207B) 또는 회전된 입력(211A/211B) 또는 회전된 입력(1811A/1811B)을 선택할지를 제어하는 제어 입력(213)을 수신한다. 최종적으로, mux-reg 1A는 그 입력(1811A) 상에서 mux-reg 0B의 출력(209B)을 수신하고, mux-reg 1B는 그 입력(1811B) 상에서 mux-reg 1A의 출력(209A)을 수신하고, 이와 같은 방식으로, mux-reg 511A는 그 입력(1811A) 상에서 mux-reg 510B의 출력(209B)을 수신하고, mux-reg 511B는 그 입력(1811B) 상에서 mux-reg 511A의 출력(209A)을 수신하고, mux-reg 0A는 그 입력(1811A) 상에서 mux-reg 511B의 출력(209B)을 수신하고, mux-reg 0B는 그 입력(1811B) 상에서 mux-reg 0A의 출력(209A)을 수신한다. mux-reg(208A/208B)들의 각각은 데이터 워드(207A/207B) 또는 회전된 입력(211A/211B) 또는 회전된 입력(1811A/1811B)을 선택할지를 제어하는 제어 입력(213)을 수신한다. 아래에서 더 상세하게 기술되는 바와 같이 하나의 동작 모드에서, 제1 클록 사이클에서, 제어 입력(213)은 mux-reg(208A/208B)들의 각각이 레지스터에 저장 및 ALU(204)에 후속 제공을 위해 데이터 워드(207A/207B)를 선택하도록 제어하고; 후속 클록 사이클(예, 상술한 바와 같이 M-1 클록 사이클) 동안, 제어 입력(213)은 mux-reg(208A/208B)들의 각각이 레지스터에 저장 및 ALU(204)에 후속 제공을 위해 회전된 입력(1811A/1811B)을 선택하도록 제어한다.
이제, 도 20을 참조하면, 도 18의 실시예에 따른 NPU(126)들을 갖는 도 1의 NNU(121)의 프로그램 메모리에서의 저장 및 도 1의 NNU(121)에 의한 실행을 위한 프로그램을 도시하는 테이블이 도시된다. 도 20의 예시적인 프로그램은 많은 방식에서 도 4의 프로그램과 유사하다. 그러나, 이제 차이점들이 기술될 것이다. 어드레스 0에서 초기화 NPU 명령은 NPU(126)가 좁은 구성이 될 것을 지정한다. 추가적으로, 어드레스 2에서 곱-누산 회전 명령은 도시된 바와 같이 1023의 카운트값을 지정하고, 1023개의 클록 사이클들을 필요로 한다. 이것은, 도 20의 예가 한 층의 1024개의 좁은(예, 8비트) 뉴런들(NPU들)을 유효하게 가정하고, 각각이 1024K 연결들의 전체에 대해, 1024개의 뉴런들의 이전 층으로부터 1024개의 연결 입력들을 갖기 때문이다. 각 뉴런은 각 연결 입력으로부터 8비트 데이터값을 수신하고, 8비트 데이터 값을 적절한 8비트 웨이트값으로 곱한다.
이제, 도 21을 참조하면, 좁은 구성으로 동작하는 도 18의 NPU(126)들을 포함하는 NNU(121)에 의한 도 20의 프로그램의 실행을 도시하는 타이밍도가 도시된다. 도 21의 타이밍도는 많은 방식에서 도 5의 타이밍도와 유사하지만, 이제 차이점이 도시될 것이다.
도 21의 타이밍도에서, NPU(126)들은 좁은 구성인데, 왜냐하면 어드레스 0에서 초기화 NPU 명령이 이들을 좁은 구성으로 초기화하기 때문이다. 결과적으로, 512개의 NPU(126)들은 1024개의 좁은 NPU(또는 뉴런)들로서 효과적으로 동작하고, 이들은 열에서, NPU 0-A 및 NPU 0-B(NPU(126) 0의 2개의 좁은 NPU들), NPU 1-A 및 NPU 1-B(NPU(126) 1의 2개의 좁은 NPU들), 이와 같은 방식으로 NPU 511-A 및 NPU 511-B(NPU(126) 511의 2개의 좁은 NPU들)까지 지정된다. 설명의 단순화 및 명확성을 위해, 오로지 좁은 NPU들 0-A, 0-B, 및 511-B에 대한 동작들이 도시된다. 어드레스 2에서 곱-누산 회전이 1023의 카운트값을 지정하고, 이는 1023개의 클록들을 필요한다는 사실로 인해, 도 21의 타이밍도의 행들은 클록 사이클 1026까지를 포함한다.
클록 0에서, 1024개의 NPU들의 각각은 도 4의 초기화 명령을 수행하고, 이는 누산기(202)에 0의 값의 할당으로 도 5에 도시된다.
클록 1에서, 1024개의 좁은 NPU들의 각각은 도 20의 어드레스 1에서 곱-누산 명령을 수행한다. 좁은 NPU 0-A는 누산기(202A)의 값(값이 0인)을 데이터 RAM(122)의 행 17의 좁은 워드 0과 웨이트 RAM(124)의 행 0의 좁은 워드 0의 곱으로 누적시키고; 좁은 NPU 0-B는 누산기(202B)의 값(값이 0인)을 데이터 RAM(122)의 행 17의 좁은 워드 1과 웨이트 RAM(124)의 행 0의 좁은 워드 1의 곱으로 누적시키고; 이와 같은 방식으로, 도시된 바와 같이 좁은 NPU 511-B는 누산기(202B)의 값(값이 0인)을 데이터 RAM(122)의 행 17의 좁은 워드 1023과 웨이트 RAM(124)의 행 0의 좁은 워드 1023의 곱으로 누적시킨다.
클록 2에서, 1024개의 좁은 NPU들의 각각은 도 20의 어드레스 2에서 곱-누산 회전 명령의 제1 반복을 수행한다. 좁은 NPU 0-A는 누산기(202A)의 값(217A)을 좁은 NPU 511-B의 mux-reg(208B)의 출력(209B)(데이터 RAM(122)으로부터 수신된 좁은 데이터 워드 1023인)로부터 수신된 회전된 좁은 데이터 워드 1811A와 웨이트 RAM(124)의 행 1의 좁은 워드 0의 곱으로 누적시키고; 좁은 NPU 0-B는 누산기(202B)의 값(217B)을 좁은 NPU 0-A의 mux-reg(208A)의 출력(209A)(데이터 RAM(122)으로부터 수신된 좁은 데이터 워드 0인)로부터 수신된 회전된 좁은 데이터 워드 1811B와 웨이트 RAM(124)의 행 1의 좁은 워드 1의 곱으로 누적시키고; 이와 같은 방식으로, 도시된 바와 같이 좁은 NPU 511-B는 누산기(202B)의 값(217B)을 좁은 NPU 511-A의 mux-reg(208A)의 출력(209A)(데이터 RAM(122)으로부터 수신된 좁은 데이터 워드 1022인)로부터 수신된 회전된 좁은 데이터 워드 1811B와 웨이트 RAM(124)의 행 1의 좁은 워드 1023의 곱으로 누적시킨다.
클록 3에서, 1024개의 좁은 NPU들의 각각은 도 20의 어드레스 2에서 곱-누산 회전 명령의 제 2 반복을 수행한다. 좁은 NPU 0-A는 누산기(202A)의 값(217A)을 좁은 NPU 511-B의 mux-reg(208B)의 출력(209B)(데이터 RAM(122)으로부터 수신된 좁은 데이터 워드 1022인)로부터 수신된 회전된 좁은 데이터 워드 1811A와 웨이트 RAM(124)의 행 2의 좁은 워드 0의 곱으로 누적시키고; 좁은 NPU 0-B는 누산기(202B)의 값(217B)을 좁은 NPU 0-A의 mux-reg(208A)의 출력(209A)(데이터 RAM(122)으로부터 수신된 좁은 데이터 워드 1023인)로부터 수신된 회전된 좁은 데이터 워드 1811B와 웨이트 RAM(124)의 행 2의 좁은 워드 1의 곱으로 누적시키고; 이와 같은 방식으로, 도시된 바와 같이 좁은 NPU 511-B는 누산기(202B)의 값(217B)을 좁은 NPU 511-A의 mux-reg(208A)의 출력(209A)(데이터 RAM(122)으로부터 수신된 좁은 데이터 워드 1021인)로부터 수신된 회전된 좁은 데이터 워드 1811B와 웨이트 RAM(124)의 행 2의 좁은 워드 1023의 곱으로 누적시킨다. 도 21의 생략부호로 표시된 바와 같이, 이것은 다음의 1021개 클록 사이클들의 각각에 대해 지속된다.
클록 1024에서, 1024개의 좁은 NPU들의 각각은 도 20의 어드레스 2에서 곱-누산 회전 명령의 제 1023번째 반복을 수행한다. 좁은 NPU 0-A는 누산기(202A)의 값(217A)을 좁은 NPU 511-B의 mux-reg(208B)의 출력(209B)(데이터 RAM(122)으로부터 수신된 좁은 데이터 워드 1인)로부터 수신된 회전된 좁은 데이터 워드 1811A와 웨이트 RAM(124)의 행 1023의 좁은 워드 0의 곱으로 누적시키고; NPU 0-B는 누산기(202B)의 값(217B)을 NPU 0-A의 mux-reg(208A)의 출력(209A)(데이터 RAM(122)으로부터 수신된 좁은 데이터 워드 2인)로부터 수신된 회전된 좁은 데이터 워드 1811B와 웨이트 RAM(124)의 행 1022의 좁은 워드 1의 곱으로 누적시키고; 이와 같은 방식으로, 도시된 바와 같이 NPU 511-B는 누산기(202B)의 값을 NPU 511-A의 mux-reg(208A)의 출력(209A)(데이터 RAM(122)으로부터 수신된 좁은 데이터 워드 0인)로부터 수신된 회전된 좁은 데이터 워드 1811B와 웨이트 RAM(124)의 행 1023의 좁은 워드 1023의 곱으로 누적시킨다.
클록 1025에서, 1024개의 좁은 NPU들 각각의 AFU(212A/212B)는 도 20의 어드레스 3에서 활성함수 명령을 수행한다. 최종적으로, 클록 1026에서, 1024개의 좁은 NPU들 각각은, 그 좁은 결과(133A/133B)를 다시 데이터 RAM(122)의 행 16의 대응하는 좁은 워드에 기입함으로써, 즉 NPU 0-A의 좁은 결과(133A)가 데이터 RAM(122)의 좁은 워드 0에 기입되고, NPU 0-B의 좁은 결과(133B)가 데이터 RAM(122)의 좁은 워드 1에 기입되고, 이와 같은 방식으로, NPU 511-B의 좁은 결과(133B)가 데이터 RAM(122)의 좁은 워드 1023에 기입됨으로써, 도 20의 어드레스 4에서 기입 AFU 출력 명령을 수행한다. 도 21에 관해 위에서 기술된 동작은 또한 도 22에 블록도로서 도시된다.
이제, 도 22를 참조하면, 도 20의 프로그램을 실행하기 위한 도 18의 NPU(126)들을 포함하는 도 1의 NNU(121)를 도시하는 블록도가 도시된다. NNU(121)는 512개의 NPU(126)들, 즉 1024개의 좁은 NPU들, 어드레스 입력(123)을 수신하는 데이터 RAM(122), 및 어드레스 입력(125)을 수신하는 웨이트 RAM(124)을 포함한다. 도시되지는 않았지만, 클록 0에서, 1024개의 NPU들은 도 20의 초기화 명령을 수행한다. 도시된 바와 같이, 클록 1에서, 행 17의 1024개의 8비트 데이터 워드들은 데이터 RAM(122)으로부터 판독되어 1024개의 좁은 NPU들에 제공된다. 클록 1 내지 클록 1024에서, 행 0 내지 행 1023의 1024개의 8비트 데이터 워드들은 각각 웨이트 RAM(124)으로부터 판독되어 1024개의 좁은 NPU들에 제공된다. 도시되지는 않았지만, 클록 1에서, 1024개의 좁은 NPU들은 로딩된 데이터 워드들 및 웨이트 워드들에 대한 각 곱-누산 동작들을 수행한다. 클록 2 내지 클록 1024에서, 1024개의 좁은 NPU들의 mux-reg(208A/208B)들은 데이터 RAM(122)의 행 17의 이전에 로딩된 데이터 워드들을 인접한 좁은 NPU로 회전시키기 위한 1024개의 8비트 워드 회전자로서 동작하고, 좁은 NPU들은 각 회전된 데이터의 좁은 워드 및 웨이트 RAM(124)으로부터 로딩된 각 좁은 웨이트 워드에 대한 곱-누산 동작을 수행한다. 도시되지는 않았지만, 클록 1025에서, 1024개의 좁은 AFU(212A/212B)들은 활성 명령을 수행한다. 클록 1026에서, 1024개의 좁은 NPU들은 각 1024개의 8비트 결과(133A/133B)들을 다시 데이터 RAM(122)의 행 16에 기입한다.
알 수 있는 바와 같이, 도 18의 실시예는 예컨대 도 2의 실시예에 대해 유리할 수 있는데, 왜냐하면 이것은 프로그래머들이, 모델링되는 특정 응용이 정확도의 양을 요구할 때의 넓은 데이터 및 웨이트 워드들(예, 16비트) 및 특정 응용이 정확도의 양을 요구할 때의 좁은 데이터 및 웨이트 워드들(예, 8비트)을 사용하여 계산들을 수행하는 유연성을 제공하기 때문이다. 하나의 양상으로부터, 도 18의 실시예는 좁은 데이터 응용들에 대해, 대략 NPU(126) 면적의 50%가 증가하는 추가적인 좁은 요소(예, mux-reg(208), reg(205B), 좁은 ALU(204B), 좁은 누산기(202B), 좁은 AFU(212B))들의 비용으로, 도 2의 실시예 보다 2배의 처리량을 제공한다.
3- 모드 NPU 들
이제, 도 23을 참조하면, 다른 실시예에 따라 도 1의 동적으로 구성 가능한 NPU(126)들을 도시하는 블록도가 도시된다. 도 23의 NPU(126)는 넓은 및 좁은 구성으로뿐만 아니라, 본 명세서에서 "깔대기(funnel)" 구성으로 언급되는 제 3의 구성으로도 구성 가능하다. 도 23의 NPU(126)는 많은 면들에서 도 18의 NPU(126)와 유사하다. 그러나, 도 18의 넓은 가산기(244A)는, 좁은 mux(1896B)의 출력의 확장된 형태인 제 3의 가수(2399)를 수신하는 3-입력 넓은 가산기(2344A)를 갖는 도 23의 NPU(126)로 대체된다. 도 23의 NPU(126)들을 갖는 NNU(121)를 동작시키는 프로그램은 대부분의 면에서 도 20의 프로그램과 유사하다. 그러나, 어드레스 0에서의 초기화 NPU 명령은 NPU(126)들을 좁은 구성이 아니라 깔대기 구성으로 초기화한다. 추가적으로, 어드레스 2에서 곱-누산 회전 명령의 카운트값은 1023이 아니라 511이다.
깔대기 구성일 때, NPU(126)는, 2개의 좁은 데이터 워드(207A/207B)들 및 2개의 좁은 웨이트 워드(206A/206B)들을 수신하는 도 20의 어드레스 1에서와 같이 곱-누산 명령을 실행할 때 좁은 구성에서와 유사하게 동작한다; 넓은 곱셈기(242A)는 데이터 워드(209A)와 웨이트 워드(203A)를 곱하여 넓은 mux(1896A)가 선택하는 곱(246A)을 생성한다; 좁은 곱셈기(242B)는 데이터 워드(209B)와 웨이트 워드(203B)를 곱하여 좁은 mux(1896A)가 선택하는 곱(246B)을 생성한다. 그러나, 넓은 가산기(2344A)는 넓은 누산기(202A)의 값(217A)에 곱(246A)(넓은 mux(1896A)에 의해 선택된)과 곱(246B/2399)(넓은 mux(1896B)에 의해 선택된)을 모두 더하고, 좁은 가산기(244B) 및 좁은 누산기(202B)는 비활성이다. 더욱이, 깔대기 구성에서, 도 20의 어드레스 2에서와 같이 곱-누산 회전 명령을 실행할 때, 제어 입력(213)은 mux-reg(208A/208B)들이 2개의 좁은 워드(예, 16비트)들만큼 회전하게 한다, 즉 mux-reg(208A/208B)들은 마치 이들이 넓은 구성인 것처럼 그들의 각 입력(211A/211B)들을 선택한다. 그러나, 넓은 곱셈기(242A)는 데이터 워드(209A)와 웨이트 워드(203A)를 곱해 넓은 mux(1896A)가 선택하는 곱(246A)을 생성하고; 좁은 곱셈기(242B)는 데이터 워드(209B)와 웨이트 워드(203B)를 곱해 좁은 mux(1896B)가 선택하는 곱(246B)을 생성하고; 넓은 가산기(2344A)는 넓은 누산기(202A)의 값(217A)에 곱 (246A)(넓은 mux(1896A)에 의해 선택된)과 곱(246B/2399)(넓은 mux(1896B)에 의해 선택된)을 모두 더하고; 좁은 가산기(244B) 및 좁은 누산기(202B)는 상술한 바와 같이 비활성이다. 최종적으로 깔대기 구성에서, 도 20의 어드레스 3에서와 같이 활성함수 명령을 실행할 때, 넓은 AFU(212A)는 결과 합(215A)에 대한 활성함수를 수행하여 좁은 결과(133A)를 생성하고, 좁은 AFU(212B)는 비활성이다. 따라서, 오로지 A의 좁은 NPU들만이 좁은 결과(133A)를 생성하고, B의 좁은 NPU들에 의해 생성된 좁은 결과(133B)들은 유효하지 않다. 결과적으로, (예, 도 20의 어드레스 4의 명령에서와 같이 행 16에) 다시 기입된 결과들의 행은 홀들(holes)을 포함하는데, 왜냐하면 오로지 좁은 결과(133A)들이 유효하고, 좁은 결과(133B)들은 유효하지 않기 때문이다. 따라서, 개념적으로, 각 클록 사이클에서, 각 뉴런(도 23의 NPU(126))은, 각각이 클록 사이클당 단일 연결 데이터 입력을 처리하는 도 2 및 도 18의 실시예들과 대조적으로, 2개의 연결 데이터 입력들을 처리한다, 즉 2개의 좁은 데이터 워드들을 그들의 각 웨이트들로 곱하고, 2개의 곱들을 누적시킨다.
도 23의 실시예에 관해 알 수 있는 바와 같이, 생성되어 데이터 RAM(122) 또는 웨이트 RAM(124)에 다시 기입되는 결과 워드(뉴런 출력)들의 수는 수신된 데이터 입력(연결)들의 수의 제곱근의 절반이고, 결과들의 다시 기입된 행은 홀들을 갖는다, 즉 하나 걸러 모든 좁은 워드 결과는 유효하지 않다, 보다 구체적으로, B의 좁은 NPU 결과들은 의미 없다. 따라서, 도 23의 실시예는, 예컨대 제1 층이 제 2 층보다 2배 많은 뉴런들을 갖는(예, 제1 층은 512개 뉴런들의 제 2 층에 완전히 연결된 1024개의 뉴런들을 갖는다) 두 개의 연속적인 층들을 갖는 신경망들에서 특히 효과적일 수 있다. 더욱이, 다른 실행 유닛(112)(예, x86 AVX 유닛들과 같은 미디어 유닛들)은, NNU(121)가 데이터 RAM(122) 및/또는 웨이트 RAM(124)의 다른 행들과 관련된 다른 계산을 수행하는 동안 후속하는 계산들에서 사용을 위해, 필요하다면 결과들을 간결하게(즉, 홀들이 없게) 하기 위해, 결과들의 분산 행(즉, 홀들을 갖는)에 대해 팩(pack) 동작들을 수행할 수 있다.
하이브리드 NNU 동작; 컨벌루션 및 풀링 성능들
본 명세서에서 기술된 실시예들에 따른 NNU(121)의 장점은, 자신의 내부 프로그램을 실행하는 점에서 코프로세서를 닮은 방식으로 동시에 동작할 수 있고, 배출받은 아키텍쳐 프로그램들(또는 이로부터 변환된 마이크로명령들)을 실행한다는 점에서 프로세서의 실행 유닛을 닮은 방식으로 동작할 수 있다는 점이다. 아키텍쳐 명령들은, NNU(121)를 포함하는 프로세서에 의해 수행되는 아키텍쳐 프로그램으로 이루어진다. 이러한 방식으로, NNU(121)는 하이브리드 방식으로 동작하고, 이는 NNU(121)의 높은 이용을 유지하는 능력을 제공하기 때문에 유리하다. 예컨대, 도 24 내지 도 26은 NNU(121)가 높게 이용되는 컨벌루션 동작을 수행하기 위한 NNU(121)의 동작을 도시하고, 도 27 내지 도 28은 풀링 동작을 수행하기 위한 NNU(121)의 동작을 도시하고, 이들은 컨벌루션 층들과 풀링 층들을 위해, 및 이미지 처리(예, 엣지 검출, 샤프닝(Sharpening), 블러링(blurring), 인식/분류)와 같은 다른 디지털 데이터 계산 응용들을 위해 필요하다. 그러나, NNU(121)의 하이브리드 동작은 컨벌루션 또는 풀링 동작을 수행하는 것에 국한되지 않고, 오히려 하이브리드 특징은 도 4 내지 도 13에 관해 위에서 기술한 고전적인 신경망 곱-누산 및 활성함수 동작들과 같은 다른 동작들을 수행하기 위하여 사용될 수 있다. 즉, 프로세서(100)(보다 구체적으로, 예약 스테이션(108))는 MTNN(1400) 및 MFNN(1500) 명령들을 NNU(121)에 배출하고, 이에 따라 NNU(121)는 데이터를 메모리(122/124/129)들에 기입하고, NNU(121)에 의해 메모리(122/124)들에 기입된 결과들을 그로부터 판독하고, 이와 동시에, NNU(121)는, 프로세서(100)에 의한 (MTNN(1400) 명령을 통해) 프로그램 메모리(129)에 기입된 프로그램들의 실행에 응답하여, 메모리(122/124/129)들을 판독 및 기입한다.
이제, 도 24를 참조하면, 컨벌루션 동작을 수행하기 위해 도 1의 NNU(121)에 의해 사용된 데이터 구조들의 예를 도시하는 블록도가 도시된다. 이 블록도는 컨벌루션 커넬(2402), 데이터 어레이(2402), 도 1의 데이터 RAM(122) 및 웨이트 RAM(124)을 포함한다. 바람직하게, 데이터 어레이(2404)(예, 이미지 픽셀들의)는 프로세서(100)에 부착된 시스템 메모리(미도시)에 유지되고, MTNN 명령(1400)을 실행하는 프로세서(100)에 의해 NNU(121)의 웨이트 RAM(124)에 로딩된다. 컨벌루션 동작은 제 제 2 매트릭스를 통해 1 매트릭스를 선회시키는 동작이고, 제 2 매트릭스는 본 명세서에서 컨벌루션 커넬로 언급된다. 본 개시사항의 내용에서 이해되는 바와 같이, 컨벌루션 커넬은 계수들의 매트릭스이고, 이는 또한 웨이트들, 파라미터들, 요소들 또는 값들로 언급될 수 있다. 바람직하게, 컨벌루션 커넬(2042)은 프로세서(100)에 의해 실행되고 있는 아키텍쳐 프로그램의 정적 데이터이다.
데이터 어레이(2404)는 데이터 값들의 2-차원 어레이이고, 각 데이터 값(예, 이미지 픽셀 값)은 데이터 RAM(122) 또는 웨이트 RAM(124)의 워드의 크기(예, 16비트 또는 8비트)이다. 본 예에서, 데이터 값들은 16비트 워드들이고, NNU(121)는 512 폭 구성의 NPU(126)들로 구성된다. 추가적으로, 본 실시예에서, NPU(126)들은 아래에서 더 상세하게 기술되는 바와 같이 웨이트 RAM(124)으로부터 수신된 데이터 값들의 한 행의 집단적인 회전자 동작을 수행하기 위하여, 도 7의 mux-reg(705)와 같은, 웨이트 RAM(124)으로부터 웨이트 워드(206)들을 수신하기 위한 mux-reg들을 포함한다. 본 예에서, 데이터 어레이(2404)는 2560열×1600행의 픽셀 어레이이다. 아키텍쳐 프로그램이 컨벌루션 커넬(2402)을 통해 데이터 어레이(2404)를 선회시킬 때, 데이터 어레이(2404)를 20개의 청크들로 분리하고, 각 청크는 도시된 바와 같이 512×400 데이터 매트릭스(2406)이다.
컨벌루션 커넬(2402)은 본 예에서 계수들, 웨이트들, 파라미터들 또는 요소들의 3×3 매트릭스이다. 계수들의 제1 행은 C0,0; C0,1; 및 C0,2로 표시되고; 계수들의 제 2 행은 C1,0; C1,1; 및 C1,2로 표시되고; 계수들의 제 3 행은 C2,0; C2,1; 및 C2,2로 표시된다. 예컨대, 엣지 검출을 수행하기 위해 사용될 수 있는 컨벌루션 커넬은 다음의 계수들을 갖는다: 0, 1, 0, 1, -4, 1, 0, 1, 0. 다른 예로서, 이미지를 가우시안 블러링을 수행하기 위하여 사용될 수 있는 컨벌루션 커넬은 다음의 계수들을 갖는다: 1, 2, 1, 2, 4, 2, 1, 2, 1. 이러한 경우, 최종 누적된 값에 대해 전형적으로 나눗셈이 수행되고, 이 때 제수는 컨벌루션 커넬(2402)의 요소들의 절대 값들의 합이고, 본 예에서 16이다. 다른 예로서, 제수는 컨벌루션 커넬(2402)의 요소들의 수이다. 다른 예로서, 제수는 컨벌루션들을 다시 값들의 원하는 범위 내로 압축하는 값이고, 이러한 제수는, 컨벌루션 커넬(2402)의 요소들의 값들, 및 선회되는 매트릭스의 원하는 범위 및 입력값들의 범위로부터 결정된다.
도 24에 도시되고, 도 25에 관해 더 상세하게 기술되는 바와 같이, 아키텍쳐 프로그램은 데이터 RAM(122)에 컨벌루션 커넬(2402)의 계수들을 기입한다. 바람직하게, 데이터 RAM(122)의 9개(컨벌루션 커넬(2402) 내의 요소들의 수)의 연속 행들의 각각의 모든 워드들은 컨벌루션 커넬(2402)의 상이한 요소와 함께 행-우선 순위로 기입된다. 즉, 한 행의 각 워드는 제1 계수 C0, 0과 함께 기입되고; 다음 행은 제 2 계수 C0, 1과 함께 기입되고; 다음 행은 제 3 계수 C0, 2과 함께 기입되고; 다음 행은 제 4 계수 C1, 0과 함께 기입되고; 이와 같은 방식으로, 제 9 행의 각 워드는 도시된 바와 같이 제 9 계수 C2, 2와 함께 기입된다. 데이터 어레이(2404)의 청크의 데이터 매트릭스(2406)를 선회하기 위하여, 특히 도 26a에 관해 아래에서 더 상세하게 기술되는 바와 같이, NPU들(126)은 컨벌루션 커넬(2402)의 계수들을 유지하는 데이터 RAM(122)의 9개 행들을 반복하여 순서대로 판독한다.
도 24에 도시되고, 도 25에 관해 더 상세하게 기술되는 바와 같이, 아키텍쳐 프로그램은 웨이트 RAM(124)에 데이터 매트릭스(2406)의 값들을 기입한다. NNU 프로그램이 컨벌루션을 수행하기 때문에, 최종 매트릭스를 웨이트 RAM(124)에 다시 기입한다. 바람직하게, 아키텍쳐 프로그램은 제1 데이터 매트릭스(2406)를 웨이트 RAM(124)에 기입하고, NNU(121)를 시작하고, NNU(121)가 컨벌루션 커넬(2402)을 통해 제1 데이터 매트릭스(2406)를 선회시키는 동안, 아키텍쳐 프로그램은 제 2 데이터 매트릭스(2406)를 웨이트 RAM(124)에 기입하여, NNU(121)가 제1 데이터 매트릭스(2406)의 컨벌루션을 종료하자마자, NNU(121)는 도 25에 관해 더 상세하게 기술되는 바와 같이, 제 2 데이터 매트릭스(2406)의 선회를 시작할 수 있다. 이러한 방식으로, 아키텍쳐 프로그램은 NNU(121)가 완전히 사용된 채로 유지하기 위하여 웨이트 RAM(124)의 2개의 영역들 사이에서 앞뒤로 반복한다. 따라서, 도 24의 예는, 웨이트 RAM(124)의 행 0 내지 행 399를 점유하는 제1 청크에 대응하는 제1 데이터 매트릭스(2406A), 및 웨이트 RAM(124)의 행 500 내지 행 899를 점유하는 제 2 청크에 대응하는 제 2 데이터 매트릭스(2406B)를 도시한다. 더욱이, 도시된 바와 같이, NNU(121)는 컨벌루션들의 결과들을 웨이트 RAM(124)의 행 900 - 행 1299 및 행 1300 - 행 1699에 다시 기입하고, 아키텍쳐 프로그램은 후속적으로 이를 웨이트 RAM(124)으로부터 판독한다. 웨이트 RAM(124)에 유지된 데이터 매트릭스(2406)의 데이터 값들은 "Dx,y"로 표시되고, 여기에서 "x"는 웨이트 RAM(124)의 행 번호이고, "y"는 웨이트 RAM(124)의 워드, 또는 열, 번호이다. 따라서, 예컨대 행 399 내의 데이터 워드 511는 도 24에서 D399, 511로 표시되고, 이는 NPU(511)의 mux-reg(705)에 의해 수신된다.
이제, 도 25를 참조하면, NNU(121)를 사용하는 아키텍쳐 프로그램을 수행하여, 도 24의 데이터 어레이(2404)를 통한 컨벌루션 커넬(2042)의 컨벌루션을 수행하기 위한 도 1의 프로세서(100)의 동작을 도시하는 흐름도가 도시된다. 흐름은 블록(2502)에서 시작한다.
블록(2502)에서, 프로세서(100), 즉 프로세서(100) 상에서 실행중인 아키텍쳐 프로그램은 도 24의 컨벌루션 커넬(2402)을 도 24에 관해 도시되고 기술되는 방식으로, 데이터 RAM(122)에 기입한다. 추가적으로, 아키텍쳐 프로그램은 변수 N을 1의 값으로 초기화한다. 변수 N은 NNU(121)에 의해 처리되는 데이터 어레이(2404)의 현재의 청크를 나타낸다. 추가적으로, 아키텍쳐 프로그램은 변수 NUM_CHUNKS를 20의 값으로 초기화한다. 흐름은 블록(2504)으로 진행한다.
블록(2504)에서, 프로세서(100)는 도 24(예, 청크 1의 데이터 매트릭스(2406A))에 도시된 바와 같이, 청크 1에 대한 데이터 매트릭스(2406)를 웨이트 RAM(124)에 기입한다. 흐름은 블록(2506)으로 진행한다.
블록(2506)에서, 프로세서(100)는, 프로그램 메모리(129)를 기입하기 위한 함수(1432)를 지정하는 MTNN(1400) 명령들을 사용하여, 컨벌루션 프로그램을 NNU(121)의 프로그램 메모리(129)에 기입한다. 프로세서(100)는 이후 프로그램의 실행을 시작하기 위한 함수(1432)를 지정하는 MTNN(1400) 명령을 사용하여 NNU 컨벌루션 프로그램을 시작한다. NNU 컨벌루션 프로그램의 일 예는 도 26a에 관해 더 상세하게 기술된다. 흐름은 결정 블록(2508)으로 진행한다.
결정 블록(2508)에서, 아키텍쳐 프로그램은 변수 N의 값이 NUM_CHUNKS보다 작은지를 결정한다. 만약 작다면, 흐름은 블록(2512)으로 진행하고; 그렇지 않을 경우 흐름은 블록(2514)으로 진행한다.
블록(2512)에서, 프로세서(100)는 청크 N+1에 대한 데이터 매트릭스(2406)를 도 24(예, 청크 2의 데이터 매트릭스(2406B))에 도시된 바와 같이, 웨이트 RAM(124)에 기입한다. 따라서, 유리하게 아키텍쳐 프로그램은 다음 청크에 대한 데이터 매트릭스(2406)를 웨이트 RAM(124)에 기입하고, 동시에 NNU(121)는 현재 청크에 대한 컨벌루션을 수행하여, NNU(121)는 현재 청크의 컨벌루션이 완료되면, 즉 웨이트 RAM(124)에 기입되면, 다음 청크에 대한 컨벌루션의 수행을 즉시 시작할 수 있다. 흐름은 블록(2514)으로 진행한다.
블록(2514)에서, 프로세서(100)는 현재 실행중인 NNU 프로그램(청크 1의 경우 블록(2506)에서 시작된, 및 청크 2-20의 경우 블록(2518)에서 시작된)이 종료되었음을 결정한다. 바람직하게, 프로세서(100)는 NNU(121)의 상태 레지스터(127)를 판독하기 위한 MFNN(1500) 명령을 실행함으로써 이를 실행한다. 다른 실시예에 있어서, NNU(121)는 컨벌루션 프로그램을 종료했음을 나타내기 위한 인터럽트를 생성한다. 흐름은 결정 블록(2516)으로 진행한다.
결정 블록(2516)에서, 아키텍쳐 프로그램은 변수 N의 값이 NUM_CHUNKS보다 작은 지를 결정한다. 만약 작다면, 흐름은 블록(2518)으로 진행하고; 그렇지 않을 경우, 흐름은 블록(2522)으로 진행한다.
블록(2518)에서, 프로세서(100)는 청크 N+1를 선회할 수 있도록 컨벌루션 프로그램을 경신한다. 더욱 특별히, 프로세서(100)는 어드레스 0에서 초기화 NPU 명령의 웨이트 RAM(124) 행의 값을 데이터 매트릭스(2406)의 제1행(예, 데이터 매트릭스(2406A)에 대한 행 0으로, 또는 데이터 매트릭스(2406B)에 대한 행 500으로)으로 경신하고, 출력 행을 (예, 900 또는 1300으로) 경신한다. 프로세서(100)는 이후 경신된 NNU 컨벌루션 프로그램을 시작한다. 흐름은 블록(2522)으로 진행한다.
블록(2522)에서, 프로세서(100)는 청크 N에 대해 웨이트 RAM(124)으로부터 NNU 컨벌루션 프로그램의 결과들을 판독한다. 흐름은 결정 블록(2524)으로 진행한다.
결정 블록(2524)에서, 아키텍쳐 프로그램은 변수 N의 값이 NUM_CHUNKS보다 작은지를 결정한다. 만약 작다면, 흐름은 블록(2526)으로 진행하고; 그렇지 않을 경우 흐름은 종료된다.
블록(2526)에서, 아키텍쳐 프로그램은 N을 1만큼 증가시킨다. 흐름은 결정 블록(2508)으로 진행한다.
이제, 도 26a을 참조하면, 도 24의 컨벌루션 커넬(2042)을 통해 데이터 매트릭스(2406)의 컨벌루션을 수행하고 이를 다시 웨이트 RAM(124)에 기입하는 NNU 프로그램의 프로그램 목록이 도시된다. 프로그램은, 어드레스 1 내지 어드레스 9에서 명령의 루프 몸체를 통해 다수회 루프 반복한다. 어드레스 0에서 초기화 NPU 명령은 각 NPU(126)가 루프 본체를 실행하는 횟수를 지정하고, 이는 도 26a의 예에서 도 24의 데이터 매트릭스(2406) 내의 행들의 수에 대응하는 400의 루프 카운트 값을 갖고, 루프의 마지막(어드레스 10)에서 루프 명령은 현재의 루프 카운트 값을 감소시키고, 결과가 0이 아니라면, 제어가 루프 몸체의 상부로(즉, 어드레스 1에서의 명령으로) 되돌아 가게 한다. 초기화 NPU 명령은 또한 누산기(202)를 0으로 소거한다. 바람직하게, 어드레스 10에서 루프 명령은 또한 누산기(202)를 0으로 소거한다. 대안적으로, 상술한 바와 같이, 어드레스 1에서 곱-누적 명령은 누산기(202)를 0으로 소거하도록 지정한다.
프로그램의 루프 본체의 각 실행을 위해, 512개의 NPU들(126)은 3×3 컨벌루션 커넬(2402) 및 데이터 매트릭스(2406)의 512개의 각 3×3 하위-매트릭스들의 512번의 컨벌루션을 동시에 수행한다. 컨벌루션은 컨벌루션 커넬(2402)의 요소와 각 하위-매트릭스의 대응하는 요소의 9개의 곱들의 합이다. 도 26a의 실시예에서, 512개의 각 3×3 하위-매트릭스들의 각각의 원점(중심 요소)은 도 24의 데이터 워드 Dx+1,y+1이고, 여기에서 y(열번호)는 NPU(126)의 번호이고, x(행 번호)는 도 26a의 프로그램의 어드레스 1에서 곱-누적 명령에 의해 판독된 현재의 웨이트 RAM(124)의 행 번호이다(또한, 행 번호는 어드레스 0에서 초기화 NPU 명령에 의해 초기화되고, 어드레스 3 및 어드레스 5에서 곱-누적 명령들의 각각에서 증가되고, 어드레스 9에서 감소 명령에 의해 경신된다). 따라서, 프로그램의 각 루프에 대해, 512개의 NPU(126)들은 512개의 컨벌루션들을 계산하고, 512개의 컨벌루션 결과들을 웨이트 RAM(124)의 지정된 행에 다시 기입한다. 본 설명에서, NPU(126)들의 집단적인 회전 특징의 사용이 데이터 매트릭스(2406)의(이미지 처리의 경우, 이미지의) 하나의 수직 엣지로부터 다른 수직 엣지로 (예, 좌측 엣지로부터 우측 엣지로, 또는 그 역으로) 열들 중 2개에 대한 랩핑(wrapping)을 야기할 것임을 주목해야 하지만, 엣지 처리는 단순화를 위해 무시된다. 루프 몸체가 이제 설명될 것이다.
어드레스 1에서, 곱-누산 명령은 데이터 RAM(122)의 행 0을 지정하고, 현재의 웨이트 RAM(124)의 행을 명확하게 사용하고, 이는 바람직하게 시퀀서(128)에 유지된다(그리고 이는 루프 몸체에 대한 제1 패스쓰루를 위해 어드레스 0에서의 명령에 의해 0으로 초기화된다). 즉, 어드레스 1에서의 명령은 NPU(126)들의 각각이 데이터 RAM(122)의 행 0으로부터 대응하는 워드를 판독하고, 현재의 웨이트 RAM(124)의 행으로부터 대응하는 워드를 판독하고, 2개의 워드들에 대한 곱-누산 동작을 수행하게 한다. 따라서, 예컨대 NPU 5는 C0, 0과 Dx, 5를 곱하고(여기에서, "x"는 웨이트 RAM(124)의 행이다), 결과를 누산기(202)의 값(217)에 더하고, 합을 다시 누산기(202)에 기입한다.
어드레스 2에서, 데이터 RAM(122)의 행을 증가시키고(즉, 행 1로), 이후 증가된 어드레스에서 데이터 RAM(122)으로부터의 행을 판독하도록 지정하는 것은 곱-누산 명령이다. 명령은 또한 각 NPU(126)의 mux-reg(705) 내의 값들을 인접한 NPU(126)로 회전하도록 지정하고, 이 경우 어드레스 1에서 명령에 따라 웨이트 RAM(124)으로부터 바로 판독된 것은 데이터 메트릭스(2406)의 값들의 행이다. 도 24 내지 도 26의 실시예에서, NPU들(126)은 mux-reg(705)의 값들을 좌측으로, 즉 도 3, 도 7 및 도 19에 관해 위에서 기술된 바와 같이, NPU J로부터 NPU J+1로가 아니라, NPU J로부터 NPU J-1으로 회전시키도록 구성된다. NPU(126)들이 오른쪽으로 회전하도록 구성되는 실시예에서, 아키텍쳐 프로그램은 컨벌루션 커넬(2402)의 계수 값들을 유사한 컨벌루션 결과를 달성하기 위하여 다른(예, 그 중앙 열 주위로 회전된) 순서로 데이터 RAM(122)에 기입한다. 더욱이, 아키텍쳐 프로그램은 컨벌루션 커넬(2402)의 추가적인 사전-처리(예, 전치)를 필요에 따라 수행할 수 있다. 추가적으로, 명령은 2의 카운트 값을 지정한다. 따라서, 어드레스 2에서의 명령은 NPU들(126)의 각각이 데이터 RAM(122)의 행 1로부터 대응하는 워드를 판독하고, 회전된 워드를 mux-reg(705) 안으로 수신하고, 2개의 워드들에 대한 곱-누산 동작을 수행하게 한다. 2의 카운트 값으로 인해, 명령은 또한 NPU들(126)의 각각이 바로 기술된 동작을 반복하게 한다. 즉, 시퀀서(128)는 데이터 RAM(122) 행의 어드레스(123)를 증가시키고(즉, 행 2로), 각 NPU(126)는 데이터 RAM(122)의 행 2로부터 대응하는 워드를 판독하고, 회전된 워드를 mux-reg(705) 안으로 수신하고, 2 개의 워드들에 대한 곱-누산 동작을 수행한다. 따라서, 예컨대, 현재의 웨이트 RAM(124)의 행이 27인 것을 가정하여, 어드레스 2에서 명령을 실행한 후, NPU 5는 C0, 1 및 D27, 6의 곱과 C0, 2 및 D27, 7의 곱을 누산기(202)에 누적시킬 것이다. 따라서, 어드레스 1 및 어드레스 2에서 명령들의 종료 후, C0, 0 및 D27, 5의 곱, C0, 1 및 D27, 6의 곱, 및 C0, 2 및 D27, 7의 곱이, 루프 몸체에 대한 이전의 패스쓰루들로부터 다른 모든 누적된 값들과 함께, 누산기(202)에 누적될 것이다.
어드레스 3 및 어드레스 4에서의 명령들은 어드레스 1 및 어드레스 2에서의 명령들과 유사한 동작을 수행한다, 하지만 웨이트 RAM(124)의 행 증가 표시자로 인해 웨이트 RAM(124)의 다음 행에 대해, 및 데이터 RAM(122)의 다음 3개의 행들에 대해, 즉 행 3 내지 행 5에 대해, 수행한다. 즉, NPU 5에 관해, 예컨대 어드레스 1 내지 어드레스 4에서 명령들의 종료 이후, C0, 0 및 D27, 5의 곱, C0, 1 및 D27, 6의 곱, C0, 2 및 D27, 7의 곱, C1, 0 및 D28, 5의 곱, C1, 1 및 D28, 6의 곱, 및 C1, 2 및 D28, 7의 곱이, 루프 몸체를 통한 이전 통과로부터 다른 누적된 값들 모두와 함께, 누산기(202)에 누적될 것이다.
어드레스 5 및 어드레스 6에서의 명령들은 어드레스 3 및 어드레스 4에서의 명령들과 유사한 동작을 수행한다, 하지만 웨이트 RAM(124)의 다음 행에 대해, 및 데이터 RAM(122)의 다음 3개의 행들에 대해, 즉 행 6 내지 행 8에 대해, 수행한다. 즉, NPU 5에 관해, 예컨대 어드레스 1 내지 어드레스 6에서 명령들의 종료 이후, C0, 0 및 D27, 5의 곱, C0, 1 및 D27, 6의 곱, C0, 2 및 D27, 7의 곱, C1, 0 및 D28, 5의 곱, C1, 1 및 D28, 6의 곱, C1, 2 및 D28, 7의 곱, C2, 0 및 D29, 5의 곱, C2, 1 및 D29, 6의 곱 및 C2, 2 및 D29, 7의 곱이 루프 몸체에 대한 이전 패스쓰루로부터 다른 누적된 값들 모두와 함께, 누산기(202)에 누적될 것이다. 즉, 어드레스 1 내지 어드레스 6에서 명령들의 종료 이후, 루프 몸체의 시작에서 웨이트 RAM(124)의 행이 27인 것을 가정하여, 예컨대 NPU 5는 다음의 3×3 하위-매트릭스를 선회하기 위하여 컨벌루션 커넬(2402)을 사용할 것이다:
D27,5 D27,6 D27,7
D28,5 D28,6 D28,7
D29,5 D29,6 D29,7
보다 일반적으로, 어드레스 1 내지 어드레스 6에서 명령들의 종료 이후, 512개의 NPU들(126)의 각각은 다음의 3×3 하위-매트릭스를 선회하기 위하여 컨벌루션 커넬(2402)을 사용할 것이다:
Dr,n Dr,n+1 Dr,n+2
Dr+1,n Dr+1,n+1 Dr+1,n+2
Dr+2,n Dr+2,n+1 Dr+2,n+2
여기에서, r은 루프 몸체의 시작시 웨이트 RAM(124)의 행 어드레스 값이고, n은 NPU(126)의 번호이다.
어드레스 7에의 명령은 누산기(202)의 값(217)을 AFU(212)를 통해 전달한다. 패스쓰루(pass through) 함수는 데이터 RAM(122) 및 웨이트 RAM(124)으로부터 판독된 워드들의 크기(비트수)(즉, 본 예에서 16비트)인 워드를 전달한다. 바람직하게, 사용자는 출력의 포맷, 예컨대 아래에서 더 상세하게 기술되는 바와 같이 얼마나 많은 출력 비트들이 분수 비트들인지를 지정한다. 대안적으로, 패스쓰루 활성함수를 지정하는 것보다, 예컨대 도 30의 "분할기"(3014/3016) 중 하나를 사용하여 예컨대 도 29a 및 도 30에 관해 본 명세서에서 기술되는 것과 같은, 분할기를 통해 누산기(202)의 값(217)을 나누는 나눗셈 활성함수가 지정된다. 예컨대, 상술한 가우시안 블러(Gaussian blur) 커넬의 1/16 계수와 같은 계수를 갖는 컨벌루션 커넬(2402)의 경우, 패스쓰루 함수보다, 어드레스 7에서의 활성함수 명령이 나눗셈(예, 16에 의한) 활성함수를 지정할 수 있다. 대안적으로, 아키텍쳐 프로그램은, 컨벌루션 커넬(2402)의 계수들에 대해, 이들을 데이터 RAM(122)에 기입하기 전에 16에 의한 나눗셈을 수행할 수 있고, 예컨대 아래에서 기술되는 도 29의 데이터 이진 포인트(2922)를 사용하여 컨벌루션 커넬(2402) 값들에 대해 이진 포인트의 위치를 적절하게 조절할 수 있다.
어드레스 8에서 명령은 AFU(212)의 출력을 출력 행 레지스터의 현재 값에 의해 지정된 웨이트 RAM(124)의 행에 기입하고, 이러한 현재값은 어드레스 0에서의 명령에 의해 초기화되었고, 이는 명령 내의 증가 표시자 덕분에 루프의 각 패스쓰루시 증가된다.
3×3 컨벌루션 커넬(2402)을 갖는 도 24 내지 도 26의 예로부터 결정될 수 있는 바와 같이, NPU들(126)은 데이터 매트릭스(2406)의 한 행을 판독하기 위하여 대략 매 3번째 클록 사이클에 웨이트 RAM(124)을 판독하고, 컨벌루션 결과 매트릭스를 기입하기 위하여 대략 매 12개 클록 사이클마다 웨이트 RAM(124)을 기입한다. 추가적으로 도 17의 버퍼(1704)와 같은 기입 및 판독 버퍼를 포함하는 실시예를 가정하여, NPU(126)가 판독하고 기입하는 것과 동시에, 프로세서(100)는 웨이트 RAM(124)을 판독 및 기입하여, 버퍼(1704)는 데이터 매트릭스(2406)들을 기입하고 컨벌루션 결과 매트릭스를 판독하기 위하여 대략 매 16개 클록 사이클들마다 웨이트 RAM(124)의 한 번의 판독과 한 번의 기입을 각각 수행하게 된다. 따라서, 대략 웨이트 RAM(124)의 대역폭의 절반은 NNU(121)가 컨벌루션 동작을 수행하는 하이브리드 방식에 의해 소비된다. 본 예가 3×3 컨벌루션 커넬(2402)을 포함하지만, 2×2, 4×4, 5×5, 6×6, 7×7, 8×8, 등의 매트릭스들과 같은 다른 크기의 컨벌루션 커넬들이 채용될 수 있고, 이 경우 NNU 프로그램이 변할 것이다. 더 큰 컨벌루션 커넬의 경우, 웨이트 RAM(124) 대역폭의 더 작은 백분율이 소비되는데, 왜냐하면 곱-누산 명령들의 회전 형태들에서 카운트가 더 커서 (예, 더 큰 컨벌루션 커넬을 위해 필요할 도 26a의 프로그램 및 추가적인 이러한 명령들의 어드레스 2, 4 및 6에서) NPU(126)들이 웨이트 RAM(124)을 더 작은 비율의 시간에 판독하기 때문이다.
대안적으로, 컨벌루션들의 결과들을 웨이트 RAM(124)의 상이한 행(예, 900-1299 및 1300-1699)들에 다시 기입하는 것이 아니라, 아키텍쳐 프로그램은 행들이 더 이상 필요하지 않게 된 후 입력 데이터 매트릭스(2406)의 행들을 덮어쓰도록 NNU 프로그램을 구성한다. 예컨대, 3×3 컨벌루션 커넬의 경우, 데이터 매트릭스(2406)를 웨이트 RAM(124)의 행들 0-399에 기입하는 것이 아니라, 아키텍쳐 프로그램은 데이터 매트릭스(2406)를 행들 2-401에 기입하고, NNU 프로그램은 행 0에서 시작하여 루프 본체의 각 패스쓰루마다 증가시키면서 컨벌루션 결과를 웨이트 RAM(124)에 기입하도록 구성된다. 이러한 방식으로, NNU 프로그램은 더 이상 필요하지 않은 행들만을 덮어쓴다. 예컨대, 루프 본체의 제1 패스쓰루 이후(또는 보다 특별히 웨이트 RAM(124)의 행 0에 로딩하는 어드레스 1의 명령의 실행 이후), 행들 1-3 내의 데이터는 루프 본체의 제 2 패스쓰루에 필요할 것이고, 따라서 루프 본체의 제1 패스쓰루에 의해 덮여 쓰여지지 않지만, 행 0의 데이터는 이제 덮어 쓰여질 수 있고; 유사하게, 루프 본체의 제 2 패스쓰루 이후, 행들 2-4 내의 데이터는 루프 본체의 제 2 패스쓰루에 필요할 것이고, 따라서 루프 본체의 제 2 패스쓰루에 의해 덮여 쓰여지지 않지만, 행 1의 데이터는 이제 덮여 쓰여질 수 있는, 등의 방식이다. 이러한 실시예에서, 각 데이터 매트릭스(2406)(청크)의 높이는 더 클 수 있어(에, 800 행들), 더 적은 청크들을 초래한다.
대안적으로, 컨벌루션들의 결과들을 웨이트 RAM(124)에 다시 기입하는 것이 아니라, 아키텍쳐 프로그램은 컨벌루션 커넬(2402) 위의(예, 행 8 위의) 데이터 RAM(122)의 행들에 컨벌루션들의 결과들을 다시 기입하도록 NNU 프로그램을 구성하고, 아키텍쳐 프로그램은 NNU(121)이 그들을 기입한 데이터 RAM(122)으로부터 (예, 아래에서 기술된 도 26b의 가장 최근에 기입된 데이터 RAM(122)의 행(2606)의 어드레스를 사용하여) 결과들을 판독한다. 이러한 대안은 웨이트 RAM(124)이 단일-포트로 이루어지고 데이터 RAM(122)이 2중-포트로 이루어진 실시예에서 유리할 수 있다.
도 24 내지 도 26a의 실시예에 따른 NNU(121)의 동작으로부터 알 수 있는 바와 같이, 도 26a의 프로그램의 각 실행은 대략 5000개 클록 사이클들이 걸리고, 결과적으로 도 24의 전체 2560×1600 데이터 어레이(2404)의 선회는 대략 100,000개 클록 사이클들이 걸리고, 이는 종래의 방법들에 의해 유사한 업무를 수행하기 위하여 필요한 클록 사이클들의 수보다 상당히 적을 수 있다.
이제, 도 26b를 참조하면, 일 실시예에 따라 도 1의 NNU(121)의 제어 레지스터(127)의 특정 필드들을 도시하는 블록도가 도시된다. 상태 레지스터(127)는, NPU들(126)에 의해 기입된 웨이트 RAM(124)의 가장 최근 행의 어드레스를 나타내는 필드(2602); NPU들(126)에 의해 기입된 데이터 RAM(122)의 가장 최근 행의 어드레스를 나타내는 필드(2606); NPU들(126)에 의해 판독된 웨이트 RAM(124)의 가장 최근 행의 어드레스를 나타내는 필드(2604); 및 NPU들(126)에 의해 판독된 데이터 RAM(122)의 가장 최근 행의 어드레스를 나타내는 필드(2608)를 포함한다. 이것은 프로세서(100)상에서 실행중인 아키텍쳐 프로그램이 NNU(121)가 데이터 RAM(122) 및/또는 웨이트 RAM(124)의 판독 및/또는 기입을 행할 때 NNU(121)의 진행을 결정하는 것을 가능케 한다. 상술한 바와 같이 입력 데이터 매트릭스를 덮어쓰기 (또는 위에서 언급한 바와 같이 결과들을 데이터 RAM(122)에 기입하기) 위한 선택과 함께 이러한 성능을 채용하면서, 도 24의 데이터 어레이(2404)는 예컨대 다음과 같이 512×400의 20개 청크들이 아니라 512×1600의 5개 청크들로서 처리될 수 있다. 프로세서(100)는 행 2에서 시작하여 512×1600의 청크를 웨이트 RAM(124)에 기입하고, NNU 프로그램(1600의 루프 카운트를 갖고, 0의 초기화된 웨이트 RAM(124)의 출력 행을 갖는)을 시작한다. NNU(121)가 NNU 프로그램을 실행할 때, 프로세서(100)는, (1) NNU(121)에 의해 (행 0에서 시작하여) 기입된 유효한 컨벌루션 결과들을 갖는 웨이트 RAM(124)의 행들을 (MFNN(1500) 명령을 사용하여) 판독하고, (2) 이들이 이미 판독되었다면, 유효한 컨벌루션 결과들에 걸쳐 (행 2에서 시작하여) 제 2 512×1600 데이터 매트릭스(2406)를 기입하기 위하여, 웨이트 RAM(124) 출력의 위치/어드레스를 모니터링하고, 이에 의해 NNU(121)가 제1의 512×1600 청크에 대한 NNU 프로그램을 종료할 때, 프로세서(100)는 필요할 때 NNU 프로그램을 즉시 경신할 수 있고, 제2의 512×1600 청크를 처리하기 위하여 이를 다시 시작한다. 이러한 처리는 나머지 3개의 512×1600 청크들에 대해 3번 더 반복하여, NNU(121)의 높은 이용을 달성한다.
유리하게, 일 실시예에 있어서, AFU(212)는 특히 도 29a 및 도 29b 및 도 30에 관해 아래에서 더 상세하게 기술되는 바와 같이, 누산기(202)의 값(217)의 유효한 나눗셈을 효과적으로 수행하는 능력을 포함한다. 예컨대, 누산기(202)의 값(217)을 16으로 나누는 활성함수의 NNU 명령은 위에서 기술한 가우시안 블러링 매트릭스를 위해 사용될 수 있다.
비록 도 24의 예에서 사용된 컨벌루션 커넬(2402)이 전체 데이터 어레이(2404)에 가해진 작은 정적 컨벌루션 커넬이지만, 다른 실시예들에서 컨벌루션 커넬은, 컨벌루션 신경망들에서 공통적으로 발견되는 것과 같이, 데이터 어레이(2404)의 상이한 데이터 값들과 관련된 고유한 웨이트들을 갖는 대형 매트릭스가 될 수 있다. NNU(121)가 이러한 방식으로 사용될 때, 아키텍쳐 프로그램은 데이터 매트릭스 및 컨벌루션 커넬의 위치들, 즉 데이터 RAM(122) 내의 데이터 매트릭스가 있는 및 웨이트 RAM(124) 내에 컨벌루션 커넬이 있는 장소를 교환할 수 있고, NNU 프로그램의 주어진 실행에 의해 처리될 수 있는 행들의 수는 상대적으로 적을 수 있다.
이제 도 27을 참조하면, 블록도는 풀링 동작이 도 1의 NNU(121)에 의해 수행되는 입력 데이터로 채워진 도 1의 웨이트 RAM(124)의 예를 도시한다. 인공 신경망의 풀링 층에 의해 수행되는 풀링 동작은 입력 매트릭스의 하위-영역들, 또는 하위-매트릭스들을 취하고, 하위-매트릭스의 최대 또는 평균값을 계산함으로써 입력 데이터 매트릭스(예, 이미지 또는 선회된 이미지)의 크기들을 줄일 수 있고, 최대 또는 평균값들은 최종 매트릭스 또는 풀링된 매트릭스가 된다. 도 27 및 도 28의 예에서, 풀링 동작은 각 하위-매트릭스의 최대값을 계산한다. 풀링 동작들은 예컨대 물체 분류 또는 검출을 행하는 인공 신경망에 특히 유용하다. 일반적으로, 풀링 동작은 시험되는 하위-매트릭스 내의 요소들의 수의 인자만큼 입력 매트릭스의 크기를 효과적으로 감소시키고, 특히 하위-매트릭스의 대응하는 크기의 요소들의 수만큼 각 크기 내의 입력 매트릭스를 감소시킨다. 도 27의 예에서, 입력 데이터는 웨이트 RAM(124)의 행 0 내지 행 1599에 저장된 넓은 워드들(예, 16비트)의 512×1600 매트릭스이다. 도 27에서, 워드들은 그들의 행, 열의 위치로 표시된다, 예컨대 행 0 및 열 0의 워드는 D0,0으로 표시되고; 행 0 및 열 1의 워드는 D0,1로 표시되고; 행 0 및 열 2의 워드는 D0,2로 표시되고; 이와 같은 방식으로, 행 0 및 열 511의 워드는 D0,511로 표시된다. 유사하게, 행 1 및 열 0의 워드는 D1,0으로 표시되고; 행 1 및 열 1의 워드는 D1,1로 표시되고; 행 1 및 열 2의 워드는 D1,2로 표시되고; 이와 같은 방식으로, 행 1 및 열 511의 워드는 D1,511로 표시되고; 이와 같은 방식으로 행 1599 및 열 0의 워드는 D1599,0으로 표시되고; 행 1599 및 열 1의 워드는 D1599,1로 표시되고; 행 1599 및 열 2의 워드는 D1599,2로 표시되고; 이와 같은 방식으로, 행 1599 및 열 511의 워드는 D1599,511로 표시된다.
이제, 도 28을 참조하면, 도 27의 입력 데이터 매트릭스의 풀링 동작을 수행하고 이를 다시 웨이트 RAM(124)에 기입하는 NNU 프로그램의 프로그램 목록이 도시된다. 도 28의 예에서, 풀링 동작은 입력 데이터 매트릭스의 각 4×4 하위-매트릭스들의 최대값을 계산한다. 프로그램은 어드레스 1 내지 어드레스 10에서 명령의 루프 몸체를 통해 다수회 루프 반복한다. 어드레스 0에서 초기화 NPU 명령은 각 NPU 루프 몸체를 실행하는 횟수를 지정하고, 이 횟수는 도 28의 예에서 400의 루프 카운트 값을 갖고, 루프의 마지막(어드레스 11에서)에서 루프 명령은 현재의 루프 카운트 값을 감소시키고, 결과가 0이 아니라면, 제어가 루프 몸체의 상부(즉, 어드레스 1에서의 명령)로 되돌아가게 한다. 웨이트 RAM(124) 내의 입력 데이터 매트릭스는, 4개의 인접한 행들, 즉 행들 0-3, 행들 4-7, 행들 8-11, 이와 같은 방식으로 행들 1596-1599의 400개의 상호 배타적인 그룹들로서 NNU 프로그램에 의해 효과적으로 취급된다. 4개의 인접한 행들의 각 그룹은 128개의 4×4 하위-매트릭스들, 즉 한 그룹의 4개 행들 및 4개의 인접한 열들, 즉 열들 0-3, 4-7, 8-11, 등과 같이 열들 508-511의 교차에 의해 형성된 요소들의 4×4 하위-매트릭스들을 포함한다. 512개의 NPU(126) 중, 512개의 NPU(126)의 매 4번째 NPU(126)(즉, 128)은 각 4×4 하위-매트릭스에 대한 풀링 동작을 수행하고, NPU(126)의 다른 3/4는 사용되지 않는다. 보다 특별히, NPU들 0, 4, 8, 이와 같은 방식으로 NPU 508 각각은, NPU 번호에 대응하는 가장 좌측의 열 번호를 갖고, 현재의 웨이트 RAM(124)의 행 값에 대응하는 하부 행을 갖는 각 4×4 하위-매트릭스에 대한 풀링 동작을 수행하고, 아래에서 더 상세하게 기술되는 바와 같이, 이는 어드레스 0에서 초기화 명령에 의해 0으로 초기화되고, 루프 몸체의 각 반복시 4만큼 증가된다. 루프 몸체의 400회의 반복은 도 27의 입력 데이터 매트릭스의 4×4 하위-매트릭스들의 그룹들(4로 나누어진 입력 데이터 매트릭스의 1600개 행들)의 수에 대응한다. 초기화 NPU 명령은 또한 누산기(202)를 0으로 소거한다. 바람직하게, 어드레스 11에서 루프 명령은 또한 누산기(202)를 0으로 소거한다. 대안적으로, 어드레스 1에서 maxwacc 명령은 누산기(202)를 0으로 소거하는 것을 지정한다.
프로그램의 루프 몸체의 각 반복을 위해, 128개의 사용된 NPU(126)들은 입력 데이터 매트릭스의 현재의 4-행 그룹의 128개 각 4×4 하위-매트릭스들의 128개 풀링 동작들을 동시에 수행한다. 보다 특별히, 풀링 동작은 4×4 하위-매트릭스의 16개 요소들 중 최대값의 요소를 결정한다. 도 28의 실시예에서, 사용된 128개의 NPU(126)들의 각 NPU y에 대해, 4×4 하위-매트릭스의 좌측 하부 요소는 도 27의 요소 Dx,y이고, 여기에서 x는 루프 몸체의 시작에서 현재의 웨이트 RAM(124)의 행 번호이고, 이는 도 28의 프로그램의 어드레스 1에서 maxwacc 명령에 의해 판독된다(또한, 행 번호는 어드레스 0에서 초기화 NPU 명령에 의해 초기화되고, 어드레스 3, 5 및 7에서 maxwacc 명령들의 각각에서 증가된다). 따라서, 프로그램의 각 루프에 대해, 사용된 128개 NPU(126)들은 행들의 현재 그룹의 각 128개 4×4 하위-매트릭스의 대응하는 최대값의 요소를 웨이트 RAM(124)의 지정된 행에 다시 기입한다. 루프 몸체가 이제 기술될 것이다.
어드레스 1에서, 현재의 웨이트 RAM(124)의 행을 명백하게 사용하는 것은 maxwacc 명령이고, 이는 바람직하게 시퀀서(128) 내에 유지된다(및 이것은 루프 몸체의 제1 패스쓰루를 위해 어드레스 0에서의 명령에 의해 0으로 초기화된다). 어드레스 1에서의 명령은 각 NPU(126)들이 웨이트 RAM(124)의 현재의 행으로부터 대응하는 워드를 판독하게 하고, 이 워드를 누산기(202)의 값(217)과 비교하고, 2개 값들 중 최대값을 누산기(202)에 저장한다. 따라서, 예컨대 NPU 8은 누산기(202)의 값(217) 및 데이터 워드 Dx,8(여기에서 "x"는 현재의 웨이트 RAM(124)의 행) 중 최대값을 결정하고, 최대값을 다시 누산기(202)에 기입한다.
어드레스 2에서 각 NPU(126)의 mux-reg(705) 내의 값들을 인접한 NPU(126)로 회전시키도록 지정하는 것은 maxwacc 명령이고, 이는 이 경우 어드레스 1에서의 명령에 응답하여 웨이트 RAM(124)으로부터 방금 판독된 입력 데이터 매트릭스 값들의 행이다. 도 27 내지 도 28의 실시예에서, NPU(126)들은 mux-reg(705)들의 값들을 좌측으로, 즉 도 24 내지 도 26에 관해 위에서 기술된 바와 같이 MPU J로부터 NPU J-1로 회전시키도록 구성된다. 추가적으로, 명령은 3의 카운트 값을 지정한다. 따라서, 어드레스 2에서의 명령은 NPU(126)들의 각각 회전된 워드를 mux-reg(705) 안으로 수신하고, 회전된 워드 및 누산기(202)의 값(217) 중 최대값을 결정하고, 이후 이러한 동작을 2번 더 반복하게 한다. 즉, 각 NPU(126)는 회전된 워드를 mux-reg(705) 안으로 수신하고, 회전된 워드 및 누산기(202)의 값(217) 중 최대값을 3번 결정한다. 따라서, 예컨대 루프 몸체의 시작시 현재의 웨이트 RAM(124)의 행이 36인 것을 가정하면, 어드레스 1 및 어드레스 2에서의 명령을 실행한 후, 예컨대 NPU 8은 루프 몸체의 시작에서 누산기(202)의 최대값을 누산기(202)에 저장할 것이고, 4개의 웨이트 RAM(124)에 워드들 D36,8 및 D36,9 및 D36,10 및 D36,11을 저장할 것이다.
어드레스 3 및 4에서의 maxwacc 명령들은 어드레스 1 및 2에서의 명령들과 유사한 동작을 수행하지만, 웨이트 RAM(124)의 행 증가 표시자 때문에 웨이트 RAM(124)의 다음 행에 대해 수행한다. 즉, 루프 몸체의 시작시 현재의 웨이트 RAM(124)의 행이 36인 것을 가정하면, 어드레스 1 내지 어드레스 4에서의 명령들의 종료 후, NPU 8은 예컨대 루프 몸체의 시작에서 누산기(202)의 최대값을 누산기(202)에 저장할 것이고, 8개의 웨이트 RAM(124)에 워드들 D36,8 및 D36,9 및 D36,10 및 D36,11 및 D37,8 및 D37,9 및 D37,10 및 D37,11을 저장할 것이다.
어드레스 5 내지 8에서의 maxwacc 명령들은 어드레스 3 및 4에서의 명령들과 유사한 동작을 수행하지만, 웨이트 RAM(124)의 다음 2개 행들에 대해 수행한다. 즉, 루프 몸체의 시작시 현재의 웨이트 RAM(124)의 행이 36인 것을 가정하면, 어드레스 1 내지 어드레스 8에서의 명령들의 종료 후, NPU 8은 예컨대 루프 몸체의 시작에서 누산기(202)의 최대값을 누산기(202)에 저장할 것이고, 16개의 웨이트 RAM(124)에 워드들 D36,8 및 D36,9 및 D36,10 및 D36,11 및 D37,8 및 D37,9 및 D37,10 및 D37,11 및 D38,8 및 D38,9 및 D38,10 및 D38,11 및 D39,8 및 D39,9 및 D39,10 및 D39,11을 저장할 것이다. 즉, 어드레스 1 내지 어드레스 8에서의 명령들의 종료 후, 루프 몸체의 시작시 웨이트 RAM(124)의 행이 36인 것을 가정하면, 예컨대, NPU 8은 다음의 4×4 하위-매트릭스의 최대값을 결정할 것이다:
D36,8 D36,9 D36,10 D36,11
D37,8 D37,9 D37,10 D37,11
D38,8 D38,9 D38,10 D38,11
D39,8 D39,9 D39,10 D39,11
보다 일반적으로, 어드레스 1 내지 어드레스 8에서의 명령들의 종료 후, 사용된 128개 NPU들(126)의 각각은 다음의 4×4 하위-매트릭스의 최대값을 결정할 것이다.
Dr,n Dr,n+1 Dr,n+2 Dr,n+3
Dr+1,n Dr+1,n+1 Dr+1,n+2 Dr+1,n+3
Dr+2,n Dr+2,n+1 Dr+2,n+2 Dr+2,n+3
Dr+3,n Dr+3,n+1 Dr+3,n+2 Dr+3,n+3
여기에서 r은 루프 몸체의 시작에서 웨이트 RAM(124)의 행 어드레스 값이고, n은 NPU(126)의 번호이다.
어드레스 9에서 명령은 AFU(212)를 통해 누산기(202)의 값(217)을 전달한다. 패스쓰루 함수는 웨이트 RAM(124)으로부터 판독된 워드들의 크기(비트수)(즉, 본 예에서 16비트)인 워드를 전달한다. 바람직하게, 출력의 포맷, 예컨대 아래에서 더 상세하게 기술되는 바와 같이, 얼마나 많은 출력 비트들이 분수 비트들인지를 지정할 수 있다.
어드레스 10에서의 명령은 누산기(202)의 값(217)을 출력 행 레지스터의 현재 값에 의해 지정된 웨이트 RAM(124)의 행에 기입하고, 이 값은 어드레스 0에서의 명령에 의해 초기화되고, 명령 내의 증가 표시자 때문에 루프의 각 패스쓰루시 증가된다. 보다 특별히, 어드레스 10에서의 명령은 누산기(202)의 넓은 워드(예, 16비트)를 웨이트 RAM(124)에 기입한다. 바람직하게, 아래의 도 29a 및 도 29b에 관해 아래에서 더 상세하게 기술되는 바와 같이, 이 명령은 출력 이진 포인트(2916)에 의해 지정된 16 비트를 기입한다.
알 수 있는 바와 같이, 루프 몸체의 반복에 의해 웨이트 RAM(124)에 기입된 각 행은 유효하지 않은 데이터를 갖는 홀들을 포함한다. 즉, 최종 133개의 넓은 워드들 1 내지 3, 5 내지 7, 9 내지 11, 등과 같이, 넓은 워드들 509 내지 511는 유효하지 않고, 사용되지 않는다. 일 실시예에 있어서, AFU(212)는, 출력 웨이트 RAM(124)의 행에 다시 기입하기 위해, 도 11의 행 버퍼(1104)와 같은, 행 버퍼의 인접한 워드들에 결과들의 패킹을 가능케 하는 mux를 포함한다. 바람직하게, 활성함수 명령은 각 홀 내에 워드들의 수를 지정하고, 홀 내의 워드들의 수는 mux가 결과들을 패킹하도록 제어하기 위하여 사용된다. 일 실시예에 있어서, 홀들의 수는 3×3, 4×4, 5×5, 6×6, 또는 7×7 하위-매트릭스들의 풀링의 결과들을 패킹하기 위하여, 2로부터 6까지의 값들로 지정될 수 있다. 대안적으로, 프로세서(100) 상에서 실행중인 아키텍쳐 프로그램은 웨이트 RAM(124)으로부터 최종 성긴(즉, 홀들을 포함하는) 결과 행들을 판독하고, 아키텍쳐 팩 명령들, 예컨대 x86 SSE 명령들을 사용하는 미디어 유닛과 같은, 다른 실행 유닛(112)을 사용하여 패킹 함수를 수행한다. 유리하게, 위에서 기술한 및 NNU(121)의 하이브리드 특성을 이용하는 것들과 유사한 동시의 방식에서, 프로세서(100) 상에서 실행중인 아키텍쳐 프로그램은 상태 레지스터(127)를 판독할 수 있어서, 웨이트 RAM(124)의 가장 최근에 기입된 행(예, 도 26b의 필드(2602))을 모니터링하여, 최종 성긴 행을 판독하고, 이를 패킹하고, 웨이트 RAM(124)의 동일한 행에 다시 기입함으로써, 컨벌루션 층 또는 전통적인 신경망 층(즉, 곱-누적 층)과 같은 신경망의 다음 층을 위한 입력 데이터 매트릭스로서 사용될 준비가 된다. 더욱이, 4×4 하위-매트릭스들에 대한 풀링 동작을 수행하는 실시예가 기술되지만, 도 28의 NNU 프로그램은 3×3, 5×5, 6×6, 또는 7×7 하위-매트릭스들과 같은 다른 크기의 하위-매트릭스들에 대한 풀링 동작들을 수행하도록 변경될 수 있다.
또한 알 수 있는 바와 같이, 웨이트 RAM(124)에 기입된 결과 행들의 수는 입력 데이터 매트릭스의 행들의 수의 1/4이다. 최종적으로, 본 예에서, 데이터 RAM(122)은 사용되지 않는다. 그러나, 대안적으로, 풀링 동작을 수행하기 위하여 웨이트 RAM(124)이 아니라 데이터 RAM(122)이 사용될 수 있다.
도 27 및 도 28의 예에서, 풀링 동작은 하위-영역의 최대값을 계산한다. 그러나, 도 28의 프로그램은, 예컨대 maxwacc 명령들을 sumwacc 명령들(웨이트 워드와 누산기(202)의 값(217)을 합하는)로 대체함으로써, 및 누적된 결과들을 본 예에서 16인 각 하위-영역의 요소들의 수로 나누기 위하여(바람직하게는 아래에서 기술되는 역의 곱셈을 통해) 어드레스 9에서 활성함수 명령을 변경함으로써, 하위-영역의 평균값을 계산하도록 변경될 수 있다.
도 27 및 도 28의 실시예에 따른 NNU(121)의 동작으로 알 수 있는 바와 같이, 도 28의 프로그램의 각 실행은 도 27의 전체 512×1600 데이터 매트릭스의 풀링 동작을 수행하는데 대략 6000개 클록 사이클들이 걸리고, 이는 종래의 방법들에 의해 유사한 업무를 수행하기 위하여 필요한 클록 사이클들의 수보다 상당히 적을 수 있다.
대안적으로, 풀링 동작의 결과들을 웨이트 RAM(124)에 다시 기입하는 것이 아니라, 아키텍쳐 프로그램은 결과들을 다시 데이터 RAM(122)의 행들에 기입하도록 NNU 프로그램을 구성하고, 아키텍쳐 프로그램은 NNU(121)가 기입한 데이터 RAM(122)으로부터 결과들을 판독한다(예, 도 26b의 가장 최근에 기입된 데이터 RAM(122)의 행(2606)의 어드레스를 사용하여). 이러한 대안은 웨이트 RAM(124)이 단일-포트로 이루어지고 데이터 RAM(122)이 2중-포트로 이루어진 실시예에서 유리할 수 있다.
사용자- 공급 이진 포인트들 , 완전한 정확도의 고정 포인트 누적, 사용자-지정 역수 값, 누산기 값의 확률론적 반올림, 및 선택 가능한 활성/출력 함수들을 통한 고정 포인트 연산
일반적으로 말해, 디지털 계산 디바이스들에서 산술을 행하는 하드웨어 유닛들은 공통적으로 "정수" 유닛들 및 "부동소수점" 유닛들로 불리는 것들로 나뉠 수 있는데, 왜냐하면 이들이 각각 정수 및 부동소수점 수들에 대한 산술 동작들을 수행하기 때문이다. 부동소수점 수는 크기(또는 가수) 및 지수, 및 전형적으로 부호를 갖는다. 지수는 크기에 관한 기수점(전형적으로 이진 포인트)의 위치의 표시이다. 대조적으로, 정수는 지수를 갖지 않고, 오로지 크기만을 갖고, 빈번하게 부호를 갖는다. 부동소수점 유닛의 장점은, 프로그래머가 매우 큰 범위 내의 상이한 값들 상에서 가질 수 있는 수들에 대해 작업하는 것을 가능케 하고, 하드웨어가 프로그래머가 그렇게 하지 않고도 필요에 따라 수들의 지수값들을 조정할 수 있다는 점이다. 예컨대, 2개의 부동소수점 수들 0.111×1029 및 0.81×1031이 곱해지는 것을 가정한다. (부동소수점 유닛들이 가장 공통적으로 밑수 2의 부동소수점 수들에 대해 작용하지만, 10진수의 또는 밑수 10인 예가 본 예에서 사용된다.) 부동소수점 유닛은 자동적으로 가수를 곱하고, 지수를 더하고, 이후 결과를 다시 0.8991×1059의 값으로 정상화할 수 있다. 다른 예로서, 동일한 2개의 부동소수점 수들이 더해지는 것을 가정한다. 부동소수점 유닛은 자동적으로 이들을 더하기 전에 가수의 이진 포인트들을 정렬하여, 0.81111×1031의 값을 값는 결과 합을 생성할 수 있다.
그러나, 부동소수점 유닛들과 관련된, 복잡도 및 크기의 증가, 전력 소모 및 명령당 클록들 및/또는 길어진 사이클 시간들은 잘 알려져 있다. 실제, 이러한 이유 때문에, 많은 디바이스들(예, 내장형 프로세서들, 마이크로컨트롤러들 및 상대적으로 낮은 비용 및/또는 낮은 파워의 마이크로프로세서들)은 부동소수점 유닛을 포함하지 않는다. 위의 예로부터 알 수 있는 바와 같이, 부동소수점 유닛의 복잡성들의 일부는 부동소수점 덧셈 및 곱셈/나눗셈과 관련된 지수 계산들을 수행하는 로직(부동소수점 곱셈/나눗셈에 대한 결과 지수값을 생성하기 위하여 피연산자들의 지수들을 덧셈/감산하기 위한 가산기, 부동소수점 덧셈에 대한 이진 포인트 정렬 이동량을 결정하기 위하여 피연산자들의 감산 지수들을 결정하기 위한 감산기), 부동소수점 덧셈에 대한 가수의 이진 포인트 정렬을 달성하는 시프터들, 부동소수점 결과들을 정상화하는 시프터들을 포함한다. 추가적으로, 흐름은 블록 유닛들로 진행하고, 이들 블록 유닛들은 전형적으로, 부동소수점 결과들의 반올림을 수행하기 위한 로직, 정수와 부동소수점 포맷들 사이 또는 상이한 부동소수점 정밀도의 포맷들(예, 확장된 정밀도, 배정밀도, 단정밀도, 절반 정밀도) 사이에서 변환하기 위한 로직, 선행 0 및 선행 1 검출기들, 및 비정상 수들, NANs 및 무한과 같은 특별한 부동소수점 수들을 처리하기 위한 로직을 필요로 한다.
더욱이, 주로 설계가 검증되어야 하는 증가된 수의 공간으로 인해 부동소수점 유닛의 정확성의 검증에서 상당한 복잡도의 단점이 존재하고, 이는 제품 개발 사이클 및 출시 기간을 확장시킬 수 있다. 더욱이, 상술한 바와 같이, 부동소수점 산술은 계산에 수반된 각 부동소수점 수에 대한 별도의 가수 및 지수 필드들의 저장 및 사용을 부가하고, 이는, 정수 수들을 저장하기 위한 저장의 동일한 양이 주어졌을 때, 필요한 저장의 양을 증가시키고 및/또는 정밀도를 감소시킨다. 많은 이들 단점들은 정수 수들에 대한 산술 동작들을 수행하는 정수 유닛들의 사용에 의해 회피된다.
빈번하게, 프로그래머들은 분수 수들, 즉 자연수들이 아닌 수를 처리하는 프로그램을 기입한다. 프로그램들은, 부동소수점 유닛들을 갖지 않는 프로세서들에서 실행될 수 있고, 만약 그렇다면 프로세서의 정수 유닛들에 의해 실행된 정수 명령들이 더 빨라질 수 있다. 정수 유닛들과 관련된 잠재적인 성능 장점들을 이용하기 위하여, 프로그래머들은 고정 포인트 수들에 대해 고정 포인트 연산으로서 일반적으로 알려진 것을 사용한다. 이러한 프로그램들은 정수 수들, 또는 정수 데이터를 처리하기 위하여 정수 유닛들 상에서 실행되는 명령들을 포함한다. 소프트웨어는 데이터가 분수인 것을 인식하고, 정수 데이터에 대한 동작을 수행하는 명령들을 포함하여, 데이터가 실제로 분수인, 예컨대 정렬 시프트들인 사실을 다룬다. 필수적으로, 고정 포인트 소프트웨어는 부동소수점 유닛이 수행하는 기능의 일부 또는 모두를 수동으로 수행한다.
본 개시사항에서 사용된 바와 같이, "고정 포인트" 수(또는 값 또는 피연산자 또는 입력 또는 출력)는, 본 명세서에서 "분수 비트들"로 언급되는 고정 포인트 수의 분수 부분을 나타내는 비트들을 포함하는 것으로 이해되는 저장 비트들을 갖는 수이다. 고정 포인트 수의 저장의 비트들은 메모리 또는 레지스터에, 예컨대 메모리 또는 레지스터에 8비트 또는 16비트 워드로 포함된다. 더욱이, 고정 포인트 수의 저장의 비트들은 크기를 나타내기 위하여 모두 사용되고, 일부 경우들에서, 하나의 비트는 부호를 나타내기 위하여 사용되지만, 고정 포인트 수의 저장 비트들 중 어느 것도 수의 지수를 나타내기 위하여 사용되지 않는다. 더욱이, 고정 포인트 수의, 분수 비트들의 수, 또는 이진 포인트 위치는 저장에서 지정되고, 이러한 저장은 고정 포인트 수의 저장 비트들로부터 명확하고, 예컨대 처리 유닛들의 어레이의 입력 피연산자들, 누적된 값들 또는 출력 결과들의 세트와 같은, 고정 포인트 수가 속한 고정 포인트 수들의 세트에 대해, 공유된 또는 전역 방식으로 분수 비트들의 수, 또는 이진 포인트 위치를 나타낸다.
유리하게, ALU들이 정수 유닛들이지만, 활성함수 유닛들이 고정 포인트 연산 하드웨어 보조장치 또는 가속도를 포함하는 실시예들이 본 명세서에서 기술된다. 이것은 ALU 부분들이 더 작고 더 빠르게 되는 것을 허용하고, 이것은 다이 위의 주어진 공간 내에 더 많은 ALU들을 갖는 것을 용이하게 한다. 이것은 다이 공간당 더 많은 뉴런들을 부가하고, 이는 특히 신경망 유닛에서 유리하다.
추가로 유리하게, 각 부동소수점 수들에 대해 지수 저장 비트들을 필요로 하는 부동소수점 수들과는 대조적으로, 고정 포인트 수들이 수들의 전체 세트에 대해 분수 비트들인 저장 비트들의 수의 표시를 통해 표현되는 실시예들이 기술되지만, 이러한 표시는, 예컨대 일련의 동작들에 대한 입력들의 세트, 이러한 동작들의 누적된 값들의 세트, 출력들의 세트와 같은, 전체 세트의 모든 수들에 대한 분수 비트들의 수를 전체적으로 나타내는 단일의 공유된 저장에 위치된다. 바람직하게, NNU의 사용자는 수들의 세트에 대해 분수 저장 비트들의 수를 지정하는 것이 가능하게 된다. 따라서, 많은 배경들(예, 일반 수학)에서 용어 "정수(integer)"가 부호가 있는 자연수, 즉 분수 부분을 갖지 않는 수를 언급하지만, 본 배경 내에서 용어 "정수"는 분수 부분을 갖는 수들을 언급할 수 있다. 또한, 본 배경 내에서 용어 "정수"는 그들의 개별 저장의 비트들의 일부가 부동소수점 수의 지수를 나타내기 위하여 사용되는 부동소수점 수들과 구별하도록 의도된다. 유사하게, 정수 유닛에 의해 수행되는 정수 곱셈 또는 덧셈 또는 비교와 같은 정수 산술 동작은 피연산자들이 지수를 갖지 않는 것을 가정한다, 그러므로 정수 유닛의 정수 요소들, 예컨대 정수 곱셈기, 정수 가산기, 정수 비교기는 지수를 다루기 위한 로직을 포함하지 않는다, 예컨대 덧셈 또는 비교 동작들을 위해 이진 포인트들을 정렬하기 위해 가수들을 이동시키지 않고, 곱셈 동작들을 위해 지수들을 더하지 않는다.
추가적으로, 큰 일련의 정수 동작들(예, 1000개의 곱-누적들)을 정확도의 손실 없이 누적시키기 위한 대형 하드웨어 정수 누산기를 포함하는 실시예들이 본 명세서에서 기술된다. 이것은, NNU를 포화시키거나 오버플로우들로 인한 부정확한 결과들을 초래하는 것 없이, 동시에 누적된 값들에서 완전한 정확도를 유지하면서, NNU가 부동소수점 수들을 다루는 것을 회피하는 것을 가능케 한다. 일단 일련의 정수 동작들이 완전한 정확도의 누산기에 결과들을 누적시키면, 고정 포인트 하드웨어 보조장치는, 아래에서 더 상세하게 기술되는 바와 같이, 누적된 값의 분수 비트들의 수, 및 출력값에서 분수 비트들의 원하는 수의 사용자 지정 표시들을 사용하여, 완전한 정확도의 누적된 값을 출력값으로 변환하기 위해 필요한 크기조정 및 포화를 수행한다.
아래에서 더 상세하게 기술되는 바와 같이, 바람직하게 활성함수 유닛들은, 활성함수에 대한 입력으로서 사용을 위해 또는 전달되도록 하기 위해 완전한 정확도 형태로부터 누산기 값을 압축할 때, 누산기 값에 대한 확률론적 반올림을 선택적으로 수행할 수 있다. 최종적으로, 상이한 활성함수들을 적용하고, 및/또는 신경망의 주어진 층의 상이한 요구들에 의해 지시된 누산기 값의 다양한 상이한 형태들을 출력하도록, NPU들은 선택적으로 명령받을 수 있다.
이제 도 29a를 참조하면, 도 1의 제어 레지스터(127)의 실시예를 도시하는 블록도가 도시된다. 제어 레지스터(127)는 복수의 제어 레지스터들(127)을 포함할 수 있다. 제어 레지스터(127)는 도시된 다음의 필드들을 포함한다: 구성(2902), 부호가 있는 데이터(2912), 부호가 있는 웨이트(2914), 데이터 이진 포인트(2922), 웨이트 이진 포인트(2924), ALU 함수(2926), 반올림 제어(2932), 활성함수(2934), 역수(2942), 이동량(2944), 출력 RAM(2952), 출력 이진 포인트(2954), 및 출력 명령(2956). 제어 레지스터(127) 값들은 초기화 명령과 같은, MTNN 명령(1400) 및 NNU 프로그램의 명령 모두에 의해 기록될 수 있다.
구성(2902) 값은 상술한 바와 같이 NNU(121)가 좁은 구성, 넓은 구성 또는 깔대기 구성인지를 지정한다. 구성(2902)은 데이터 RAM(122) 및 웨이트 RAM(124)으로부터 수신된 입력 워드들의 크기를 부가한다. 좁은 및 깔대기 구성들에서, 입력 워드들의 크기는 좁고(예, 8 비트 또는 9 비트), 반면에 넓은 구성에서 입력 워드들의 크기는 넓다(예, 12 비트 또는 16 비트). 더욱이, 구성(2902)은 입력 워드 크기와 동일한 출력 결과(133)의 크기를 부가한다.
부호가 있는 데이터 값(2912)은, 참이라면 데이터 RAM(122)로부터 수신된 데이터 워드들이 부호가 있는 값들임을 나타내고, 거짓이라면 이들이 부호가 없는 값들임을 나타낸다. 부호가 있는 웨이트(2914)는, 참이라면 웨이트 RAM(124)으로부터 수신된 웨이트 워드들이 부호가 있는 값임을 나타내고, 거짓이라면 이들이 부호가 없는 값들임을 나타낸다.
데이터 이진 포인트(2922) 값은 데이터 RAM(122)으로부터 수신된 데이터 워드들에 대한 이진 포인트의 위치를 나타낸다. 바람직하게, 데이터 이진 포인트(2922) 값은 이진 포인트의 위치에 대해 우측으로부터 비트 위치들의 수를 나타낸다. 달리 언급하면, 데이터 이진 포인트(2922)는 데이터 워드의 얼마나 많은 최하위 비트들이 분수 비트들인지, 즉 이진 포인트의 우측에 있는지를 나타낸다. 유사하게, 웨이트 이진 포인트(2924) 값은 웨이트 RAM(124)으로부터 수신된 웨이트 워드들에 대한 이진 포인트의 위치를 나타낸다.
ALU 함수(2926)가 곱셈 및 누산 또는 누산기의 출력일 때, NPU(126)는, 데이터 이진 포인트(2922) 및 웨이트 이진 포인트(2924)의 합으로서, 누산기(202)에 유지된 값에 대한 이진 포인트의 우측에 대한 비트들의 수를 결정한다. 따라서, 예컨대 데이터 이진 포인트(2922)의 값이 5이고, 웨이트 이진 포인트(2924)의 값이 3이면, 누산기(202) 내의 값은 이진 포인트의 우측에 8개 비트들을 갖는다. ALU 함수(2926)가 합/최대값 누산기 및 데이터/웨이트 워드 또는 패스쓰루 데이터/웨이트 워드일 때, NPU(126)는 각각 데이터/웨이트 이진 포인트(2922/2924)로서 누산기(202) 내에 유지된 값을 위한 이진 포인트의 우측에 대한 비트들의 수를 결정한다. 도 29b에 대해 아래에서 기술된 다른 실시예에 있어서, 개별적인 데이터 이진 포인트(2922) 및 웨이트 이진 포인트(2924)를 지정하는 것이 아니라, 단일 누산기 이진 포인트(2923)가 지정된다.
ALU 함수(2926)는 NPU(126)의 ALU(204)에 의해 수행되는 함수를 지정한다. 상술한 바와 같이, ALU 함수(2926)는, 데이터 워드(209) 및 웨이트 워드(203)를 곱하여 곱을 누산기(202)에 누적시키고; 누산기(202)와 웨이트 워드(203)를 합하고; 누산기(202)와 데이터 워드(209)를 합하고; 누산기(202)와 데이터 워드(209)의 최대값; 누산기(202)와 웨이트 워드(203)의 최대값; 누산기(202)를 출력하고; 데이터 워드(209)를 전달하고; 웨이트 워드(203)를 전달하고; 0을 출력하는 것을 포함하지만, 이에 국한되지는 않는다. 일 실시예에 있어서, ALU 함수(2926)는 NNU 시작 명령에 의해 지정되고, 실행 명령(미도시)에 따라 ALU(204)에 의해 사용된다. 일 실시예에 있어서, ALU 함수(2926)는 위에서 기술된 곱-누산 및 maxwacc 명령들과 같은 개별적인 NNU 명령들에 의해 지정된다.
반올림 제어(2932)는 어느 형태의 반올림이 반올림기(3004)(도 30의)에 의해 사용될지를 지정한다. 일 실시예에 있어서, 지정될 수 있는 반올림 모드들은, 반올림 없음, 가장 후방으로 반올림, 및 확률론적인 반올림을 포함하지만 이에 국한되는 것은 아니다. 바람직하게, 프로세서(100)는 랜덤 비트들(3005)을 생성하는 랜덤 비트 소스(3003)(도 30의)를 포함하고, 랜덤 비트들은 반올림 바이어스의 가능성을 줄이기 위하여 확률론적인 반올림을 수행하기 위하여 샘플링되어 사용된다. 일 실시예에 있어서, 반올림 비트(3005)가 1이고, 스티키 비트(sticky bit)가 0일 때, 샘플링된 랜덤 비트(3005)가 참이면 NPU(126)는 위로 반올림되고, 랜덤 비트(3005)가 거짓이면 NPU(126)는 위로 반올림되지 않는다. 일 실시예에 있어서, 랜덤 비트 소스(3003)는, 다른 실시예들이 고려되지만, 반도체 다이오드 또는 레지스터를 가로지르는 열 잡음과 같은, 프로세서(100)의 랜덤 전기 특성들의 샘플링에 기초하여 랜덤 비트들(3005)을 생성한다.
활성함수(2934)는 NPU(126)의 출력(133)을 생성하기 위하여 누산기(202)의 값(217)에 적용되는 함수를 지정한다. 위에서 및 아래에서 더 상세하게 기술되는 바와 같이, 활성함수(2934)는 시그모이드; 쌍곡 탄젠트; 소프트플러스; 정류; 지정된 2의 제곱으로 나눗셈; 유효 나눗셈을 달성하기 위하여 사용자 지정 역수값으로의 곱셈; 완전한 누산기의 패스쓰루; 및 아래에서 더 상세하게 기술된 규정 크기로서 누산기의 패스쓰루를 포함하지만, 이에 국한되는 것은 아니다. 일 실시예에 있어서, 활성함수는 NNU 활성함수 명령에 의해 지정된다. 대안적으로, 활성함수는 초기 명령에 의해 지정되고, 출력 명령, 예컨대 도 4의 어드레스 4에서 기록 AFU 출력 명령에 응답하여 적용되고, 이러한 실시예에서 도 4의 어드레스 3에서 활성함수 명령은 출력 명령에 의해 포함된다.
역수(2942) 값은 누산기(202)의 값(217)에 의한 나눗셈을 달성하기 위하여 누산기(202)의 값(217)에 의해 곱해진 값을 지정한다. 즉, 사용자는 실제 원하는 제수의 역수로서 역수(2942) 값을 지정한다. 이것은 예컨대 본 명세서에서 기술되는 컨벌루션 및 풀링 동작들과 관련하여 유용하다. 바람직하게, 사용자는 아래의 도 29c에 관해 더 상세하게 기술되는 바와 같이, 역수(2942)를 2개 부분들로 지정한다. 일 실시예에 있어서, 제어 레지스터(127)는 사용자가 공통적으로 사용된 컨벌루션 커넬들의 크기, 예컨대 9, 25, 36 또는 49인 복수의 내장된 제수 값들 중 하나에 의한 나눗셈을 지정하는 것을 가능케 하는 필드(미도시)를 포함한다. 이러한 실시예에 있어서, AFU(212)는 누산기(202)의 값(217)에 의한 곱셈을 위해 내장된 제수들의 역수들을 저장할 수 있다.
이동량(2944)은, AFU(212)의 시프터가, 2의 제곱에 의한 나눗셈을 달성하기 위해 누산기(202)의 값(217)을 오른쪽으로 이동시키는 비트들의 수를 지정한다. 이것은 또한 2의 제곱인 크기를 갖는 컨벌루션 커넬들과 관련되어 유용할 수 있다.
출력 RAM(2952) 값은 데이터 RAM(122) 및 웨이트 RAM(124) 중 어느 것이 출력 결과(133)를 수신할지를 지정한다.
출력 이진 포인트(2954) 값은 출력 결과(133)에 대한 이진 포인트의 위치를 나타낸다. 바람직하게, 출력 이진 포인트(2954)는 출력 결과(133)를 위한 이진 포인트의 위치에 대해 우측으로부터 비트 위치들의 수를 나타낸다. 달리 언급하면, 출력 이진 포인트(2954)는 출력 결과(133)의 얼마나 많은 최하위 비트들이 분수 비트들인지, 즉 이진 포인트의 우측에 있는지를 나타낸다. AFU(212)는 출력 이진 포인트(2954)의 값에 기초하여(및 대부분의 경우, 데이터 이진 포인트(2922), 웨이트 이진 포인트(2924), 활성함수(2934) 및/또는 구성(2902)의 값에 기초하여) 반올림, 압축, 포화 및 크기 변환을 수행한다.
출력 명령(2956)은 출력 결과(133)의 다양한 양상들을 제어한다. 일 실시예에 있어서, AFU(212)는 구성(2902)에 의해 지정된 폭의 크기(비트수)의 두배인 규정 크기의 개념을 채용한다. 따라서, 예컨대 구성(2902)이 데이터 RAM(122) 및 웨이트 RAM(124)으로부터 수신된 입력 워드들이 크기가 8 비트인 것을 암시하면, 규정 크기는 16 비트이고; 다른 예로서, 구성(2902)이 데이터 RAM(122) 및 웨이트 RAM(124)으로부터 수신된 입력 워드들이 크기가 16 비트인 것을 암시하면, 규정 크기는 32 비트이다. 본 명세서에서 기술된 바와 같이, 중간 계산들, 예컨대 1024개 및 512개의 NNU 곱-누적 명령들의 완전한 정확도를 각각 보존하기 위하여 누산기(202)의 크기는 크다(예, 좁은 누산기(202B)는 28 비트이고, 넓은 누산기(202A)는 41 비트). 결과적으로 누산기(202)의 값(217)은 활성함수(2934)(완전한 누산기의 패스쓰루를 제외하고)의 대부분의 값들에 대해, 규정 크기 및 AFU(212)(예, 도 30에 관해 아래에서 기술된 CCS(3008))보다 크고(비트수), 누산기(202)의 값(217)을 규정 크기인 값으로 하향 압축한다. 출력 명령(2956)의 제1의 미리 결정된 값은 AFU(212)가 지정된 활성함수(2934)를 수행하여, 원래의 입력 워드들과 동일한 크기인, 즉 규정 크기의 절반인 내부 결과를 생성하고, 출력 결과(133)로서 내부 결과를 출력하도록 명령한다. 출력 명령(2956)의 제 2의 미리 결정된 값은 AFU(212)가 지정된 활성함수(2934)를 수행하여, 원래의 입력 워드들 크기의 2배인, 즉 규정 크기인 내부 결과를 생성하고, 출력 결과(133)로서 내부 결과의 하부 절반을 출력하도록 명령하고; 출력 명령(2956)의 제3의 미리 결정된 값은 AFU(212)가 출력 결과(133)로서 내부 결과의 규정 크기의 상부 절반을 출력하도록 명령한다. 출력 명령(2956)의 제4의 미리 결정된 값은 AFU(212)가 출력 결과(133)로서 누산기(202)의 미처리 최하위 워드(구성(2902)에 의해 지정된 폭을 갖는)를 출력하도록 명령하고; 제5의 미리 결정된 값은 AFU(212)가 출력 결과(133)로서 누산기(202)의 미처리 중위(middle-significant) 워드를 출력하도록 명령하고; 도 8 내지 도 10에 관해 위에서 기술된 바와 같이, 제6의 미리 결정된 값은 AFU(212)가 출력 결과(133)로서 누산기(202)의 미처리 최상위 워드를 출력하도록 명령한다. 상술한 바와 같이, 완전한 누산기(202) 크기 또는 규정 크기의 내부 결과를 출력하는 것은, 예컨대 프로세서(100)의 다른 실행 유닛들(112)이 소프트맥스 활성함수와 같은 활성함수를 수행하는 것을 가능케 하기 위하여, 유리할 수 있다.
도 29a(및 도 29b 및 도 29c)의 필드들이 제어 레지스터(127)에 있는 것으로 기술되었지만, 다른 실시예들에서 하나 이상의 필드들이 NNU(121)의 다른 부분들에 존재할 수 있다. 바람직하게, 많은 필드들은 NNU 명령들 자체에 포함되고 ALU(204)들 및/또는 AFU(212)들을 제어하는 마이크로-명령(3416)(도 34의)들을 생성하도록 시퀀서(128)에 의해 디코딩된다. 추가적으로, 필드들은 ALU(204)들 및/또는 AFU(212)들을 제어하는 미디어 레지스터(118)에 저장된 마이크로-명령(3414)(도 34의)들에 포함될 수 있다. 이러한 실시예들에 있어서, 초기화 NNU 명령의 사용은 최소화되고, 다른 실시예들에서 초기화 NNU 명령은 제거된다.
상술한 바와 같이, NNU 명령은 메모리 피연산자(예, 데이터 RAM(122) 및/또는 웨이트 RAM(124)로부터의 워드)들 또는 회전된 피연산자(예, mux-reg(208/705)로부터)에 대한 ALU 동작들을 수행하도록 지정할 수 있다. 일 실시예에서, NNU 명령은 또한 활성함수의 등록된 출력(도 30의 레지스터(3038)의 출력)으로서 피연산자를 지정할 수 있다. 추가적으로, 상술한 바와 같이, NNU 명령은 데이터 RAM(122) 또는 웨이트 RAM(124)의 현재의 행 어드레스를 증가시키도록 지정할 수 있다. 일 실시예에서, NNU 명령은 1이 아닌 값만큼 증가 또는 감소를 달성하기 위하여 현재의 행에 더해지는 즉시 부호있는 정수 델타 값을 지정할 수 있다.
이제 도 29b를 참조하면, 다른 실시예에 따라 도 1의 제어 레지스터(127)의 일 실시예를 도시하는 블록도가 도시된다. 도 29b의 제어 레지스터(127)는 도 29a의 제어 레지스터(127)와 유사하지만; 도 29b의 제어 레지스터(127)는 누산기 이진 포인트(2923)를 포함한다. 누산기 이진 포인트(2923)는 누산기(202)에 대한 이진 포인트의 위치를 나타낸다. 바람직하게, 누산기 이진 포인트(2923) 값은 이진 포인트의 위치에 대해 우측으로부터 비트 위치들의 수를 나타낸다. 달리 언급하면, 누산기 이진 포인트(2923)는 누산기(202)의 얼마나 많은 최하위 비트들이 분수 비트들인지, 즉 이진 포인트의 우측에 있는지를 나타낸다. 본 실시예에서, 누산기 이진 포인트(2923)는, 도 29a의 실시예에 관해 상술한 바와 같이, 암시적으로 결정되는 것이 아니라 명시적으로 지정된다.
이제 도 29c를 참조하면, 일 실시예에 따라 2개 부분으로 저장된 도 29a의 역수(2942)의 일 실시예를 도시하는 블록도가 도시된다. 제1 부분(2962)은 이동 값이고, 이러한 값은 사용자가 누산기(202) 값(217)에 의해 곱해지기를 희망하는 실제 역수값에서 억압된 선행 0들(2962)의 수를 나타낸다. 선행 0들의 수는 이진 포인트의 바로 우측의 연속된 0들의 수이다. 제 2 부분(2694)는 선행 0-억압된 역수(2964) 값, 즉 모든 선행 0들이 제거된 실제 역수 값이다. 일 실시예에서, 억압된 선행 0들(2962)의 수는 4비트로 저장되고, 선행 0-억압된 역수(2964) 값은 8비트 부호없는 값으로 저장된다.
예를 통해 도시하기 위하여, 사용자가 누산기(202) 값(217)이 49의 역수로 곱해지기를 희망한다고 가정한다. 13개의 분수 비트들로 표현된 49의 역수의 이진 표현은 0.0000010100111이고, 이는 5개의 선행 0들을 갖는다. 이 경우, 사용자는 억압된 선행 0(2962)들의 수에 5의 값으로 채우고, 선행 0-억압된 역수(2964)에 10100111의 값으로 채운다. 역수 곱셈기("분할기 A"; 3014)(도 30의)가 누산기(202) 값(217)과 선행 0-억압된 역수(2964) 값을 곱한 후, 결과의 곱을 억압된 선행 0(2962)의 수만큼 우측으로 이동시킨다. 이러한 실시예는 역수(2942) 값을 표현하기 위하여 사용된 비트들의 상대적으로 적은 수로 유리하게 높은 정밀도를 달성할 수 있다.
이제, 도 30을 참조하면, 도 2의 AFU(212)의 실시예를 더 상세하기 도시하는 블록도가 도시된다. AFU(212)는, 도 1의 제어 레지스터(127); 누산기(202) 값(217)을 수신하는 양의 형태의 변환기(PFC) 및 출력 이진 포인트 정렬기(OBPA)(3002); 누산기(202) 값(217) 및 OBPA(3002)에 의해 밖으로 이동된 비트들의 수의 표시를 수신하는 반올림기(3004); 상술한 바와 같이 랜덤 비트(3005)들을 생성하는 랜덤 비트 소스(3003); PFC 및 OBPA(3002)의 출력 및 반올림기(3004)의 출력을 수신하는 제1 mux(3006); 제1 mux(3006)의 출력을 수신하는 규정 크기로의 압축기(CCS) 및 포화기(3008); CCS 및 포화기(3008)의 출력을 수신하는 비트 선택기 및 포화기(3012); CCS 및 포화기(3008)의 출력을 수신하는 정류기(3018); CCS 및 포화기(3008)의 출력을 수신하는 역수 곱셈기(3014); CCS 및 포화기(3008)의 출력을 수신하는 우측 시프터(3016); 비트 선택기 및 포화기(3012)의 출력을 수신하는 쌍곡탄젠트(tanh) 모듈(3022); 비트 선택기 및 포화기(3012)의 출력을 수신하는 시그모이드 모듈(3024); 비트 선택기 및 포화기(3012)의 출력을 수신하는 소프트플러스 모듈(3026); tanh 모듈(3022), 시그모이드 모듈(3024), 소프트플러스 모듈(3026),정류기(3108), 역수 곱셈기(3014) 및 우측 시프터(3016)의 출력 및 CCS 및 포화기(3008)의 패스쓰루 규정 크기 출력(3028)을 수신하는 제 2 mux(3032); 제 2 mux(3032)의 출력을 수신하는 부호 복구자(3034); 부호 복구자(3034)의 출력을 수신하는 크기 변환기 및 포화기(3036); 크기 변환기 및 포화기(3036)의 출력 및 누산기 출력(217)을 수신하는 제 3 mux(3037); 및 mux(3037)의 출력을 수신하고 도 1의 결과(133)로서 출력을 갖는 출력 레지스터(3038)를 포함한다.
PFC 및 OBPA(3002)는 누산기(202) 값(217)을 수신한다. 바람직하게, 누산기(202) 값(217)은 상술한 바와 같이 완전한 정확도의 값이다. 즉, 누산기(202)는, 정확도의 어떠한 손실도 존재하지 않도록, 곱셈기(242)의 개별적인 곱들 중 임의의 비트들, 또는 가산기(244)의 합을 버리지 않고, 정수 가산기(244)에 의해 생성된, 정수 곱셈기(242)에 의해 생성된 일련의 곱들의 합인 누적된 값을 유지하기 위해, 충분한 수의 저장 비트들을 구비한다. 바람직하게, 누산기(202)는 NNU(121)가 수행하도록 프로그램 가능한 곱들의 누적의 최대 수를 유지하기 위하여 적어도 충분한 수의 비트들을 갖는다. 예컨대, 도시하기 위한 도 4의 프로그램을 참조하면, NNU(121)가 넓은 구성일 때 수행하도록 프로그램 가능한 곱 누적들의 최대 수는 512이고, 누산기(202)의 비트 폭은 41이다. 다른 예로서, 도시하기 위한 도 20의 프로그램을 참조하면, NNU(121)가 좁은 구성일 때 수행하도록 프로그램 가능한 곱 누적들의 최대 수는 1024이고, 누산기(202)의 비트 폭은 28이다. 일반화하기 위하여, 완전한 정확도의 누산기(202)는 적어도 Q개의 비트들을 포함하고, 여기에서 Q는 M 및 log2P의 합이고, M은 곱셈기(242)의 정수 곱의 비트 폭(예, 좁은 곱셈기(242)에 대해 16 비트, 또는 넓은 곱셈기(242)에 대해 32비트)이고, P는 누산기(202)에 누적될 수 있는 정수 곱들의 최대 허용가능한 수이다. 바람직하게, 곱 누적들의 최대 수는 NNU(121)의 프로그래머에 대한 프로그래밍 규격을 통해 지정된다. 일 실시예에 있어서, 시퀀서(128)는, 데이터/웨이트 RAM(122/124)로부터 데이터/웨이트 워드들(206/207)의 행을 로딩하는 하나의 이전 곱-누산 명령(예, 도 4의 어드레스 1에서의 명령)의 가정을 통해, 곱-누산 NNU 명령(예, 도 4의 어드레스 2에서의 명령)의 예컨대 511인 카운트의 최대값을 실시한다.
유리하게, 최대 수의 허용 가능한 누적들에 대해 완전한 정확도 값을 누적시키기 위한 충분히 큰 비트 폭을 갖는 누산기(202)를 포함함으로써, NPU(126)의 ALU(204) 부분의 설계를 단순화시킨다. 특히, 이것은 정수 가산기(244)에 의해 생성된 합들을 포화시키기 위한 로직에 대한 필요성을 경감시키는데, 이러한 로직은 더 작은 누산기를 오버플로우시킬 수 있고, 오버플로우가 발생하였는지를 결정하여 포화가 필요하였는지를 알기 위해 누산기의 이진 포인트 위치에 대한 추적의 유지가 필요할 것이다. 완전하지 않은 정확도의 누산기를 포함하고, 대신에 완전하지 않은 정확도의 누산기의 오버플로우들을 처리하기 위한 포화 로직을 포함하는 설계에 대한 문제점을 예를 통해 도시하기 위하여, 다음을 가정한다.
(1) 데이터 워드 값들의 범위는 0과 1 사이이고, 모든 저장 비트들은 분수 비트들을 저장하기 위하여 사용된다. 웨이트 워드들의 범위는 -8과 +8 사이이고, 3개의 저장 비트를 제외한 모든 저장 비트들은 분수 비트들을 저장하기 위하여 사용된다. 그리고, 쌍곡 탄젠트 함수에 대한 입력을 위해 누적된 값들의 범위는 -8과 +8 사이이고, 3개의 저장 비트를 제외한 모든 저장 비트들은 분수 비트들을 저장하기 위하여 사용된다.
(2) 누산기의 비트 폭은 완전하지 않은 정확도이다(예, 오로지 곱들의 비트 폭).
(3) 최종 누적된 값은 누산기가 완전한 정확도인 것을 가정하여 대략 -8과 +8 사이(예, +4.2)일 것이지만; 이들 열 내에서 "점 A" 앞의 곱들은 훨씬 자주 양이 되는 경향이 있고, 반면에 점 A 뒤의 곱들은 훨씬 자주 음이 되는 경향이 있다.
이러한 상황에서, 정확하지 않은 결과(즉, +4.2 이외의 결과)가 얻어질 수 있다. 이것은, 점 A 앞의 일부 점에서 누산기가 더 큰 값, 예 +8.2를 가져야만 할 때 누산기는 최대 +8의 값으로 포화될 수 있어서, 나머지 +0.2의 손실을 야기한다. 누산기는 심지어 더 많은 곱 누산들에 대해 포화된 값으로 유지되어, 심지어 더 큰 양의 값의 손실을 초래할 수 있다. 따라서, 누산기의 최종 값은, 누산기가 완전한 정확도의 비트 폭을 갖는 경우 가질 수 있는 것보다 더 적은 수(즉, +4.2 미만)가 될 수 있다.
PFC(3002)는 누산기(202) 값(217)을, 만약 값이 음이라면, 양의 형태로 변환하고, 원래의 값이 양 또는 음인지를 나타내는 추가 비트를 생성하고, 이는 그 값과 함께 AFU(212) 파이프라인을 통해 아래로 전달된다. 양의 형태로 변환하는 것은 AFU(212)에 의한 후속 동작들을 단순화시킨다. 예컨대, 이는 오로지 양의 값들이 tahn(3022) 및 시그모이드(3024) 모듈들에 입력되는 것을 가능케 하고, 따라서 이들을 단순화시킨다. 추가적으로, 이는 반올림기(3004) 및 포화기(3008)를 단순화시킨다.
OBPA(3002)는 양의-형태 값을 제어 레지스터(127)에서 지정된 출력 이진 포인트(2954)와 정렬시키기 위하여, 양의-형태 값을 우측으로 이동시키거나, 크기 조정한다. 바람직하게, OBPA(3002)는 차이로서 이동량을 계산하고, 이러한 차이는 누산기(202)의 값(217)의 분수 비트들의 수(예, 누산기 이진 포인트(2923)에 의해, 또는 데이터 이진 포인트(2922) 및 웨이트 이진 포인트(2924)의 합에 의해 지정된)로부터 감산된 출력의 분수 비트들의 수(예, 출력 이진 포인트(2954)에 의해 지정된)이다. 따라서, 예컨대 누산기(202) 이진 포인트(2923)가 8(위의 예에서와 같이)이고, 출력 이진 포인트(2954)는 3이라면, OBPA(3002)는 양의-형태의 값을 오른쪽으로 5비트 이동시켜, mux(3006)와 반올림기(3004)에 제공되는 결과를 생성한다.
반올림기(3004)는 누산기(202) 값(217)을 반올림한다. 바람직하게, 반올림기(3004)는 PFC 및 OBPA(3002)에 의해 생성된 양의-형태의 값의 반올림된 형태를 생성하여, 반올림된 형태를 mux(3006)에 제공한다. 반올림기(3004)는 상술한 반올림 제어(2932)에 따라 반올림하고, 반올림 제어는 위에서 및 아래에서 기술된 바와 같이, 랜덤 비트(3005)을 사용하는 확률론적인 반올림을 포함할 수 있다. mux(3006)는 반올림 제어(2932)(본 명세서에서 기술된 바와 같이, 확률론적인 반올림을 포함할 수 있는)에 기초하여, 입력들 중 하나, 즉 PFC 및 OBPA(3002)로부터의 양의-형태의 값 또는 반올림기(3004)로부터 이의 반올림된 형태를 선택하고, 선택된 값을 CCS 및 포화기(3008)에 제공한다. 바람직하게, 반올림 제어(2932)가 어떠한 반올림도 지정하지 않으면, mux(3006)는 PFC 및 OBPA(3002)의 출력을 선택하고, 그렇지 않으면 반올림기(3004)의 출력을 선택한다. AFU(212)가 추가적인 반올림을 수행하는 다른 실시예들이 고려된다. 예컨대, 일 실시예에 있어서, 비트 선택기(3012)는, CCS 및 포화기(3008) 출력의 비트들을 압축할 때(아래에서 기술된) 손실된 하위 비트들에 기초하여 반올림한다. 다른 예로서, 일 실시예에서, 역수 곱셈기(3014)(아래에서 기술된)의 곱이 반올림된다. 또 다른 예로서, 일 실시예에서, 크기 변환기(3036)는, 적절한 출력 크기(아래에서 기술된)로 변환할 때, 반올림하고, 이는 반올림 결정시 사용된 하위 비트들의 손실을 수반한다.
CCS(3008)는 mux(3006) 출력을 규정 크기로 압축한다. 따라서, 예컨대 NPU(126)가 좁은 또는 깔대기 구성(2902)이라면, CCS(3008)은 28-비트 mux(3006) 출력값을 16비트로 압축하고; NPU(126)가 넓은 구성(2902)이라면, CCS(3008)은 41-비트 mux(3006) 출력값을 32비트로 압축한다. 그러나, 규정 크기로 압축하기 전에, 사전-압축된 값이 규정 형태로 표현할 수 있는 최대값보다 크다면, 포화기(3008)는 사전-압축된 값을 규정 형태로 표현할 수 있는 최대값으로 포화시킨다. 예컨대, 최상위 규정 형태의 비트 중 좌측의 사전-압축된 값의 비트들 중 임의의 것이 1의 값을 갖는다면, 포화기(3008)는 최대값으로(예, 모두 1들로) 포화시킨다.
바람직하게, tanh(3022), 시그모이드(3024) 및 소프트플러스(3026) 모듈들은 룩업 테이블들, 예컨대 프로그램 가능한 로직 어레이(PLA), 판독 전용 메모리(ROM), 조합 로직 게이트, 등을 포함한다. 일 실시예에 있어서, 모듈들(3022/3024/3026)의 크기를 단순화시키고 줄이기 위하여, 이들은 3.4 형태, 즉 3개의 자연수 비트들과 4개의 분수 비트들을 갖는 입력값을 제공받는다, 즉 입력값은 이진 포인트의 우측에 4개의 비트들 및 이진 포인트의 좌측에 3개 비트들을 갖는다. 3.4 형태의 입력값 범위(-8, +8)의 극한들에서 출력값들은 그들의 최소/최대값들에 비대칭적으로 접근하기 때문에, 이들 값들이 선택된다. 그러나, 이진 포인트를 상이한 위치에, 예컨대 4.3 형태 또는 2.5 형태로 배치시키는 다른 실시예들이 고려된다. 비트 선택기(3012)는 3.4 형태의 규정을 충족시키는 CCS 및 포화기(3008) 출력의 비트들을 선택하고, 이는, 규정 형태가 큰 수의 비트들을 갖기 때문에, 압축을 수반한다, 즉 일부 비트들이 손실된다. 그러나, CCS 및 포화기(3008) 출력값을 선택/압축하기 전에, 사전-압축된 값이 3.4 형태로 표현할 수 있는 최대값보다 크다면, 포화기(3012)는 사전-압축된 값을 3.4 형태로 표현할 수 있는 최대값으로 포화시킨다. 예컨대, 최상위 3.4 형태의 비트의 좌측의 사전-압축된 값의 비트들 중 임의의 비트가 1 값을 가지면, 포화기(3012)는 최대값으로(예, 모두 1들로) 포화시킨다.
tanh(3022), 시그모이드(3024) 및 소프트플러스(3026) 모듈들은 결과를 생성하기 위하여 CCS 및 포화기(3008)에 의해 출력된 3.4 형태의 값에 대해 그들의 각 활성함수들(상술된)을 수행한다. 바람직하게, tanh(3022) 및 시그모이드(3024)의 결과는 0.7 형태, 즉 0의 자연수 비트들 및 7개의 분수 비트들의 7 비트 결과이다, 즉 입력값은 이진 포인트 우측에 7개의 비트들을 갖는다. 바람직하게, 소프트플러스 모듈(3026)의 결과는 3.4 형태, 즉 모듈(3026)의 입력과 동일한 형태의 7비트 결과이다. 바람직하게, tanh(3022), 시그모이드(3024) 및 소프트플러스(3026) 모듈들의 출력들은 규정 형태(예, 필요할 때 선행 0들이 추가되는)로 확장되고, 출력 이진 포인트(2954) 값에 의해 지정된 이진 포인트를 갖도록 정렬된다.
정류기(3018)는 CCS 및 포화기(3008)의 출력값의 정류된 형태를 생성한다. 즉, CCS 및 포화기(3008)의 출력값(그 부호는 상술한 바와 같이 파이프를 통해 아래로 전달된다)이 음이라면, 정류기(3018)는 0의 값을 출력하고; 그렇지 않을 경우, 정류기(3018)는 그 입력값을 출력한다. 바람직하게, 정류기(3018)의 출력은 규정 형태이고, 출력 이진 포인트(2954) 값에 의해 지정된 이진 포인트를 갖는다.
역수 곱셈기(3014)는 CCS 및 포화기(3008)의 출력을 역수값(2942)에서 지정된 사용자-지정 역수값으로 곱하여, 규정 형태의 곱을 생성하고, 이 곱은 효과적으로 CCS 및 포화기(3008)의 출력 및 제수의 몫이고, 이는 역수(2942) 값의 역수이다. 바람직하게, 역수 곱셈기(3014)의 출력은 규정 형태이고, 출력 이진 포인트(2954) 값에 의해 지정된 이진 포인트를 갖는다.
우측 시프터(3016)는 CCS 및 포화기(3008)의 출력을 이동량 값(2944)에서 지정된 비트들의 사용자-지정 수만큼 이동시켜, 규정 크기의 몫을 생성한다. 바람직하게, 우측 시프터(3016)의 출력은 규정 형태이고, 출력 이진 포인트(2954) 값에 의해 지정된 이진 포인트를 갖는다.
mux(3032)는 활성함수(2934) 값에 의해 지정된 적절한 입력을 선택하고, 이러한 선택을 부호 복구자(3034)에 제공하고, 부호 복구자(3034)는, 원래의 누산기(202)의 값(217)이 음의 값, 예컨대 2의 보수 형태이면, mux(3032)의 양의 형태의 출력을 음의 형태로 변환시킨다.
크기 변환기(3036)는 부호 복구자(3034)의 출력을 도 29a에 관해 위에서 기술된 출력 명령(2956)의 값에 기초하여 적절한 크기로 변환시킨다. 바람직하게, 부호 복구자(3034)의 출력은 출력 이진 포인트(2954) 값에 의해 지정된 이진 포인트를 갖는다. 바람직하게, 출력 명령(2956)의 제1의 미리 결정된 값에 대해, 크기 변환기(3036)는 부호 복구자(3034) 출력의 상부 절반의 비트들을 폐기한다. 또한, 부호 복구자(3034)의 출력이 양이고, 구성(2902)에 의해 지정된 워드 크기로 표현할 수 있는 최대값을 초과하거나, 음이고 워드 크기로 표현할 수 있는 최소값보다 작다면, 포화기(3036)는 그 출력을 워드 크기로 표현할 수 있는 각 최대/최소값으로 포화시킨다. 제2 및 제3의 미리 결정된 값들에 대해, 크기 변환기(3036)는 부호 복구자(3034) 출력을 전달한다.
mux(3037)는 출력 레지스터(3038)에 대한 제공을 위해 출력 명령(2956)에 기초하여, 크기 변환기 및 포화기(3036) 출력 또는 누산기(202)의 값(217)을 선택한다. 보다 특별하게, 출력 명령(2956)의 제1 및 제2의 미리 결정된 값들에 대해, mux(3037)는 크기 변환기 및 포화기(3036)의 출력의 하위 워드(구성(2902)에 의해 지정된 크기를 갖는)를 선택한다. 제3의 미리 결정된 값들에 대해, mux(3037)는 크기 변환기 및 포화기(3036)의 출력의 상위 워드를 선택한다. 제4의 미리 결정된 값들에 대해, mux(3037)는 미처리 누산기(202)의 값(217)의 하위 워드를 선택하고; 제5의 미리 결정된 값들에 대해, mux(3037)는 미처리 누산기(202)의 값(217)의 중간 워드를 선택하고; 제6의 미리 결정된 값들에 대해, mux(3037)는 미처리 누산기(202)의 값(217)의 상위 워드를 선택한다. 상술한 바와 같이, AFU(212)는 미처리 누산기(202)의 값(217)의 상위 워드의 상위 비트들을 0에 덧붙인다.
이제, 도 31을 참조하면, 도 30의 AFU(212)의 동작의 일 예가 도시된다. 도시된 바와 같이, 구성(2902)은 NPU들(126)의 좁은 구성으로 설정된다. 추가적으로, 부호가 있는 데이터(2912) 및 부호가 있는 웨이트(2914) 값들은 참이다. 추가적으로, 데이터 이진 포인트(2922) 값은, 이진 포인트의 우측에 7개 비트들이 존재하도록 데이터 RAM(122)에 대한 이진 포인트가 위치함을 나타내고, NPU들(126) 중 하나에 의해 수신된 제1 데이터 워드의 예시적인 값은 0.1001110으로 도시된다. 또한, 웨이트 이진 포인트(2924) 값은, 이진 포인트의 우측에 3개 비트들이 존재하도록 웨이트 RAM(124)에 대한 이진 포인트가 위치함을 나타내고, NPU들(126) 중 하나에 의해 수신된 제1 데이터 워드의 예시적인 값은 00001.010으로 도시된다.
제1의 데이터 및 웨이트 워드들의 16-비트 곱(누산기(202)의 초기 0 값과 함께 누적된)은 000000.1100001100으로 도시된다. 데이터 이진 포인트(2912)가 7이고 웨이트 이진 포인트(2914)가 3이기 때문에, 적용된 누산기(202)의 이진 포인트는, 이진 포인트의 우측에 10개 비트들이 존재하도록, 위치된다. 좁은 구성의 경우, 예시적인 실시예에서 누산기(202)는 28 비트 폭이다. 본 예에서, 모든 ALU 동작들(예, 도 20의 모든 1024개의 곱-누적들)이 수행된 후 누산기(202)의 000000000000000001.1101010100의 값(217)이 도시된다.
출력 이진 포인트(2954) 값은, 출력에 대한 이진 포인트를 이진 포인트의 우측에 7개 비트들이 존재하도록 위치됨을 나타낸다. 그러므로, OBPA(3002) 및 CCS(3008)를 전달한 후, 누산기(202)의 값(217)은 000000001.1101011의 규정 형태의 값으로 크기조정, 반올림 및 압축된다. 본 예에서, 출력 이진 포인트 위치는 7개의 분수 비트들을 나타내고, 누산기(202) 이진 포인트 위치는 10개의 분수 비트들을 나타낸다. 그러므로, OBPA(3002)는 3의 차이를 계산하고, 우측으로 3 비트 이동시킴으로써 누산기(202)의 값(217)을 크기조정한다. 이것은 누산기(202)의 값(217)의 3개의 최하위 비트들(이진 100)의 손실로 도 31에 표시된다. 본 예에서 또한, 반올림 제어(2932) 값은 확률론적 반올림의 사용을 나타내고, 본 예에서 샘플링된 랜덤 비트(3005)가 참인 것이 가정된다. 결과적으로, 위의 설명에 따라 누산기(202)의 값(217)의 반올림 비트(누산기(202)의 값(217)의 크기조정에 의해 밖으로 이동된 3개 비트들 중 최상위 비트)는 1이었고, 스티키 비트(누산기(202)의 값(217)의 크기조정에 의해 밖으로 이동된 3개 비트들 중 2개의 최하위 비트들의 불린 OR)가 0이었기 때문에, 최하위 비트가 반올림되었다.
활성함수(2934)는 본 예에서 시그모이드 함수를 사용하는 것을 나타낸다. 결과적으로, 비트 선택기(3012)는, 시그모이드 모듈(3024)에 대한 입력이 상술한 바와 같이 3개의 자연수 비트들과 4개의 분수 비트들, 즉 도시된 바와 같이 001.1101의 값을 갖도록, 규정 형태의 비트들을 선택한다. 시그모이드 모듈(3024)은 0000000001.1101110으로 도시된 규정 형태의 값을 출력한다.
본 예에서 출력 명령(2956)은 구성(2902)에 의해 지시된 워드 크기를 출력하기 위한 제1의 미리 결정된 값을 지정하고, 이 경우 구성은 좁은 워드(8 비트)이다. 결과적으로, 크기 변환기(3036)는 규정의 시그모이드 출력값을, 7개 비트들이 이진 포인트의 우측에 있도록 위치하는 적용된 이진 포인트를 갖는 8비트 양으로 변환시켜, 도시된 바와 같이 01101110의 출력값을 산출한다.
이제, 도 32를 참조하면, 도 30의 AFU(212)의 동작의 제 2의 예가 도시된다. 도 32의 예는 활성함수(2934)가 규정 크기의 누산기(202)의 값(217)을 패스쓰루하는 것을 나타낼 때, AFU(212)의 동작을 도시한다. 도시된 바와 같이, 구성(2902)은 NPU들(126)의 좁은 구성으로 설정된다.
본 예에서, 누산기(202)는 28비트 폭이고, 누산기(202)의 이진 포인트는, 10개 비트들이 이진 포인트의 우측에 있도록 위치한다(데이터 이진 포인트(2912) 및 웨이트 이진 포인트(2914)의 합이 일 실시예에 따라 10이기 때문에, 또는 상술한 바와 같이 누산기 이진 포인트(2923)가 다른 실시예에 따라 10의 값을 갖는 것으로 명시적으로 지정되기 때문에). 본 예에서, 도 32는 모든 ALU 동작들이 수행된 후 누산기(202)의 0000011 00000011011.1101111010의 값(217)을 도시한다.
본 예에서, 출력 이진 포인트(2954) 값은, 출력을 위한 이진 포인트를 4개 비트들이 이진 포인트의 우측에 있도록, 위치한다. 그러므로, OBPA(3002) 및 CCS(3008)를 패스쓰루한 후, 누산기(202)의 값(217)은 도시된 바와 같이 111111111111.1111의 규정 형태의 값으로 포화되어 압축되고, 이는 규정 크기의 패스쓰루 값(3028)로서 mux(3032)에 의해 수신된다.
본 예에서, 2개 출력 명령들(2956)이 도시된다. 제1의 출력 명령(2956)은, 규정 형태 크기의 하위 워드를 출력하기 위한 제2의 미리 결정된 값을 지정한다. 구성(2902)에 의해 지정된 크기가 좁은 워드(8 비트)이고, 이는 16비트의 규정 크기를 의미하기 때문에, 크기 변환기(3036)는 규정 크기 패스쓰루 값(3028)의 하위 8 비트들을 선택하여 도시된 11111111의 8비트 값을 산출한다. 제2의 출력 명령(2956)은, 규정 형태 크기의 상위 워드를 출력하기 위한 제3의 미리 결정된 값을 지정한다. 결과적으로, 크기 변환기(3036)는 규정 크기 패스쓰루 값(3028)의 상위 8 비트들을 선택하여 도시된 11111111의 8 비트 값을 산출한다.
이제, 도 33를 참조하면, 도 30의 AFU(212)의 동작의 제 3의 예가 도시된다. 도 33의 예는 활성함수(2934)가 규정 크기의 누산기(202)의 값(217)을 패스쓰루하는 것을 나타낼 때, AFU(212)의 동작을 도시한다. 도시된 바와 같이, 구성(2902)은 NPU들(126)의 넓은 구성(예, 16비트 입력 워드들)으로 설정된다.
본 예에서, 누산기(202)는 41비트 폭이고, 누산기(202)의 이진 포인트는, 8개 비트들이 이진 포인트의 우측에 있도록 위치한다(데이터 이진 포인트(2912) 및 웨이트 이진 포인트(2914)의 합이 일 실시예에 따라 8이기 때문에, 또는 상술한 바와 같이 누산기 이진 포인트(2923)가 다른 실시예에 따라 8의 값을 갖는 것으로 명시적으로 지정되기 때문에). 본 예에서, 도 33은 모든 ALU 동작들이 수행된 후 누산기(202)의 001000000000000000001100000011011.11011110의 값(217)을 도시한다.
본 예에서, 3개 출력 명령들(2956)이 도시된다. 제1의 출력 명령(2956)은, 미가공 누산기(202)의 값의 하위 워드를 출력하기 위한 제4의 미리 결정된 값을 지정하고; 제2의 출력 명령(2956)은, 미가공 누산기(202)의 값의 중간 워드를 출력하기 위한 제5의 미리 결정된 값을 지정하고; 제3의 출력 명령(2956)은, 미가공 누산기(202)의 값의 상위 워드를 출력하기 위한 제6의 미리 결정된 값을 지정한다. 구성(2902)의 지정된 크기가 넓은 워드(16 비트)이기 때문에, 도 33은, 제1의 출력 명령(2956)에 응답하여, mux(3037)가 0001101111011110의 16비트 값을 선택하고; 제2의 출력 명령(2956)에 응답하여, mux(3037)가 0000000000011000의 16비트 값을 선택하고; 제3의 출력 명령(2956)에 응답하여, mux(3037)가 0000000001000000의 16비트 값을 선택하는 것을 도시한다.
상술한 바와 같이, 유리하게 NNU(121)는 부동소수점 데이터가 아니라 정수 데이터에 대해 동작한다. 이것은 각 NPU(126), 또는 적어도 ALU(204) 부분을 단순화시키는 장점을 갖는다. 예컨대, ALU(204)는 곱셈기(242)의 피승수들의 지수들을 가산하기 위한 부동소수점 구현에서 필요할 가산기들의 포함을 요구하지 않는다. 유사하게, ALU(204)는 가산기(234)를 위한 가수들의 이진 포인트들을 정렬하기 위한 부동소수점 구현에서 필요할 시프터들의 포함을 요구하지 않는다. 당업자가 인식하는 것과 같이, 부동소수점 유닛들은 매우 복잡하고; 따라서, 이들은 ALU(204)에 대한 오로지 단순화들의 예들이고, 사용자가 해당 이진 포인트들을 지정하는 것을 가능케 하는 하드웨어 고정 포인트 보조장치를 갖는 인스턴트 정수 실시예들에 의해 다른 단순화들이 얻어질 수 있다. ALU들(204)이 정수 유닛들이라는 사실은 유리하게 부동소수점 실시예보다 더 작은(및 더 빠른) NPU(126)를 초래할 수 있고, 이는 더 유리하게 NPU들(126)의 큰 어레이의 NNU(121) 내로의 통합을 용이하게 한다. AFU(212) 부분은, 바람직하게는 사용자가-지정한, 누산된 값에서 요구되는 분수 비트들의 수 및 출력값에서 요구되는 분수 비트들의 수에 기초하여, 누산기(202)의 값(217)의 크기조정 및 포화를 처리한다. 유리하게, AFU(212)들의 고정 포인트 하드웨어 보조장치에 임의의 추가적인 복잡도 및 수반하는 크기, 전력 소모 및/또는 시간에서의 증가는, 예컨대 AFU(1112)들의 수가 공유된 실시예에서 줄어들 수 있기 때문에, 도 11의 실시예에 관해 기술된 바와 같이, ALU(204) 부분들 중에서 AFU(212)들을 공유함으로써 상각될 수 있다.
유리하게, 본 명세서에서 기술된 실시예들은, 분수 수들, 즉 이진 포인트를 갖는 수들에 대해 연산 동작들을 여전히 제공하면서, 부동소수점 연산 유닛들에 대하여 하드웨어 정수 연산 유닛들의 감소된 복잡도와 관련된 많은 이점들을 얻는다. 부동소수점 연산의 장점은, 개별적인 값들이 매우 넓은 범위(지수 범위의 크기에 의해 오로지 효과적으로 제한되고, 매우 클 수 있는)의 값들 내의 어느 곳에나 있을 수 있는 데이터 상에 연산 동작들을 적응시키는 점이다. 즉, 부동소수점 수는 자신의 잠재적으로 고유한 지수값을 갖는다. 그러나, 입력 데이터가 고도로 병렬화되고, 상대적으로 좁은 범위 내에 있는 값들을 가져, 모든 병렬화된 값들에 대한 "지수"들이 동일할 수 있는 특정 응용들이 존재한다는 사실을 인식하고 이를 이용하는 실시예들이 본 명세서에서 기술된다. 그러므로, 이러한 실시예들은 사용자가 모든 입력값들 및/또는 누적값들에 대해 이진 포인트 위치를 한 번 지정하는 것을 가능케 한다. 유사하게, 실시예들은 사용자가 모든 출력값들에 대해 이진 포인트 위치를 한 번 지정하는 것을 가능케 하여, 병렬화된 출력들의 유사한 범위 특징들을 인식하고 이를 이용한다. 이러한 실시예들이 다른 응용들을 위한 계산들을 수행하기 위하여 이용될 수 있지만, 인공 신경망은 이러한 응용의 예이다. 각 개별적인 입력 수에 대해서가 아니라, 입력들에 대한 이진 포인트 위치를 한 번 지정함으로써, 실시예들은 부동소수점 구현에 대해 메모리 공간의 더 효율적인 사용을 제공하고(더 적은 메모리를 요구하고), 및/또는 메모리의 유사한 양에 대해 정밀도에서의 증가를 제공하는데, 왜냐하면 부동소수점 구현에서 지수를 위해 사용될 비트들이 크기에서 큰 정밀도를 지정하기 위하여 사용될 수 있기 때문이다.
더 유리하게, 실시예들은 큰 일련의 정수 동작들의 누적 동안 경험할 수 있는 정밀도의 잠재적인 손실(예, 더 적은 중요도의 분수 비트들의 오버플로우 또는 손실)을 인식하고, 정밀도 손실을 회피하기 위하여 기본적으로 충분히 큰 누산기의 형태의 해결책을 제공한다.
NNU 마이크로-동작의 직접 실행
이제, 도 34를 참조하면, 도 1의 프로세서(100)를 도시하고, 도 1의 NNU(121)의 부분들을 더 상세하게 도시하는 블록도가 도시된다. NNU(121)는 NPU들(126)의 파이프라인 단계(3401)들을 포함한다. 레지스터들을 다단으로 함으로써 분리된 파이프라인 단계(3401)들은, 불린 로직 게이트들, 멀티플렉서들, 가산기들, 곱셈기들, 비교기들, 등과 같이 본 명세서에서 기술된 NPU(126)들의 동작을 달성하는 조합 로직을 포함한다. 파이프라인 단계(3401)들은 mux(3402)로부터 마이크로-동작(3418)을 수신한다. 마이크로-동작(3418)은 파이프라인 단계(3401)들 아래로 흐르고 그들의 조합 로직을 제어한다. 마이크로-동작(3418)은 비트들의 모음이다. 바람직하게, 마이크로-동작(3418)은 데이터 RAM(122)의 메모리 어드레스(123), 웨이트 RAM(124)의 메모리 어드레스(125), 프로그램 메모리(129)의 메모리 어드레스(131), mux-reg(208/705)의 제어 신호(213/713)들, mux(802)의 제어 신호(803), 및 (예컨대 특히, 도 29a 내지 도 29c의) 제어 레지스터(127)의 많은 필드들의 비트들을 포함한다. 일 실시예에 있어서, 마이크로-동작(3418)은 대략 120개 비트들을 포함한다. mux(3402)는 3개의 상이한 소스들로부터 마이크로-동작을 수신하고, 이들 중 하나를 파이프라인 단계(3401)들에 제공하기 위한 마이크로-동작(3418)으로서 선택한다.
mux(3402)에 대한 하나의 마이크로-동작 소스는 도 1의 시퀀서(128)이다. 시퀀서(128)는 프로그램 메모리(129)로부터 수신된 NNU 명령들을 디코딩하고, 이에 응답하여 mux(3402)의 제1 입력에 제공되는 마이크로-동작(3416)을 생성한다.
mux(3402)에 대한 제 2 마이크로-동작 소스는, GPR(116) 및 미디어 레지스터(118)로부터의 피연산자들과 함께, 도 1의 예약 스테이션(108)으로부터 마이크로-명령(105)들을 수신하는 디코더(3404)이다. 바람직하게, 마이크로명령(105)들은 상술한 바와 같이, MTNN 명령(1400) 및 MFNN 명령(1500)들을 변환하는 것에 응답하여 명령 변환기(104)에 의해 생성된다. 마이크로명령(105)들은, 상술한 바와 같이, 프로그램 메모리(129) 내의 프로그램의 실행을 시작 및 정지, 미디어 레지스터(118)들로부터 마이크로-동작의 직접 실행, 또는 NNU(121)의 메모리를 판독/기록하는 것과 같은, 특정 함수(MTNN 명령(1400) 또는 MFNN 명령(1500)들에 의해 지정된)를 지정하는 즉시 필드를 포함할 수 있다. 디코더(3404)는 마이크로명령(105)들을 디코딩하고, 이에 응답하여 mux(3402)의 제 2 입력에 제공되는 마이크로-동작(3412)을 생성한다. 바람직하게, MTNN/MFNN(1400/1500) 명령의 일부 함수(1432/1532)들에 응답하여, 디코더(3404)가 마이크로-동작(3412)을 생성하여 파이프라인(3401) 아래로 전달하는 것이 필요하지 않은데, 이러한 마이크로-동작은, 예컨대, 제어 레지스터(127)에 기록, 프로그램 메모리(129) 내의 프로그램의 실행의 시작, 프로그램 메모리(129) 내의 프로그램의 실행의 정지, 프로그램 메모리(129) 내의 프로그램의 실행의 종료를 위한 대기, 상태 레지스터(127)로부터 판독 및 NNU(121)의 리세팅이다.
mux(3402)에 대한 제 3 마이크로-동작 소스는 미디어 레지스터(118)들 자체이다. 바람직하게, 도 14에 관해 위에서 기술된 바와 같이, MTNN 명령(1400)은, NNU(121)가 미디어 레지스터들(118)로부터 mux(3402)의 제 3 입력에 제공되는 마이크로-명령(3414)을 직접 실행하도록 명령하는 함수를 지정할 수 있다. 구조적인 미디어 레지스터(118)들에 의해 제공된 마이크로-동작(3414)의 직접 실행은, 시험, 예컨대 내장된 자가 시험(Built-In Self Test, BIST), 및 NNU(121)의 디버그를 위해 특히 유용할 수 있다.
바람직하게, 디코더(3404)는 mux(3402) 선택을 제어하는 모드 표시자(3422)를 생성한다. MTNN 명령(1400)이 프로그램 메모리(129)로부터 프로그램의 실행을 시작하는 함수를 지정할 때, 디코더(3404)는 모드 표시자(3422) 값을 생성하고, 이 값은, 에러가 발생하거나 또는 디코더(3404)가 프로그램 메모리(129)로부터 프로그램의 실행을 중지하는 함수를 지정하는 MTNN 명령(1400)을 만날 때까지, mux(3402)가 시퀀서(128)로부터 마이크로-동작(3416)을 선택하게 한다. MTNN 명령(1400)이 함수를 지정하고, 이 함수가 NNU(121)로 하여금 미디어 레지스터(118)로부터 제공된 마이크로-동작(3414)을 직접 실행하도록 명령 때, 디코더(3404)는 모드 표시자(3422) 값을 생성하고, 이러한 값은 mux(3402)가 지정된 미디어 레지스터(118)들로부터 마이크로-동작(3414)을 선택하게 한다. 그렇지 않을 경우, 디코더(3404)는 mux(3402)가 디코더(3404)로부터 마이크로-동작(3412)을 선택하게 하는 모드 표시자(3422) 값을 생성한다.
가변 속도의 신경망 유닛
NNU(121)가 프로그램을 구동하고, 이후 다름 프로그램을 구동할 수 있기 전에 프로세서(100)가 필요로 하는 뭔가를 행하는 것을 대기하면서 휴지 상태에 있는 상황들이 존재할 수 있다. 예컨대, NNU(121)가 곱-누산-활성함수 프로그램(또한 피드포워드 신경망 층의 프로그램으로 언급될 수 있는)의 2 이상의 연속 예들을 구동하는, 도 3 내지 도 6에 관해 기술된 것과 유사한 상황을 가정한다. 프로세서(100)가 NNU 프로그램의 다음 실행에 의해 사용될 512KB 만큼의 웨이트 값들을 웨이트 RAM(124)에 기록하는데 걸리는 것은 NNU(121)이 프로그램을 실행하는 걸리는 것보다 더 길게 걸릴 수 있다. 달리 말하면, NNU(121)는 상대적으로 짧은 양의 시간에 프로그램을 구동할 수 있고, 이후 프로세서(100)가 프로그램의 다음 구동을 위해 다음 웨이트 값들을 웨이트 RAM(124)에 기록하는 것을 완료하는 동안 휴지 상태로 놓인다. 이러한 상황은 아래에서 더 상세하게 기술되는 도 36a에 시각적으로 도시된다. 이러한 상황들에서, NNU(121)를 더 느린 속도로 구동하고, 프로그램을 실행하는데 더 길게 걸리고, 이에 의해 NNU(121)가 프로그램을 실행하는 필요한 에너지 소비를 더 많은 시간에 걸쳐 분산하는 것이 유리할 수 있고, 이는 NNU(121)의 온도를, 아마도 일반적으로 프로세서(100)의 온도를 낮게 유지하는 경향이 있을 수 있다. 이러한 상황은 완화된 모드로 언급되고, 아래에서 더 상세하게 기술되는 도 39b에 시각적으로 도시된다.
이제, 도 35를 참조하면, 가변 속도의 NNU(121)를 포함하는 프로세서(100)를 도시하는 블록도가 도시된다. 프로세서(100)는 많은 면에서 도 1의 프로세서(100)와 유사하고, 유사 번호가 메겨진 요소들은 유사하다. 도 35의 프로세서(100)는 또한, 프로세서(100)의 기능 유닛들 즉, 명령 인출 유닛(101), 명령 캐시(102), 명령 변환기(104), 재명명 유닛(106), 예약 스테이션(108), NNU(121), 다른 실행 유닛들(112), 메모리 하위시스템(114), 범용 레지스터들(116) 및 미디어 레지스터들(118)에 결합된 클록 생성 로직(3502)을 포함한다. 클록 생성 로직(3502)은 기본 클록 속도, 즉 클록 주파수를 갖는 클록 신호를 생성하는 위상 동기 루프(PLL)와 같은 클록 생성기를 포함한다. 예컨대, 기본 클록 속도는 1 GHz, 1.5 GHz, 2 GHz, 등이 될 수 있다. 클록 속도는 초당 클록 신호의 사이클들, 예컨대 높은 상태와 낮은 상태 사이의 발진들의 수를 나타낸다. 바람직하게, 클록 신호는 균형잡힌 듀티 사이클, 즉 높은 절반의 주기와 낮은 다른 절반의 사이클을 갖고; 대안적으로, 클록 신호는 높은 상태의 클록 신호가 낮은 상태에서의 신호보다 더 길거나 또는 그 반대인 균형잡히지 않은 듀티 사이클을 갖는다. 바람직하게, PLL은 다수의 클록 속도들의 기본 클록 신호를 생성하도록 구성될 수 있다. 바람직하게, 프로세서(100)는, 프로세서(100)의 동적으로 검출되는 동작 온도, 사용, 및 원하는 성능 및/또는 전력 절감 표시자들을 나타내는 시스템 소프트웨어(예, 운영체계, BIOS)로부터 명령들을 포함하는 다양한 인자들에 기초하여 자동적으로 기본 클록 속도를 조정하는 전력 관리 모듈을 포함한다.
클록 생성 로직(3502)은 또한 클록 분배 네트워크, 또는 클록 트리를 포함한다. 클록 트리는 기본 클록 신호를 프로세서(100)의 기능 유닛들에 분배하고, 기본 클록 신호들은 도 35에서 명령 인출 유닛(101)에 대한 클록 신호(3506-1), 명령 캐시(102)에 대한 클록 신호(3506-2), 명령 변환기(104)에 대한 클록 신호(3506-10), 재명명 유닛(106)에 대한 클록 신호(3506-9), 예약 스테이션(108)에 대한 클록 신호(3506-8), NNU(121)에 대한 클록 신호(3506-7), 다른 실행 유닛(112)들에 대한 클록 신호(3506-4), 메모리 하위시스템(114)에 대한 클록 신호(3506-3), 범용 레지스터(116)들에 대한 클록 신호(3506-5), 및 미디어 레지스터(118)들에 대한 클록 신호(3506-6)로서 표시되고, 이들은 집단적으로 클록 신호(3506)들로 언급된다. 클록 트리는 기본 클록 신호(3506)를 그들의 각 기능 유닛들에 전송하는 노드들, 또는 배선들을 포함한다. 추가적으로, 바람직하게 클록 생성 로직(3502)은 특히 긴 노드들을 위해 크리너 클록 신호들 제공하고 및/또는 기본 클록 신호의 전압 레벨들을 높이기 위하여 필요한 기본 클록 신호를 재생성하는 클록 버퍼를 포함한다. 추가적으로, 각 기능 유닛은 또한 자신이 수신한 각 기본 클록 신호를 재생성하고 및/또는 이의 전압을 높이는 자신의 하위-클록 트리를 필요할 때 포함할 수 있다.
NNU(121)는 완화 표시기(3512)를 수신하고, 기본 클록 신호(3506-7)를 수신하여 이에 응답으로 제 2 클록 신호를 생성하는 클록 감소 로직(3504)을 포함한다. 제 2 클록 신호는, 기본 클록 속도와 동일한 클록 속도이거나, 또는 완화된 모드일 때, 완화 표시기(3512)에 프로그램된 양만큼 기본 클록 속도에 대해 감소된 클록 속도를 갖고, 이는 잠재적으로 열적 이득들을 제공한다. 클록 감소 로직(3504)은, 제 2 클록 신호를 NNU(121)의 다양한 블록들에 분배하는 클록 분배 네트워크, 또는 트리를 갖는 점에서, 많은 양상에서 클록 생성 로직(3502)과 유사하고, 제2 클록 신호들은, NPU들(126)의 어레이에 대한 클록 신호(3508-1), 시퀀서(128)에 대한 클록 신호(3508-2) 및 인터페이스 로직(3514)에 클록 신호(3508-3)로 표시되고, 이들은 집단적으로 또는 개별적으로 제2 클록 신호(3508)로서 언급된다. 바람직하게, NPU들(126)은 도 34에 관해 기술된 복수의 파이프라인 단계(3401)들을 포함하고, 이러한 단계들은 클록 감소 로직(3504)으로부터 제2 클록 신호(3508-1)를 수신하는 파이프라인 스테이징 레지스터들을 포함한다.
NNU(121)는 또한 기본 클록 신호(3506-7) 및 제2 클록 신호(3508-3)를 수신하는 인터페이스 로직(3514)을 포함한다. 인터페이스 로직(3514)은 프로세서(100)의 전단의 하위 부분들(예, 예약 스테이션(108), 미디어 레지스터들(118) 및 범용 레지스터(116)들) 및 NNU(121)의 다양한 블록들, 즉 클록 감소 로직(3504), 데이터 RAM(122), 웨이트 RAM(124), 프로그램 메모리(129) 및 시퀀서(128) 사이에 결합된다. 인터페이스 로직(3514)은 데이터 RAM 버퍼(3522), 웨이트 RAM 버퍼(3524), 도 34의 디코더(3404) 및 완화 표시기(3512)를 포함한다. 완화 표시기(3512)는 얼마나 느려지는지를 지정하는 값을 유지하고, 이러한 값이 있다면 NPU(126)들의 어레이는 NNU 프로그램 명령들을 실행할 것이다. 바람직하게, 완화 표시기(3512)는 제수(Divisor)값 N을 지정하고, 클록 감소 로직(3504)은 이러한 제수로 기본 클록 신호(3506-7)를 나누어, 제2 클록 신호(3508)가 1/N인 속도를 갖도록, 제2 클록 신호(3508)를 생성한다. 바람직하게, N의 값은 복수의 상이한 미리 결정된 값들 중 어느 하나로 프로그램되어, 클록 감소 로직(3504)이 기본 클록 속도보다 낮은 대응하는 복수의 상이한 속도로 제2 클록 신호(3508)를 생성하게 할 수 있다.
일 실시예에서, 클록 감소 로직(3504)은 완화 표시기(3512) 값으로 1차 클록 신호(3506-7)를 분할하기 위하여 클록 분할기 회로로 이루어진다. 일 실시예에서, 클록 감소 로직(3504)은 1차 클록 신호(3506-7)의 모든 N 사이클에 대해서 1회만 참(true)인 인에이블 신호로 1차 클록 신호(3506-7)를 통전하는 클록 게이트(예, AND 게이트)로 이루어진다. 예컨대, 인에이블 신호를 발생하기 위하여, N까지 계수하는 카운터를 포함하는 회로를 사용할 수 있다. 카운터의 출력이 N과 일치함을 동반 로직이 검출할 때, 로직은 2차 클록 신호(3508)에 대하여 참 펄스를 발생하고 카운터를 리셋한다. 바람직하기로는, 완화 표시기(3512) 값이 도 14의 MTNN(1400) 명령과 같은 아키텍쳐 명령에 의하여 프로그램 가능하다. 바람직하기로는, 프로세서(100) 상에서 실행되는 아키텍쳐 프로그램은, 도 37과 관련하여 보다 상세하게 설명된 바와 같이, NNU(121)가 NNU 프로그램을 시작하도록 명령하기 바로 전에, 완화값을 완화 표시기(3512)에 프로그램한다.
웨이트 RAM 버퍼(3524)는 웨이트 RAM(124)와 미디어 레지스터(118) 사이에 데이터 전송을 버퍼링하기 위하여 웨이트 RAM(124)과 미디어 레지스터(118) 사이에 결합된다. 바람직하기로는, 웨이트 RAM 버퍼(3524)는 도 17의 버퍼(1704)에 대한 하나 이상의 실시예와 유사하다. 바람직하기로는, 미디어 레지스터(118)로부터 데이터를 수신하는 웨이트 RAM 버퍼(3524) 부분은 1차 클록 속도로 1차 클록 신호(3506-7)에 의하여 클록되고, 웨이트 RAM(124)으로부터 데이터를 수신하는 웨이트 RAM 버퍼(3524) 부분은 2차 클록 속도로 2차 클록 신호(3508-3)에 의하여 클록되는데, 2차 클록 속도는 완화 표시기(3512)에 프로그램된 값에 따라, 즉, NNU(121)가 완화 모드로 동작되는지 또는 정상 모드로 동작되는지 여부에 따라 1차 클록 속도에 비하여 감소될 수 있거나 없다. 일 실시예에서, 웨이트 RAM(124)은 도 17에 대하여 전술한 바와 같이 단일의-포트로 되며, 웨이트 RAM 버퍼(3524)를 통하여 미디어 레지스터(118) 및 NPU(126) 또는 도 11의 행 버퍼(1104) 모두에 의하여 중재된 방식으로 접속 가능하다. 택일적인 일 실시예에서, 웨이트 RAM(124)은, 도 16에 관련하여 전술한 바와 같이, 이중-포트로 되며, 각각의 포트는 웨이트 RAM 버퍼(3524)를 통하여 미디어 레지스터(118) 및 NPU(126) 또는 행 버퍼(1104) 모두에 의하여 동시에 접속 가능하다.
마찬가지로, 데이터 RAM 버퍼(3522)는 데이터 RAM(122) 및 미디어 레지스터(118) 사이에 데이터 전송을 버퍼링하기 위하여 데이터 RAM(122) 및 미디어 레지스터(118) 사이에 결합된다. 바람직하기로는, 데이터 RAM 버퍼(3522)는 도 17의 버퍼(1704)에 대한 하나 이상의 실시예와 유사하다. 바람직하기로는, 미디어 레지스터(118)로부터 데이터를 수신하는 데이터 RAM 버퍼(3522) 부분은 1차 클록 속도로 1차 클록 신호(3506-7)에 의하여 클록되고, 데이터 RAM(122)으로부터 데이터를 수신하는 데이터 RAM 버퍼(3522) 부분은 2차 클록 속도로 2차 클록 신호(3508-3)에 의하여 클록되는데, 2차 클록 속도는 완화 표시기(3512)에 프로그램된 값에 따라, 즉, NNU(121)가 완화 모드로 동작되는지 또는 정상 모드로 동작되는지 여부에 따라 1차 클록 속도에 비하여 감소될 수 있거나 없다. 일 실시예에서, 데이터 RAM(122)은 도 17에 대하여 전술한 바와 같이 단일-포트로 되며, 데이터 RAM 버퍼(3522)를 통하여 미디어 레지스터(118) 및 NPU(126) 또는 도 11의 행 버퍼(1104) 모두에 의하여 중재된 방식으로 접속 가능하다. 택일적인 일 실시예에서, 데이터 RAM(122)은, 도 16에 관련하여 전술한 바와 같이, 이중-포트로 되며, 각각의 포트는 데이터 RAM 버퍼(3522)를 통하여 미디어 레지스터(118) 및 NPU(126) 또는 행 버퍼(1104) 모두에 의하여 동시에 접속 가능하다.
바람직하기로는, 인터페이스 로직(3514)은, 데이터 RAM(122) 및/또는 웨이트 RAM(124)이 단일의-포트로 되는지 또는 이중-포트로 되는지에 관계없이, 1차 클록 도메인과 2차 클록 도메인 사이에 동기화를 제공하기 위하여, 데이터 RAM 버퍼(3522) 및 웨이트 RAM 버퍼(3524)를 포함한다. 바람직하기로는, 각각의 데이터 RAM(122), 웨이트 RAM(124) 및 프로그램 메모리(129)는 판독 가능, 기입 가능 및 메모리 선택 신호 각각을 포함하는 스태틱(static) RAM(SRAM)으로 이루어진다.
전술한 바와 같이, NNU(121)는 프로세서(100)의 실행 유닛이다. 실행 유닛은, 도 1의 아키텍쳐 명령(103)로부터 변환되는 마이크로 명령(105)처럼 아키텍쳐 명령으로부터 변환되는 마이크로 명령을 실행하거나 아키텍쳐 명령(103) 그 자체를 실행하는 프로세서의 기능 유닛이다. 실행 유닛은 GPR(116) 및 미디어 레지스터(118)과 같은 피연산자를 프로세서의 범용 레지스터로부터 수신한다. 실행 유닛은 범용 레지스터에 기입될 수 있는 마이크로 명령 또는 아키텍쳐 명령을 실행함에 응답하여 발생된다. 아키텍쳐 명령(103)의 예에는 각각 도 14 및 15에 관련하여 설명된 MTNN 명령(1400) 및 MFNN 명령(1500)이 있다. 마이크로 명령은 아키텍쳐 명령을 구현한다. 더욱 상세하게는, 아키텍쳐 명령으로부터 변환되는 하나 이상의 마이크로 명령의 실행 유닛에 의한 집단적인 실행은, 아키텍쳐 명령에 의하여 정의된 결과를 생성하기 위하여, 아키텍쳐 명령에 의하여 구체화된 입력에 대하여 아키텍쳐 명령에 의하여 구체화된 동작을 수행한다.
이제 도 36a를 참조하면, 정상 모드에서, 즉, 1차 클록 속도에서, 동작하는 NNU(121)를 갖는 프로세서(100)의 동작의 일예를 나타내는 타이밍도가 도시된다. 타이밍도에서 시간은 좌측에서 우측으로 흐른다. 프로세서(100)는 1차 클록 속도에서 아키텍쳐 프로그램을 운영한다. 더욱 상세하게는, 프로세서(100) 선단부(예, 명령 인출(fetch) 유닛(101), 명령 캐시(102), 명령 변환기(104), 재명명 유닛(106), 예약 스테이션(108)) 인출은 1차 클록 속도로, NNU(121) 및 기타 실행 유닛(112)에 아키텍쳐 명령을 디코딩하여 발생한다.
처음에, 아키텍쳐 프로그램은 선단부(100)가 NNU(121)에 발생하여 NNU(121)로 하여금 그의 프로그램 메모리(129)에서 NNU 프로그램을 실행 시작하도록 NNU(121)에 지시하는 아키텍쳐 명령(예, MTNN 명령(1400))을 실행한다. 앞서, 아키텍쳐 프로그램은 1차 클록 속도를 지정하는 값으로 완화 표시기(3512)를 기입하기 위하여, 즉, NNU(121)를 정상 모드로 하기 위하여 아키텍쳐 명령을 실행하였다. 더욱 상세하게는, 완화 표시기(3512)에 프로그램된 값은 클록 감소 로직(3504)으로 하여금 1차 클록 신호(3506)의 1차 클록 속도로 2차 클록 신호(3508)를 발생하도록 한다. 바람직하기로는, 이 경우, 클록 감소 로직(3504)의 클록 버퍼는 1차 클록 신호(3506)를 단순히 부스팅한다. 또한 이전에, 아키텍쳐 프로그램은 데이터 RAM(122) 및 웨이트 RAM(124)에 기입하기 위하여 그리고 NNU 프로그램을 프로그램 메모리(129)에 기입하기 위하여 아키텍쳐 명령을 실행하였다. 완화 표시기(3512)가 1차 속도값으로 프로그램되었으므로, 시작 NNU 프로그램 MTNN 명령(1400)에 따라, NNU(121)는 1차 클록 속도로 NNU 프로그램 실행을 시작한다. NNU(121) 실행을 시작한 후, 아키텍쳐 프로그램은 1차 클록 속도로 아키텍쳐 명령의 실행을 계속하는데, 아키텍쳐 명령은 NNU 프로그램의 다음 인스턴스, 또는 호출 또는 실행에 대비하여 데이터 RAM(122) 및 웨이트 RAM(124)를 기입 및/또는 판독하기 위한 MTNN 명령(1400)을 포함하며 주로 MTNN 명령(1400)이다.
도 36a의 예에 나타낸 바와 같이, NNU(121)는 아키텍쳐 프로그램이 데이터 RAM(122) 및 웨이트 RAM(124)의 기입/판독을 종료하는 데에 걸리는 시간보다 상당히 적은 시간 (예, 시간의 1/4) 이내에 NNU 프로그램의 실행을 종료한다. 예컨대, NNU(121)는 NNU 프로그램을 실행하는 데에 대략 1000 클록 사이클을 취할 수 있으나, 반면에 아키텍쳐 프로그램은 실행에 대략 4000클록 사이클을 취하고, 이는 양쪽 모두 1차 클록 속도인 경우이다. 결과적으로, NNU(121)는 시간의 나머지, 예에서 상당히 긴 시간 동안, 예컨대, 대략 3000개의 1차 클록 속도 사이클 동안 휴지 상태로 된다. 도 36a의 예에 나타낸 바와 같이, 이러한 패턴은 또 다른 시간 동안 계속되고, 신경망의 크기 및 구성에 따라, 몇 번 더 계속될 수 있다. NNU(121)는 프로세서(100)의 상대적으로 크고 트랜지스터 밀도가 높은 기능 유닛 일 수 있기 때문에, 특히 1차 클록 속도로 동작 할 때 상당한 양의 열을 발생할 수 있다.
이제 도 36b를 참조하면, NNU(121)가 완화(relax) 모드에서 동작하는, 즉, 1차 클록 속도보다 낮은 속도로 동작하는 프로세서(100) 동작의 일 예를 나타내는 타이밍도가 도시된다. 도 36b의 타이밍도는 프로세서(100)가 1차 클록 속도로 아키텍쳐 프로그램을 실행한다는 점에서 여러 면에서 도 36b의 타이밍도와 유사하다. 또한, 이 예에서는 도 36b의 아키텍쳐 프로그램 및 NNU 프로그램이 도 36a의 것과 동일하다고 가정한다. 그러나, NNU 프로그램을 시작하기에 앞서, 아키텍쳐 프로그램은 MTNN 명령(1400)을 실행하여 클록 감소 로직(3504)으로 하여금 2차 클록 신호(3508)를 1차 클록 속도보다 낮은 2차 클록 속도로 발생하도록 하는 값으로 완화 표시기(3512)를 프로그램한 MTNN 명령(1400)을 실행하였다. 즉, 아키텍쳐 프로그램은 NNU(121)를 도 36a에서와 같이 정상 모드가 아닌 도 36b의 완화 모드로 둔다. 결과적으로, NPU(126)는 완화된 모드에서 1차 클록 속도보다 낮은 2차 클록 속도로 NNU 프로그램을 실행한다. 상기 예에서, 완화 표시기(3512)는 2차 클록 속도가 1차 클록 속도의 1/4임을 명시하는 값으로 프로그램된 것으로 가정한다. 그 결과, NNU(121)는, 도 36a 및 도 36b를 비교함으로써 알 수 있는 바와 같이, NNU(121)가 정상 모드에서 NNU 프로그램을 실행하는 것보다 완화된 모드에서 NNU 프로그램을 실행하는 데에 약 4배 더 긴 시간이 걸리며, 휴지 상태인 시간의 양을 상대적으로 짧게 한다. 결과적으로, NNU 프로그램을 실행하는 데에 사용되는 에너지는 도 36a의 정상 모드에서 NNU(121)가 프로그램을 실행했을 때보다 대략 4배 더 긴 기간 동안 도 36b의 NNU(121)에 의해 소모된다. 따라서, NNU(121)는 도 36a에서와 마찬가지로 도 36b에서 대략 1/4의 속도로 NNU 프로그램을 가동시키기 위해 열을 발생시키며, 이는 이에 설명된 바와 같이 열적 이득을 가질 수 있다.
이제 도 37을 참조하면, 도 35의 프로세서(100)의 동작을 도시하는 흐름도가 도시된다. 흐름도는 도 35, 도 36a 및 도 36b와 관련하여 전술한 바의 동작과 여러 면에서 유사한 동작을 도시한다. 흐름은 블록(3702)에서 시작한다.
블록(3702)에서, 프로세서(100)는 웨이트 RAM(124)에 웨이트를 기입하고 데이터 RAM(122)에 데이터를 기입하도록 MTNN 명령(1400)을 실행한다. 흐름은 블록(3704)으로 진행된다.
블록(3704)에서, 프로세서(100)는 1차 클록 속도보다 낮은 속도를 지정하는 값, 즉, NNU(121)를 완화 모드로 설정하는 값으로 완화 표시기(3512)를 프로그램하도록 MTNN 명령(1400)을 실행한다. 흐름은 블록(3706)으로 진행된다.
블록(3706)에서, 프로세서(100)는, 도 36b에서 나타낸 방식과 유사하게, NUU프로그램 실행을 시작하도록 NNU(121)에 지시하기 위하여 MTNN 명령(1400)을 실행한다. 흐름은 블록(3708)으로 진행된다.
블록(3708)에서, NNU(121)는 NNU 프로그램 실행을 시작한다. 병행하여, 프로세서(100)는 새로운 웨이트로 웨이트 RAM(124)을 (및, 잠재적으로, 새로운 데이터로 데이터 RAM(122)를) 기입하기 위하여 MTNN 명령(1400)을 실행하고 및/또는 데이터 RAM(122)으로부터의 (및, 잠재적으로 웨이트 RAM(124)으로부터의) 결과를 판독하기 위하여 MFNN 명령(1500)을 실행한다. 흐름은 블록(3712)으로 진행된다.
블록(3712)에서, 프로세서(100)는 NNU(121)의 프로그램 실행이 종료되는지를 검출하기 위하여 MFNN 명령(1500)을 실행한다 (예, 상태 레지스터(127) 판독). 아키텍쳐 프로그램이 완화 표시기(3512)의 양호한 값을 선택한다고 가정하면, 도 36b에 나타낸 바와 같이, NNU(121)이 NNU 프로그램을 실행하는 데에는 프로세서(100)가 웨이트 RAM(124) 및/또는 데이터 RAM(122)에 접속하는 아키텍쳐 프로그램 부분을 실행하는 데에 걸리는 시간과 대략 동일한 양의 시간이 걸린다. 흐름은 블록(3714)으로 진행된다.
블록(3714)에서, 프로세서(100)는 MTNN 명령(1400)을 실행하여 1차 클록 속도를 지정하는 값, 즉 NNU(121)를 정상 모드로 설정하는 값으로 완화 표시기(3512)를 프로그래밍한다. 흐름은 블록(3716)으로 진행된다.
블록(3716)에서, 프로세서(100)는 MTNN 명령(1400)을 실행하여, 도 36a에 나타낸 방식과 유사하게, NNU(121))가 NNU 프로그램의 실행을 시작하도록 명령한다. 흐름은 블록(3718)으로 진행된다.
블록(3718)에서, NNU(121)는 정상 모드에서 NNU 프로그램을 실행하기 시작한다. 흐름은 블록(3718)에서 종료된다.
전술한 바와 같이, 정상 모드에서(즉, 프로세서의 1차 클록 속도로) NNU가 프로그램을 실행하는 시간에 비하여, 완화 모드로 NNU 프로그램을 실행하는 것은 NNU가 프로그램을 실행하는 시간을 분산시키며, 이는 열적 이득을 제공할 수 있다. 더욱 상세하게는, NNU는 NNU (예, 반도체 장치, 금속층, 하부 기판) 및 주변 패키지 및 냉각 솔루션에 의해 (예, 히트 싱크, 팬에 의해) 소산되는 열을 느리게 생성하기 때문에, NNU가 완화 모드에서 프로그램을 실행하는 동안 장치(예, 트랜지스터, 커패시터, 와이어)는 보다 낮은 온도에서 동작할 것이다. 이는 또한 일반적으로 프로세서 다이의 기타 부분에 있는 장치의 온도를 낮출 수 있다. 장치의 보다 낮은 동작 온도, 특히 접합 온도는, 누설 전류가 적다는 이점을 가질 수 있다. 더욱이, 단위 시간당 사용되는 전류의 양이 적기 때문에, 유도 잡음 및 IR 강하 잡음이 감소될 수 있다. 또한, 보다 낮은 온도는 프로세서의 MOSFET의 네거티브-바이어스 온도 불안정성(negative-bias temperature instability NBTI) 및 포지티브 바이어스 온도 불안정성(positive-bias temperature instability PBTI)에 긍정적 영향을 줄 수 있으며, 그에 따라서 장치의 신뢰성 및/또는 수명을 그리고 결과적으로 프로세서 부분의 신뢰성 및/또는 수명을 증가시킬 수 있다. 보다 낮은 온도는 또한 프로세서의 금속층에서 주울 가열(Joule heating)과 일렉트로 마이그레이션(electromigration)을 줄일 수 있다.
NNU의 공유 자원에 관한 아키텍쳐 프로그램과 비- 아키텍쳐 프로그램 간의 통신 메커니즘
전술한 바와 같이, 예컨대 도 24 내지 도 28 및 도 35 내지 도 37에 관련하여, 데이터 RAM(122) 및 웨이트 RAM(124)은 공유 자원이다. NPU(126) 및 프로세서(100)의 선단부는 모두 데이터 RAM(122) 및 웨이트 RAM(124)을 공유한다. 더욱 상세하게는, NPU(126) 및 프로세서(100)의 선단부, 예컨대, 미디어 레지스터(118)는 모두 데이터 RAM(122) 및 웨이트 RAM(124)을 기입 및 판독한다. 양자 택일적으로 말하자면, 프로세서(100) 상에서 실행되는 아키텍쳐 프로그램은 NNU(121)상에서 실행되는 NNU 프로그램과 함께 데이터 RAM(122) 및 웨이트 RAM(124)을 공유하며, 경우에는 따라서는, 전술한 바와 같이, 아키텍쳐 프로그램과 NNU 프로그램 사이의 흐름 제어가 요구된다. 이러한 자원 공유는, 아키텍쳐 프로그램이 이를 기입하고 시퀀서(128)가 이를 판독하기 때문에, 프로그램 메모리(129)에도 어느 정도 해당된다. 이하에서는 아키텍쳐 프로그램과 NNU 프로그램 간의 공유 자원에 대한 접속 흐름을 제어하기 위하여 고성능 솔루션을 제공하는 실시예가 설명된다.
설명되는 실시예에서, NNU 프로그램은 또한 비-아키텍쳐 프로그램이라고도 지칭되고, NNU 명령은 또한 비-아키텍쳐 명령으로도 지칭되며, NNU 명령 세트는 (위에서 NPU 명령 세트라고도 칭함) 또한 비-아키텍쳐 명령 세트라고도 칭한다. 비-아키텍쳐 명령 세트는 아키텍쳐 명령 세트와 구별된다. 프로세서(100)가 아키텍쳐 명령을 마이크로 명령으로 변환하는 명령 변환기(104)를 포함하는 실시예에서, 비-아키텍쳐 명령 세트는 또한 마이크로 명령 세트와 구별된다.
이제 도 38을 참조하면, NNU(121)의 시퀀서(128)를 보다 상세히 도시한 블록도가 도시된다. 시퀀서(128)는, 상술한 바와 같이, 시퀀서(128)에 제공되는 비-아키텍쳐 명령을 선택하기 위해 프로그램 메모리(129)에 메모리 어드레스(131)를 제공한다. 메모리 어드레스(131)는 도 38에 나타낸 바와 같이 시퀀서(128)의 프로그램 카운터(3802) 내에 보유된다. 시퀀서(128)는 루프 또는 분기 명령과 같은 비-아키텍쳐 제어 명령을 만나지 않는 한 일반적으로 프로그램 메모리(129)의 순차적인 어드레스를 통해 증가하며, 이 경우 시퀀서(128)는 프로그램 카운터(3802)를, 프로그램 카운터(3802) 제어 명령의 타깃 어드레스, 즉, 제어 명령의 타깃에 있는 비-아키텍쳐 명령의 어드레스에 경신한다. 그러므로, 프로그램 카운터(3802)에 보유되는 어드레스(131)는 NPU(126)에 의한 실행을 위해 현재 인출되는 비-아키텍쳐 프로그램의 비-아키텍쳐 명령의 프로그램 메모리(129)의 어드레스를 특정한다. 바람직하게는, 도 39와 관련하여 아래에 설명되는 바와 같이, 프로그램 카운터(3802)의 값은 상태 레지스터(127)의 NNU 프로그램 카운터 필드(3912)를 통해 아키텍쳐 프로그램에 의해 획득될 수 있다. 이는 아키텍쳐 프로그램으로 하여금 비-아키텍쳐 프로그램의 진행에 기초하여 데이터 RAM(122) 및/또는 웨이트 RAM(124)에/으로부터 데이터를 판독/기입하는 위치에 관한 결정을 내릴 수 있도록 한다.
시퀀서(128)는 또한 예를 들어 도 26a의 어드레스(10)에서 1개 명령에 대한 루프 및 도 26a의 어드레스(11)에서 1개 명령에 대한 루프처럼 비-아키텍쳐 루프 명령과 함께 사용되는 루프 카운터(3804)를 포함한다. 도 26a 및 도 28의 예에서, 루프 카운터(3804)는 어드레스(0)에서 비-아키텍쳐 초기화 명령에 지정된 값, 예컨대 400의 값으로 로딩된다. 시퀀서(128)가 루프 명령을 만나 타깃 명령으로 점프 할 때마다 (예컨대, 도 26a의 어드레스(1)의 곱-누적 명령 또는 도 28의 어드레스(1)에서 maxwacc명령), 시퀀서(128)는 루프 카운터(3804)를 감소시킨다. 일단 루프 카운터(3804)가 제로에 도달하면, 시퀀서(128)는 다음 순서의 비-아키텍쳐 명령으로 진행된다. 택일적인 일 실시예에서, 루프 명령이 최초로 직면할 때, 루프 카운터(3804)는 루프 명령에 특정된 루프 카운트값으로 로딩되어, 비-아키텍쳐 초기화 명령을 통해 루프 카운터(3804)의 초기화에 대한 필요성을 제거한다. 따라서, 루프 카운터(3804)의 값은 비-아키텍쳐 프로그램의 루프 본체가 몇 번 더 실행될 것인지를 나타낸다. 바람직하기로는, 루프 카운터(3804)의 값은, 도 39와 관련하여 후술되는 바와 같이, 상태 레지스터(127)의 루프 카운트(3914) 필드를 통해 아키텍쳐 프로그램에 의해 획득될 수 있다. 이는 아키텍쳐 프로그램이 비-아키텍쳐 프로그램의 진행에 기초하여 데이터 RAM(122) 및/또는 웨이트 RAM(124)으로부터/에로 데이터를 판독/기입하는 위치에 관한 결정을 내릴 수 있도록 한다. 일 실시예에서, 시퀀서(128)는 비-아키텍쳐 프로그램에서 내포된 루프를 수용하기 위해 3개의 추가적인 루프 카운터를 포함하고, 나머지 3개의 루프 카운터의 값은 또한 상태 레지스터(127)를 통해 판독 가능하다. 루프 명령의 비트는 4개 중 어느 루프 카운터가 즉석 루프 명령에 사용되는지를 나타낸다.
시퀀서(128)는 또한 반복 카운터(3806)를 포함한다. 반복 카운터(3806)는, 예를 들어, 도 4, 도 9, 도 20 및 도 26A에서 어드레스(2)에서의 곱-누적 명령과 같은 비-아키텍쳐 명령 및 도 28의 어드레스(2)에서 maxwacc 명령과 함께 사용되며, 이는 이하 "실행" 명령으로 칭한다. 위의 예에서, 각 실행 명령은 각각 511, 511, 1023, 2 및 3의 반복 카운트를 지정한다. 시퀀서(128)가 비-제로 반복 카운트를 지정하는 실행 명령을 만나면, 시퀀서(128)는 반복 카운터(3806)에 지정값을 로딩한다. 또한, 시퀀서(128)는 실행을 위해 도 34의 NPU(126) 파이프라인 단계(stage) (3401) 내의 로직을 제어하기 위해 적절한 마이크로-동작 (3418)을 생성하고 반복 카운터(3806)를 감소시킨다. 반복 카운터(3806)가 제로보다 크면, 시퀀서(128)는 NPU(126)의 로직을 제어하기 위해 적절한 마이크로-동작 (3418)을 다시 생성하고 반복 카운터(3806)를 감소시킨다. 시퀀서(128)는 반복 카운터(3806)가 제로에 이를 때까지 이러한 방식으로 계속된다. 따라서, 반복 카운터(3806)의 값은 비-아키텍쳐 실행 명령에 (예를 들어, 곱-누적, 최대, 누산기의 합 및 데이터/웨이트 워드 합에) 지정된 동작이 몇 번 더 수행되는지를 나타낸다. 바람직하기로는, 반복 카운터(3806)의 값은, 도 39와 관련하여 후술되는 바와 같이, 상태 레지스터(127)의 반복 카운트(3916) 필드를 통해 아키텍쳐 프로그램에 의해 획득될 수 있다. 이는 아키텍쳐 프로그램으로 하여금 비-아키텍쳐 프로그램의 진행에 기초하여 데이터 RAM(122) 및/또는 웨이트 RAM(124)으로부터/에로 데이터를 판독/기입하는 위치에 관한 결정을 내릴 수 있도록 한다.
이제 도 39를 참조하면, NNU(121)의 제어 및 상태 레지스터(127)의 특정 필드를 도시하는 블록도가 도시된다. 필드는, 도 26b에 관련하여 상술된 바와 같이, 비-아키텍쳐 프로그램을 실행하는 NPU(126)에 의해 가장 최근에 기입된 웨이트 RAM 행(2602)의 어드레스, 비-아키텍쳐 프로그램을 실행하는 NPU(126)에 의해 가장 최근에 판독된 웨이트 RAM 행(2604)의 어드레스, 비-아키텍쳐 프로그램을 실행하는 NPU(126)에 의해 가장 최근에 기입된 데이터 RAM 행(2606)의 어드레스, 및 비-아키텍쳐 프로그램을 실행하는 NPU(126)에 의해 가장 최근에 판독된 데이터 RAM 행(2604)의 어드레스를 포함한다. 또한, 필드는 NNU 프로그램 카운터(3912), 루프 카운트(3914) 및 반복 카운트(3916)를 포함한다. 전술한 바와 같이, 상태 레지스터(127)는 아키텍쳐 프로그램에 의해, 예를 들면, NNU 프로그램 카운터(3912), 루프 카운트(3914) 및 반복 카운트(3916)의 필드값을 포함하여, MFNN 명령(1500)에 의해, 미디어 레지스터(118) 및/또는 범용 레지스터(116)로 판독가능하다. 프로그램 카운터(3912)값은 도 38의 프로그램 카운터(3802)의 값을 반영한다. 루프 카운트(3914) 값은 루프 카운터(3804)의 값을 반영한다. 반복 카운트(3916) 값은 반복 카운터(3806)의 값을 반영한다. 일 실시예에서, 시퀀서(128)는 프로그램 카운터(3802), 루프 카운터(3804) 또는 반복 카운터(3806)를 수정할 때마다 프로그램 카운터(3912), 루프 카운트(3914) 및 반복 카운트(3916)의 필드값을 경신하므로, 필드값은 아키텍쳐 프로그램이 이를 읽을 때가 현재이다. 다른 일 실시예에서, 상태 레지스터(127)를 판독하는 아키텍쳐 명령을 NNU(121)가 실행할 때, NNU(121)는 단순히 프로그램 카운터(3802), 루프 카운터(3804), 및 반복 카운터(3806)의 값을 획득하고 이를 다시 아키텍쳐 명령에로(예, 미디어 레지스터(118) 또는 범용 레지스터(116)에로) 제공한다.
전술한 바와 같이, 도 39의 상태 레지스터(127)의 필드값은 NNU(121)에 의해 비-아키텍쳐 프로그램가 실행되는 동안 비-아키텍쳐 프로그램에 의해 이루어진 진행을 나타내는 정보로서 특징지어질 수 있다. 프로그램 카운터(3802)값, 루프 카운터(3804) 값, 반복 카운터(3806) 값, 가장 최근에 기입/판독된 웨이트 RAM(124) 어드레스(125)(2602/2604), 및 가장 최근에 기입/판독된 데이터 RAM(122) 어드레스(123)(2606/2608)와 같은, 비-아키텍쳐 프로그램 진행의 구체적인 양상은 위에서 설명한 바와 같다. 프로세서(100)상에서 실행되는 아키텍쳐 프로그램은 도 39의 비-아키텍쳐 프로그램 진행값을 상태 레지스터(127)로부터 판독할 수 있고, 예를 들어 비교 및 분기 명령과 같은 아키텍쳐 명령에 의해 결정을 내리기 위해 정보를 사용할 수 있다. 예를 들어, 아키텍쳐 프로그램은 데이터 RAM(122) 및/또는 웨이트 RAM(124)으로 및 데이터 RAM(122) 및/또는 웨이트 RAM(124)으로부터의 데이터 흐름을 제어하기 위하여, 특히 대형 데이터 세트를 위하여 및/또는 상이한 비-아키텍쳐 프로그램의 실행 인스턴스를 오버랩하기 위하여, 데이터 RAM(122) 및/또는 웨이트 RAM(124)으로/로부터의 데이터/웨이트를 기입/판독하기 위한 행을 결정한다. 아키텍쳐 프로그램에 의한 결정은 이상 및 이하에서 설명된다.
예를 들어, 도 26a와 관련하여 상술한 바와 같이, 아키텍쳐 프로그램은 컨볼루션의 결과를 컨볼루션 커넬 (2402) 위의 데이터 RAM(122)의 행(예컨대, 행(8))에 재 기입하도록 비-아키텍쳐 프로그램을 구성하고, 아키텍쳐 프로그램은 NNU(121)가 가장 최근에 기입된 데이터 RAM(122) 행(2606)의 어드레스를 사용하여 이를 기입함에 따라 데이터 RAM(122)으로부터 결과를 판독한다.
다른 일 실시예로서, 도 26b와 관련하여 전술한 바와 같이, 아키텍쳐 프로그램은 도 38의 상태 레지스터(127) 필드로부터의 정보를 사용하여 5개의 512 × 1600 청크(chunk)에서 도 24의 데이터 어레이(2404)의 컨볼루션을 수행하도록 비-아키텍쳐 프로그램의 진행을 결정한다. 아키텍쳐 프로그램은 2560 × 1600 데이터 어레이(2404)의 제1 512 × 1600 청크를 웨이트 RAM(124)에 기입하고 루프 카운트가 1600이고 초기화된 웨이트 RAM(124) 출력 행이 0인 비-아키텍쳐 프로그램을 시작한다. NNU(121)가 비-아키텍쳐 프로그램을 실행함에 따라, 아키텍쳐 프로그램은 상태 레지스터(127)를 판독하여 가장 최근에 기입된 웨이트 RAM 행(2602)을 결정하여 비-아키텍쳐 프로그램에 의해 기입된 유효 컨볼루션 결과를 판독할 수 있고, 아키텍쳐 프로그램이 이를 판독한 후 유효 컨볼루션 결과에 다음의 512 × 1600 청크를 기입할 수 있으므로, NNU(121)가 제1 512 × 1600 청크에 대하여 비-아키텍쳐 프로그램을 종료할 때, 프로세서(100)는 필요에 따라 비-아키텍쳐 프로그램을 즉시 경신할 수 있고, 다음의 512 × 1600 청크 처리를 다시 시작할 수 있다.
다른 일 실시예로서, 웨이트가 웨이트 RAM(124)에 저장되고 그 결과가 데이터 RAM(122)에 다시 기입되는 일련의 고전적인 신경망 곱-누적-활성함수 동작을 아키텍쳐 프로그램이 NNU(121)로 하여금 수행하게 한다고 가정한다. 이 경우, 비-아키텍쳐 프로그램이 웨이트 RAM(124)의 행을 일단 판독하면, 이는 웨이트 RAM(124)의 행을 다시 판독하지 않을 것이다. 그러므로, 일단 현재의 웨이트가 비-아키텍쳐 프로그램에 의하여 판독/사용되면, 아키텍쳐 프로그램은 비-아키텍쳐 프로그램의 다음 실행 인스턴스에 대하여 (예컨대, 다음 신경망층에 대하여) 새로운 웨이트를 웨이트 RAM(124)에 중복기입하기 시작하도록 구성될 수 있다. 이 경우, 아키텍쳐 프로그램은, 웨이트 RAM(124)에 새로운 웨이트 세트를 기입할 수 있는 위치를 결정하기 위하여, 가장 최근에 판독된 웨이트 RAM 행(2604)의 어드레스를 획득하기 위해서 상태 레지스터(127)를 판독한다.
다른 일 실시예로서, 비-아키텍쳐 프로그램이 도 20의 어드레스(2)에서의 비-아키텍쳐 곱-누적 명령과 같은 큰 반복 카운트를 갖는 실행 명령을 포함한다는 것을 아키텍쳐 프로그램이 알고 있다고 가정한다. 이러한 경우, 아키텍쳐 프로그램은 비-아키텍쳐 명령을 종료하는데 대략 얼마나 많은 클록 사이클가 걸릴지를 알기 위하여 그리하여 아키텍쳐 프로그램이 두개 이상의 동작 중 어느 것을 수행할지 결정할 수 있도록, 반복 카운트(3916)를 알 필요가 있을 수 있다. 예를 들어, 시간이 오래 걸리면, 아키텍쳐 프로그램은 운영 체제와 같은 다른 아키텍쳐 프로그램에 제어권을 넘겨 줄 수 있다. 마찬가지로, 아키텍쳐 프로그램은, 도 28의 비-아키텍쳐 프로그램처럼, 비-아키텍쳐 프로그램이 상대적으로 큰 루프 카운트를 갖는 루프 본체를 포함하고 있음을 알고 있다고 가정한다. 그러한 경우에, 아키텍쳐 프로그램은 비-아키텍쳐 프로그램을 종료하는데 대략 얼마나 많은 클록 사이클가 걸릴지를 알기 위하여 그리하여 아키텍쳐 프로그램이 둘 이상의 동작 중 어느 것을 수행할 것인지를 결정할 수 있도록 루프 카운트(3914)를 알 필요가 있을 수도 있다.
다른 예로서, 도 27 및 도 28과 관련하여 설명된 바의 풀링될 데이터가 웨이트 RAM(124)에 저장되고 그 결과가 다시 웨이트 RAM(124)에 기입되는 것과 유사한 풀링 동작을 아키텍쳐 프로그램이 NNU(121)로 하여금 실행하도록 하는 것으로 가정한다. 그러나, 도 27 및 도 28의 예와는 달리, 결과는 웨이트 RAM(124)의 상위 400행, 예를 들어, 행(1600 내지 1999)에 다시 기입된다고 가정한다. 이 경우, 풀링하는 웨이트 RAM(124)의 4개의 행을 비-아키텍쳐 프로그램이 일단 판독하면, 비-아키텍쳐 프로그램은 이를 다시 판독하지 않을 것이다. 그러므로, 일단 현재 4개의 행이 비-아키텍쳐 프로그램에 의하여 판독/사용되면, 아키텍쳐 프로그램은 새로운 데이터(예, 비-아키텍쳐 프로그램의 다음 실행 인스턴스를 위한 웨이트, 예컨대, 풀링된 데이터에 고전적인 곱-누적-활성함수 동작을 수행하기 위하여)을 웨이트 RAM(124)에 중복 기입하기 시작하도록 구성될 수 있다. 이 경우, 아키텍쳐 프로그램은, 웨이트 RAM(124)에 새로운 웨이트 세트를 기입할 수 있는 위치를 결정하기 위하여, 가장 최근에 판독된 웨이트 RAM 행(2604)의 어드레스를 획득하기 위해서 상태 레지스터(127)를 판독한다.
NNU 메모리 및 캐시 메모리로서의 메모리 어레이의 이중-사용
이제 도 40을 참조하면, 프로세서(4000)를 도시하는 블록도가 도시된다. 프로세서(4000)는 링 버스(4024)를 형성하기 위하여 양방향식으로 서로 연결된 복수의 링 스톱(4004)들을 포함한다. 도 40의 실시예는 4004-0, 4004-1, 4004-2, 4004-3 및 4004-M 및 4004-U로 표시된 6개의 링 스톱들을 포함한다. 프로세서(4000)는 개별적으로 코어 콤플렉스 0(4012-0), 코어 콤플렉스 1(4012-1), 코어 콤플렉스 2(4012-2) 및 코어 콤플렉스 3(4012-3)으로 불리는 4개의 코어 콤플렉스(4012)를 포함하며, 이는 코어 콤플렉스들을 링 버스(4024)에 결합시키는 4개의 링 스톱(4004-0, 4004-1, 4004-2, 및 4004-3)들을 포함한다. 프로세서(4000)는 또한 언코어 부분(4012)을 포함하는 데, 이는 언코어(40126)를 링 버스(4024)에 결합하는 링 스톱(4004-U)을 포함한다. 마지막으로, 프로세서(4000)는 링 스톱(4004-M)에 의하여 링 버스(4024)에 결합된 동적 랜덤 액세스 메모리(DRAM) 및 NNU(121)를 포함한다. NNU(121)(예컨대, 도 1의 웨이트 RAM(124))의 NPUs(126)의 어레이에 의하여 사용되는 메모리로서 또는 이하 보다 상세하게 설명되는 바와 같은, 예컨대, 최종-레벨 캐시(LLC)의 부분으로서 또는 희생 캐시로서 코어 콤플렉스(4012)에 의하여 공유되는 캐시 메모리로서 채용될 수 있는 메모리 어레이(4152)(도 41 참조)를 포함한다. 도 40의 예는 4개의 코어 콤플렉스(4012)들을 포함하지만, 다른 수의 코어 콤플렉스(4012)들을 포함하는 다른 예들이 고려된다.
언코어(4016)는, 예컨대, 비디오 콘트롤러, 디스크 콘트롤러, 주위 버스 콘트롤러(예컨대, PCI-E), 등과 같은 주위 장치들이 결합될 수 있는 시스템 버스(4022)에 프로세서(4000)에 의하여 접속을 제어하는 버스 콘트롤러(4014)를 포함한다. 일 실시예에서, 시스템 버스(4022)는 공지의 V4-버스이다. 언코어(4016)는 또한 파워 관리 유닛 및 사용 RAM(예컨대, 코어(4002)들에 의하여 사용되는 비-아키텍쳐 메모리)와 같은 다른 기능 유닛들을 포함할 수 있다.
DRAM 콘트롤러는 시스템 메모리인 DRAM(예컨대, 비동기 DRAM, 또는 이중 데이터 속도 동기화 DRAM, 직접 램버스 DRAM 또는 대기시간이 감축된 DRAM과 같은 동기화 DRAM(SDRAM))을 제어한다.
코어 콤플렉스(4012), 언코어(4016) 및 NNU(121)는 링 버스(4024)를 통해 시스템 메모리에 접속한다. 보다 구체적으로, NNU(121)는 신경망 웨이트와 데이터를 시스템 메모리로부터 메모리 어레이(4152)로 판독하여 메모리 어레이(4152)로부터의 신경망 결과를 링 버스(4024)를 통해 시스템 메모리에 기입한다. 추가적으로, 희생 캐시(도 41의 4006-4 참조)로서 동작할 때, 캐시 제어 로직(4108)의 제어 하의 메모리 어레이(4152)는 캐시 라인들을 시스템 메모리에 방출시킨다. 또한, LLC 부분(도 41의 4006-4 참조)으로 동작할 때, 메모리 어레이(4152)와 캐시 제어 로직(4108)은 시스템 메모리로부터 캐시 라인을 채우고 캐시 라인을 재기입하여 시스템 메모리에 축출시킨다.
4개의 코어 콤플렉스(4102)들은 각각의 LLC 부분(4102-0, 4012-1, 4012-2 및 4012-3)을 포함하며, 각각은 링 스톱(4004)에 결합되고, 개별적으로, 종으로서 LLC 부분(4006)으로 그리고 집단적으로 LLC 부분(4006)들로 불린다. 각각의 코어(4002)는 링 스톱(4004)에 결합된 레벨-2(L2) 캐시(4008)와 같은 캐시 메모리를 포함한다. 각 코어(4002)는 또한 레벨-1 캐시(도시 없음)를 포함할 수 있다. 또 다른 ISA, 예컨대, ARM, SPARC, MIPS와 같은 ISA의 코어(4002)들인 다른 실시예들이 고려되지만, 일 실시예에서, 코어들은 x86 명령 세트의 구조(ISA) 코어들이다.
LLC 부분(4006-0, 4006-1, 4006-2, 및 4006-3)들은 도 40에 도시된 바와 같이 코어 콤플렉스(4012)들에 의하여 공유되는 프로세서(4000)의 LLC(4005)를 집단적으로 형성한다. 각각의 LLC 부분(4006)은 도 41의 메모리 어레이(4152)와 캐시 제어 로직(4108)에 유사한 메모리 어레이 및 캐시 제어 로직을 포함한다. 모드 표시기(예컨대, 도 41의 모드 입력(4199))는 NNU(121)의 메모리 어레이(4152)가 이하 보다 상세하게 설명되는 바와 같이, LLC(4005)의 추가적인(예컨대, 제5 또는 제9) 성분(4006-4)으로 동작하도록 설정될 수 있다.
추가적인 LLC 부분(4006-4)을 선택적으로 구성하는 메모리 어레이(4152)( 및 도 41의 캐시 제어 로직(4108))은 또한 NNU LLC 부분(4006-4)으로 불린다. 일 실시예에서, 다른 크기들을 가진 다른 실시예들이 고려되지만, 메모리 어레이(4152)와 각각의 LLC 부분(4006)은 2MB의 메모리 어레이를 포함한다. 또한, 메모리 어레이(4152)와 LLC 성분(4006)들의 크기가 다른 실시예들이 고려된다. 바람직하게, LLC(4005)는 캐시 계층(예컨대, L1 캐시)에서 l2 캐시(4008) 및 다른 캐시들을 포함한다.
링 버스(4024), 또는 링(4024)은 DRAM 콘트롤러(4018), 언코어(4016), 및 LLC 부분(4006)을 포함하는 고유 성분들 사이의 통신을 촉진하는 스케일러블(scalable) 양방향성 상호 접속부이다. 링(4024)은 두 개의 일방향성 링들을 포함하는 데, 그 각각은 추가로 아래와 같은 5개의 하위-링들을 포함하며; 로드를 포함한 대부분의 패킷 요청 유형을 운반하기 위한 요청(Request); 스누프 요청 패킷을 운송하기 위한 스누프(Snoop); 응답 요청을 운송하기 위한 확인(Acknowledge); 기입을 포함한 일정한 요청 아이템들과 데이터 패킷들을 이송하기 위한 데이터; 및, 원격 큐(remote queue)에서 신용을 발행하고 획득하기 위한 신용(Credit). 링(4204)에 부착된 각각의 노드는 링 스톱(4004)을 통해 연결되며, 이는 링(4024)에서 패킷들을 송신하고 수신하기 위한 큐들을 포함한다. 큐들은 원격 큐에서 수신될 부착된 성분을 위하여 링(4024)에서 요청을 개시하는 출구(egress) 큐이거나, 부착된 성분들을 향하여 보내질 링(4024)으로부터의 요청들을 수신하는 유입(ingress) 큐이다. 출구 큐가 링에서 요청을 시작하기 전에 출구 큐는 원격 목표지의 유입 큐로부터 신용 링 위에서 제1 신용을 얻는다. 이로써 멀리 있는 유입 큐는 확실히 그 도착 시에 요청을 처리하기에 유용한 자원을 가진다. 출구 큐가 링(4024)에 거래 패킷을 보내기를 바라면, 원격 노드로 향하는 진입 패킷을 선점하지 않으려는 경우에만 그와 같이 할 수 있다. 유입 패킷이 어느 방향으로나 링 스톱(4004)에 도달할 때, 이 링 스톱(4004)이 패킷의 최종 목적지인 여부를 결정하도록 패킷의 목적지 ID는 질문을 받는다. 목적지 ID가 링 스톱(4004)의 노드 ID와 같지 않으면, 패킷은 후속 클록에서 다음 링 스톱(4004)으로 계속 진행한다. 그렇지 않으면, 동일한 클록에서 패킷은 링(4024)을 떠나서 패킷의 거래 유형이 의미하는 유입 큐에 의하여 소비된다.
일반적으로, LLC(4005)는 N개의 LLC 부분(4006)들을 포함하며, N개의 부분(4006)은 각각 해싱 알고리즘, 또는 해시 알고리즘, 또는 단순히 해시(hash)에 의하여 결정된 프로세서(4000)의 물리적인 주소 공간의 명백히 대략 1/N의 은닉에 대해 책임이 있다. 해시는 입력으로서 물리적인 주소를 취하고 물리적인 주소의 은닉에 대해 책임이 있는 적절한 LLC 부분을 선택하는 함수이다. 코어(4002) 또는 스누핑 대리인으로부터, LLC(4005)에 대해 요청이 이루어져야 할 때, 요청은 요청의 물리적인 주소를 은닉한 책임이 있는 적절한 LLC 부분(4006)에 대해 보내져야 한다. 적절한 LLC 부분(4006)은 요청의 물리적인 주소에 해시를 적용함으로써 결정된다.
해시 알고리즘은 그 영역이 물리적 주소의 세트, 또는 그 보조 세트이며, 그 범위가 현재 포함된 LLC 부분(4006)의 수인 전사(surjective) 함수이다. 보다 구체적으로, 범위는 LLC 부분(4006)의 지수들의 세트, 예컨대, 8개의 LLC 부분(4006)의 경우, 0 내지 7이다. 함수는 물리적인 주소 비트들의 적절한 보조 세트를 시험함으로써 계산될 수 있다. 예컨대, 8개의 LLC 부분(4006)들을 가지는 시스템에서, 해싱 알고리즘의 출력은 단순히 PA[10:8]일 수 있으며, 이것은 물리적인 주소 비트의 셋, 즉 비트(8 내지 10)이다. LLC 부분(4006)의 수가 8인 또 다른 실시예에서, 해시의 출력은 다른 주소 비트들의 논리 함수, 예컨대, PA[17], PA[14], PA[12]^PA[10]^PA[9]로서 생성된 3 비트들이다.
LLC(4005)의 모든 요청자들은 소정의 LLC(4005)가 수행되기 전에 동일한 해시 알고리즘이어야 한다. 해시가 동작 중에 은닉되어야 하는 주소들과 보내져야 하는 스누프들을 지정하므로, 해시는 단지 모든 코어들, LLC 부분(4006)들, 그리고 스누핑 대리인들 사이의 조정을 통해 변경된다. 도 42 및 43과 관련해서 이하 보다 구체적으로 설명되는 바와 같이, 해시 알고리즘의 경신은 기본적으로 이하와 같은 단계들을 포함하며: (1) 새로운 은닉가능한 접속을 방지하기 위하여 모든 코어(4002)들을 동기화하며; (2) 현재 LLC(4005)에 포함된 모든 LLC 성분(4006)들의 재기입-실효를 실행하며, 이는 시스템 메모리에 수정된 캐시 라인들을 중복 기입하고 모든 캐시 라인들을 실효시키며(중복 기입-실효는 이하 설명되는 바와 같이 선택적인 중복 기입-실효이며, 과거의 해시 알고리즘이 축출되는, 즉, 실효되고, 수정되면, 실효되기 전에 중복 기입되기보다 새로운 해시 알고리즘을 가지는 주소의 캐시 라인들만이 다른 성분으로 혼합된다); (3) 해시 경신 메시지를 각 코어(4002) 및 스누프 소스에 통보하며, 이는 그들에게 새로운 해시로 변경하는 것을 지시하며(이하 설명되는 바와 같이, 포함하는 해시로부터 제외하는 해시로, 또는 역으로); (4) 메모리 어레이(4152)로의 접속을 제어하는 선택 로직(4158)(도 41 참조)으로의 모드 입력(4199)을 경신하며; 및 (5) 새로운 해시 알고리즘으로 실행을 재개하는 것을 포함한다.
위에 설명된 해시 알고리즘은 LLC 부분(4006)의 수(N)가 2의 차수인 8일 때 유용하며, 이들 알고리즘은 변형되어 2의 다른 차수를 수용할 수 있으며, 예컨대, 4개의 부분들에 대해 PA[9:8]이고 16개의 부분들에 대해 PA[11:8]이다. 그러나, LLC(4005)(그리고 코어 콤플렉스(4012)의 수)에 NNU의 LLC 부분(4006-4)이 포함되는 여부에 따라, N은 2의 차수일 수도 있으며 아닐 수도 있다. 그러므로, 이하의 도 42와 43과 관련해서 설명되는 바와 같이, LLC 부분(4006)의 수에 따라, 적어도 두 개의 다른 해시들이 사용된다. 즉, 제1 해시-내포적 해시로 불림-는 NNU의 LLC 부분(4006-4)이 LLC(4005)에 포함될 때 사용되며 제2 해시 - 배제적 해시로 불림 - 는 NNU의 LLC 부분(4006-4)이 LLC(4005)에서 제외될 때 사용된다.
하나의 해시 알고리즘이 PA[45:6] 모드(mod) N을 출력한다. N의 값이 2의 차수가 아닌 경우도 N개의 LLC 부분(4006)에 걸쳐(물리적 주소들의 비교적 균등한 분포를 가정) 이러한 해시는 기본적으로 조화된 방식으로 물리적 주소를 분배하는 이점을 가진다. N이 2의 차수이면, 모드 연산은 PA[45:6]의 하위 N-1 비트들을 단순히 출력함으로써 실행될 수 있다. 그러나, N이 2의 차수가 아닐 때, 모드 연산은 불리하게 정수 분할을 필요로 할 수 있다.
PA 모드(N)을 근사 계산하는 또 다른 해시는 물리적 주소의 더 작은 하위 세트를 제외하고 실행하며, 이는 N이 2의 차수가 아닐 때 보다 효율적으로 실시될 수 있으며, N = 9일 때, 이하와 같이 정의된다:
def calc_hash(PA):
if (PA[11:8] == 0xF)
return 8
else
return PA[10:8]
calc_hash()의 경우, PA[11:8]이 해시에 대해 사용되고, PA[11:8] > 8이면, PA[10:8]이 사용되고, 이는 범위[0,7]에 있는 것이 확실하다. 알 수 있는 바와 같이, calc_hash()는 PA[45:6] 모드 N보다 비교적 덜 균형을 이룬 방식으로(다시 물리적 주소들의 균등한 분포를 가정) LLC 부분(4006)들 중에서 물리적 주소들을 분포시킬 수 있으며, 즉, 부분(0 내지 6)들은 약 1/8의 확률을 가지고, 반면에 부분(7 및 8)들은 약1/16의 확률을 가진다. 그러나, PA[45:6]이 2의 차수이나 N은 2의 차수가 아닌 요소들의 수를 가지는 영역을 나타내므로, PA[45:6] 모드 N 해시 알고리즘은 완전히 균등하게 균형을 이룬 분포를 생성하지 못하는 것을 유의하여야 한다.
일반적으로, N이 2의 차수가 아닐 때, 해시 알고리즘은 먼저 2^P 가능한 결과의 범위에 물리적 주소를 실행하며, 여기서 P = 실링(log2(N))이며, 이어서 N이상인 제1 해시의 결과(즉, 기존 성분(4006)들에 대응하지 않는 결과)들을 N이하인 출력(즉, 기존 부분(4006))들에 매핑한다.
하드웨어에서 비교적 효율적으로 실행되는 또 다른 해시 알고리즘은 이하와 같다:
def calc_hash_2(PA):
if (PA[13:11] == 0x7)
return 8
else
return PA[10:8]
Calc_hash_2()는, calc_hash()보다 비교적 균형 있는 방식으로 물리적 주소들을 LLC 부분(4006)들 중에 분배할 수 있으며(재차 물리적 주소들의 비교적 균등한 분배를 가정), 즉, 부분(0 내지 7)들은 약7/64의 확률을 가지며, 반면에 부분(8)은 약 8/64 또는 1/8의 확률을 가진다. 다른 실시예들에서, calc_hash()와 calc_2hash() 알고리즘들은 균등한 더 큰 수의 물리적 주소 비트들을 이용하여 균등한 비교적 더욱 균형있는 방식으로 물리적 주소들을 분배하도록 변형될 수 있다.
여기 설명된 바와 같이, 바람직하게, 실시예들은 이하의 두 가지 다른 해시 알고리즘들을 채용하며: LLC 부분(4006)으로서의 메모리 어레이(4152)를 제외하는 하나와 LLC 부분(4006)으로서의 메모리 어레이(4152)를 포함하는 다른 하나이다. 예컨대, 코어 콤플렉스(4012)들과 그들의 대응하는 LLC 부분(4006)의 수가 8인 프로세서(4000)에서, 메모리 어레이(4152)를 제외하는 해시는 PA[10:8]일 수 있으며, 메모리 어레이(4152)를 포함하는 해시는 위에 설명된 바와 같은 calc_2hash(PA)일 수 있으며, 이는 9개의 다른 부분들에 매핑된다. 일 실시예에서, 두 개의 해시 알고리즘들은 바람직하게 최적화로서 선택적인 중복 기입-실효를 지지하도록 바람직하게 구성될 수 있으며, 즉, 다른 성분들로 내포적인 해시와 배제적인 해시가 해시할 수 있는 캐시 라인들만을 축출시킨다(즉, 중복 기입-실효). 일부 실시예들에서, 내포적인 해시에서 제외적인 해시로의 이전시, 이는 단지 NNU의 LLC 부분(4006)들만이 중복 기입-실효되고(즉, NNU가 아닌 LLC 부분(4006)들은 중복 기입-실효될 필요가 없으며); 배제 해시에서 내포 해시로의 이전 시, 도 42와 43의 블록에 대해 이하 보다 상세하게 설명되는 바와 같이, 내포적이고 제외적인 해시 알고리즘들이 다른 부분들로 해시될 주소들을 가지는 NNU가 아닌 LLC 부분들의 캐시 라인들만이 방출될 필요가 있다. 제외 해시가 PA[10:8], 또는 유사한 해시이고, 내포 해시가 cal_hash_2, 또는 유사한 것인 실시예가 그러한 실시예이다.
이제 도 41을 참조하면, 도 40의 링 스톱(4004-M)과 도 40의 NNU(121)를 보다 상세하게 도시하는 블록도가 도시된다. 도 41의 NNU(121)는 많은 면에서 위에 설명된 바와 같은 NNU(121)의 실시예들과 유사하나, 또한 캐시 제어 로직(4108), 선택 로직(4158) 및 메모리 어레이(4152)를 포함하며, 이는 NNU(121)의 웨이트 RAM(124) 또는 데이터 RAM(122)에 의하여 포함될 수 있다. 도 41에 도시되지는 않았지만, NNU(121)는 또한 도 1의 프로그램 메모리(129), 시퀀서(128), 데이터 RAM(122), 및 웨이트 RAM(124)을 포함한다. NNU(121)는 또한 도 41 도시와 같이 NPU(126)들의 어레이 및 도 1의 제어/상태 레지스터(127)를 포함한다. 예컨대, 도 34와 관련해서 위에 설명된 바와 같이, 어레이의 NPU(126)들의 각각은 위에 상세하게 설명된 바와 같은 명령들과 데이터를 처리하는 단계들의 파이프라인을 포함한다. NPU 파이프 라인(126)의 제1 단계는 메모리 어레이(4152)에 기입되도록 선택 로직(4158)에 데이터를 제공하고 제2 단계는 메모리 어레이(4152)로부터 데이터를 수신한다. 일 실시예에서, 파이프라인(126)은 10개의 단계들을 포함하고 6개의 단계들은 메모리 어레이(4152)로부터 데이터를 수신하고 9개의 단계는 메모리 어레이(4152)에 기입하도록 선택 로직(4158)에 데이터를 제공한다.
메모리 어레이(4152)는 NPU 파이프라인(126)에 결합된다. 선택 로직(4158)은 메모리 어레이(4152)에 입력을 제공한다. 선택 로직(4158)은 모드를 특정하는 모드 입력(4199)에 의하여 제어된다. 바람직하게, 모드 입력(4199)은 모드를 캐시 메모리 모드로부터 NNU 모드로 변경하기 위하여 기입되는 제어/상태 레지스터(127)의 비트의 출력이다. 모드는 메모리 어레이(4152)가 NNU 모드 또는 캐시 메모리 모드로서 동작하는 것을 표시한다. NNU 모드로서 동작할 때, 메모리 어레이(4152)는 NNU(121)의 웨이트 RAM(124)으로서 동작한다. (메모리 어레이(4152)가 웨이트 RAM(124)으로서 기능하는 것이 전체적으로 참조되지만, 대신해서, 메모리 어레이(4152)가 데이터 RAM(122)으로 동작할 수 있다). 그러나, 캐시 메모리 모드로서 동작할 때, 메모리 어레이(4152)는 캐시 메모리로서 동작한다. 캐시 메모리 모드의 두 개의 실시예들이 설명되는 데: 첫째는 메모리 어레이(4152)가 코어 콤플렉스(4012)에 의하여 고유의 LLC(4005)의 부분(4006)으로서 동작하며, 둘째는 메모리 어레이(4152)가 코어 콤플렉스(4012)에 의하여 공유되는 희생 캐시로서 동작한다. 모드 제어(4199)가 NNU 모드를 표시할 때, 선택 로직(4108)은 NNU 파이프라인(126)에 의하여 제공된 데이터를 선택하고 메모리 어레이(4152)는 데이터를 NNU 어레이의 파이프라인(126)에 기입하므로, 메모리 어레이(4152)는 NNU(121)의 웨이트 RAM(124)으로 동작한다. 대조적으로, 모드 콘트롤(4199)이 캐시메모리 모드를 표시할 때, 선택 로직(4158)은 캐시제어 로직(4108)의 데이터 파이프라인(4146)에 의하여 제공된 데이터를 선택하고, 메모리 어레이(4152)는 캐시 제어 로직(4108)의 데이터 파이프라인(4146)에 데이터를 기입한다. 이와 같이, 메모리 어레이(4152)는 코어(4002)들에 의하여 공유된 캐시 메모리, 예컨대, 희생 캐시, 또는 LLC 부분(4006-4)으로서 기능한다. 바람직하게, 두 개의 RAM(122/124)들의 더 큰 메모리 어레이는 캐시 메모리 어레이에 사용된다. 또한, 웨이트 RAM(124)과 데이터 RAM(122) 모두의 메모리 어레이들이 코어(4002)들에 의하여 공유되는 캐시 메모리들로서 채용된 실시예들이 고려된다.
바람직하게, 데이터 파이프라인(4146)으로부터의 데이터를 메모리 어레이(4152)로 제공하는 데이터 버스는 64 바이트 넓이(예컨대, 캐시 라인의 크기)이며, 메모리 어레이(4152)로부터 NPU 어레이 파이프라인(126)으로 데이터를 제공하는 데이터 버스는 어레이의 NPU(126)들의 수와 같은 워드의 수, 예컨대, 1024 워드들이다. 역으로, NPU 어레이 파이프라인(126)으로부터 메모리 어레이(4152)에 데이터를 제공하는 데이터 버스는 어레이의 NPU(126)들의 수와 같은 워드들의 수이다. 바람직하게, 선택 로직(4158)과 메모리 어레이(4152) 사이의 버스는 주소 버스, 기입 데이터 버스, 및 16개의 캐시 라인(예컨대, 1024바이트 넓이의 메모리 어레이 및 64 바이트의 캐시 라인들을 가정)들의 어느 캐시 라인이 접속되는지를 지시하는, RD/WR 콘트롤과 캐시 라인 인에이블(CLEs)들을 포함한다. NPU 어레이 파이프라인(126)으로부터의 메모리 어레이(4152)에 기입하는 경우, 통상적으로 모든 NPU(126)들이 웨이트 RAM(124)의 행으로 기입하므로 통상적으로 모든 CLEs는 참이다. 선택 로직(도시 없음)은 판독 또는 기입을 가능하게 하도록 정확한 뱅크 또는 메모리 어레이(4152)들의 뱅크들을 선택하기 위하여 데이터가 메모리 어레이(4152)에 기입될 때 CLEs를 사용한다.
도 41의 실시예에서, NNU 모드로서 동작할 때, 바람직하게 코어(4002) 위에 실행하는 구조적인 프로그램들이, 도 1 내지 도 35와 관련해서 위에 설명된 실시예들과 같이, 코어의 실행 유닛인 NNU(121)보다, 링 버스(4024) 위로 주위 장치로서 NNU(121)에 접속한다. 바람직하게, 도 35의 인터페이스 로직(3514)(도 41에 도시 없음)과 제어/상태 레지스터(127)는 링 스톱(4004-M)에 결합되며, 이로써 아키텍쳐 로드/저장 명령(도 14와 15의 MTNN(1400) 및 MFNN(1500)보다)을 이용하여 인터페이스 로직(3514)을 통해 코어(4002)들은 제어/상태 레지스터(127)에 판독하고 기입하며 데이터 RAM(122), 웨이트 RAM(124), 및 프로그램 메모리(129)에 판독하고 기입할 수 있다. 추가적으로, 데이터/웨이트 워드들은 시스템 메모리와 데이터 RAM(122)/웨이트 RAM(124) 사이에 직접 메모리 접속(DMA) 이송을 통해 이송될 수 있다. 마지막으로, NNU(121) 자체가 시스템 메모리와 데이터 RAM(122)/웨이트 RAM(124) 사이에 데이터/웨이트들을 이송하기 위하여 명령들의 로드/저장을 실행하는 실시예들이 고려된다. 바람직하게, 운영 시스템은 NNU(121)를 다른 코어(4002)들에서 실행하는 시스템의 다양한 프로세스들에 의하여 공유되는 글로벌 자원으로 관리하고, 운영 시스템은 사용하기 전에 NNU(121)의 소유권을 획득하기 위한 프로세스를 필요로 한다. 바람직하게, 운영 시스템은 NNU(121)가 동작하는 모드(4199)를 제어하며, 보다 구체적으로 도 42 내지 도 45와 관련해서 이하 보다 상세하게 설명되는 바와 같이, 메모리 어레이(4152)가 기능하는 방식들을 제어한다. 일 실시예에서, 크기가 더 크거나 더 작은 다른 실시예들이 고려되지만, 메모리 어레이(4152)는 2MB의 정적인 RAM 어레이이다.
캐시 제어 로직(4108)은 링 스톱(4004-M) 및 선택 로직(4158)과 메모리 어레이(4152)에 결합된다. 캐시 제어 로직(4108)은 링 스톱(4004-M)에 결합된 태그 파이프라인(4144), 링 스톱(4004-M)에 결합된 데이터 파이프라인(4146), 및 태그 파이프라인(4144)에 결합된 태그/MESI/LRU 어레이(4142)를 포함한다. 캐시 제어 로직(4108)은 또한 충진 큐(4122), 스누프 큐(4124) 및 태그 파이프라인(4144)와 데이터 파이프라인(4146)에 접속하기 위하여 충진 큐(4122)와 스누프 큐(4124) 사이에서 중재하는 중재기(4136)를 포함한다. 캐시 제어 로직(4108)은 또한 로드 큐(4112), 축출 큐(4114), 질문 큐(4116) 및 태그 파이프라인(4144)와 데이터 파이플인(4146)에 접속하기 위하여 로드 큐(4112), 축출 큐(4114), 질문 큐(4116) 사이에서 중재하는 중재기(4138)을 포함하는 코어 계면(4148)을 포함한다. 중재기(Arbiter)(4132)는 태그 파이프라인(4144)으로의 접속하기 위하여 외부 계면(4147)과 코어 계면(4148) 사이에 개재되고, 중재기(4134)는 데이터 파이프라인(4146)으로의 접속을 위하여 외부 계면(4147)과 코어 계면(4148) 사이에 개재된다. 일 실시예에서, 각각의 캐시 제어 로직(4108)은 또한 그와 같이 수행하도록 하는 요청에 응답하여, 즉, 코어(4002)로부터의 중복 기입-실효 요청에 응답하여 메모리 어레이(4152)의 중복 기입-실효 동작을 수행하는 상태 머신을 포함한다. 추가적으로, 상태 머신은 그와 같이 수행하도록 하는 요청에 응답하여, 예컨대, 코어(4002)로부터의 실효 요청에 응답하여 상태 머신은 메모리 어레이(4152)의 실효 동작을 수행한다. 실효 동작을 수행하기 위하여 상태 머신은 메모리 어레이(4152)의 각각의 캐시 라인의 태그/MESI 어레이(4142) 내의 상태를 실효 상태로 경신하고 메모리 어레이(4152)의 각각의 세트에 대해 LRU 어레이(4142) 내에서 교체 정보를 재설정한다.
태그 파이프라인(4144)은 요청을 수신하고 중재기(4132)로부터 태그 경신하고 캐시 라인 상태를 제공하고 링 스톱(4004-M)과 외부 계면(4147)과 코어 외부 계면(4148)에 응답한다. 데이터 파이프라인(4146)은 중재기(4134)로부터 요청과 데이터를 수신하고 선택 로직(4158)과 링 스톱(4004-M)으로 데이터를 제공한다. 캐시 메모리 모드에서, 태그/MESI 어레이(4142)는 메모리 어레이(4152)에 저장된 캐시 라인용 태그들과 상태를 저장한다. 바람직하게, 메모리 어레이(4152)는 캐시 메모리 모드에 있을 때 세트 결합 메모리로서 동작하고, LRU 어레이(4142)는 선택된 세트의 교체 방법을 결정하기 위하여 캐시 라인 교체정보를 저장한다.
충진 큐(4122)는 메모리 어레이(4152)( 중복 적재 요청)로의 새로운 배당과 메모리 어레이(4152)로부터의 축출(희생 요청)을 취급한다. 희생 요청의 경우, 충진 큐(4122)가 있으면, 축출되는 것이 필요한 캐시 라인을 결정하기 위하여 태그 파이프라인(4144)으로의 접속을 요청하고 시스템 메모리로 기입하기 위하여 메모리 어레이(4152)로부터 수정된 데이터를 판독하기 위하여 데이터 파이프라인(4146)에 접속하는 것을 요청한다. 재로드 요청의 경우, 충진 큐(4122)는 새로 배당된 캐시 라인의 주소를 태그 어레이(4142)에 기입하고 MESI 어레이(4142)에 초기 MESI 상태를 설정하기 위하여 태그 파이프라인(4144)에의 접속을 요청하고 메모리 어레이(4152)에 새로운 데이터를 기입하기 위하여 데이터 파이프라인(41460으로 접속하는 것을 요청한다. 스누프(snoop) 큐(4124)는 시스템 버스(4022)로부터 발생하는 스누프들을 취급한다. 스누프 큐(4124)는 스누프 요청에서 특정된 캐시 라인의 상태를 결정하기 위하여 태그 파이프라인(4144)으로의 접속을 요청하고 스누프 요청에 대해 응답하기 위하여 메모리 어레이(4152)로부터(있으면) 수정된 데이터를 판독하기 위하여 데이터 파이프라인(4146)으로의 접속을 요청한다. 부하가 모든 하부 레벨 캐시들을 상실할 때(메모리 어레이(4152)와 캐시 제어 로직(4108)이 이하 보다 상세하게 설명되는 바와 같이 희생 캐시(4006-4)로서 동작할 때의 L3 캐시(4005)를 포함), 로드 큐(4112)는 코어(4002)의 L2 캐시(4008)(그리고 다른 캐시, 예컨대, L2 캐시(4008)가 그들을 포함하지 않는 실시예들에서, 예컨대, L1 데이터 및 L1 명령)으로부터의 부하를 취급한다. 로드 큐(4112)는 메모리 어레이(4152)에 특정 캐시 라인이 존재하는 여부를 결정하기 위하여 태그 파이프라인(4144)으로 접속을 요청하고 링 버스(4024)를 통해 요청 코어(4002)에 기입하기 위하여 메모리 어레이(4152)에서 특정 데이터를 판독하기 위하여 데이터 파이프라인(4146)으로의 접속을 요청한다. 축출 큐(4114)는 코어(L2)의 캐시(4008)로부터의 축출을 취급한다. 희생 캐시(5806-4)로서 동작할 때, 축출 큐(4114)는 하위 레벨 캐시 메모리로부터 축출된 캐시 라인의 주소를 태그 어레이(4142)에 기입하고 MESI 어레이(4142)에 MESI 상태를 설정하기 위하여 태그 파이프라인(4114)로의 접속을 요청한다. LLC 성분(5805)의 성분으로서 동작할 때, 축출 큐(4114)는 축출된 캐시 라인이 변형되면 MESI 어레이(4142)의 MESI 상태를 경신하도록 태그 파이프라인(4144)으로의 접속을 요청한다. 질문 큐(4116)는 코어(L2)의 캐시(4008)로의 스누프를 취급한다. 질문 큐(4116)는 코어(4002)가 Modified에 응답 후에 MESI 상태를 Modified로 경신하기 위하여 택 파이프라인(4144)로의 접속을 요청하고 스누프 응답으로부터의 변형된 캐시라인들을 메모리 어레이(4152)에 기입하기 위하여 데이터 파이프라인(4146)으로의 접속을 요청한다. 일 실시예에서, 캐시 제어 로직(4108)은 각 코어(4002)에 대한 코어 계면(4148)을 포함한다. 일 실시예에서, 각각의 코어 계면(4148)은 코어(4002)의 별도의 데이터/명령 캐시에 의하여 부하, 축출, 및 스누프를 각각 취급하기 위하여, 별개의 데이터/명령 로드 큐(4112), 축출 큐(4114) 및 질문 큐(4116)를 포함한다.
이제 도 42를 참조하면, 도 41의 메모리 어레이(4152)가 LLC 부분(4006)으로 사용되는 때의 캐시 메모리 모드로부터 NNU(121)가 도시된 웨이트/데이터 RAM(124/122)으로 사용된 때의 NNU 모드로 천이될 때 도 40의 프로세서(4000)의 동작을 도시하는 흐름도가 도시된다. 위에 설명된 바와 같이, NNU(121)는 대형 메모리를 가지는 데, 예컨대, 웨이트 RAM(124)은 일 실시예에서 2MB이다. 도 42와 도 43은 추가적인 LLC 부분(4006)으로서 메모리 어레이(4152)를 동작시킬 수 있으므로 시스템에서 동작되는 일정한 공정에 의하여 신경망 유닛으로서 NNU(121)가 사용되지 않을 때 LLC(4005)의 크기를 상당히(예컨대, 25% 정도) 증가시킬 수 있도록 하는 실시예를 설명한다. 보다 구체적으로, 도 42는 LLC 부분(4006)으로 동작하는 것으로부터 NNU(121)의 웨이트 RAM(124)으로서 동작하도록 메모리 어레이(4152)를 천이시키는 방법을 설명한다. 바람직하게, 모드(4199)가 캐시 메모리 모드로서 설정된 때 도 41의 캐시 제어 로직(4108)과 메모리 어레이(4152) 및 선택 로직(4158)은 도 42와 도 43의 실시예에서 집단적으로 LLC 부분(4006)으로 동작한다. 흐름은 블록(4402)에서 시작한다.
블록(4202)에서, LLC(4005)의 부분(4006)으로서 메모리 어레이(4152)를 사용하는 것으로부터 NNU(121)의 웨이트 RAM(124)으로 메모리 어레이(4152)를 사용하는 것으로 이전하도록 요청이 이루어진다. 바람직하게, 프로세서(4000)에서 가동되는 운영 시스템에 의하여 이전은 제어된다. 예컨대, 프로세서(4000) 위에서 동작하는 어플리케이션 프로그램이 NNU(121)를 사용하도록 운영 시스템에게 요청하고, 운영 시스템은 LLC 부분(4006)으로서 현재 메모리 어레이(4152)가 사용되는 것을 검출하여 캐시 메모리 모드로부터 NNU 모드로의 이전이 필요한 것을 요청한다. 흐름은 블록(4204)으로 진행한다.
블록(4204)에서, 블록(4202)에서의 이전 요청에 응답하여, 운영 시스템은 모든 코어(4002)들이 그 자체로 동기화하도록 한다. 즉, 운영 시스템은 코어(4002)들로 하여금 구조적인 명령의 인출을 중지하고 메모리에 접속하는 것을 중지하도록 한다. 보다 구체적으로, 이는 LLC(4005)로의 접속을 중지하고, 이는 현재 메모리 어레이(4152)를 포함한다. 일 실시예에서, 운영 시스템은 각각의 코어(4002) 위에서 코어(4002)에게 동기화하도록 명령하는 구조적인 명령을 실행한다. 대체적인 실시예에서, 운영 시스템은 코어(4002)들의 하나에 명령을 실행하고, 응답으로, 하나의 코어(4002)는, 예컨대, 마이크로코드를 거쳐 다른 코어(4002)들의 각각에게 동기화하도록 신호를 보낸다. 흐름은 블록(4206)으로 진행한다.
블록(4206)에서, 중복 기입-실효가 LLC 부분(4005)에 대해 수행된다. 일 실시예에서, 코어(4002)의 마이크로코드는 바람직하게 운영 시스템의 구조적인 명령의 실행에 응답하여 중복 기입-실효를 요청한다. 중복 기입-실효는 변형된 캐시 라인(있으면)들을 중복 기입하고 LLC 부분(4006-4)을 포함하는 모든 LLC 부분(4006)을 실효시킨다. 대체적인 실시예에서, 중복 기입-실효는 선택적이다. 일반적으로, 선택적인 중복 기입-실효는 이하의 의사코드에 따른 동작을 의미한다:
각각의 부분에 대해://0 내지 N-1, 여기서 N은 부분(NNU 부분을 포함)들의 현재수.
부분의 각각의 캐시라인에 대해:
if exclusive_hash(cacheline address) != slice:
evict cacheline
물론, 부분이 NNU 일 때(예컨대, 8개의 비-NNU 부분(4006)의 경우, 부분 = 8 + 하나의 NNU LLC 부분(4006-4)), 제외 해시가 NNU LLC 부분(4006-4)의 지수로 결코 복귀하지 않으므로 exclusive_hash (cacheline_address)는 부분과 같지 않을 것이며, 그래서 NNU LLC 부분(4006-4)의 모든 캐시 라인들은 축출될 것이며, 즉, 변형되면 중복 기입되고, 실효된다. 사용되는 내포적인 및 배제적인 해시들에 따라, 비-NNU LLC 부분(4006-4)으로부터의 축출이 필요한 캐시 라인들의 수는 변한다. 예컨대, 배제적이고 내포적인 해시들은 모두 PA[45:6] % N이라고 가정하면, 여기서 N은 각각에 대해 다르고, 즉, N은 내포적인 해시보다 배제적인 해시에서 1만큼 작으며, 그리고 내포적인 해시에 대해 N은 9이며 배제적인 해시에 대해 8이다. 이 경우, 비-NNU LLC 부분(4006)들의 캐시 라인의 상당히 더 큰 비율은 축출을 필요로 하며, 대략 88%이다. 이 경우, 모든 LLC 부분(4006)의 모든 캐시 라인들을 단순히 중복 기입-실효시키는 것이 효율적이거나 더욱 효율적일 수 있다. 대조적으로, 또 다른 예에 대해, 배제 해시는 PA[10:8]이며, 내포적인 해시는 위에 설명된 바와 같이 cal_hash_2이다. 이 경우, 비-NNU LLC 부분(4006)들의 캐시 라인들의 어느 것도 내포적인 해시로부터 배제적인 해시로의 이전에 대해 축출을 필요로 하지 않으며, 이는 도 42에서 수행된 이전이다. 흐름이 블록(4208)으로 진행한다.
블록(4208)에서, LLC 부분(4006)에 캐시 라인들의 물리적 주소들을 해시하기 위하여 사용된 해싱 알고리즘은 경신되어 위에 설명된 바와 같이 LLC(4005)의 부분(4006)들로서 메모리 어레이(4152)를 배제하였다. 바람직하게, 해시 경신 메시지는 각각의 코어(4002) 및 스누프 소스에게 통보되었고 그들의 해시 알고리즘을 변경하여 해시를 제외하였으며, 즉, NNU LLC 부분(4006)을 제외하는 해시를 제외하였다. 블록(4212)으로 진행한다.
블록(4212)에서, 모드(4199)는 NNU 모드를 지시하도록 경신되었으며 이로써 선택 로직(4158)이 메모리 어레이(4152)를 코어(4002)에서 실행하는 구조적인 프로그램들과 NPU(126) 파이프라인(124)에 의하여 접속되는 웨이트 RAM(124)으로서 사용하기에 유용하도록 만들었다. 일 실시예에서, 운영 시스템(예컨대, 장치 드라이버)은 캐시 메모리 모드로부터 NNU 모드로 모드(4199)를 변경하기 위하여 모드(4199)를 ㅂ제어하는 비트를 경신하기 위하여 NNU9121) 제어/상태 레지스터(127)에 기입하는 코어(4002)들의 하나에 대한 구조적인 명령을 실행한다. 구조적인 명령은 제어/상태 레지스터(127)에 메모리-매핑된 I/O 기입을 수행하는 I/O 공간 또는 메모리 저장 명령으로의 기입일 수 있다. 흐름도는 블록(4214)으로 진행한다.
블록(4214)에서, 코어(4002)들은 동작을 재개하고, 즉, 그들은 더 이상 동기되지 않고 대신에 구조적인 명령의 인출과 실행을 시작하며, 이는 접속 메모리를 포함할 수 있다. 일 실시예에서, 운영 시스템은 코어(4002)에 동작을 재개하도록 명령하는 각각의 코어(4002)에 구조적인 명령을 실행한다. 대체적인 실시예에서, 운영 시스템은 코어(4002)들의 하나의 코어에 대해 명령을 실행하고, 응답하여, 하나의 코어(4002)는 예컨대, 마이크로코드를 통해, 동작을 재개하도록 다른 코어(4002)들 각각에게 신호를 보낸다. 흐름도는 블록(4214)으로 진행한다.
이제 도 43을 참조하면, NNU(121)의 웨이트/데이터 RAM(124/122)으로 사용될 때의 NNU 모드로부터 LLC 성분(4006)으로 사용될 때의 캐시 메모리 모드로 도 41의 메모리 어레이(4152)가 천이할 때의 도 40의 프로세서(4000)의 동작을 설명하는 흐름도가 도시된다. 흐름도는 블록(4302)에서 시작한다.
블록(4302)에서, NNU(121)의 웨이트 RAM(124)으로 메모리 어레이(4152)를 사용하는 것으로부터 LLC(4005)의 성분(4006)으로 메모리 어레이(4152)를 사용하는 것으로 천이하기 위한 요청이 이루어졌다. 바람직하게, 천이는 프로세서(4000)에서 가동되는 운영 시스템에 의하여 제어된다. 예컨대, 프로세서(4000)에서 가동되는 어플리케이션 프로그램이 운영 시스템에게, NNU(121)를 더 이상 사용하지 않으며 어떤 다른 어플리케이션 프로그램도 NNU(121)를 사용하기를 요청하지 않는 것을 알리며, 운영 시스템은 메모리 어레이(4152)가 현재 웨이트 RAM(124)으로 사용되므로 NNU 모드로부터 캐시 메모리 모드로의 천이를 필요로 하는 것을 검출한다. 흐름도는 블록(4304)으로 진행한다.
블록(4304)에서, 블록(4302)에서의 천이 요청에 응답하여, 운영 시스템은 모든 코어(4002)들이 블록(4204)와 관련해서 설명된 방식으로 그 자체 동기화되도록 한다. 보다 구체적으로, 이는 LLC(4005)에의 접속을 중단하고, 이는 즉시 메모리 어레이(4152)를 배제시킨다. 흐름도는 블록(4306)으로 진행한다.
블록(4306)에서, LLC(4005)에 대한 재기입-실효가 수행된다. 재기입-실효는 변형된 캐시 라인을 재기입하고(있으면) 모든 LLC 성분(4006)들의 모든 캐시 라인들을 실효시킨다(현재 LLC(4005)에 포함되지 않았으므로 NNU LLC 성분(4006-4)을 배제하면서). 대체적인 실시예에서, 재기입-실효는 선택적이다. 일반적으로, 선택적인 재기입-실효는 이하의 의사코드에 따른 동작을 의미한다:
각각의 성분에 대해://0 내지 N-1, 여기서 N은 성분(NNU 성분을 배제)들의 현재수.
성분의 각각의 캐시라인에 대해:
if inclusive_hash(cacheline address) != slice:
evict cacheline
도 43의 배제적인 해시에서 내포적인 해시로의 천이에서, 부분은 결코 NNU의 부분이 아니므로, NNU의 LLC 부분(4006-4)의 캐시 라인들은 방출되지 않을 것이다. 채용된 내포적인 해시 및 배제적인 해시에 따라, NNU가 아닌 LLC 부분(4006)으로부터의 방출이 필요한 캐시 라인들의 수가 변한다. 예컨대, 배제적인 해시와 내포적인 해시가 모두 PA[45:6] % N으로 가정하면, 여기서 N은 각각에 대해 다르고, 즉, N은 내포적인 해시에 대해서보다 배제적인 해시의 경우가 1만큼 적고, 내포적인 해시에 대해 N이 9이면 배제적인 해시에 대해 8로 가정한다. 이 경우, 비-NNU의 LLC 부분(4006)의 캐시 라인들의 상당히 큰 비율이 방출을 필요로 하며, 대략 88%이다. 이 경우, 모든 LLC 부분(4006)의 모든 캐시 라인들을 단순히 중복기입-실효시키는 것이 효율적일 수 있다. 대조적으로, 위에 설명된 바와 같이, 배제적인 해시가 PA[10:8]이고 내포적인 해시는 calc_hash_2 인 것으로 가정한다. 이 경우, 비-NNU의 LLC 부분(4006)의 캐시 라인들의 비교적 작은 비율, 예컨대, 12%가 방출을 필요로 한다. 흐름이 블록(4308)으로 진행한다.
블록(4308)에서, 캐시 라인들의 물리적인 주소들을 LLC 부분(4006)의 캐시 라인들로 감추기 위해 사용되는 해싱 알고리즘은 경신되어, 위에 설명된 바와 같이, LLC(4005)의 부분(4006)으로서 메모리 어레이(4152)를 포함하게 된다. 즉, 해시 경신 메시지가 각각의 코어(4002) 및 스누프 소스로 통지되어 그들의 해시 알고리즘을 내포적인 해시, NNU의 LLC 부분(4006-4)을 포함하는 해시로 변경된다. 흐름이 블록(4311)으로 진행한다.
블록(4311)에서, 캐시 제어 로직(4108)은, 위에 설명된 바와 같이, 모든 캐시 라인들을 실효시키기 위하여 MESI 어레이(4142)의 상태를 경신함으로써 메모리 어레이(4152)에 대한 실효 동작을 수행한다. 바람직하게, 캐시 제어 로직(4108)은 또한 LRU 어레이(4142)에 교체 정보를 재설정한다. 일 실시예에서, 코어(4002) 마이크로 코드는 실효 요청을 수행하도록 NNU의 LLC 부분(4006)에 요청하며, 이에 응답하여 캐시 제어 로직(4108)이 수행한다. 흐름은 블록(4312)으로 진행한다.
블록(4312)에서, 모드(4199)는 경신되어 캐시 메모리 모드에 지시하여 선택 로직(4158)으로 하여금 메모리 어레이(4152)를 LLC 부분(4006)으로서 사용하기에 유용하도록 만든다. 흐름은 블록(4314)으로 진행한다.
블록(4314)에서, 코어(4002)들은 동작을 재개하며, 즉, 그들은 더 이상 동기되지 않고 대신에 인출을 시작하고 구조적인 명령을 실행하고, 이는 블록(4124)과 관련해서 설명된 방식과 같이, 접속 메모리를 포함할 수 있다. 흐름은 블록(4314)에서 종료한다.
이제 도 44를 참조하면, NNU(121)의 웨이트/데이터 RAM(124/122)으로서 사용될 때의 NNU 모드로부터 희생 캐시(4006-4)로서 사용될 때의 캐시 메모리 모드로 도 41의 메모리 어레이(4152)가 이전될 때의 도 40의 프로세서(4000)의 동작을 설명하는 흐름도가 도시된다. 희생 캐시는 프로세서(4000)의 캐시 계통에서 하위 캐시 메모리에 의하여 방출된 캐시 라인들만을 보유하는 캐시 메모리이다. 예컨대, L2 캐시(4008) 및/또는 L1 데이터/명령 캐시들은 하위 레벨 캐시들이다. 추가적으로, 메모리 어레이(4152)가 희생 캐시(4006-4)로서 동작할 수 있는 실시예에서, LLC(4005)는 레벨-3(L3) 캐시로 고려되고 희생 캐시(4006-4)에 대해 하위레벨 캐시로 고려되며 희생 캐시(4006-4)로 캐시 라인들을 방출한다. 예컨대, 로드 요청 또는 스누프 요청에 응답하여 희생 캐시에 직면할 때, 희생 캐시는 데이터를 제공한다. 일 실시예에서, L3 캐시(4005)는 코어 콤플렉스(4012)의 하위 레벨 캐시 및 L2 캐시를 포함하며, 희생 캐시는 L3 캐시(4005)로 배당하기 위하여 히트 데이터를 제공하며, 이는 다시 데이터를 L2 캐시(4008)에 제공하고, 이는 다시 데이터를 더 하위 레벨 캐시들에 제공한다. 또 다른 실시예에서, 코어 콤플렉스(4012)들의 L3 캐시(4005), L2 캐시(4008) 및 하위 레벨 캐시들은 내포적이 아니고, 희생 캐시는 각 레벨의 캐시들에 직접 배당하도록 히트 데이터를 제공한다. 바람직하게, 도 41의 캐시 제어 로직(4108)과 메모리 어레이(4152) 및 선택 로직(4158)은 모드(4199)가 NNU 모드로서 설정된 때 도 44와 도 45의 실시예에서 희생 캐시(4006-4)로서 집단적으로 동작한다. 일 실시예에서, 희생 캐시(4006-4)는 캐시로 방출된 수정된 캐시 라인을 로드하는 중복 기입 캐시로서 동작할 수 있으며 또한 그에 대해 방출된 수정된 캐시 라인을 로드하지 않으나 수정된 캐시 라인들을 시스템 메모리로 전송하는 연속기입(write-through) 캐시로서 동작할 수 있다. 중복 기입 희생 캐시(4006-4)는 도 45의 설명으로부터 알 수 있는 바와 같이(보다 구체적으로 블록(4506, 4508 및 4512)), NNU 모드의 웨이트 RAM(124)으로서 메모리 어레이(4152)를 사용하는 것으로의 더욱 신속한 이동의 이점을 가지며, 중복 기입 희생 캐시(4006-4)는 프로세서(4000)에 대한 더욱 큰 전체적인 캐시 효율의 이점을 가질 수 있다. 바람직하게, 희생 캐시(4006-4)는 중복 기입 또는 연속 기입 모드로서 구성가능하다. 흐름은 블록(4402)에서 시작한다.
블록(4402)에서, NNU(121)의 웨이트 RAM(124)으로 메모리 어레이(4152)를 사용하는 것으로부터 코어 콤플렉스(4012)에 의하여 공유된 희생 캐시(4006-4)로서의 메모리 어레이(4152)를 사용하는 것으로의 이전 요청이 이루어진다. 바람직하게, 이전은 블록(4302)과 관련해서 위에 설명된 것과 유사한 방식으로 프로세서(4000)에서 가동하는 운영 시스템에 의하여 제어된다. 흐름은 블록(4404)으로 진행한다.
블록(4404)에서, 모드(4199)는 경신되어 캐시 메모리 모드에 지시하여 선택 로직(4158)으로 하여금 희생 캐시(4006-4)로서 사용하기에 유용하도록 메모리 어레이(4152)를 만들게 한다. 흐름은 블록(4406)으로 진행한다.
블록(4406)에서, 버스 콘트롤러(4014)는 희생 캐시(4006-4)로의 스누프를 지시하는 것을 시작하도록 지시되며 하위 레벨 캐시들은 희생 캐시(4006-4)로 로드 요청과 방출 요청을 지시하는 것을 시작하도록 지시된다. 흐름은 블록(4408)으로 진행한다.
블록(4408)에서, 희생 캐시(4006-4)는 희생 데이터를 로드하는 것을 시작한다. 도 41의 실시예에서, 방출 큐(4114)는 요청들을 수신하고, 하위 레벨 캐시들, 예컨대, L3 캐시(4005), L2 캐시(4008) 및/또는 L1D/L1I 캐시들로부터 캐시 라인들을 축출하도록 요청들, 예컨대, 캐스트아웃을 수신한다. 응답으로, 희생 캐시(4006-4)는 메모리 어레이(4152)에 방출된 캐시들을 배당한다. 흐름은 블록(4412)으로 진행한다.
블록(4412)에서, 희생 캐시(4006-4)는 데이터에 접속하기 위하여 요청을 수신하고 요청의 주소가 희생 캐시(4006-4)를 만나면 데이터에 의하여 응답한다. 도 41의 실시예에서, 스누프 큐(4124)와 로드 큐(4112)는 요청을 수신한다. 보다 구체적으로 희생 캐시(4006-4)는 또 다른 캐시 대리인이 판독하는 중복 기입-실효 캐시 라인으로 스누프된다. 추가적으로, 희생 캐시(4006-4)는 하위-레벨 캐시들에서 누락된 부하에 대해 하위-레벨 캐시로부터 로드 요청을 수신한다. 요청이 희생 캐시(4006-4)에서 응답되면, 요청자에게 히트 데이터를 제공한다. 흐름은 블록(4412)에서 종료한다.
이제 도 45를 참조하면, 희생 캐시(4006-4)로서 사용될 때의 캐시 메모리 모드로부터 NNU(121)의 웨이트/데이터 RAM(124/122)으로서 사용될 때의 NNU 모드로 도 41의 메모리 어레이(4152)가 이전될 때의 도 40의 프로세서(4000)의 동작을 설명하는 흐름도가 도시된다. 위에 설명된 바와 같이, 희생 캐시(4006-4)는 연속기입 유형의 캐시로서 또는 중복 기입 유형 캐시로서 동작할 수 있다. 흐름은 블록(4502)에서 시작한다.
블록(4502)에서, 희생 캐시(4006-4)로서 메모리 어레이(4152)를 사용하는 것으로부터 NNU(121)의 웨이트 RAM(124)으로서 메모리 어레이(4152)를 사용하는 것으로 이전 요청이 이루어졌다. 바람직하게, 이전은 프로세서(4000)에서 실행하는 운영 시스템에 의하여 제어된다. 예컨대, 프로세서(4000)에서 실행하는 어플리케이션 프로그램은 운영 시스템에게 NNU(121)을 사용하도록 요청하고, 운영 시스템은 희생 캐시(4006-4)으로서 메모리 어레이(4152)가 현재 사용되어 캐시 메모리 모드로부터 NNU 모드로의 이전을 필요로 하는 것을 검출한다. 흐름은 블록(4504)으로 진행한다.
블록(4504)에서, 버스 콘트롤러(4014)는 희생 캐시(4006-4)로의 스누프를 인도하는 것을 정지하도록 지시된다. 흐름은 블록(4506)으로 진행한다.
결정 블록(4506)에서, 희생 캐시(4006-4)가 연속기입 유형의 캐시로 동작하면, 흐름은 블록(4512)으로 진행하고; 아니면, 흐름은 블록(4508)으로 진행한다.
블록(4508)에서, 캐시 제어 로직(4108)은 희생 캐시(4006-4)에 대해 중복 기입-실효를 수행한다. 즉, 희생 캐시(4006-4)는 시스템 메모리에게 모든 그의 수정된 캐시 라인들을 중복 기입하고 이어서 모든 그의 캐시 라인들을 실효시킨다(모든 캐시 라인들을 실효시키기 위하여 MESI 어레이(4142)의 상태를 경신함으로써; 바람직하게, 캐시 제어 로직(4108)은 또한 LRU 어레이(4142)에 교체 정보를 재설정하며). 바람직하게, 캐시 제어 로직(4108)은 로드 요청과 스누프 요청에 대해 계속 응답하면서 중복 기입-실효 요청을 수행한다. 흐름도는 블록(4514)으로 진행한다. 블록(4512)에서, 캐시 제어 로직(4108)은 메모리 어레이(4152)에 대해 모든 캐시 라인들을 실효시킨다. 즉, 캐시 제어 로직(4108)은 메모리 어레이(4152)의 모든 캐시 라인들을 실효시킨다. 알 수 있는 바와 같이, 희생 캐시(4006-4)가 연속기입 유형의 캐시로서 동작할 때, 웨이트 RAM(124)으로서의 메모리 어레이(4152)를 이용하는 것으로의 이전은 바람직하게 희생 캐시(4006-4)가 중복 기입 유형의 캐시로서 동작할 때보다 더 신속할 수 있는 데, 블록(4512)에서의 수정된 캐시 라인들의 중복 기입이 수행될 필요가 없기 때문이며(즉, 여기 블록(4512)에서 실효만이 수행되는 것이 필요), 희생 캐시(4006-4)가 비교적 클 때 이것은 상당한 절약일 수 있다. 흐름은 블록(4514)으로 진행한다.
블록(4514)에서, 하위 레벨 캐시들은 로드 요청들을 희생 캐시(4006-4)로 인도하는 것을 중지하도록 지시되고, 버스 콘트롤러(4014)는 희생 캐시(4006-4)로 스누프들을 인도하는 것을 중지하도록 지시된다. 흐름은 블록(4516)으로 진행한다.
블록(4516)에서, 모드(4199)가 경신되어 NNU 모드에게 지시하여 선택 로직(4158)로 하여금 NPU(126) 파이프라인(124)에 의하여 접속되는 웨이트 RAM(124)으로서 사용하기에 유용하도록 메모리 어레이(4152)를 만들도록 하며 아키텍쳐 프로그램은 블록(4121)에 대해 설명된 바와 같은 방식으로, 코어(4002)들에 실행한다. 흐름은 블록(4518)으로 진행한다.
블록(4518)에서, 캐시 제어 로직(4108)은 희생 데이터를 로드하는(블록(4408)에서 로드하는 것을 시작함) 것을 중지한다. 더욱이, 캐시 제어 로직(4108)은 버스 콘트롤러(4014)에게 수신한 후속의 로드, 방출, 또는 스누프 요청을 전송한다. 마지막으로, 코어(4002)들에서 실행되는 아키텍쳐 프로그램들은 NPU(126)의 파이프라인(124)을 접속되는 웨이트 RAM(124)으로서 사용할 수 있다. 흐름은 블록(4518)에서 종료한다.
본 발명의 여러 실시예들이 여기 설명되었지만, 그들은 예로서 제공된 것이며 제한이 아닌 것이 이해되어야 한다. 형태와 세부 사항의 다양한 변경이 본 발명의 범위로부터 벗어나지 않고 이루어질 수 있음이 관련 컴퓨터 기술의 전문 기술자들에게 명확해질 것이다. 예컨대, 소프트웨어에 의하면, 예컨대, 여기 설명된 장치 및 방법들의 기능, 제조, 모델링, 시물레이션, 설명 및/또는 시험이 가능할 수 있다.이는 일반 프로그래밍 언어(예컨대, C, C++), Verilog HDL, VHDL, 기타, 또는 다른 유용한 프로그램들을 포함하는 하드웨어 설명 언어(HDL)를 사용함으로써 달성될 수 있다. 그러한 소프트웨어는 자기 테이프, 반도체, 자기 디스크, 또는 광학 디스크(예컨대, CD-ROM, DVD-ROM, 등)와 같은 공지의 컴퓨터 이용가능한 매체에 배치될 수 있다. 여기 설명된 장치 및 방법의 실시예들은 프로세서 코어(예컨대, 구현되거나, 또는 특정되거나, HDL로)와 같은 반도체 지적재산권 코어에 포함될 수 있으며 집적회로 제조에서 하드웨어로 변환될 수 있다. 추가적으로, 여기 설명된 장치와 방법들은 하드웨어와 소프트웨어의 결합으로서 구현될 수 있다. 이와 같이, 본 발명은 여기 설명된 예시적인 실시예들에 의하여 제한되어서는 안되고, 이하의 특허청구범위와 그 균등물에 따라 단지 규정되어야 한다. 구체적으로, 본 발명은 범용 컴퓨터에 사용될 수 있는 프로세서 장치 내에서 실시될 수 있다. 마지막으로, 첨부 특허청구범위에 의하여 규정된 바와 같은 본 발명의 범위로부터 벗어나지 않고 본 발명과 동일한 목적을 실시하기 위하여 다른 구조를 설계하거나 수정하기 위한 기초로서 개시된 개념과 특정 실시예들을 용이하게 사용할 수 있는 것을 이 기술 분야의 전문가들은 이해하여야 한다.
100: 프로세서
102: 명령 캐시
104: 명령 변환기
106: 재명명 유닛
112: 실행 유닛
116: 범용 레지스터

Claims (20)

  1. 프로세서이고,
    복수의 프로세스 코어들;
    상기 복수의 프로세스 코어들에 의해 공유된 라스트 레벨 캐시 메모리(LLC), 상기 LLC는 복수의 성분들을 포함하고; 및
    신경 프로세스 유닛(NPU)의 어레이; 및
    메모리 어레이;
    를 포함하는 신경망 유닛(NNU):을 포함하고,
    상기 메모리 어레이가 상기 복수의 NPU들에 의해 판독된 신경망 웨이트들을 저장하기 위하여 동작하는 제1 모드로부터 상기 복수의 성분들뿐만 아니라 상기 메모리 어레이도 상기 LLC의 성분들로서 동작하는 제2 모드로 천이하기 위하여, 상기 프로세서는:
    상기 LLC를 재기입-실효화(invalidate)시키고; 그리고
    상기 복수의 성분들뿐만 아니라 상기 메모리 어레이도 상기 LLC의 성분으로 포함하기 위하여 해싱 알고리즘을 경신하고; 그리고
    상기 제2 모드로부터 상기 제1 모드로 천이하기 위하여, 상기 프로세서는:
    상기 LLC를 재기입-실효화시키고, 그리고
    상기 LLC로부터 상기 메모리 어레이를 제외하기 위하여 상기 해싱 알고리즘을 경신하고,
    상기 제1 모드로부터 상기 제2 모드로 천이하기 위하여, 상기 프로세서는 또한 상기 메모리 어레이를 실효화시키고,
    상기 프로세서는 상기 NNU, 상기 복수의 성분들, 및 상기 복수의 프로세스 코어들을 결합시키기 위한 링 버스를 더 포함하고,
    상기 제1 모드에서 동작할 때, 상기 복수의 프로세스 코어들은 신경망 연산들을 가속하기 위하여 주변 장치로서의 상기 링 버스를 통해 상기 NNU에 접속하는 것을 더 포함하는 것을 특징으로 하는 프로세서.
  2. 삭제
  3. 제 1 항에 있어서,
    상기 제1 모드로부터 상기 제2 모드로 천이하도록 상기 LLC를 재기입- 실효화시키기 위하여, 상기 프로세서는 상기 복수의 성분들을 재-기입-실효화시키고; 그리고
    상기 제2 모드로부터 상기 제1 모드로 천이하도록 상기 LLC를 재기입-실효화시키기 위하여, 상기 프로세서는 상기 복수의 성분들과 상기 메모리 어레이를 재기입-실효화시키는 것을 특징으로 하는 프로세서.
  4. 제 1 항에 있어서,
    상기 제1 모드로부터 상기 제2 모드로 천이하도록 상기 LLC를 재기입-실효화시키기 위하여, 상기 프로세서는 상기 메모리 어레이를 포함하는 상기 해싱 알고리즘과는 상이한 성분으로 메모리 어레이 해시를 제외하는 해싱 알고리즘을 처리하는 상기 복수의 성분들의 캐시 라인들만을 재기입-실효화시키고; 그리고
    상기 제2 모드로부터 상기 제1 모드로 천이하도록 상기 LLC를 재기입-실효화시키기 위하여, 상기 프로세서는 상기 메모리 어레이를 포함하는 상기 해싱 알고리즘과는 상이한 성분으로 상기 메모리 어레이 해시를 제외하는 해싱 알고리즘을 처리하는 상기 복수의 성분들 및 상기 메모리 어레이의 캐시 라인들만을 재기입-실효화시키는 것을 특징으로 하는 프로세서.
  5. 제 4 항에 있어서,
    어드레스들이 상기 메모리 어레이를 포함하는 상기 해싱 알고리즘에 의해 상기 복수의 성분들로 매핑되는 상기 모든 캐시 라인들은 상기 메모리 어레이를 제외하는 상기 해싱 알고리즘에 의해 동일한 성분들에 매핑되고; 그리고
    상기 제2 모드로부터 상기 제1 모드로 천이하도록 상기 LLC를 재기입-실효화시키기 위하여, 상기 프로세서는 상기 복수의 성분들 중 아무런 캐시 라인들도 재기입-실효화시키지 않고 그리고 상기 메모리 어레이의 캐시 라인들을 재기입-실효화시키는 것을 특징으로 하는 프로세서.
  6. 제 5 항에 있어서,
    상기 메모리 어레이를 포함하는 상기 해싱 알고리즘은, 상기 캐시 라인 어드레스들 중 제1 복수의 비트들과 상이한 상기 캐시 라인 어드레스들 중 제2 복수의 비트들뿐만 아니라 상기 캐시 라인 어드레스들 중 상기 제1 복수의 비트들을 사용하는 것을 특징으로 하는 프로세서.
  7. 제 6 항에 있어서,
    상기 메모리 어레이를 포함하는 상기 해싱 알고리즘은, 상기 캐시 라인 어드레스들 중 상기 제2 복수의 비트들이 소정값과 동일할 때 상기 메모리 어레이를 선택하고 그리고 그렇지 않다면 상기 캐시 라인 어드레스들 중 상기 제1 복수의 비트들을 사용하는 상기 복수의 성분들 중 하나를 선택하는 것을 포함하는 것을 특징으로 하는 프로세서.
  8. 삭제
  9. 삭제
  10. 제 1 항에 있어서,
    상기 제1 모드로부터 상기 제2 모드로 천이하기 위하여 그리고 상기 제2 모드로부터 상기 제1 모드로 천이하기 위하여, 상기 프로세서는 상기 LLC의 상기 재기입 실효화 이전에 상기 복수의 프로세스 코어들을 동기화하고 그리고 상기 LLC의 상기 재기입 실효화 이후에 실행을 재개하는 것을 특징으로 하는 프로세서.
  11. 복수의 프로세스 코어들; 상기 복수의 프로세스 코어들에 의해 공유된 라스트 레벨 캐시 메모리(LLC), 상기 LLC는 복수의 성분들을 포함하고; 및 신경 프로세스 유닛(NPU)의 어레이; 및 메모리 어레이;를 포함하는 신경망 유닛(NNU):을 포함하는 프로세서의 동작 방법이고, 상기 방법은:
    상기 메모리 어레이가 상기 복수의 NPU들에 의해 판독된 신경망 웨이트들을 저장하기 위하여 동작하는 제1 모드로부터 상기 복수의 성분들뿐만 아니라 상기 메모리 어레이도 상기 LLC의 성분들로서 동작하는 제2 모드로 천이하는 단계; 상기 단계는:
    상기 LLC를 재기입-실효화(invalidate)시키는 단계; 및
    상기 복수의 성분들뿐만 아니라 상기 메모리 어레이도 상기 LLC의 성분으로 포함하기 위하여 해싱 알고리즘을 경신하는 단계;를 포함하고, 그리고
    상기 제2 모드로부터 상기 제1 모드로 천이하는 단계; 상기 단계는:
    상기 LLC를 재기입-실효화시키는 단계; 및
    상기 LLC로부터 상기 메모리 어레이를 제외하기 위하여 상기 해싱 알고리즘을 경신하는 단계;를 포함하고,
    상기 제1 모드로부터 상기 제 2 모드로 천이하는 상기 단계는 상기 메모리 어레이를 실효화시키는 단계를 더 포함하고,
    상기 프로세서는, 상기 NNU, 상기 복수의 성분들, 및 상기 복수의 프로세스 코어들을 결합시키기 위한 링 버스를 더 포함하고,
    상기 방법은 제1 모드에서 동작할 때, 상기 복수의 프로세스 코어들에 의해 신경망 연산들을 가속하기 위하여 주변 장치로서의 상기 링 버스를 통해 상기 NNU에 접속하는 단계를 더 포함하는 것을 특징으로 하는 프로세서의 동작 방법.
  12. 삭제
  13. 제 11 항에 있어서,
    상기 제1 모드로부터 상기 제2 모드로 천이하도록 상기 LLC를 재기입-실효화시키는 단계는 상기 복수의 성분들을 재기입-실효화시키는 단계로 구성되고; 그리고
    상기 제2 모드로부터 상기 제1 모드로 천이하도록 상기 LLC를 재기입-실효화시키는 단계는 상기 복수의 성분들 및 상기 메모리 어레이를 재기입-실효화시키는 단계로 구성되는 것을 특징으로 하는 프로세서의 동작 방법.
  14. 제 11 항에 있어서,
    상기 제1 모드로부터 상기 제2 모드로 천이하도록 상기 LLC를 재기입-실효화시키는 단계는, 상기 메모리 어레이를 포함하는 상기 해싱 알고리즘과는 상이한 성분으로 메모리 어레이 해시를 제외하는 해싱 알고리즘을 처리하는 상기 복수의 성분들의 캐시 라인들만을 재기입-실효화시키는 단계로 구성되고; 그리고
    상기 제2 모드로부터 상기 제1 모드로 천이하도록 상기 LLC를 재기입-실효화시키는 단계는, 상기 메모리 어레이를 포함하는 상기 해싱 알고리즘과는 상이한 성분으로 상기 메모리 어레이 해시를 제외하는 해싱 알고리즘을 처리하는 상기 복수의 성분들 및 상기 메모리 어레이의 캐시 라인들만을 재기입-실효화시키는 단계로 구성되는 것을 특징으로 하는 프로세서의 동작 방법.
  15. 제 14 항에 있어서,
    어드레스들이 상기 메모리 어레이를 포함하는 상기 해싱 알고리즘에 의해 상기 복수의 성분들로 매핑되는 상기 모든 캐시 라인들은 상기 메모리 어레이를 제외하는 상기 해싱 알고리즘에 의해 동일한 성분들에 매핑되고; 그리고
    상기 제2 모드로부터 상기 제1 모드로 천이하도록 상기 LLC를 재기입-실효화시키는 단계는 상기 복수의 성분들 중 아무런 캐시 라인들도 재기입-실효화시키지 않고 그리고 상기 메모리 어레이의 캐시 라인들을 재기입-실효화시키는 단계로 구성되는 것을 특징으로 하는 프로세서의 동작 방법.
  16. 제 15 항에 있어서,
    상기 메모리 어레이를 포함하는 상기 해싱 알고리즘은, 상기 캐시 라인 어드레스들 중 제1 복수의 비트들과 상이한 상기 캐시 라인 어드레스들 중 제2 복수의 비트들뿐만 아니라 상기 캐시 라인 어드레스들 중 상기 제1 복수의 비트들을 사용하는 것을 특징으로 하는 프로세서의 동작 방법.
  17. 제 16 항에 있어서,
    상기 메모리 어레이를 포함하는 상기 해싱 알고리즘은, 상기 캐시 라인 어드레스들 중 상기 제2 복수의 비트들이 소정값과 동일할 때 상기 메모리 어레이를 선택하고 그리고 그렇지 않다면 상기 캐시 라인 어드레스들 중 상기 제1 복수의 비트들을 사용하는 상기 복수의 성분들 중 하나를 선택하는 것을 포함하는 것을 특징으로 하는 프로세서의 동작 방법.
  18. 삭제
  19. 삭제
  20. 계산 장치로 사용하기 위한 컴퓨터 사용가능한 매체에 인코딩된 컴퓨터 프로그램으로서, 상기 컴퓨터 프로그램은:
    프로세서를 특정하기 위하여, 상기 매체에 탑재된 컴퓨터 사용가능한 프로그램 코드를 포함하며, 상기 컴퓨터 사용 가능한 프로그램 코드는:
    복수의 프로세스 코어들을 특정하기 위한 제1 프로그램 코드;
    상기 복수의 프로세스 코어들에 의해 공유된 라스트 레벨 캐시 메모리(LLC)를 특정하기 위한 제2 프로그램 코드, 상기 LLC는 복수의 성분들을 포함하고; 그리고
    신경 프로세스 유닛(NPU)의 어레이; 및
    메모리 어레이;를 포함하는 신경망 유닛(NNU)을 특정하기 위한 제3 프로그램 코드;를 포함하며,
    상기 메모리 어레이가 상기 복수의 NPU들에 의해 판독된 신경망 웨이트들을 저장하기 위하여 동작하는 제1 모드로부터 상기 복수의 성분들뿐만 아니라 상기 메모리 어레이도 상기 LLC의 성분으로서 동작하는 제2 모드로 천이하기 위하여, 상기 프로세서는:
    상기 LLC를 재기입-실효화(invalidate)시키고; 그리고
    상기 복수의 성분들뿐만 아니라 상기 메모리 어레이도 상기 LLC의 성분으로 포함하기 위하여 해싱 알고리즘을 경신하고; 그리고
    상기 제2 모드로부터 상기 제1 모드로 천이하기 위하여, 상기 프로세서는:
    상기 LLC를 재기입-실효화시키고, 그리고
    상기 LLC로부터 상기 메모리 어레이를 제외하기 위하여 상기 해싱 알고리즘을 경신하며,
    상기 제1 모드로부터 상기 제2 모드로 천이하기 위하여, 상기 프로세서는 또한 상기 메모리 어레이를 실효화시키고,
    상기 컴퓨터 프로그램은 상기 NNU, 상기 복수의 성분들, 및 상기 복수의 프로세스 코어들을 결합시키기 위한 링 버스를 특정하기 위한 제4 프로그램 코드;를 더 포함하고;
    상기 제1 모드에서 동작할 때, 상기 복수의 프로세스 코어들은 신경망 연산들을 가속하기 위하여 주변 장치로서의 상기 링 버스를 통해 상기 NNU에 접속하는 것을 특징으로 하는 컴퓨터 프로그램.
KR1020160183877A 2016-12-01 2016-12-30 라스트 레벨 캐시 성분 또는 신경망 유닛 메모리로서 동작 가능한 메모리 어레이를 가지는 프로세서 KR101997325B1 (ko)

Applications Claiming Priority (2)

Application Number Priority Date Filing Date Title
US15/366,053 US10430706B2 (en) 2016-12-01 2016-12-01 Processor with memory array operable as either last level cache slice or neural network unit memory
US15/366,053 2016-12-01

Publications (2)

Publication Number Publication Date
KR20180062913A KR20180062913A (ko) 2018-06-11
KR101997325B1 true KR101997325B1 (ko) 2019-10-01

Family

ID=57570828

Family Applications (1)

Application Number Title Priority Date Filing Date
KR1020160183877A KR101997325B1 (ko) 2016-12-01 2016-12-30 라스트 레벨 캐시 성분 또는 신경망 유닛 메모리로서 동작 가능한 메모리 어레이를 가지는 프로세서

Country Status (5)

Country Link
US (1) US10430706B2 (ko)
EP (1) EP3330860B1 (ko)
JP (1) JP6250781B1 (ko)
KR (1) KR101997325B1 (ko)
CN (1) CN108133267B (ko)

Families Citing this family (27)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US11238334B2 (en) 2017-04-04 2022-02-01 Hailo Technologies Ltd. System and method of input alignment for efficient vector operations in an artificial neural network
US11544545B2 (en) 2017-04-04 2023-01-03 Hailo Technologies Ltd. Structured activation based sparsity in an artificial neural network
US11551028B2 (en) 2017-04-04 2023-01-10 Hailo Technologies Ltd. Structured weight based sparsity in an artificial neural network
US10387298B2 (en) * 2017-04-04 2019-08-20 Hailo Technologies Ltd Artificial neural network incorporating emphasis and focus techniques
US11615297B2 (en) 2017-04-04 2023-03-28 Hailo Technologies Ltd. Structured weight based sparsity in an artificial neural network compiler
US11037330B2 (en) * 2017-04-08 2021-06-15 Intel Corporation Low rank matrix compression
CN112334915A (zh) * 2018-06-25 2021-02-05 奥林巴斯株式会社 运算处理装置
JP2020004247A (ja) * 2018-06-29 2020-01-09 ソニー株式会社 情報処理装置、情報処理方法およびプログラム
US10558573B1 (en) 2018-09-11 2020-02-11 Cavium, Llc Methods and systems for distributing memory requests
CN111209231B (zh) * 2018-11-21 2021-05-11 上海寒武纪信息科技有限公司 数据处理方法、装置及相关产品
CN109472355B (zh) 2018-11-06 2021-01-01 地平线(上海)人工智能技术有限公司 卷积处理引擎及控制方法和相应的卷积神经网络加速器
CN109857460B (zh) * 2019-02-20 2021-09-21 南京华捷艾米软件科技有限公司 基于risc-v架构的矩阵卷积计算方法、接口、协处理器及系统
KR102351087B1 (ko) * 2019-06-04 2022-01-14 주식회사 딥엑스 인공신경망의 데이터 로컬리티 기반의 데이터 캐슁을 이용하여 고속의 인공신경망 오퍼레이션을 지원하는 데이터 관리 장치
CN110673786B (zh) 2019-09-03 2020-11-10 浪潮电子信息产业股份有限公司 数据缓存的方法和装置
RU2732201C1 (ru) * 2020-02-17 2020-09-14 Российская Федерация, от имени которой выступает ФОНД ПЕРСПЕКТИВНЫХ ИССЛЕДОВАНИЙ Метод построения процессоров для вывода в сверточных нейронных сетях, основанный на потоковых вычислениях
US11521085B2 (en) 2020-04-07 2022-12-06 International Business Machines Corporation Neural network weight distribution from a grid of memory elements
CN111753962B (zh) * 2020-06-24 2023-07-11 国汽(北京)智能网联汽车研究院有限公司 一种加法器、乘法器、卷积层结构、处理器及加速器
CN115668121A (zh) * 2020-08-31 2023-01-31 麦姆瑞克斯公司 存储器处理单元架构和配置
US11221929B1 (en) 2020-09-29 2022-01-11 Hailo Technologies Ltd. Data stream fault detection mechanism in an artificial neural network processor
US11263077B1 (en) 2020-09-29 2022-03-01 Hailo Technologies Ltd. Neural network intermediate results safety mechanism in an artificial neural network processor
US11874900B2 (en) 2020-09-29 2024-01-16 Hailo Technologies Ltd. Cluster interlayer safety mechanism in an artificial neural network processor
US11811421B2 (en) 2020-09-29 2023-11-07 Hailo Technologies Ltd. Weights safety mechanism in an artificial neural network processor
US11237894B1 (en) 2020-09-29 2022-02-01 Hailo Technologies Ltd. Layer control unit instruction addressing safety mechanism in an artificial neural network processor
US20220137866A1 (en) * 2020-11-02 2022-05-05 Deepx Co., Ltd. Memory device for an artificial neural network
CN112597079B (zh) * 2020-12-22 2023-10-17 上海安路信息科技股份有限公司 卷积神经网络加速器的数据回写系统
CN113033769B (zh) * 2021-03-02 2022-08-16 北京航空航天大学 一种概率计算神经网络方法和异步逻辑电路
US11748266B1 (en) * 2022-03-04 2023-09-05 International Business Machines Corporation Special tracking pool enhancement for core local cache address invalidates

Citations (2)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US20120041914A1 (en) * 2010-08-16 2012-02-16 Durga Deep Tirunagari System and Method for Effective Caching Using Neural Networks
US20160188474A1 (en) * 2014-12-26 2016-06-30 Intel Corporation Hardware/software co-optimization to improve performance and energy for inter-vm communication for nfvs and other producer-consumer workloads

Family Cites Families (29)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US5204938A (en) 1989-05-30 1993-04-20 Loral Aerospace Corp. Method of implementing a neural network on a digital computer
JPH045774A (ja) * 1990-04-24 1992-01-09 Seiko Epson Corp 神経網計算機
FR2686175B1 (fr) 1992-01-14 1996-12-20 Andre Thepaut Systeme de traitement de donnees multiprocesseur.
US5623628A (en) 1994-03-02 1997-04-22 Intel Corporation Computer system and method for maintaining memory consistency in a pipelined, non-blocking caching bus request queue
JPH08180034A (ja) * 1994-12-20 1996-07-12 Hitachi Microcomput Syst Ltd 情報処理装置
US5956703A (en) 1995-07-28 1999-09-21 Delco Electronics Corporation Configurable neural network integrated circuit
DE19625569A1 (de) 1996-06-26 1998-01-02 Philips Patentverwaltung Signalprozessor
US6782463B2 (en) * 2001-09-14 2004-08-24 Intel Corporation Shared memory array
US7689641B2 (en) 2003-06-30 2010-03-30 Intel Corporation SIMD integer multiply high with round and shift
AT413895B (de) 2003-09-08 2006-07-15 On Demand Informationstechnolo Digitale signalverarbeitungseinrichtung
CN1658153B (zh) 2004-02-18 2010-04-28 联发科技股份有限公司 复合式动态定点数表示法与运算法及其处理器结构
JP5368687B2 (ja) * 2007-09-26 2013-12-18 キヤノン株式会社 演算処理装置および方法
CN101452400B (zh) 2007-11-29 2011-12-28 国际商业机器公司 处理多处理器系统中事务缓冲器溢出的方法和系统
CN101236530B (zh) * 2008-01-30 2010-09-01 清华大学 高速缓存替换策略的动态选择方法
CN102023809B (zh) * 2009-09-21 2012-10-17 成都市华为赛门铁克科技有限公司 存储系统、从存储系统读取数据的方法及写入数据的方法
US8937622B2 (en) 2010-09-20 2015-01-20 Qualcomm Incorporated Inter-processor communication techniques in a multiple-processor computing platform
JP2012252490A (ja) * 2011-06-02 2012-12-20 Renesas Electronics Corp マルチプロセッサおよびそれを用いた画像処理システム
ES2658188T3 (es) * 2012-12-27 2018-03-08 Huawei Technologies Co., Ltd. Método y aparato de extensión de particiones
JP6135392B2 (ja) * 2013-08-16 2017-05-31 富士通株式会社 キャッシュメモリ制御プログラム，キャッシュメモリを内蔵するプロセッサ及びキャッシュメモリ制御方法
EP3063637A4 (en) * 2013-10-31 2017-07-19 Intel Corporation A method, apparatus and system for dynamically controlling an addressing mode for a cache memory
US9418009B2 (en) * 2013-12-27 2016-08-16 Intel Corporation Inclusive and non-inclusive tracking of local cache lines to avoid near memory reads on cache line memory writes into a two level system memory
FR3028069B1 (fr) * 2014-11-05 2016-12-09 Oberthur Technologies Procede de chargement de fichier en memoire vive dans un appareil electronique et appareil electronique associe
US20160210044A1 (en) 2015-01-15 2016-07-21 Commvault Systems, Inc. Intelligent hybrid drive caching
US9582329B2 (en) * 2015-02-17 2017-02-28 Qualcomm Incorporated Process scheduling to improve victim cache mode
US20160328644A1 (en) 2015-05-08 2016-11-10 Qualcomm Incorporated Adaptive selection of artificial neural networks
US10776690B2 (en) 2015-10-08 2020-09-15 Via Alliance Semiconductor Co., Ltd. Neural network unit with plurality of selectable output functions
US10228911B2 (en) 2015-10-08 2019-03-12 Via Alliance Semiconductor Co., Ltd. Apparatus employing user-specified binary point fixed point arithmetic
US10353860B2 (en) 2015-10-08 2019-07-16 Via Alliance Semiconductor Co., Ltd. Neural network unit with neural processing units dynamically configurable to process multiple data sizes
US10380481B2 (en) 2015-10-08 2019-08-13 Via Alliance Semiconductor Co., Ltd. Neural network unit that performs concurrent LSTM cell calculations

Patent Citations (2)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US20120041914A1 (en) * 2010-08-16 2012-02-16 Durga Deep Tirunagari System and Method for Effective Caching Using Neural Networks
US20160188474A1 (en) * 2014-12-26 2016-06-30 Intel Corporation Hardware/software co-optimization to improve performance and energy for inter-vm communication for nfvs and other producer-consumer workloads

Also Published As

Publication number Publication date
CN108133267A (zh) 2018-06-08
EP3330860B1 (en) 2020-04-01
US20180157967A1 (en) 2018-06-07
CN108133267B (zh) 2020-08-21
JP2018092562A (ja) 2018-06-14
KR20180062913A (ko) 2018-06-11
EP3330860A1 (en) 2018-06-06
JP6250781B1 (ja) 2017-12-20
US10430706B2 (en) 2019-10-01

Similar Documents

Publication Publication Date Title
KR101997325B1 (ko) 라스트 레벨 캐시 성분 또는 신경망 유닛 메모리로서 동작 가능한 메모리 어레이를 가지는 프로세서
KR101902658B1 (ko) 캐시 메모리 또는 신경망 유닛 메모리로서 동작 가능한 메모리 어레이를 가지는 프로세서
KR101881676B1 (ko) 희생 캐시 또는 신경망 유닛 메모리로서 동작 가능한 메모리 어레이를 갖는 프로세서
US11029949B2 (en) Neural network unit
US10725934B2 (en) Processor with selective data storage (of accelerator) operable as either victim cache data storage or accelerator memory and having victim cache tags in lower level cache wherein evicted cache line is stored in said data storage when said data storage is in a first mode and said cache line is stored in system memory rather then said data store when said data storage is in a second mode
CN111680790B (zh) 神经网络单元
KR101979069B1 (ko) 효율적인 3-차원 컨벌루션을 수행하는 신경망 유닛
US11216720B2 (en) Neural network unit that manages power consumption based on memory accesses per period
KR102064642B1 (ko) 신경 메모리 및 신경 메모리로부터 수신된 데이터의 행의 멀티-워드 거리의 회전을 집단적으로 수행하는 신경 처리 유닛들의 어레이를 갖는 신경망 유닛
CN106598545B (zh) 沟通共享资源的处理器与方法及非瞬时计算机可使用媒体
CN106484362B (zh) 利用使用者指定二维定点算术运算的装置
CN108804139B (zh) 可编程设备及其操作方法和计算机可用介质
CN108805276B (zh) 处理器、用于操作处理器的方法和计算机可用介质
US11226840B2 (en) Neural network unit that interrupts processing core upon condition
US11221872B2 (en) Neural network unit that interrupts processing core upon condition
CN108805275B (zh) 可编程设备及其操作方法和计算机可用介质

Legal Events

Date Code Title Description
A201 Request for examination
AMND Amendment
E902 Notification of reason for refusal
AMND Amendment
E902 Notification of reason for refusal
AMND Amendment
E601 Decision to refuse application
AMND Amendment
X701 Decision to grant (after re-examination)
GRNT Written decision to grant