KR20190031494A - 블록 기반의 프로세서에 대한 트랜잭션 레지스터 파일 - Google Patents
블록 기반의 프로세서에 대한 트랜잭션 레지스터 파일 Download PDFInfo
- Publication number
- KR20190031494A KR20190031494A KR1020197003192A KR20197003192A KR20190031494A KR 20190031494 A KR20190031494 A KR 20190031494A KR 1020197003192 A KR1020197003192 A KR 1020197003192A KR 20197003192 A KR20197003192 A KR 20197003192A KR 20190031494 A KR20190031494 A KR 20190031494A
- Authority
- KR
- South Korea
- Prior art keywords
- instruction
- register
- block
- core
- processor core
- Prior art date
Links
- 238000000034 method Methods 0.000 claims abstract description 107
- 238000004891 communication Methods 0.000 claims description 39
- 238000011144 upstream manufacturing Methods 0.000 claims description 21
- 230000004044 response Effects 0.000 claims description 17
- 230000009471 action Effects 0.000 claims description 9
- 230000007704 transition Effects 0.000 description 27
- 238000003860 storage Methods 0.000 description 24
- 238000012545 processing Methods 0.000 description 22
- 239000000872 buffer Substances 0.000 description 14
- 230000008569 process Effects 0.000 description 14
- 238000010586 diagram Methods 0.000 description 10
- 238000012360 testing method Methods 0.000 description 10
- 238000012546 transfer Methods 0.000 description 9
- 230000003111 delayed effect Effects 0.000 description 7
- 230000001976 improved effect Effects 0.000 description 7
- 230000002829 reductive effect Effects 0.000 description 7
- 230000000694 effects Effects 0.000 description 6
- 238000005516 engineering process Methods 0.000 description 6
- 238000013507 mapping Methods 0.000 description 6
- 239000002131 composite material Substances 0.000 description 5
- 230000006870 function Effects 0.000 description 5
- 230000008901 benefit Effects 0.000 description 4
- 230000003139 buffering effect Effects 0.000 description 4
- 230000000670 limiting effect Effects 0.000 description 4
- 238000007726 management method Methods 0.000 description 4
- 230000003068 static effect Effects 0.000 description 4
- 239000000835 fiber Substances 0.000 description 3
- 238000007667 floating Methods 0.000 description 3
- 230000004927 fusion Effects 0.000 description 3
- 230000005055 memory storage Effects 0.000 description 3
- 230000003287 optical effect Effects 0.000 description 3
- 238000004458 analytical method Methods 0.000 description 2
- 238000013459 approach Methods 0.000 description 2
- 238000003491 array Methods 0.000 description 2
- 230000005540 biological transmission Effects 0.000 description 2
- 230000001413 cellular effect Effects 0.000 description 2
- 230000008878 coupling Effects 0.000 description 2
- 238000010168 coupling process Methods 0.000 description 2
- 238000005859 coupling reaction Methods 0.000 description 2
- 230000001419 dependent effect Effects 0.000 description 2
- 238000001514 detection method Methods 0.000 description 2
- 238000005265 energy consumption Methods 0.000 description 2
- 230000006872 improvement Effects 0.000 description 2
- 230000002452 interceptive effect Effects 0.000 description 2
- 230000004048 modification Effects 0.000 description 2
- 238000012986 modification Methods 0.000 description 2
- 230000036961 partial effect Effects 0.000 description 2
- 238000002360 preparation method Methods 0.000 description 2
- 230000000630 rising effect Effects 0.000 description 2
- 230000001960 triggered effect Effects 0.000 description 2
- XLYOFNOQVPJJNP-UHFFFAOYSA-N water Substances O XLYOFNOQVPJJNP-UHFFFAOYSA-N 0.000 description 2
- 230000000903 blocking effect Effects 0.000 description 1
- 238000004364 calculation method Methods 0.000 description 1
- 230000008859 change Effects 0.000 description 1
- 230000001010 compromised effect Effects 0.000 description 1
- 238000005094 computer simulation Methods 0.000 description 1
- 238000013500 data storage Methods 0.000 description 1
- 238000013461 design Methods 0.000 description 1
- 238000011156 evaluation Methods 0.000 description 1
- 238000005206 flow analysis Methods 0.000 description 1
- 230000000977 initiatory effect Effects 0.000 description 1
- 230000009249 intrinsic sympathomimetic activity Effects 0.000 description 1
- 238000004519 manufacturing process Methods 0.000 description 1
- 230000007246 mechanism Effects 0.000 description 1
- 230000002093 peripheral effect Effects 0.000 description 1
- 238000000206 photolithography Methods 0.000 description 1
- 230000003863 physical function Effects 0.000 description 1
- 238000005381 potential energy Methods 0.000 description 1
- 238000011084 recovery Methods 0.000 description 1
- 239000004065 semiconductor Substances 0.000 description 1
- 238000001228 spectrum Methods 0.000 description 1
- 230000000638 stimulation Effects 0.000 description 1
- 230000008093 supporting effect Effects 0.000 description 1
- 230000001360 synchronised effect Effects 0.000 description 1
- 230000008685 targeting Effects 0.000 description 1
- 230000000007 visual effect Effects 0.000 description 1
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/30—Arrangements for executing machine instructions, e.g. instruction decode
- G06F9/38—Concurrent instruction execution, e.g. pipeline or look ahead
- G06F9/3854—Instruction completion, e.g. retiring, committing or graduating
- G06F9/3858—Result writeback, i.e. updating the architectural state or memory
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/30—Arrangements for executing machine instructions, e.g. instruction decode
- G06F9/30098—Register arrangements
- G06F9/30141—Implementation provisions of register files, e.g. ports
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/30—Arrangements for executing machine instructions, e.g. instruction decode
- G06F9/30003—Arrangements for executing specific machine instructions
- G06F9/3004—Arrangements for executing specific machine instructions to perform operations on memory
- G06F9/30043—LOAD or STORE instructions; Clear instruction
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/30—Arrangements for executing machine instructions, e.g. instruction decode
- G06F9/30098—Register arrangements
- G06F9/30101—Special purpose registers
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/30—Arrangements for executing machine instructions, e.g. instruction decode
- G06F9/30098—Register arrangements
- G06F9/30105—Register structure
- G06F9/30116—Shadow registers, e.g. coupled registers, not forming part of the register space
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/30—Arrangements for executing machine instructions, e.g. instruction decode
- G06F9/30145—Instruction analysis, e.g. decoding, instruction word fields
- G06F9/3016—Decoding the operand specifier, e.g. specifier format
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/30—Arrangements for executing machine instructions, e.g. instruction decode
- G06F9/38—Concurrent instruction execution, e.g. pipeline or look ahead
- G06F9/3824—Operand accessing
- G06F9/3826—Bypassing or forwarding of data results, e.g. locally between pipeline stages or within a pipeline stage
- G06F9/3828—Bypassing or forwarding of data results, e.g. locally between pipeline stages or within a pipeline stage with global bypass, e.g. between pipelines, between clusters
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/30—Arrangements for executing machine instructions, e.g. instruction decode
- G06F9/38—Concurrent instruction execution, e.g. pipeline or look ahead
- G06F9/3836—Instruction issuing, e.g. dynamic instruction scheduling or out of order instruction execution
- G06F9/3842—Speculative instruction execution
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/30—Arrangements for executing machine instructions, e.g. instruction decode
- G06F9/38—Concurrent instruction execution, e.g. pipeline or look ahead
- G06F9/3854—Instruction completion, e.g. retiring, committing or graduating
- G06F9/3858—Result writeback, i.e. updating the architectural state or memory
- G06F9/38585—Result writeback, i.e. updating the architectural state or memory with result invalidation, e.g. nullification
-
- G06F9/3859—
Landscapes
- Engineering & Computer Science (AREA)
- Software Systems (AREA)
- Theoretical Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Executing Machine-Instructions (AREA)
Abstract
블록 기반의 프로세서 아키텍쳐에 대한 레지스터 파일에 관련되는 기술이 개시된다. 개시된 기술의 하나의 예에서, 트랜잭션 레지스터 파일 및 실행 유닛을 포함하는 프로세서 코어는 명령어 블록을 실행하기 위해 사용될 수 있다. 트랜잭션 레지스터 파일은 복수의 레지스터를 포함할 수 있는데, 각각의 레지스터는 이전 값 필드 및 다음 값 필드를 포함한다. 이전 값 필드는, 레지스터 기록 메시지가 수신되고 프로세서 코어가 제1 상태에 있는 경우에 업데이트될 수 있다. 다음 값 필드는, 레지스터 기록 메시지가 수신되고 프로세서 코어가 제2 상태에 있는 경우에 업데이트될 수 있다. 실행 유닛은 명령어 블록의 명령어를 실행할 수 있다. 실행 유닛은, 이전 값 필드로부터 레지스터 값을 판독하도록 그리고 레지스터에 기록되는 명령어를 실행하는 경우에 레지스터 기록 메시지로 하여금 프로세서 코어로부터 송신되게 하도록 구성될 수 있다.
Description
마이크로프로세서는, 관련된 프로세서 명령어 세트 아키텍쳐(Instruction Set Architecture; ISA)에서 거의 변화 없이, 무어의 법칙에 의해 예측되는 계속된 트랜지스터 스케일링으로 인한 트랜지스터 수, 집적 회로 비용, 제조 자본, 클록 주파수, 및 에너지 효율성에서의 지속적인 이득으로부터 이익을 얻고 있다. 그러나, 지난 40년 동안 반도체 산업을 주도해온 포토리소그래피 스케일링으로 실현되는 이점은 느려지고 있거나 또는 심지어 역전되고 있다. 축약형 명령어 세트 컴퓨팅(reduced instruction set computing; RISC) 아키텍쳐는 수년 동안 프로세서 설계에서 지배적인 패러다임이었다. 비순차 수퍼스칼라(out-of-order superscalar) 구현은 면적 또는 성능에서 지속적인 개선을 보여주지 못했다. 따라서, 프로세서 ISA에서의 개선이 성능 향상을 확장시킬 충분한 기회가 있다.
블록 기반의 프로세서 명령어 세트 아키텍쳐(block-based processor instruction set architecture; BB-ISA)의 로드-저장 큐(load-store queue)에 대한 방법, 시스템, 장치, 및 컴퓨터 판독 가능 스토리지 디바이스가 개시된다. 설명된 기법(technique) 및 도구는 잠재적으로 프로세서 성능을 향상시킬 수 있고 별도로 또는 서로와의 다양한 조합으로 구현될 수 있다. 하기에서 더욱 완전히 설명되는 바와 같이, 설명된 기법 및 도구는, 디지털 신호 프로세서, 마이크로프로세서, 주문형 반도체(application-specific integrated circuit; ASIC), 소프트 프로세서(예를 들면, 재구성 가능한 로직을 사용하는 필드 프로그래밍 가능 게이트 어레이(field programmable gate array; FPGA)에서 구현되는 마이크로프로세서 코어), 프로그래밍 가능한 로직, 또는 다른 적절한 로직 회로부(logic circuitry)에서 구현될 수 있다. 기술 분야에서 통상의 지식을 가진 자에게 쉽게 명백한 바와 같이, 개시된 기술(technology)은, 서버, 메인프레임, 셀폰, 스마트폰, PDA, 핸드헬드 디바이스, 핸드헬드 컴퓨터, 터치 스크린 태블릿 디바이스, 태블릿 컴퓨터, 웨어러블 컴퓨터, 및 랩탑 컴퓨터를 포함하는, 그러나 이들로 제한되지는 않는 다양한 컴퓨팅 플랫폼에서 구현될 수 있다.
개시된 기술의 몇몇 예에서, 프로세서 코어는 명령어 블록을 실행하기 위해 사용될 수 있다. 프로세서 코어는 트랜잭션 레지스터 파일(transactional register file) 및 실행 유닛을 포함할 수 있다. 트랜잭션 레지스터 파일은 복수의 레지스터를 포함할 수 있는데, 각각의 레지스터는 이전 값 필드(previous value field) 및 다음 값 필드(next value field)를 포함한다. 이전 값 필드는, 이전 값 필드가 프로세서 코어 상에서의 명령어 블록의 실행 이전의 상태에 대응하는 값을 저장할 수 있도록, 레지스터 기록 메시지(register-write message)가 수신되고 프로세서 코어가 투기적으로(speculatively) 실행되고 있는 경우 업데이트될 수 있다. 다음 값 필드는, 다음 값 필드가 프로세서 코어 상에서의 명령어 블록의 실행 이후의 상태에 대응하는 값을 저장할 수 있도록, 레지스터 기록 메시지가 수신되고 프로세서 코어가 비투기적으로(non-speculatively) 실행되고 있는 경우 업데이트될 수 있다. 실행 유닛은 명령어 블록의 명령어를 실행하도록 구성될 수 있다. 실행 유닛은, 트랜잭션 레지스터 파일의 이전 값 필드로부터 레지스터 값을 판독하도록 그리고 명령어 블록의 명령어가 레지스터로 기록되는 경우 레지스터 기록 메시지로 하여금 프로세서 코어로부터 송신되게 하도록 구성될 수 있다.
이 개요는 하기의 상세한 설명에서 더 설명되는 엄선된 개념을 단순화된 형태로 소개하기 위해 제공된다. 이 개요는 청구된 주제의 주요 피쳐 또는 필수 피쳐를 식별하도록 의도되는 것도 아니고, 청구된 주제의 범위를 제한하기 위해 사용되도록 의도되는 것도 아니다. 개시된 주제의 전술한 및 다른 목적 피쳐, 및 이점은 첨부 도면을 참조하여 진행되는 다음의 상세한 설명으로부터 더욱 명백해질 것이다.
도 1은, 개시되는 기술의 몇몇 예에서 사용될 수 있는 바와 같은, 다수의 프로세서 코어를 포함하는 블록 기반의 프로세서를 예시한다.
도 2는, 개시되는 기술의 몇몇 예에서 사용될 수 있는 바와 같은, 블록 기반의 프로세서 코어를 예시한다.
도 3은, 개시된 기술의 소정의 예에 따른, 다수의 명령어 블록을 예시한다.
도 4는 소스 코드의 일부분 및 각각의 명령어 블록을 예시한다.
도 5는, 개시되는 기술의 몇몇 예에서 사용될 수 있는 바와 같은, 블록 기반의 프로세서 헤더 및 명령어를 예시한다.
도 6은 블록 기반의 프로세서의 프로세서 코어의 상태의 진행의 예를 예시하는 플로우차트이다.
도 7은 블록 기반의 프로세서에 대한 프로그램의 명령어의 예시적인 스니펫(snippet)을 예시한다.
도 8 및 도 9는, 개시되는 기술의 몇몇 예에서 사용될 수 있는 바와 같은, 다수의 프로세서 코어 및 프로그램의 명령어 블록을 실행하기 위한 트랜잭션 레지스터 파일을 포함하는 예시적인 시스템을 예시한다.
도 10은, 개시되는 기술의 몇몇 예에서 사용될 수 있는 바와 같은, 블록 기반의 프로세서 코어에 대한 예시적인 상태도를 예시한다.
도 11 및 도 12는, 개시된 기술의 몇몇 예에서 수행될 수 있는 바와 같은, 다수의 블록 기반의 프로세서 코어를 포함하는 프로세서 상에서 프로그램의 명령어 블록을 실행하는 예시적인 방법을 예시하는 플로우차트이다.
도 13은, 개시된 기술의 몇몇 실시형태를 구현하기 위한 적절한 컴퓨팅 환경을 예시하는 블록도이다.
도 2는, 개시되는 기술의 몇몇 예에서 사용될 수 있는 바와 같은, 블록 기반의 프로세서 코어를 예시한다.
도 3은, 개시된 기술의 소정의 예에 따른, 다수의 명령어 블록을 예시한다.
도 4는 소스 코드의 일부분 및 각각의 명령어 블록을 예시한다.
도 5는, 개시되는 기술의 몇몇 예에서 사용될 수 있는 바와 같은, 블록 기반의 프로세서 헤더 및 명령어를 예시한다.
도 6은 블록 기반의 프로세서의 프로세서 코어의 상태의 진행의 예를 예시하는 플로우차트이다.
도 7은 블록 기반의 프로세서에 대한 프로그램의 명령어의 예시적인 스니펫(snippet)을 예시한다.
도 8 및 도 9는, 개시되는 기술의 몇몇 예에서 사용될 수 있는 바와 같은, 다수의 프로세서 코어 및 프로그램의 명령어 블록을 실행하기 위한 트랜잭션 레지스터 파일을 포함하는 예시적인 시스템을 예시한다.
도 10은, 개시되는 기술의 몇몇 예에서 사용될 수 있는 바와 같은, 블록 기반의 프로세서 코어에 대한 예시적인 상태도를 예시한다.
도 11 및 도 12는, 개시된 기술의 몇몇 예에서 수행될 수 있는 바와 같은, 다수의 블록 기반의 프로세서 코어를 포함하는 프로세서 상에서 프로그램의 명령어 블록을 실행하는 예시적인 방법을 예시하는 플로우차트이다.
도 13은, 개시된 기술의 몇몇 실시형태를 구현하기 위한 적절한 컴퓨팅 환경을 예시하는 블록도이다.
I. 일반적인 고려 사항
본 개시는, 어떠한 방식으로든 제한하는 것으로 의도되지 않는 대표적인 실시형태의 맥락에서 기술된다.
본 출원에서 사용될 때, 단수 형태 "a(한)", "an(한)" 및 "the(그)"는, 문맥이 명확하게 달리 지시하지 않는 한, 복수 형태를 포함한다. 추가적으로, 용어 "include(포함한다)"는 "comprise(포함한다)"를 의미한다. 또한, 용어 "커플링되는"은, 아이템을 커플링 또는 연결하는 기계적, 전기적, 자기적, 광학적, 뿐만 아니라 다른 실용적인 방식을 포괄하며, 커플링된 아이템 사이의 중간 엘리먼트의 존재를 배제하지는 않는다. 또한, 본원에서 사용될 때, 용어 " 및/또는"은 어구 내의 임의의 하나의 아이템 또는 아이템의 조합을 의미한다.
본원에서 설명되는 시스템, 방법, 및 장치는 어떤 식으로든 제한하는 것으로 해석되어서는 안된다. 대신, 본 개시는, 단독의 그리고 서로의 다양한 조합 및 부조합의, 다양한 개시된 실시형태의 모든 신규의 자명하지 않은 피쳐 및 양태에 관한 것이다. 개시된 시스템, 방법, 및 장치는 임의의 특정한 양태 또는 피쳐 또는 그 조합으로 제한되지도 않으며, 개시된 물(thing) 및 방법은, 임의의 하나 이상의 특정한 이점이 존재해야 하거나 또는 문제점이 해결되어야 한다는 것을 규정하지도 않는다. 또한, 개시된 실시형태의 임의의 피쳐 또는 양태는, 서로의 다양한 조합 및 부조합으로 사용될 수 있다.
비록 개시된 방법 중 일부의 동작이 편리한 표현을 위해 특정한 순차적인 순서로 설명되지만, 이 방식의 설명은, 특정한 순서화가 하기에서 기술되는 특정한 언어에 의해 요구되지 않는 한, 재배치를 포괄한다는 것이 이해되어야 한다. 예를 들면, 순차적으로 설명되는 동작은, 몇몇 경우에, 재배치될 수도 있거나 또는 동시에 수행될 수도 있다. 또한, 간략화를 위해, 첨부된 도면은, 개시된 물 및 방법이 다른 물 및 방법과 연계하여 사용될 수 있는 다양한 방식을 나타내지 않을 수도 있다. 추가적으로, 설명은, 개시된 방법을 설명하기 위해, "생산한다(produce)", "생성한다(generate)", "디스플레이한다(display)", "수신한다(receive)", "방출한다(emit)", "검증한다(verify)", "실행한다(execute)" 및 "개시한다(initiate)"와 같은 용어를 때때로 사용한다. 이들 용어는, 수행되는 실제 동작의 하이 레벨의 설명이다. 이들 용어에 대응하는 실제 동작은 특정한 구현예에 따라 변할 것이고 기술 분야에서 통상의 지식을 가진 자에 의해 쉽게 식별 가능할 것이다.
본 개시의 장치 또는 방법을 참조하여 본원에서 제시되는 동작의 이론, 과학적 원리, 또는 다른 이론적 설명은 더 나은 이해의 목적을 위해 제공되었으며 범위에서 제한하는 것으로 의도되는 것은 아니다. 첨부된 청구범위에서의 장치 및 방법은, 동작의 이러한 이론에 의해 설명되는 방식으로 기능하는 그들 장치 및 방법으로 제한되지는 않는다.
개시된 방법 중 임의의 것은, 하나 이상의 컴퓨터 판독 가능 매체(예를 들면, 컴퓨터 판독 가능 매체, 예컨대 하나 이상의 광학 매체 디스크, 휘발성 메모리 컴포넌트(예컨대 DRAM 또는 SRAM), 또는 불휘발성 메모리 컴포넌트(예컨대 하드 드라이브)) 상에 저장되는 그리고 컴퓨터(예를 들면, 스마트폰 또는 컴퓨팅 하드웨어를 포함하는 다른 모바일 디바이스를 비롯한, 임의의 상업적으로 이용 가능한 컴퓨터) 상에서 실행되는 컴퓨터 실행 가능 명령어로서 구현될 수 있다. 개시된 기법을 구현하기 위한 컴퓨터 실행 가능 명령어 중 임의의 것뿐만 아니라, 개시된 실시형태의 구현 동안 생성되고 사용되는 임의의 데이터는, 하나 이상의 컴퓨터 판독 가능 매체(예를 들면, 컴퓨터 판독 가능 저장 매체) 상에 저장될 수 있다. 컴퓨터 실행 가능 명령어는, 예를 들면, 웹 브라우저 또는 다른 소프트웨어 애플리케이션(예컨대, 원격 컴퓨팅 애플리케이션)을 통해 액세스되거나 또는 다운로드되는 소프트웨어 애플리케이션 또는 전용 소프트웨어 애플리케이션의 일부일 수 있다. 이러한 소프트웨어는, 예를 들면, (예를 들면, 임의의 적절한 상업적으로 이용 가능한 컴퓨터 상에서 실행하는 범용 및/또는 블록 기반의 프로세서를 갖는) 단일의 로컬 컴퓨터 상에서 또는 하나 이상의 네트워크 컴퓨터를 사용하여 (예를 들면, 인터넷, 광역 네트워크, 근거리 통신망, 클라이언트 서버 네트워크(예컨대 클라우드 컴퓨팅 네트워크), 또는 다른 이러한 네트워크를 통해) 네트워크 환경에서 실행될 수 있다.
명확화를 위해, 소프트웨어 기반의 구현예의 소정의 선택된 양태만이 설명된다. 기술 분야에서 널리 공지되어 있는 다른 세부 사항은 생략된다. 예를 들면, 개시된 기술은 임의의 특정한 컴퓨터 언어 또는 프로그램으로 제한되지 않는다는 것이 이해되어야 한다. 예를 들면, 개시된 기술은 C, C++, Java(자바) 또는 임의의 다른 적절한 프로그래밍 언어로 작성되는 소프트웨어에 의해 구현될 수 있다. 마찬가지로, 개시된 기술은 임의의 특정한 컴퓨터 또는 임의의 특정한 타입의 하드웨어로 제한되지 않는다. 적절한 컴퓨터 및 하드웨어의 소정의 세부 사항은 널리 공지되어 있으며 본 개시에서는 상세하게 기술될 필요가 없다.
또한, 소프트웨어 기반의 실시형태(예를 들면, 컴퓨터로 하여금 개시된 방법 중 임의의 것을 수행하게 하는 컴퓨터 실행 가능 명령어를 포함함) 중 임의의 것은, 적절한 통신 수단을 통해 업로드될 수 있거나, 다운로드될 수 있거나, 또는 원격으로 액세스될 수 있다. 이러한 적절한 통신 수단은, 예를 들면, 인터넷, 월드 와이드 웹, 인트라넷, 소프트웨어 애플리케이션, 케이블(광섬유 케이블 포함함), 자기 통신, 전자기 통신(RF, 마이크로파, 및 적외선 통신을 포함함), 전자 통신, 또는 다른 이러한 통신 수단을 포함한다.
II. 개시된 기술에 대한 소개
수퍼스칼라 비순차 마이크로아키텍쳐는, 레지스터의 이름을 바꾸기 위해, 데이터플로우 순서로 명령어를 스케줄링하기 위해, 잘못된 투기(miss-speculation) 이후 정리하기(clean up) 위해, 정확한 예외 처리(precise exception)를 위해 결과를 순차적으로 회수하기(retire) 위해, 상당한 회로 리소스를 활용한다. 이것은, 깊고 많은 포트의 레지스터 파일, 데이터플로우 명령어 스케줄링 웨이크업을 위한 많은 포트의 콘텐츠 액세스 가능 메모리(content-accessible memory; CAM), 많은 와이드 버스 멀티플렉서(many-wide bus multiplexer) 및 바이패스 네트워크와 같은 고가의 에너지 소비 회로를 포함하는데, 이들 모두는 리소스 집약적이다. 예를 들면, 다중 판독, 다중 기록 포트 랜덤 액세스 메모리(random-access memory; RAM)의 FPGA 기반의 구현예는, 통상적으로, 복제, 다중 사이클 동작, 클록 더블링(clock doubling), 뱅크 인터리빙, 유효 값 테이블, 및 기타 고가의 기법의 혼합을 필요로 한다.
개시된 기술은, 프로세서 하드웨어 및 관련 소프트웨어 둘 모두에서 상당한 복잡도 및 오버헤드를 피하면서, 높은 명령어 레벨 병렬 처리(instruction-level parallelism; ILP), 비순차, 수퍼스칼라 실행을 포함하는 기법의 적용을 통해 에너지 효율성 및/또는 성능 향상을 실현할 수 있다. 개시된 기술의 몇몇 예에서, 다수의 프로세서 코어를 포함하는 블록 기반의 프로세서는, 면적 효율적인 그리고 에너지 효율적인 높은 ILP 실행을 위해 설계되는 명시적인 데이터 그래프 실행(Explicit Data Graph Execution; EDGE) ISA를 사용한다. 몇몇 예에서, EDGE 아키텍쳐 및 관련된 컴파일러의 사용은, 레지스터 리네이밍(register renaming), CAM, 및 복잡도의 많은 것을 해결한다. 몇몇 예에서, 블록 기반의 프로세서의 각각의 코어는, 반복적으로 실행될 수도 있는 페치되어 디코딩된 명령어를 저장 또는 캐싱할 수 있고, 페치되고 디코딩된 명령어는 재사용되어 감소된 전력 및/또는 증가된 성능을 잠재적으로 달성할 수 있다.
개시된 기술의 소정의 예에서, EDGE ISA는, C 및 C++와 같은 주류 프로그래밍 언어를 지원하면서, 레지스터 리네이밍, 데이터플로우 분석, 잘못된 투기(misspeculation) 복구, 및 순차적 회수를 비롯한, 하나 이상의 복잡한 아키텍쳐 피쳐에 대한 필요성을 제거할 수 있다. 개시된 기술의 소정의 예에서, 블록 기반의 프로세서는 복수의 두 개 이상의 명령어를 원자 블록(atomic block)으로서 실행한다. 블록 기반의 명령어는, 프로그램 데이터 플로우 및/또는 명령어 플로우의 의미를 더욱 명시적인 양식으로 표현하기 위해 사용될 수 있어서, 향상된 컴파일러 및 프로세서 성능을 허용할 수 있다. 개시된 기술의 소정의 예에서, 명시적 데이터 그래프 실행 명령어 세트 아키텍쳐(EDGE ISA)는, 부적절한 제어 플로우 명령어의 검출을 향상시키고, 그에 의해 성능을 증가시키기 위해, 메모리 리소스를 절약하기 위해, 및/또는 에너지를 절약하기 위해 사용될 수 있는 프로그램 제어 플로우에 관한 정보를 포함한다.
개시된 기술의 몇몇 예에서, 명령어 블록 내에서 편제되는 명령어는 페치되고, 실행되고, 원자적으로 커밋된다(committed). 원자 명령어 블록(atomic instruction block) 내의 명령어에 의해 생성되는 중간 결과는, 명령어 블록이 커밋될 때까지 로컬하게 버퍼링된다. 명령어 블록이 커밋되면, 명령어 블록의 명령어를 실행하는 것으로부터 유래하는 가시적인 아키텍쳐 상태에 대한 업데이트가 다른 명령어 블록에게 보이게 된다. 블록 내부의 명령어는 데이터플로우 순서대로 실행되는데, 이것은 레지스터 리네이밍의 사용을 감소시키거나 또는 제거하고 전력 효율적인 비순차적 실행을 제공한다. ISA를 통해 데이터 의존성을 명시적으로 인코딩하기 위해 컴파일러가 사용될 수 있어서, 런타임시 의존성을 재발견하는 것으로부터 프로세서 코어 제어 로직에 대한 부담을 감소시키거나 또는 제거한다. 술어적 실행(predicated execution)을 사용하면, 블록 내(intra-block) 분기가 데이터플로우 명령어로 변환될 수 있고, 메모리 의존성 이외의 의존성이 직접적인 데이터 의존성으로 제한될 수 있다. 개시된 타겟 형태 인코딩 기법은, 블록 내의 명령어가 피연산자 버퍼를 통해 그들의 피연산자를 직접적으로 전달하는 것을 허용하여, 전력이 부족한 다중 포트 물리적 레지스터 파일에 대한 액세스를 감소시킨다.
명령어 블록 사이에서, 명령어는 메모리 및 레지스터와 같은 가시적인 아키텍쳐 상태를 사용하여 통신할 수 있다. 따라서, 하이브리드 데이터플로우 실행 모델을 활용하는 것에 의해, EDGE 아키텍쳐는 명령적 프로그래밍 언어(imperative programming language) 및 순차적인 메모리 의미론을 여전히 지원할 수 있지만, 그러나 바람직하게는 또한 거의 순차적인 전력 효율성 및 복잡도를 갖는 비순차적 실행의 이점을 누릴 수 있다. 프로그램의 상이한 명령어 블록은 프로세서의 다수의 프로세서 코어 상에서 병렬로 실행될 수 있다. 예를 들면, 비투기적(non-speculative) 명령어 블록이 제1 프로세서 코어 상에서 실행될 수 있고 하나 이상의 투기적 명령어 블록이 추가적인 프로세서 코어 상에서 실행될 수 있다. 투기적 명령어 블록은, 비투기적 명령어 블록으로부터의 아키텍쳐적으로(architecturally) 가시적인 결과 및 프로그램 순서에서 더 이전에 투기적으로 실행된 명령어 블록에 의존할 수도 있다. 명령어 블록의 원자적 본질을 유지하는 기본 접근법에서, 더 이전에 실행된 명령어 블록으로부터의 결과는, 명령어 블록이 커밋될 때까지, 이용 가능하게 되지 않는다. 그러나, 이 접근법은, 더 이전의 명령어 블록이 커밋하기를 대기하는 동안 더 나중에 실행된 명령어 블록이 정지될(stall) 수도 있기 때문에, 병렬로 수행될 수 있는 작업의 양을 감소시킬 수도 있다.
본원에서 개시되는 바와 같이, 프로세서의 프로세서 코어는 커밋되지 않은 상태를, 프로그램 플로우에서 명령어 블록을 더 나중에 투기적으로 실행하는 프로세서 코어로 포워딩할 수 있다. 구체적으로, 프로그램 순서에서 더 나중에 실행되는 명령어 블록으로 투기적인 비커밋 상태(speculative uncommitted state)를 포워딩하면서 명령어 블록의 원자적 성질을 유지하기 위해 트랜잭션 레지스터 파일이 사용될 수 있다. 추가적으로, 트랜잭션 레지스터 파일은, 더 이전에 실행되는 명령어 블록이 아직 생성되지 않은 레지스터 값의 소스인 때를 추적하도록 프로세서 코어에 의해 사용될 수 있고, 레지스터 값이 생성될 때까지, 생성될 레지스터 값에 의존하는 명령어가 지연될 수 있다. 각각의 명령어 블록에 대한 기록 마스크와 같은 컴파일러 생성 상태는, 추적을 지원하도록 그리고 하드웨어 복잡도를 잠재적으로 감소시키도록 트랜잭션 레지스터 파일에 의해 사용될 수 있다. 추가적으로, 트랜잭션 레지스터 파일은, 명령어 블록의 내부 중단 조건(internal abort condition) 또는 잘못된 투기(mispeculation)에 기인하여 명령어 블록이 중단되는(aborted) 경우 임의의 커밋되지 않은 변경을 레지스터 값으로 롤백하기 위해 프로세서 코어에 의해 사용될 수 있다. 트랜잭션 레지스터 파일을 사용하는 것에 의해, 하드웨어 복잡도가 (레지스터 리네이밍 로직과 비교하여) 잠재적으로 감소될 수 있고, 성능은, 원자 트랜잭션 계산 모델(atomic transaction computational model)을 유지하면서, 잠재적으로 증가될 수 있다. 관련 기술 분야에서 통상의 지식을 가진 자에게 쉽게 이해되는 바와 같이, 개시된 기술의 구현의 스펙트럼은, 다양한 면적, 성능, 및 전력 트레이드오프를 가지고 가능하다.
III. 예시적인 블록 기반의 프로세서
도 1은 개시된 기술의 몇몇 예에서 구현될 수 있는 바와 같은 블록 기반의 프로세서(100)의 블록도(10)이다. 프로세서(100)는, 레지스터 모델, 블록 기반의 명령어에 의해 수행되는 다수의 정의된 동작, 메모리 모델, 및 다른 아키텍쳐 피쳐를 비롯한, 프로세서 동작의 다수의 양태를 설명하는, 명령어 세트 아키텍쳐(instruction set architecture; ISA)에 따라 명령어의 원자 블록을 실행하도록 구성된다. 블록 기반의 프로세서는, 프로세서 코어(111)를 비롯한, 복수의 프로세싱 코어(110)를 포함한다.
도 1에서 도시되는 바와 같이, 프로세서 코어는 코어 인터커넥트(core interconnect)(120)를 통해 서로 연결된다. 코어 인터커넥트(120)는, 코어(110) 중 개개의 코어, 메모리 인터페이스(140), 및 입력/출력(I/O) 인터페이스(145) 사이에서 데이터 및 제어 신호를 전달한다. 코어 인터커넥트(120)는, 전기적, 광학적, 자기적, 또는 다른 적절한 통신 기술을 사용하여 신호를 송신 및 수신할 수 있고, 특정한 소망되는 구성에 따라, 다수의 상이한 토폴로지에 따라 배열되는 통신 연결을 제공할 수 있다. 예를 들면, 코어 인터커넥트(120)는, 크로스바, 버스, 포인트 투 포인트 버스(point-to-point bus), 링, 또는 다른 적절한 토폴로지를 가질 수 있다. 몇몇 예에서, 코어(110) 중 임의의 하나는 다른 코어 중 임의의 코어에 연결될 수 있고, 한편, 다른 예에서는, 몇몇 코어는 다른 코어의 서브세트에만 연결된다. 예를 들면, 각각의 코어는 가장 가까운 4, 8, 또는 20 개의 이웃하는 코어에만 연결될 수도 있다. 코어 인터커넥트(120)는, 코어로 그리고 코어로부터 입력/출력 데이터를 송신하도록, 뿐만 아니라 코어로 그리고 코어로부터 제어 신호 및 다른 정보 신호를 송신하도록 사용될 수 있다. 예를 들면, 코어(110)의 각각은, 각각의 코어의 각각에 의해 현재 실행되고 있는 명령어의 실행 상태를 나타내는 세마포어를 수신 및 송신할 수 있다. 몇몇 예에서, 코어 인터커넥트(120)는, 코어(110), 및 메모리 시스템을 연결하는 와이어로서 구현되고, 한편, 다른 예에서, 코어 인터커넥트는, 액티브 신호 드라이버 및 리피터, 또는 다른 적절한 회로부를 비롯한, 인터커넥트 와이어(들), 스위치 및/또는 라우팅 컴포넌트 상에서 데이터 신호를 멀티플렉싱하기 위한 회로부를 포함할 수 있다. 개시된 기술의 몇몇 예에서, 프로세서(100) 내에서 그리고 프로세서(100)로/로부터 송신되는 신호는 풀 스윙 전기 디지털 신호(full swing electrical digital signal)로 제한되는 것이 아니라, 프로세서는 차동 신호, 펄스 신호, 또는 데이터 및 제어 신호를 송신하기 위한 다른 적절한 신호를 포함하도록 구성될 수 있다.
도 1의 예에서, 프로세서의 메모리 인터페이스(140)는, 로드 및 저장 데이터의 로컬 버퍼링을 위해 그리고 추가적인 메모리에 연결하기 위해 사용되는 로직(예컨대 로드-저장 큐 및/또는 L1 캐시 메모리)을 포함한다. 예를 들면, 추가적인 메모리는 프로세서(100)와는 별개의 다른 집적 회로 상에 위치될 수 있다. 도 1에서 도시되는 바와 같이, 외부 메모리 시스템(150)은 L2 캐시(152) 및 메인 메모리(155)를 포함한다. 몇몇 예에서, L2 캐시는 정적 RAM(static RAM; SRAM)을 사용하여 구현될 수 있고, 메인 메모리(155)는 동적 RAM(dynamic RAM; DRAM)을 사용하여 구현될 수 있다. 몇몇 예에서, 메모리 시스템(150)은 프로세서(100)의 다른 컴포넌트와 동일한 집적 회로 상에 포함된다. 몇몇 예에서, 메모리 인터페이스(140)는, 레지스터 파일(들) 및/또는 프로세서(100)를 사용하지 않고도 메모리 내에서의 데이터의 블록의 전송을 허용하는 직접 메모리 액세스(direct memory access; DMA) 컨트롤러를 포함한다. 몇몇 예에서, 메모리 인터페이스(140)는, 가상 메모리를 관리 및 할당하여, 이용 가능한 메인 메모리(155)를 확장하기 위한 메모리 관리 유닛(memory management unit; MMU)을 포함할 수 있다.
I/O 인터페이스(145)는, 하드웨어 인터럽트, 시스템 제어 신호, 주변장치 인터페이스, 코프로세서 제어 및/또는 데이터 신호(예를 들면, 그래픽 프로세싱 유닛, 부동 소수점 코프로세서, 물리적 프로세싱 유닛, 디지털 신호 프로세서, 또는 다른 코프로세싱 컴포넌트용 신호), 클록 신호, 세마포어, 또는 다른 적절한 I/O 신호와 같은, 다른 컴포넌트로의 입력 및 출력 신호를 수신 및 전송하기 위한 회로부를 포함한다. I/O 신호는 동기식일 수도 있거나 또는 비동기식일 수도 있다. 몇몇 예에서, I/O 인터페이스의 전부 또는 일부분은 메모리 인터페이스(140)와 연계하여 메모리 매핑 I/O 기법(memory-mapped I/O technique)을 사용하여 구현된다.
블록 기반의 프로세서(100)는 또한 제어 유닛(160)을 포함할 수 있다. 제어 유닛은, 코어 인터커넥트(120) 또는 측대역 인터커넥트(도시되지 않음)를 통해 프로세싱 코어(110), I/O 인터페이스(145), 및 메모리 인터페이스(140)와 통신할 수 있다. 제어 유닛(160)은 프로세서(100)의 동작을 감독한다. 제어 유닛(160)에 의해 수행될 수 있는 동작은, 명령어 프로세싱을 수행하기 위한 코어의 할당 및 할당 해제, 코어, 레지스터 파일, 메모리 인터페이스(140), 및/또는 I/O 인터페이스(145) 중 임의의 것 사이의 입력 데이터 및 출력 데이터의 제어, 실행 플로우의 수정, 및 분기 명령어, 명령어 헤더, 및 제어 플로우에서의 다른 변경의 타겟 위치(들)를 검증하는 것을 포함할 수 있다. 제어 유닛(160)은 또한 하드웨어 인터럽트를 프로세싱할 수 있고, 특수한 시스템 레지스터, 예를 들면, 하나 이상의 레지스터 파일(들)에 저장되어 있는 프로그램 카운터의 판독 및 기록을 제어할 수 있다. 개시된 기술의 몇몇 예에서, 제어 유닛(160)은 프로세싱 코어(110) 중 하나 이상을 사용하여 적어도 부분적으로 구현되고, 한편, 다른 예에서, 제어 유닛(160)은 비 블록 기반의 프로세싱 코어(예를 들면, 메모리에 커플링되는 범용 RISC 프로세싱 코어)를 사용하여 구현된다. 몇몇 예에서, 제어 유닛(160)은 다음 중 하나 이상을 사용하여 적어도 부분적으로 구현된다: 하드웨어에 내장된(hardwired) 유한 상태 머신, 프로그래밍 가능한 마이크로코드, 프로그래밍 가능한 게이트 어레이, 또는 다른 적절한 제어 회로. 대안적인 예에서, 제어 유닛 기능성(functionality)은 코어(110) 중 하나 이상에 의해 수행될 수 있다.
제어 유닛(160)은 프로세서 코어(110)에 명령어 블록을 할당하기 위해 사용되는 스케줄러를 포함한다. 본원에서 사용될 때, 스케줄러 할당은, 명령어 블록 매핑의 개시, 명령어 블록 페치, 디코딩, 실행, 커밋, 중단, 아이들링, 및 리프레시를 비롯한, 명령어 블록의 동작을 지시하기 위한 하드웨어를 가리킨다. 몇몇 예에서, 하드웨어는 컴퓨터 실행 가능 명령어를 사용하여 생성되는 신호를 수신하여 명령어 스케줄러의 동작을 지시한다. 프로세서 코어(110)는 명령어 블록 매핑 동안 명령어 블록에 할당된다. 명령어 동작의 기재된 스테이지(stage)는 예시적 목적을 위한 것이며, 개시된 기술의 몇몇 예에서, 소정의 동작은 결합될 수 있거나, 생략될 수 있거나, 다수의 동작으로 분리될 수 있거나, 또는 추가적인 동작이 추가될 수 있다.
블록 기반의 프로세서(100)는 또한, 프로세서 내의 다양한 컴포넌트(예를 들면, 코어(110), 인터커넥트(120), 메모리 인터페이스(140), 및 I/O 인터페이스(145))로 하나 이상의 클록 신호를 분배하는 클록 생성기(170)를 포함한다. 개시된 기술의 몇몇 예에서, 컴포넌트의 모두는 공통 클록을 공유하고, 한편, 다른 예에서, 상이한 컴포넌트는, 상이한 클록, 예를 들면, 상이한 클록 주파수를 갖는 클록 신호를 사용한다. 몇몇 예에서, 프로세서 컴포넌트 중 일부분이 사용 중이 아닌 경우 전력 절약을 허용하도록 클록 중 일부분은 게이트로 제어된다. 몇몇 예에서, 클록 신호는, 고정된 일정한 주파수 및 듀티 사이클의 신호를 생성하기 위해, 위상 동기 루프(phase-locked loop; PLL)를 사용하여 생성된다. 클록 신호를 수신하는 회로부는 단일의 에지(예를 들면, 상승 에지)에서 트리거될 수 있고, 한편, 다른 예에서는, 수신 회로부 중 적어도 일부는 상승 및 하강 클록 에지에 의해 트리거된다. 몇몇 예에서, 클록 신호는 광학적으로 또는 무선으로 송신될 수 있다.
IV. 예시적인 블록 기반의 프로세서 코어
도 2는, 개시된 기술의 소정의 예에서 사용될 수 있는 바와 같은, 블록 기반의 프로세서(100)에 대한 예시적인 마이크로아키텍쳐, 및, 특히, 블록 기반의 프로세서 코어(프로세서 코어(111)) 중 하나의 인스턴스를 더욱 상세하게 나타내는 블록도이다(200). 설명의 용이성을 위해, 예시적인 블록 기반의 프로세서 코어(111)는 다음의 다섯 스테이지로 예시된다: 명령어 페치(IF), 디코드(DC), 발행/피연산자 페치(IS), 실행(EX), 및 메모리/데이터 액세스(LS). 그러나, 예시된 마이크로아키텍쳐에 대한 수정, 예컨대 스테이지의 추가/제거, 동작을 수행하는 유닛의 추가/제거, 및 다른 구현 세부 사항은, 블록 기반의 프로세서에 대한 특정한 애플리케이션에 적합하도록 수정될 수 있다는 것이 관련 기술 분야에서 통상의 지식을 가진 자에 의해 쉽게 이해될 것이다.
개시된 기술의 몇몇 예에서, 프로세서 코어(111)는 프로그램의 명령어 블록을 실행 및 커밋하기 위해 사용될 수 있다. 명령어 블록은, 명령어 블록 헤더 및 복수의 명령어를 포함하는 블록 기반의 프로세서 명령어의 원자 집합(atomic collection)이다. "원자(atomic)" 또는 "트랜잭션" 블록은, (1) 관찰되고 있는 실행 블록에 의해 야기되는 아키텍쳐 상태에 대한 영향의 전체로 나타날 수 있거나 또는 영향 없음으로 나타날 수 있고; 및/또는 (2) 실행 블록에 의해 야기되는 모든 효과는, 마치 모두가 동시에 발생하는 것처럼, 동시에 관찰 가능하다. 하기에서 더 논의되는 바와 같이, 명령어 블록 헤더는, 명령어 블록의 실행 모드를 설명하는 정보 및 명령어 블록 내의 복수의 명령어 중 하나 이상의 명령어의 의미를 추가로 정의하기 위해 사용될 수 있는 정보를 포함할 수 있다. 사용되는 특정한 ISA 및 프로세서 하드웨어에 따라, 명령어 블록 헤더는 또한, 명령어의 실행 동안, 예를 들면, 명령어 및/또는 데이터의 빠른 페치(early fetching), 향상된 분기 예측, 투기적 실행, 향상된 에너지 효율성, 및 향상된 코드 압축성을 허용하는 것에 의해, 명령어 블록을 실행하는 성능을 향상시키기 위해 사용될 수 있다.
명령어 블록의 명령어는 명령어 블록의 생성자 명령어와 소비자 명령어 사이의 관계를 명시적으로 인코딩하는 데이터플로우 명령어일 수 있다. 특히, 명령어는 타겟으로 된 명령어(targeted instruction)에 대해서만 예약되는 피연산자 버퍼를 통해 타겟으로 된 명령어로 결과를 직접적으로 전달할 수 있다. 블록 원자 실행 모델(block-atomic execution model)이 명령어 블록 사이에서 최종 결과만을 전달하기 때문에, 피연산자 버퍼에 저장되는 중간 결과는 일반적으로 실행 코어 외부의 코어에게는 보이지 않는다. 원자 명령어 블록의 명령어를 실행하는 것으로부터의 최종 결과는, 명령어 블록이 커밋되는 경우에 실행 코어 외부에 보이게 된다. 따라서, 각각의 명령어 블록에 의해 생성되는 가시적인 아키텍쳐 상태는 실행 코어 외부에서 단일의 트랜잭션으로 나타날 수 있고, 중간 결과는 실행 코어 외부에서 통상적으로 관찰 가능하지 않다.
도 2에서 도시되는 바와 같이, 프로세서 코어(111)는, 다른 코어로부터 제어 신호를 수신할 수 있고 코어 동작을 제어하는 제어 신호를 생성할 수 있는 제어 유닛(205)을 포함하고, 명령어 스케줄러(206)를 사용하여 코어 내에서의 명령어의 플로우를 스케줄링한다. 제어 유닛(205)은, 코어 상태를 검사하기 위한 및/또는 프로세서 코어(111)의 동작 모드를 구성하기 위한 상태 액세스 로직(207)을 포함할 수 있다. 제어 유닛(205)은, 프로세서 코어(111)의 하나 이상의 동작 모드 동안 제어 신호를 생성하기 위한 실행 제어 로직(208)을 포함할 수 있다. 제어 유닛(205) 및/또는 명령어 스케줄러(206)에 의해 수행될 수 있는 동작은, 명령어 프로세싱을 수행하기 위한 코어의 할당 및 할당 해제, 코어, 레지스터 파일, 메모리 인터페이스(140), 및/또는 I/O 인터페이스(145) 중 임의의 것 사이의 입력 데이터 및 출력 데이터의 제어를 포함할 수 있다. 제어 유닛(205)은 또한 하드웨어 인터럽트를 프로세싱할 수 있고, 특수한 시스템 레지스터, 예를 들면, 하나 이상의 레지스터 파일(들)에 저장되어 있는 프로그램 카운터의 판독 및 기록을 제어할 수 있다. 개시된 기술의 다른 예에서, 제어 유닛(205) 및/또는 명령어 스케줄러(206)는 비 블록 기반의 프로세싱 코어(예를 들면, 메모리에 커플링되는 범용 RISC 프로세싱 코어)를 사용하여 구현된다. 몇몇 예에서, 제어 유닛(205), 명령어 스케줄러(206), 상태 액세스 로직(207), 및/또는 실행 제어 로직(208)은 다음 중 하나 이상을 사용하여 적어도 부분적으로 구현된다: 하드웨어에 내장된 유한 상태 머신, 프로그래밍 가능한 마이크로코드, 프로그래밍 가능한 게이트 어레이, 또는 다른 적절한 제어 회로.
제어 유닛(205)는 명령어 블록 헤더를 디코딩하여 명령어 블록에 관한 정보를 획득할 수 있다. 예를 들면, 명령어 블록의 실행 모드는 명령어 블록 헤더에서 다양한 실행 플래그를 통해 명시될 수 있다. 디코딩된 실행 모드는 실행 제어 로직(208)의 레지스터에 저장될 수 있다. 실행 모드에 기초하여, 실행 제어 로직(208)은, 코어 동작을 조정하는 그리고, 예컨대 명령어 스케줄러(206)를 사용하는 것에 의해, 코어(111) 내에서의 명령어의 플로우를 스케줄링하는 제어 신호를 생성할 수 있다. 예를 들면, 디폴트 실행 모드 동안, 실행 제어 로직(208)은, 프로세서 코어(111)의 하나 이상의 명령어 윈도우(예를 들면, 210, 211) 상에서 실행되는 하나 이상의 명령어 블록의 명령어를 시퀀스화할(sequence) 수 있다. 구체적으로, 명령어의 각각은, 명령어 블록의 명령어가 파이프라인식으로 연결될(pipelined) 수 있고 병렬로 실행될 수 있도록, 명령어 페치, 디코드, 피연산자 페치, 실행, 및 메모리/데이터 액세스 스테이지를 통해 시퀀스화될 수 있다. 명령어는, 그들의 피연산자가 이용 가능할 때 실행할 준비가 되고, 명령어 스케줄러(206)는 명령어를 실행할 순서를 선택할 수 있다.
상태 액세스 로직(207)은, 다른 코어 및/또는 프로세서 레벨의 제어 유닛(예컨대 도 1의 제어 유닛(160))이 코어와 통신하기 위한 그리고 코어(111)의 상태에 액세스하기 위한 인터페이스를 포함할 수 있다. 예를 들면, 상태 액세스 로직(207)은 코어 인터커넥트(예컨대 도 1의 코어 인터커넥트(120))에 연결될 수 있고, 다른 코어는 제어 신호, 메시지, 판독 및 기록 레지스터, 및 등등을 통해 통신할 수 있다.
상태 액세스 로직(207)은, 명령어 블록 및/또는 코어 상태의 모드 및/또는 상태를 수정 및/또는 검사하기 위한 다른 로직 또는 제어 상태 레지스터를 포함할 수 있다. 한 예로서, 코어 상태는, 명령어 블록이 코어(111)로 매핑되는지 또는 코어(111)의 명령어 윈도우(예를 들면, 명령어 윈도우(210, 211))로 매핑되는지의 여부, 명령어 블록이 코어(111) 상에 상주하는지의 여부, 명령어 블록이 코어(111) 상에서 실행되고 있는지의 여부, 명령어 블록이 커밋할 준비가 되어 있는지의 여부, 명령어 블록이 커밋을 수행하고 있는지의 여부, 및 명령어 블록이 아이들 상태인지의 여부를 나타낼 수 있다. 다른 예로서, 명령어 블록의 상태는, 명령어 블록이 실행 중인 가장 오래된 명령어 블록이다는 것을 나타내는 토큰 또는 플래그 및 명령어 블록이 투기적으로 실행되고 있다는 것을 나타내는 플래그를 포함할 수 있다.
제어 상태 레지스터(control state register; CSR)는 블록 기반의 프로세서에 의한 사용을 위해 예약되는 고유의 메모리 위치로 매핑될 수 있다. 예를 들면, 제어 유닛(160)(도 1)의 CSR이 제1 범위의 어드레스에 할당될 수 있고, 메모리 인터페이스(140)(도 1)의 CSR이 제2 범위의 어드레스에 할당될 수 있고, 제1 프로세서 코어가 제3 범위의 어드레스로 할당될 수 있고, 제2 프로세서 코어가 제4 범위의 어드레스로 할당될 수 있고, 및 등등일 수 있다. 하나의 실시형태에서, CSR은 블록 기반의 프로세서의 범용 메모리 판독 및 기록 명령어를 사용하여 액세스될 수 있다. 추가적으로 또는 대안적으로, CSR은, CSR에 대한 특정한 판독 및 기록 명령어(예를 들면, 명령어는 메모리 판독 및 기록 명령어와는 상이한 연산코드(opcode)를 가짐)를 사용하여 액세스될 수 있다. 따라서, 하나의 코어는, 상이한 코어의 CSR에 대응하는 어드레스를 판독하는 것에 의해 상이한 코어의 구성 상태를 검사할 수 있다. 마찬가지로, 하나의 코어는, 상이한 코어의 CSR에 대응하는 어드레스에 기록하는 것에 의해 상이한 코어의 구성 상태를 수정할 수 있다. 추가적으로 또는 대안적으로, CSR은 직렬 스캔 체인을 통해 커맨드를 상태 액세스 로직(207)으로 시프트하는 것에 의해 액세스될 수 있다. 이러한 방식에서, 하나의 코어는 상이한 코어의 상태 액세스 로직(207)을 검사할 수 있고, 하나의 코어는 상이한 코어의 상태 액세스 로직(207) 또는 모드를 수정할 수 있다.
명령어 윈도우(210 및 211)의 각각은, 인터커넥트 버스 및 명령어 캐시(227)에 연결되는 하나 이상의 입력 포트(220, 221 및 222)로부터 명령어 및 데이터를 수신할 수 있는데, 인터커넥트 버스 및 명령어 캐시(227)는, 이어서, 명령어 디코더(228 및 229)에 연결된다. 추가적인 제어 신호는 또한 추가적인 입력 포트(225) 상에서 수신될 수 있다. 명령어 디코더(228 및 229)의 각각은, 명령어 블록에 대한 명령어를 디코딩하고 디코딩된 명령어를, 각기 각각의 명령어 윈도우(210 및 211) 내에 위치되는 메모리 저장소(memory store)(215 및 216) 내에 저장한다.
프로세서 코어(111)는 L1(레벨 원) 캐시(235)에 커플링되는 레지스터 파일(230)을 더 포함한다. 레지스터 파일(230)은 블록 기반의 프로세서 아키텍쳐에서 정의되는 레지스터용 데이터를 저장하고, 하나 이상의 판독 포트 및 하나 이상의 기록 포트를 가질 수 있다. 예를 들면, 레지스터 파일은, 데이터를 레지스터 파일에 저장하기 위한 두 개 이상의 기록 포트를 포함할 수 있을 뿐만 아니라, 레지스터 파일 내의 개개의 레지스터로부터 데이터를 판독하기 위한 복수의 판독 포트를 가질 수도 있다. 몇몇 예에서, 단일의 명령어 윈도우(예를 들면, 명령어 윈도우(210))는 한 번에 레지스터 파일의 단지 하나의 포트에만 액세스할 수 있고, 한편, 다른 예에서, 명령어 윈도우(210)는 하나의 판독 포트 및 하나의 기록 포트에 액세스할 수 있거나, 또는 두 개 이상의 판독 포트 및/또는 기록 포트에 동시에 액세스할 수 있다. 몇몇 예에서, 레지스터 파일(230)은 64 개의 레지스터를 포함할 수 있는데, 레지스터의 각각은 32 비트의 데이터의 워드를 유지한다. (이 애플리케이션은, 달리 명시되지 않는 한, 32 비트의 데이터를 워드로 칭할 것이다.) 몇몇 예에서, 레지스터 파일(230) 내의 레지스터 중 일부는 특수 목적으로 할당될 수도 있다. 예를 들면, 레지스터 중 일부는 시스템 레지스터로서 전용될 수 있는데, 그 예는, 일정한 값(예를 들면, 모두 제로인 워드)을 저장하는 레지스터, 실행되고 있는 프로그램 스레드의 현재 어드레스를 나타내는 프로그램 카운터(들)(program counter; PC), 물리적 코어 번호, 논리적 코어 번호, 코어 할당 토폴로지, 코어 제어 플래그, 프로세서 토폴로지, 또는 다른 적절한 전용 목적을 포함한다. 몇몇 예에서, 하나 이상의 프로세서 코어 및/또는 프로세서에 걸쳐 다수의 실행 스레드의 동시적 실행을 허용하기 위한, 하나 또는 각각의 프로그램 카운터인, 다수의 프로그램 카운터 레지스터가 있다. 몇몇 예에서, 프로그램 카운터는 레지스터 파일 내의 레지스터 대신 지정된 메모리 위치로서 구현된다. 몇몇 예에서, 시스템 레지스터의 사용은, 오퍼레이팅 시스템 또는 다른 감독(supervisory) 컴퓨터 명령어에 의해 제한될 수도 있다. 몇몇 예에서, 레지스터 파일(230)은 플립플롭의 어레이로서 구현되고, 한편, 다른 예에서, 레지스터 파일은 래치, SRAM, 또는 다른 형태의 메모리 스토리지를 사용하여 구현될 수 있다. 주어진 프로세서, 예를 들면, 프로세서(100)에 대한 ISA 명세는, 레지스터 파일(230) 내의 레지스터가 어떻게 정의되고 사용되는지를 명시한다.
몇몇 예에서, 레지스터 파일(230)은 트랜잭션 레지스터 파일 및 복수의 프로세서 코어 사이에서 레지스터 값 및 레지스터 상태 정보를 통신하기 위한 관련 로직을 포함한다. 몇몇 예에서, 프로세서 코어와 관련되는 개개의 레지스터 파일은 결합되어, 프로세서 ISA 및 구성에 따라, 정적으로 또는 동적으로, 분산 레지스터 파일을 형성할 수 있다. 예를 들면, 각각의 프로세서 코어는 스레드 내의 모든 명령어 블록을 실행하도록 구성될 수 있고 레지스터 파일 값은 프로세서 코어 내에서 유지될 수 있다. 다른 예로서, 다수의 프로세서가 논리적으로 함께 융합되어 스레드의 명령어 블록을 실행할 수 있고, 레지스터 파일 값은 스레드를 실행하는 상이한 코어 사이에서 분산될 수 있다. 프로세서 코어를 융합시키는 것에 의해, 더 많은 명령어가 병렬로 실행되어 프로세서(100)의 단일의 스레드 성능을 잠재적으로 증가시킬 수 있다.
도 2에서 도시되는 바와 같이, 명령어 윈도우(210)의 메모리 저장소(215)는 다수의 디코딩된 명령어(241), 좌측 피연산자(left operand; LOP) 버퍼(242), 우측 피연산자(right operand; ROP) 버퍼(243), 및 명령어 스코어보드(245)를 포함한다. 개시된 기술의 몇몇 예에서, 명령어 블록의 각각의 명령어는, 도 2에서 도시되는 바와 같이, 디코딩된 명령어, 좌측 및 우측 피연산자, 및 스코어보드 데이터의 행으로 분해된다. 디코딩된 명령어(241)는, 비트 레벨 제어 신호로서 저장되는 명령어의 부분적으로 또는 완전히 디코딩된 버전을 포함할 수 있다. 피연산자 버퍼(242 및 243)는, 그들의 각각의 디코딩된 명령어가 실행 준비가 될 때까지, 피연산자(예를 들면, 레지스터 파일(230)로부터 수신되는 레지스터 값, 메모리로부터 수신되는 데이터, 명령어 내에서 코딩되는 즉시 피연산자(immediate operand), 더 이전에 발행된 명령어에 의해 계산되는 피연산자, 또는 다른 피연산자 값)를 저장한다. 명령어 피연산자는, 레지스터 파일이 아닌, 피연산자 버퍼(242 및 243)로부터 판독된다.
제2 명령어 윈도우(211)의 메모리 저장소(216)는, 메모리 저장소(215)와 유사한 명령어 정보(디코딩된 명령어, 피연산자, 및 스코어보드)를 저장하지만, 그러나 단순화의 목적을 위해 도 2에서는 도시되지 않는다. 명령어 블록은, ISA 제약에 종속하여 그리고 제어 유닛(205)에 의해 지시될 때, 제1 명령어 윈도우과 관련하여 제2 명령어 윈도우(211)에 의해 동시적으로 또는 순차적으로 실행될 수 있다.
개시된 기술의 몇몇 예에서, 프론트 엔드 파이프라인 스테이지(IF 및 DC)는, 백 엔드 파이프라인 스테이지(IS, EX, LS)로부터 분리되어 이어질 수 있다. 하나의 실시형태에서, 제어 유닛은 명령어 윈도우(210 및 211)의 각각으로 클록 사이클당 두 개의 명령어를 페치 및 디코딩할 수 있다. 대안적인 실시형태에서, 제어 유닛은 클록 사이클당 하나, 네 개, 또는 다른 수의 명령어를 페치하여 대응하는 수의 명령어 윈도우로 디코딩할 수 있다. 제어 유닛(205)은, 스코어보드(245)를 사용하여 각각의 디코딩된 명령어의 입력(예를 들면, 각기 각각의 명령어의 술어(predicate)(들) 및 피연산자(들))의 준비 상태를 모니터링하기 위한 명령어 윈도우 데이터플로우 스케줄링 로직을 제공한다. 특정한 디코딩된 명령어에 대한 모든 입력이 준비가 되면, 명령어를 발행할 준비가 된다. 그 다음, 제어 로직(205)은 각각의 사이클마다 하나 이상의 다음 명령어(들)(예를 들면, 가장 낮은 번호의 준비 명령어)의 실행을 개시하고, 그것의 디코딩된 명령어 및 입력 피연산자는 실행을 위해 하나 이상의 기능 유닛(260)으로 전송된다. 디코딩된 명령어는 또한 다수의 준비 이벤트(ready event)를 인코딩할 수 있다. 제어 로직(205) 내의 스케줄러는 이들 및/또는 이벤트를 다른 소스로부터 수용하고 윈도우 내의 다른 명령어의 준비 상태를 업데이트한다. 따라서, 실행은, 프로세서 코어(111)의 준비로부터 시작하여, 제로 입력 명령어, 제로 입력 명령어에 의해 타겟이 되는 명령어, 및 등등으로 진행한다.
디코딩된 명령어(241)는, 그들이 명령어 윈도우(210)의 메모리 저장소(215) 내에서 배열되는 동일한 순서로 실행될 필요는 없다. 오히려, 명령어 스코어보드(245)는 디코딩된 명령어의 의존성을 추적하기 위해 사용되고, 의존성이 충족될 때, 관련된 개개의 디코딩된 명령어는 실행을 위해 스케줄링된다. 예를 들면, 각각의 명령어에 대한 의존성이 충족될 때 각각의 명령어에 대한 참조가 준비 큐(ready queue)에 푸시될 수 있고, 명령어는 준비 큐로부터 선입 선출(FIFO) 순서로 스케줄링될 수 있다. 스코어보드(245)에 저장되는 정보는, 관련된 명령어의 실행 술어(예컨대, 술어 비트가 계산되기를 명령어가 대기하는지의 여부 및 술어 비트가 참이면 명령어가 실행되는지 또는 술어 비트가 거짓이면 명령어가 실행되는지의 여부), 명령어의 피연산자의 가용성, 또는 관련된 개개의 명령어를 실행하기 이전에 필요로 되는 다른 선행 조건을 포함할 수 있지만, 그러나 이들로 제한되지는 않는다.
하나의 실시형태에서, 스코어보드(245)는, 명령어 디코더(228)에 의해 초기화되는 디코딩된 준비 상태, 및 명령어의 실행 동안 제어 유닛(205)에 의해 초기화되는 액티브 준비 상태를 포함할 수 있다. 예를 들면, 디코딩된 준비 상태는, 각각의 명령어가 디코딩되었는지, 어쩌면 브로드캐스트 채널을 통해, 술어 및/또는 몇몇 피연산자(들)를 대기하고 있는지, 또는 즉시 발행할 준비가 되어 있는지의 여부를 인코딩할 수 있다. 액티브 준비 상태는, 각각의 명령어가 술어 및/또는 몇몇 피연산자(들)를 대기하고 있는지, 발행할 준비가 되어 있는지, 또는 이미 발행하였는지의 여부를 인코딩할 수 있다. 디코딩된 준비 상태는 블록 리셋 또는 블록 리프레시시에 클리어될 수 있다. 새로운 명령어 블록으로의 분기시, 디코딩된 준비 상태 및 액티브 준비 상태는 클리어된다(블록 또는 코어 리셋). 그러나, 명령어 블록이 코어 상에서 재실행되는 경우, 예컨대 그것이 자신에게 다시 분기되는 경우(블록 리프레시), 액티브 준비 상태만이 클리어된다. 블록 리프레시는 즉시(명령어 블록이 자신에게 분기할 때) 또는 다수의 다른 개재하는 명령어 블록을 실행한 이후 발생할 수 있다. 따라서, 명령어 블록에 대한 디코딩된 준비 상태는, 블록의 명령어를 재페치하고(re-fetch) 디코딩할 필요가 없도록, 유지될 수 있다. 따라서, 블록 리프레시는 루프 내에서 그리고 다른 반복적인 프로그램 구조에서 시간 및 에너지를 절약하기 위해 사용될 수 있다.
각각의 명령어 윈도우에 저장되는 명령어의 수는 일반적으로 명령어 블록 내의 명령어의 수에 대응한다. 몇몇 예에서, 명령어 블록 내의 명령어의 수는 32, 64, 128, 1024 개의, 또는 다른 수의 명령어일 수 있다. 개시된 기술의 몇몇 예에서, 명령어 블록은 프로세서 코어 내의 다수의 명령어 윈도우에 걸쳐 할당된다. 몇몇 예에서, 명령어 윈도우(210, 211)는, 다수의 명령어 블록이 단일의 프로세서 코어 상에서 실행될 수 있도록, 논리적으로 분할될 수 있다. 예를 들면, 한 개의, 두 개의, 네 개의, 또는 다른 수의 명령어 블록이 하나의 코어 상에서 실행될 수 있다. 각각의 명령어 블록은 서로 동시에 또는 순차적으로 실행될 수 있다.
명령어는 프로세서 코어(111) 내에 위치되는 제어 유닛(205)을 사용하여 할당 및 스케줄링될 수 있다. 제어 유닛(205)은 메모리로부터의 명령어의 페치, 명령어의 디코딩, 일단 명령어가 각각의 명령어 윈도우로 로딩되자마자의 명령어의 실행, 프로세서 코어(111)로의/로부터의 데이터플로우, 및 프로세서 코어에 의한 제어 신호 입력 및 출력을 조정한다. 예를 들면, 제어 유닛(205)은, 상기에서 설명되는 바와 같이, 스케줄링 명령어에서 사용하기 위한 준비 큐를 포함할 수 있다. 각기 각각의 명령어 윈도우(210 및 211)에 위치되는 메모리 저장소(215 및 216)에 저장되는 명령어는 원자적으로 실행될 수 있다. 따라서, 실행된 명령어에 의해 영향을 받는 가시적인 아키텍쳐 상태에 대한 업데이트(예컨대 레지스터 파일(230) 및 메모리에 대한 기록)은, 명령어가 커밋될 때까지, 코어 내에서 로컬하게 버퍼링될 수 있다. 제어 유닛(205)은, 명령어가 커밋될 준비가 되어 있는 때를 결정할 수 있고, 커밋 로직을 시퀀스화할 수 있고, 커밋 신호를 발행할 수 있다. 예를 들면, 명령어 블록에 대한 커밋 단계(phase)는, 모든 레지스터 기록(register write)이 버퍼링되고, 메모리에 대한 모든 기록이 버퍼링되고, 분기 타겟이 계산될 때 시작될 수 있다. 명령어 블록은 가시적인 아키텍쳐 상태에 대한 업데이트가 완료되면 커밋될 수 있다. 예를 들면, 레지스터 기록이 레지스터 파일에 기록되고, 저장물(store)이 로드-저장 유닛 또는 메모리 컨트롤러로 전송되고, 그리고 커밋 신호가 생성되는 경우, 명령어 블록이 커밋될 수 있다. 제어 유닛(205)은 또한, 각각의 명령어 윈도우의 각각에 대한 기능 유닛(260)의 할당을 적어도 부분적으로 제어한다.
도 2에서 도시되는 바와 같이, 명령어 윈도우(210 및 211) 중 어느 하나로부터의 데이터를 하나 이상의 기능 유닛(260)으로 전송하기 위해 다수의 실행 파이프라인 레지스터(255)를 구비하는 제1 라우터(250)가 사용되는데, 기능 유닛(260)은, 정수 ALU(arithmetic logic unit; 산술 로직 유닛)(예를 들면, 정수 ALU(264 및 265)), 부동 소수점 유닛(예를 들면, 부동 소수점 ALU(267)), 시프트/회전 로직(예를 들면, 배럴 시프터(268)), 또는 그래픽 함수, 물리 함수, 및 다른 수학적 연산을 포함할 수 있는 다른 적절한 실행 유닛을 포함할 수 있지만, 그러나 이들로 제한되는 것은 아니다. 기능 유닛(260)으로부터의 데이터는, 그 다음, 실행되고 있는 특정한 명령어의 요건에 의존하여, 제2 라우터(270)를 통해 출력(290, 291 및 292)으로 라우팅될 수 있거나, 피연산자 버퍼(예를 들면, LOP 버퍼(242) 및/또는 ROP 버퍼(243))로 다시 라우팅될(routed back) 수 있거나, 또는 다른 기능 유닛으로 피드백될 수 있다. 제2 라우터(270)는 로드-저장 큐 인터페이스(275), 로드-저장 파이프라인 레지스터(278), 및 레지스터 파일 인터페이스(276)를 포함할 수 있다. 로드-저장 큐 인터페이스(275)는, 다수의 프로세서 코어에 의해 공유되는 로드-저장 큐와 통신하기 위해 사용될 수 있다. 로드-저장 큐는 메모리 명령어(예를 들면, 로드 명령어 및 저장 명령어)를 프로세싱하기 위해 사용될 수 있다. 로드-저장 파이프라인 레지스터(278)는 로드-저장 큐에 입력 및 출력을 저장하기 위해 사용될 수 있다. 레지스터 파일 인터페이스(276)는 레지스터 파일(230) 및/또는 다른 프로세서 코어 상의 레지스터 파일 인터페이스와 통신하기 위해 사용될 수 있다. 예를 들면, 레지스터 파일 인터페이스(276)는 기능 유닛(260) 중 하나에 의한 명령어에 대해 생성되는 출력을 비융합 모드에서 레지스터 파일(230)로 그리고 융합 모드에서 다른 프로세서 코어의 레지스터 파일로 라우팅할 수 있다. 특히 그리고 하기에서 더 상세히 설명되는 바와 같이, 레지스터 파일 인터페이스는, 다른 프로세서 코어에 레지스터 값을 전송하기 위해 사용될 수 있는 레지스터 기록 메시지를 생성할 수 있다. 이러한 방식에서, 레지스터 파일은 프로그램의 스레드를 실행하는 다수의 프로세서 코어에 의해 분산 및 공유될 수 있다.
코어는 또한, 예를 들면, 하나 이상의 명령어 윈도우(210 또는 211)에 대한 명령어 모두의 실행이 완료된 때를 나타내기 위해 사용되는 제어 출력(295)을 포함한다. 명령어 블록의 실행이 완료되면, 명령어 블록은 "커밋된"것으로 지정되고, 제어 출력(295)으로부터의 신호는, 이어서, 블록 기반의 프로세서(100) 내의 다른 코어에 의해 및/또는 제어 유닛(160)에 의해 사용되어, 다른 명령어 블록의 스케줄링, 페치, 및 실행을 개시할 수 있다. 제1 라우터(250) 및 제2 라우터(270) 둘 모두는 데이터를 (예를 들면, 명령어 블록 내의 다른 명령어에 대한 피연산자로서) 명령어로 다시 전송할(send back) 수 있다.
관련 기술 분야에서 통상의 지식을 가진 자에게 쉽게 이해되는 바와 같이, 개개의 코어 내의 컴포넌트는 도 2에서 도시되는 컴포넌트로 제한되지 않지만, 그러나 특정한 애플리케이션의 요건에 따라 변경될 수 있다. 예를 들면, 코어는 더 적은 또는 더 많은 명령어 윈도우를 가질 수도 있고, 단일의 명령어 디코더는 둘 이상의 명령어 윈도우에 의해 공유될 수도 있을 것이고, 사용되는 기능 유닛의 수 및 타입은, 블록 기반의 프로세서에 대한 특정한 타겟으로 된 애플리케이션에 따라, 변동될 수 있다. 명령어 코어로 리소스를 선택하고 할당함에 있어서 적용하는 다른 고려 사항은, 성능 요건, 에너지 사용량 요건, 집적 회로 다이, 프로세스 기술, 및/또는 비용을 포함한다.
관련 기술 분야에서 통상의 지식을 가진 자라면, 프로세서 코어(110)의 제어 로직(205) 및 명령어 윈도우(예를 들면, 명령어 윈도우(210)) 내에서의 리소스의 할당 및 설계에 의한 프로세서 성능에서 절충이 이루어질 수 있다는 것이 쉽게 이해할 것이다. 면적, 클록 주기, 성능, 및 제한은, 개개의 코어(110)의 실현된 성능 및 블록 기반의 프로세서(110)의 스루풋을 실질적으로 결정한다.
명령어 스케줄러(206)는 다양한 기능성을 가질 수 있다. 소정의 더욱 높은 성능 예에서, 명령어 스케줄러는 고도로 동시적이다. 예를 들면, 사이클마다, 디코더(들)는 명령어의 디코딩된 준비 상태 및 디코딩된 명령어를 하나 이상의 명령어 윈도우에 기록하고, 발행할 다음 명령어를 선택하고, 백 엔드에 응답하여 준비 상태 이벤트(ready event) - 특정한 명령어의 입력 슬롯(술어, 좌측 피연산자, 우측 피연산자, 등등)을 타겟으로 하는 타겟 준비 상태 이벤트(target-ready event), 또는 모든 명령어를 타겟으로 하는 브로드캐스트 준비 상태 이벤트(broadcast-ready event) 중 어느 하나 - 를 전송한다. 디코딩된 준비 상태와 함께, 명령어별 준비 상태 비트를 사용하여, 명령어를 발행할 준비가 되어 있다는 것을 결정할 수 있다.
몇몇 예에서, 명령어 스케줄러(206)는, 개시되는 기술에 따라 명령어 블록의 실행을 스케줄링하기 위해 사용되는 정보를 나타내는 데이터를 저장하는 스토리지(예를 들면, 선입선출(FIFO) 큐, 콘텐츠 어드레스 지정 가능 메모리(content addressable memory; CAM))를 사용하여 구현된다. 예를 들면, 명령어 블록을 프로세서 코어로 매핑함에 있어서 결정을 용이하게 하기 위해, 명령어 의존성, 제어의 전송, 투기, 분기 예측, 및/또는 데이터 로드 및 저장에 관한 데이터가 스토리지에 배열된다. 예를 들면, 명령어 블록 의존성은 FIFO 또는 CAM에 저장되는 그리고 명령어 블록을 하나 이상의 프로세서 코어에 매핑하기 위해 사용되는 선택 로직에 의해 더 나중에 액세스되는 태그와 관련될 수 있다. 몇몇 예에서, 명령어 스케줄러(206)는 메모리에 커플링되는 범용 프로세서를 사용하여 구현되는데, 메모리는 명령어 블록을 스케줄링하기 위한 데이터를 저장하도록 구성된다. 몇몇 예에서, 명령어 스케줄러(206)는 특수 목적 프로세서를 사용하여 또는 메모리에 커플링되는 블록 기반의 프로세서 코어를 사용하여 구현된다. 몇몇 예에서, 명령어 스케줄러(206)는 메모리에 커플링되는 유한 상태 머신으로서 구현된다. 몇몇 예에서, 프로세서(예를 들면, 범용 프로세서 또는 블록 기반의 프로세서 코어) 상에서 실행되는 오퍼레이팅 시스템은, 우선 순위, 예측, 및 명령어 스케줄러(206)로 명령어 블록을 스케줄링하기 위해 적어도 부분적으로 사용될 수 있는 다른 데이터를 생성한다. 관련 기술 분야에서 통상의 지식을 가진 자에게 쉽게 명백한 바와 같이, 집적 회로, 프로그래밍 가능한 로직, 또는 다른 적절한 로직으로 구현되는 다른 회로 구조가 명령어 스케줄러(206)에 대한 하드웨어를 구현하기 위해 사용될 수 있다.
몇몇 경우에, 스케줄러(206)는 아직 디코딩되지 않은 타겟 명령어에 대한 이벤트를 수용하고 또한 발행된 준비 명령어의 재발행을 금지해야만 한다. 명령어는 (참 또는 거짓 조건에 기초하여) 비술어적일(non-predicated) 수 있거나, 또는 술어적일(predicated) 수 있다. 술어적 명령어(predicated instruction)는, 그것이 다른 명령어의 술어 결과에 의해 타겟으로 되고, 그 결과가 술어 조건(predicate condition)과 매치할 때까지, 준비 상태가 되지 않는다. 관련된 술어가 매치하지 않으면, 명령어는 절대로 발행되지 않는다. 몇몇 예에서, 술어적 명령어가 발행되고 투기적으로 실행될 수도 있다. 몇몇 예에서, 프로세서는, 투기적으로 발행되고 실행된 명령어가 정확하게 투기되었는지를 후속하여 체크할 수도 있다. 몇몇 예에서, 잘못 투기되어 발행된 명령어 및 자신의 출력을 소비하는 블록에서의 명령어의 특정한 전이적 닫힘(transitive closure)이 재실행될 수도 있거나, 또는 잘못 투기된 부작용이 무효화될 수도 있다. 몇몇 예에서 잘못 투기된 명령어의 발견은, 명령어의 전체 블록의 완전한 롤백 및 재실행으로 이어진다.
V. 명령어 블록의 예시적인 스트림
이제 도 3의 도면(300)을 참조하면, 다수의 가변 길이 명령어 블록(311-315)(A-E)을 포함하는 블록 기반의 명령어의 스트림의 일부분(310)이 예시된다. 명령어의 스트림은, 유저 애플리케이션, 시스템 서비스, 또는 임의의 다른 적절한 사용을 구현하기 위해 사용될 수 있다. 예를 들면, 블록 기반의 컴파일러는 프로그램의 소스 코드를 컴파일할 수 있고 명령어 블록(311-315)로 분할되는 명령어의 스트림을 생성할 수 있다. 명령어 블록의 개개의 명령어는, 프로그램 순서 또는 실행 순서와는 상이할 수 있는 순차적인 순서로 방출될 수 있다. 명령어 블록의 개개의 명령어는, 명령어의 필드 내에서 또는 명령어 블록 내의 명령어의 순차적인 순서에 기초하여 인코딩되는 명령어 식별자(instruction identifier; IID)를 포함할 수 있다. 컴파일러는 또한, 예를 들면, 로드 및/또는 저장 명령어의 구성 및 기록되는 레지스터의 목록과 같은, 각각의 명령어 블록의 특성을 설명하는 헤더 정보를 생성할 수 있다.
도 3에서 도시되는 예에서, 각각의 명령어 블록은, 다양한 수의 명령어가 뒤따르는 명령어 헤더로 시작한다. 예를 들면, 명령어 블록(311)은 헤더(320) 및 스무 개의 명령어(321)를 포함한다. 예시되는 특정한 명령어 헤더(320)는, 명령어 블록 내의 명령어의 실행을 부분적으로 제어하는, 그리고 또한, 예를 들면, 분기 예측, 투기적 실행, 지연 평가, 및/또는 다른 기법을 포함하는 향상된 성능 개선 기법을 허용하는 다수의 데이터 필드를 포함한다. 명령어 헤더(320)는 또한, 헤더가 명령어가 아니라 명령어 헤더이다는 것을 나타내는 ID 비트를 포함한다. 명령어 헤더(320)는 또한 명령어 블록 사이즈의 표시를 포함한다. 명령어 블록 사이즈는, 하나보다 더 큰 명령어의 청크, 예를 들면, 명령어 블록 내에 포함되는 4 명령어 청크의 수에 있을 수 있다. 다시 말하면, 블록의 사이즈는, 명령어 블록 사이즈를 명시하는 데 할당되는 헤더 공간을 압축하기 위해 4 비트 시프트된다. 따라서, 0의 사이즈 값은, 네 개의 명령어가 후속하는 블록 헤더인 최소 사이즈의 명령어 블록을 나타낸다. 몇몇 예에서, 명령어 블록 사이즈는, 바이트의 수로서, 워드의 수로서, n 워드 청크의 수로서, 어드레스로서, 어드레스 오프셋으로서, 또는 명령어 블록의 사이즈를 설명하기 위한 다른 적절한 표현을 사용하여 표현된다. 몇몇 예에서, 명령어 블록 사이즈는 명령어 블록 헤더 및/또는 푸터(footer)의 종결 비트 패턴에 의해 나타내어진다.
명령어 블록 헤더(320)는 또한, 특수 명령어 실행 요건을 나타내는 실행 플래그를 포함할 수 있다. 예를 들면, 분기 예측 또는 메모리 의존성 예측은, 특정한 애플리케이션에 따라, 소정의 명령어 블록에 대해 금지될 수 있다.
개시된 기술의 몇몇 예에서, 명령어 헤더(320)는, 인코딩된 데이터가 명령어 헤더이다는 것을 나타내는 하나 이상의 식별 비트를 포함한다. 예를 들면, 몇몇 블록 기반의 프로세서 ISA에서, 최하위 비트 공간의 단일의 ID 비트는, 유효한 명령어 블록의 시작을 나타내기 위해 이진 값 1로 항상 설정된다. 다른 예에서, 식별 비트(들)에 대해 상이한 비트 인코딩이 사용될 수 있다. 몇몇 예에서, 명령어 헤더(320)는, 관련된 명령어 블록이 인코딩되는 ISA의 특정한 버전을 나타내는 정보를 포함한다.
블록 명령어 헤더는 또한, 예를 들면, 분기 예측, 제어 플로우 결정, 및/또는 불량 점프 검출에서 사용하기 위한 다수의 블록 종료 타입(exit type)을 포함할 수 있다. 종료 타입은 분기 명령어의 타입이 무엇인지, 예를 들면: 메모리의 다음 인접한 명령어 블록을 가리키는 순차적인 분기 명령어인지; 오프셋에 대해 계산되는 메모리 어드레스에 있는 다른 명령어 블록으로의 분기인 오프셋 명령어인지; 서브루틴 호출, 또는 서브루틴 리턴인지를 나타낼 수 있다. 명령어 헤더에서 분기 종료 타입을 인코딩하는 것에 의해, 분기 예측기는, 동일한 명령어 블록 내의 분기 명령어가 페치 및/또는 디코딩되기 이전에, 적어도 부분적으로, 동작을 시작할 수 있다.
명령어 블록 헤더(320)는 또한, 명령어 블록에 대한 동작을 저장하기 위해 할당되는 로드-저장 큐 식별자를 식별하는 저장 마스크를 포함한다. 명령어 블록 헤더는 또한, 관련된 명령어 블록이 어떤 글로벌 레지스터(들)를 기록할 수도 있는지를 식별하는 기록 마스크를 또한 포함할 수 있다. 관련된 레지스터 파일은, 명령어 블록이 성공적으로 완료될 수 있기 이전에, 각각의 엔트리에 대한 기록 명령어 또는 널 기록 명령어(null-write instruction)를 수신할 것이다. 몇몇 예에서 블록 기반의 프로세서 아키텍쳐는 스칼라 명령어뿐만 아니라, 단일 명령어 내에서 더 많은 수의 데이터 피연산자를 갖는 연산을 허용하는 단일 명령어 다중 데이터(single-instruction multiple-data; SIMD) 명령어를 또한 포함할 수 있다.
VI. 예시적인 블록 명령어 타겟 인코딩
도 4는, 블록 기반의 명령어가 그들의 타겟을 어떻게 명시적으로 인코딩할 수 있는지를 예시하는, C 언어 소스 코드의 두 부분(410 및 415) 및 (어셈블리 언어의) 그들의 각각의 명령어 블록(420 및 425)의 예를 묘사하는 도면(400)이다. 하이 레벨의 C 언어 소스 코드는, 자신의 타겟이 블록 기반의 프로세서인 컴파일러에 의해 로우 레벨의 어셈블리 언어 및 머신 코드로 변환될 수 있다. 하이 레벨의 언어는, 프로그래머가 프로그램의 기능성에 집중할 수 있도록, 기저의 컴퓨터 아키텍쳐의 세부 사항 중 많은 것을 추상화할 수 있다. 대조적으로, 머신 코드는, 컴퓨터의 하드웨어 리소스를 사용하여, 타겟 컴퓨터 상에서 실행될 수 있도록 타겟 컴퓨터의 ISA에 따라 프로그램을 인코딩한다. 어셈블리 언어는 사람이 판독 가능한 형태의 머신 코드이다.
다음의 예에서, 어셈블리 언어 명령어는 다음의 명명법을 사용한다: "I[<번호>]"는, 명령어 블록 내에서의 명령어의 번호를 명시하는데, 번호 매김(numbering)은 명령어 헤더에 후속하는 명령어에 대해 제로에서 시작하고 명령어 번호는 각각의 연속하는 명령어에 대해 증가되고; 명령어의 동작(예컨대, READ, ADDI, DIV, 및 등등)이 명령어 번호에 후속하고; 옵션 사항의(optional) 값(예컨대 즉시 값 1) 또는 레지스터에 대한 참조치(예컨대 레지스터 0의 경우 R0)이 동작에 후속하고; 그리고 명령어의 결과를 수신할 옵션 사항의 타겟이 값 및/또는 동작에 후속한다. 타겟의 각각은 다른 명령어, 다른 명령어로의 브로드캐스트 채널, 또는 명령어 블록이 커밋될 때 다른 명령어 블록에게 보일 수 있는 레지스터에 대한 것일 수 있다. 명령어 타겟의 예는 명령어 1의 우측 피연산자를 타겟으로 하는 T[1R]이다. 레지스터 타겟의 한 예는 W[R0]인데, 이 경우 타겟은 레지스터 0에 기록된다.
도면(400)에서, 명령어 블록(420)의 처음 두 개의 READ 명령어(430 및 431)(각각 0 및 1의 IID를 가짐)는, 각각, ADD 명령어(432)(IID = 2를 가짐)의 우측(T[2R]) 및 좌측(T[2L]) 피연산자를 타겟으로 한다. 예시된 ISA에서, 판독 명령어는, 글로벌 또는 블록 간 레지스터 파일로부터 판독하는 유일한 명령어이지만; 그러나 임의의 명령어가 글로벌 레지스터 파일을 타겟으로 할 수 있다. ADD 명령어(432)가 레지스터 판독 둘 모두의 결과를 수신하면, 그것은 준비되고 실행될 것이다.
TLEI(test-less-than-equal-immediate) 명령어(433)가 ADD로부터 자신의 단일의 입력 피연산자를 수신하면, 그것은 준비가 완료되어 실행될 것이다. 그 다음, 테스트는, 이 예에서는 두 개의 술어적 분기 명령어(BRO P1t(434) 및 BRO P1f(435))인, 브로드캐스트 채널 상에서 청취하고 있는 모든 명령어로 채널 1(B[1P]) 상에서 브로드캐스트되는 술어 피연산자를 생성한다. 도면(400)의 어셈블리 언어에서, "P1f"는, 명령어가 브로드캐스트 채널 1("1") 상에서 송신되고 있는 거짓 결과(false result)("f")에 입각한다는("P") 것을 나타내고, "P1t"는, 명령어가 브로드캐스트 채널 1 상에서 송신되고 있는 참 결과(true result)에 입각한다는 것을 나타낸다. 매치하는 술어를 수신하는 분기가 실행될 것이다.
명령어 블록(420)에 대한 의존성 그래프(440)가, 명령어 노드의 어레이(450) 및 대응하는 피연산자 타겟(455 및 456)으로서, 또한 예시된다. 이것은, 블록 명령어(420), 대응하는 명령어 윈도우 엔트리, 및 명령어에 의해 표현되는 기저의 데이터플로우 그래프 사이의 관련성(correspondence)을 예시한다. 여기서, 디코딩된 명령어 READ(430) 및 READ(431)는, 그들이 입력 의존성이 없기 때문에, 발행할 준비가 되어 있다. 그들이 발행되고 실행됨에 따라, 레지스터(R6 및 R7)로부터 판독되는 값은 ADD(432)의 우측 및 좌측 피연산자 버퍼에 기록되어, ADD(432)의 좌측 및 우측 피연산자를 "준비(ready)"로 마킹한다. 결과적으로, ADD(432) 명령어는 준비가 완료되고, ALU로 발행되고, 실행되며, 합계는 TLEI(433)의 좌측 피연산자에 기록된다.
비교로서, 종래의 비순차 RISC 또는 CISC 프로세서는, 추가적인 하드웨어 복잡도, 전력, 면적을 사용하고 클록 주파수 및 성능을 감소시면서, 런타임으로 의존성 그래프를 동적으로 구축할 것이다. 그러나, 의존성 그래프는 컴파일 시간에 정적으로 알려지며 EDGE 컴파일러는 ISA를 통해 명령어 사이의 생성자-소비자 관계를 직접적으로 인코딩할 수 있어서, 그 관계를 동적으로 재발견하는 것으로부터 마이크로아키텍쳐를 자유롭게 한다. 이것은 더 간단한 마이크로아키텍쳐를 잠재적으로 가능하게 하여, 면적, 전력을 감소시키고 주파수 및 성능을 향상시킬 수 있다.
VII. 예시적인 블록 기반의 명령어 포맷
도 5는, 명령어 헤더(510), 일반적 명령어(520), 및 분기 명령어(530), 로드 명령어(540), 및 저장 명령어(550)에 대한 명령어 포맷의 일반화된 예를 예시하는 도면이다. 명령어 헤더 또는 명령어의 각각은 비트의 수에 따라 라벨링된다. 예를 들면, 명령어 헤더(510)는 네 개의 32 비트 워드를 포함하고 그것의 최하위 비트(least significant bit; lsb)(비트 0)로부터 그것의 최상위 비트(most significant bit; msb)(비트 127)까지 라벨링된다. 도시되는 바와 같이, 명령어 헤더는 기록 마스크 필드, 저장 마스크 필드, 다수의 종료 타입 필드(exit type field), 다수의 실행 플래그 필드(X 플래그), 명령어 블록 사이즈 필드, 및 명령어 헤더 ID 비트(명령어 헤더의 최하위 비트)를 포함한다.
실행 플래그 필드는 특별한 명령어 실행 모드를 나타낼 수 있다. 예를 들면, "분기 금지 예측기(inhibit branch predictor)" 플래그는, 플래그가 설정되는 경우, 명령어 블록에 대한 분기 예측을 금지하기 위해 사용될 수 있다. 다른 예로서, "메모리 의존성 예측 금지(inhibit memory dependence prediction)" 플래그는, 플래그가 설정되는 경우, 명령어 블록에 대한 메모리 의존성 예측을 금지하기 위해 사용될 수 있다. 다른 예로서, 명령어 블록이 커밋될 때 명령어 스레드를 정지시키고 인터럽트를 발생시키기 위해, "블록 이후 중지(break after block)" 플래그가 사용될 수 있다. 다른 예로서, 명령어 블록 헤더가 디코딩되는 경우 그리고 명령어 블록의 명령어가 실행되기 이전에 명령어 스레드를 정지시키고 인터럽트를 발생시키기 위해 "블록 이전 중지(break before block)" 플래그가 사용될 수 있다.
종료 타입 필드는, 명령어 블록 내에 인코딩되는 동기화 명령어 및/또는 제어 플로우의 타입을 나타내기 위해 사용될 수 있는 데이터를 포함한다. 예를 들면, 종료 타입 필드는, 명령어 블록이 다음 중 하나 이상을 포함한다는 것을 나타낼 수 있다: 순차 분기 명령어, 오프셋 분기 명령어, 간접 분기 명령어, 호출 명령어, 리턴 명령어, 및/또는 중지 명령어(break instruction). 몇몇 예에서, 분기 명령어는, 상대 및/또는 절대 어드레스를 포함하는, 그리고 조건부 또는 무조건부 술어를 사용하는, 명령어 블록 사이에서 제어 플로우를 전달하기 위한 임의의 제어 플로우 명령어일 수 있다. 종료 타입 필드는, 암시적 제어 플로우 명령어를 결정하는 것 외에도, 분기 예측 및 투기적 실행을 위해 사용될 수 있다. 몇몇 예에서, 최대 여섯 개의 종료 타입이 종료 타입 필드에서 인코딩될 수 있고, 필드와 대응하는 명시적 또는 암시적 제어 플로우 명령어 사이의 관련성은, 예를 들면, 명령어 블록에서 제어 플로우 명령어를 검사하는 것에 의해 결정될 수 있다.
예시된 일반적 블록 명령어(520)는 하나의 32 비트 워드로서 저장되고, 연산코드 필드, 술어 필드, 옵션 사항의 브로드캐스트 ID 필드(broadcast ID field; BID), 제1 타겟 필드(T1) 및 제2 타겟 필드(T2)를 포함한다. 타겟 필드보다 더 많은 소비자를 갖는 명령어의 경우, 컴파일러는 이동 명령어를 사용하여 팬아웃 트리(fanout tree)를 구축할 수 있거나, 또는 그것은 브로드캐스트에 높은 팬아웃 명령어를 할당할 수 있다. 브로드캐스트는 경량 네트워크를 통한 코어 내의 임의의 수의 소비자 명령어(consumer instruction)로의 피연산자 전송을 지원한다. 브로드캐스트 식별자는 일반적 블록 명령어(520)에서 인코딩될 수 있다.
일반적인 명령어(520)에 의해 개설되는 일반적인 명령어 포맷이 블록 기반의 프로세서에 의해 프로세싱되는 명령어의 일부 또는 전부를 나타낼 수 있지만, ISA의 특정한 예에 대해서 조차도, 명령어 필드 중 하나 이상이 특정한 명령어에 대한 일반적인 포맷으로부터 벗어날 수도 있다는 것이 기술 분야에서 숙련된 자에 의해 쉽게 이해될 것이다. 연산코드 필드는 명령어(520)의 길이 또는 폭 및 명령어(520)에 의해 수행되는 동작(들), 예컨대 메모리 로드/저장, 레지스터 판독/기록, 가산, 감산, 승산, 제산, 시프트, 회전, 무효화, 시스템 동작, 또는 다른 적절한 명령어를 명시한다.
술어적 명령어는, 명령어와 관련되는 결과가 술어 테스트 값과 매치하는지의 여부에 기초하여 조건부로 실행하는 명령어이다. 술어 필드는, 명령어가 실행될 조건을 명시한다. 예를 들면, 술어 필드는 "참" 값을 명시할 수 있고 명령어는, 대응하는 조건 플래그가 명시된 술어 값과 매치하는 경우에만 실행될 것이다. 몇몇 예에서, 술어 필드는, 적어도 부분적으로, 필드, 피연산자, 또는 술어를 비교하기 위해 사용되는 다른 리소스를 명시하고, 한편, 다른 예에서, 실행은 이전 명령어(예를 들면, 명령어 블록 내의 선행하는 명령어)에 의해 설정되는 플래그에 입각한다. 몇몇 예에서, 술어 필드는, 명령어가 항상 실행될 것이다는 것, 또는 절대 실행되지 않을 것이다는 것을 명시할 수 있다. 따라서, 술어 필드의 사용은, 분기 명령어의 수를 감소시키는 것에 의해 더 조밀한 오브젝트 코드, 향상된 에너지 효율성, 및 향상된 프로세서 성능을 허용할 수 있다.
술어적 명령어의 특정한 예로서, 결과는 다른 명령어로부터 술어적 명령어의 피연산자로 전달될 수 있고, 술어 테스트 값은 술어적 명령어의 필드에서 인코딩될 수 있다. 특정한 예로서, 명령어(520)는 술어 필드(PR)의 하나 이상의 비트가 넌제로인 경우의 술어적 명령어일 수 있다. 예를 들면, 술어 필드는 2 비트 폭일 수 있는데, 하나의 비트는 명령어가 술어적이다는 것을 나타내기 위해 사용되고 하나의 비트는 술어 테스트 값을 나타내기 위해 사용된다. 구체적으로, 인코딩 "00"은 명령어(520)가 비술어적이다는 것을 나타낼 수 있고; "10"은 명령어(520)가 거짓 조건(예를 들면, 술어 테스트 값이 "0"임)에 입각한다는 것을 나타낼 수 있고; "11"은 명령어(520)가 참 조건(예를 들면, 술어 테스트 값이 "0"임)에 입각한다는 것을 나타낼 수 있고; 및 "10"은 예약될 수 있다. 따라서, 2 비트 술어 필드는 수신된 결과를 참 또는 거짓 조건에 비교하기 위해 사용될 수 있다. 더 넓은 술어 필드는 수신된 결과를 더 큰 수와 비교하기 위해 사용될 수 있다.
다른 예에서, 술어 테스트 값에 비교될 결과는 하나 이상의 브로드캐스트 피연산자 또는 채널을 통해 명령어로 전달될 수 있다. 술어의 브로드캐스트 채널은 브로드캐스트 식별자 필드(broadcast identifier field; BID)를 사용하여 명령어(520) 내에서 식별될 수 있다. 예를 들면, 브로드캐스트 식별자 필드는, 술어 테스트 값에 비교될 값을 수신할 네 개의 가능한 브로드캐스트 채널을 인코딩하기 위해 2 비트 폭일 수 있다. 특정한 예로서, 식별된 브로드캐스트 채널 상에서 수신되는 값이 술어 테스트 값과 매치하면, 명령어(520)는 실행된다. 그러나, 식별된 브로드캐스트 채널 상에서 수신되는 값이 술어 테스트 값과 매치하지 않으면, 명령어(520)는 실행되지 않는다.
타겟 필드(T1 및 T2)는 블록 기반의 명령어의 결과가 전송되는 타겟을 명시할 수 있다. 타겟은, 명령어 블록 내의 다른 명령어의 피연산자 및 레지스터 파일의 레지스터를 포함할 수 있다. 레지스터 파일의 개개의 레지스터는 레지스터 식별자(register identifier; RID)를 사용하여 식별될 수 있다. 하나의 예로서, 명령어 슬롯 5에 있는 ADD 명령어는, 그것의 계산된 결과가 슬롯 3 및 10에 있는 명령어로 전송될 것이다는 것을 명시할 수 있다. 다른 예로서, 명령어 슬롯 5에 있는 ADD 명령어는, 그것의 계산된 결과가 레지스터 파일의 RID = 10(레지스터 10 또는 R10)을 갖는 레지스터로 전송될 것이다는 것을 명시할 수 있다. 특정한 명령어 및 ISA에 따라, 예시된 타겟 필드 중 하나 또는 둘 모두는 다른 정보에 의해 대체될 수 있다, 예를 들면, 제1 타겟 필드(T1)는 즉시 피연산자, 추가적인 연산코드에 의해 대체될 수 있고, 두 개의 타겟을 명시할 수 있고, 등등일 수 있다.
분기 명령어(530)는 연산코드 필드, 술어 필드, 브로드캐스트 ID 필드(BID), 및 오프셋 필드를 포함한다. 연산코드 및 술어 필드는 일반적인 명령어에 관해 설명되는 되는 바와 같이 포맷 및 기능에서 유사하다. 오프셋은 네 개의 명령어의 단위로 표현될 수 있고, 따라서 분기가 실행될 수 있는 메모리 어드레스 범위를 확장시킨다. 일반적 명령어(520) 및 분기 명령어(530)로 도시되는 술어는, 명령어 블록 내에서 추가적인 분기화를 방지하기 위해 사용될 수 있다. 예를 들면, 특정한 명령어의 실행은 이전 명령어의 결과에 입각할 수 있다(예를 들면, 두 개의 피연산자의 비교). 술어가 거짓이면, 명령어는 특정한 명령어에 의해 계산되는 값을 커밋하지 않을 것이다. 술어 값이 필수 술어와 매치하지 않으면, 명령어가 실행되지 않는다. 예를 들면, 거짓 술어 값을 전송받으면, BRO_F(술어적 거짓) 명령어가 발행될 것이다.
본원에서 사용될 때, 용어 "분기 명령어"는 프로그램 실행을 상대적인 메모리 위치로 변경하는 것으로 제한되는 것이 아니라, 절대 또는 상징적 메모리 위치로의 점프, 서브루틴 호출 및 리턴, 및 실행 플로우를 수정할 수 있는 다른 명령어를 또한 포함한다는 것이 쉽게 이해되어야 한다. 몇몇 예에서, 실행 플로우는 시스템 레지스터의 값(예를 들면, 프로그램 카운터(PC) 또는 명령어 포인터)을 변경하는 것에 의해 수정되고, 한편, 다른 예에서, 실행 플로우는 메모리 내의 지정된 위치에 저장되는 값을 수정하는 것에 의해 변경될 수 있다. 몇몇 예에서, 레지스터에 저장되어 있는 메모리 위치로 점프하기 위해, 점프 레지스터 분기 명령어가 사용된다. 몇몇 예에서, 서브루틴 호출 및 리턴은, 각각, 점프와 링크 및 점프 레지스터 명령어를 사용하여 구현된다.
로드 명령어(540)는, 데이터가 프로세서 코어에 의해 사용될 수 있도록, 메모리의 타겟 어드레스에 저장되어 있는 데이터를 검색하기 위해 사용된다. 데이터의 대상 어드레스는 런타임에서 동적으로 계산될 수 있다. 예를 들면, 어드레스는 로드 명령어(540)의 피연산자 및 로드 명령어(540)의 즉시 필드(immediate field )의 합일 수 있다. 다른 예로서, 어드레스는 로드 명령어(540)의 피연산자와 로드 명령어(540)의 부호 확장되고 및/또는 시프트된 즉시 필드의 합일 수 있다. 다른 예로서, 데이터의 어드레스는 로드 명령어(540)의 두 피연산자의 합일 수 있다. 로드 명령어(540)는, 명령어 블록 내의 로드의 상대적인 프로그램 순서화를 제공하기 위해 로드-저장소 식별자 필드(load-store identifier field; LSID)를 포함할 수 있다. 예를 들면, 컴파일러는 컴파일시에 명령어 블록의 각각의 로드 및 저장에 LSID를 할당할 수 있다. ISA는 명령어 블록당 로드 및 저장 명령어의 최대 수를 명시할 수 있다. LSID 필드의 비트 폭은, 명령어 블록의 상이한 로드 및 저장 명령어 모두를 고유하게 식별하도록 사이즈가 정해질 수 있다. 예를 들면, LSID 필드의 5 비트 폭은 25 또는 32 개의 고유한 로드 및 저장 명령어를 고유하게 식별할 수 있다.
로드 명령어(540)는 검색될 및/또는 포맷화될 다양하고 상이한 양 및 타입의 데이터를 명시할 수 있다. 예를 들면, 데이터는 부호가 있는 또는 부호가 없는 값으로 포맷화될 수 있고 검색되는 데이터의 양 또는 사이즈는 변할 수 있다. 예를 들면, 로드 무부호 바이트(load unsigned byte), 로드 유부호 바이트(load signed byte), 로드 더블 워드, 로드 무부호 하프 워드, 로드 유부호 하프 워드, 로드 무부호 워드, 및 로드 유부호 워드와 같은 로드 명령어(540)의 타입을 식별하기 위해 상이한 연산코드가 사용될 수 있다. 로드 명령어(540)의 출력은 타겟 필드(TO)에 의해 나타내어지는 바와 같은 타겟 명령어로 지향될 수 있다. 로드 명령어(540)는 술어 필드 및/또는 브로드캐스트 식별자 필드를 사용하여 명령어(520)와 유사하게 술어적일 수 있다.
32 비트 로드 명령어(540)의 특정한 예로서, 연산코드 필드는 비트 [31:25]에서 인코딩될 수 있고; 술어 필드는 비트 [24:23]에서 인코딩될 수 있고; 브로드캐스트 식별자 필드는 비트 [22:21]에서 인코딩될 수 있고; LSID 필드는 비트 [20:16]에서 인코딩될 수 있고; 즉시 필드는 비트 [15: 9]에서 인코딩될 수 있고; 그리고 타겟 필드는 비트 [8: 0]에서 인코딩될 수 있다.
저장 명령어(550)는 메모리의 타겟 어드레스에 데이터를 저장하기 위해 사용된다. 데이터의 대상 어드레스는 런타임에서 동적으로 계산될 수 있다. 예를 들면, 어드레스는 저장 명령어(550)의 제1 피연산자 및 저장 명령어(550)의 즉시 필드의 합일 수 있다. 다른 예로서, 어드레스는 저장 명령어(550)의 피연산자와 저장 명령어(550)의 부호 확장된 및/또는 시프트된 즉시 필드의 합일 수 있다. 다른 예로서, 데이터의 어드레스는 저장 명령어(550)의 두 개의 피연산자의 합일 수 있다. 저장 명령어(550)는, 명령어 블록 내에서의 저장물의 상대적인 프로그램 순서화를 제공하기 위한 로드-저장 식별자 필드(LSID)를 포함할 수 있다. 저장될 데이터의 양은, 예를 들면, 저장 바이트, 저장 하프 워드, 저장 워드, 및 저장 더블 워드와 같은, 저장 명령어(550)의 연산코드에 기초하여 변할 수 있다. 메모리 위치에 저장될 데이터는 저장 명령어(550)의 제2 피연산자로부터 입력될 수 있다. 제2 피연산자는 다른 명령어에 의해 생성될 수 있거나 또는 저장 명령어(550)의 필드로서 인코딩될 수 있다. 저장 명령어(550)는 술어 필드 및/또는 브로드캐스트 식별자 필드를 사용하여 명령어(520)와 유사하게 술어적일 수 있다.
32 비트 저장 명령어(550)의 특정한 예로서, 연산코드 필드는 비트 [31:25]에서 인코딩될 수 있고; 술어 필드는 비트 [24:23]에서 인코딩될 수 있고; 브로드캐스트 식별자 필드는 비트 [22:21]에서 인코딩될 수 있고; LSID 필드는 비트 [20:16]에서 인코딩될 수 있고; 그리고 즉시 필드는 비트 [15:9]에서 인코딩될 수 있다. 비트 [8:1]은 추가적인 기능을 위해 또는 미래의 사용을 위해 예약될 수 있다.
술어적 명령어의 사용은, 명령어 중 일부가 실행되지 않는 조건으로 이어질 수 있다. 예를 들면, 명령어의 제1 그룹은 참 값에 입각할 수 있고 명령어의 제2 그룹은 거짓 값에 입각할 수 있다. 따라서, 변수가 참 및 거짓 둘 모두일 수는 없기 때문에, 명령어의 그룹 중 하나만이 실행될 수 있다. 하나의 실시형태에서, 컴파일러는 명령어 블록이 완료하기 위한 소정의 조건을 식별할 수 있다. 예를 들면, 컴파일러는, 명령어 블록에 의해 실행될 수도 있는 모든 저장 명령어를 식별하는 저장 마스크 및 명령어 블록에 의해 실행될 수도 있는 모든 레지스터 기록 명령어를 식별하는 기록 마스크를 생성할 수 있다. 식별된 저장 및/또는 기록 명령어는 실행 동안 추적될 수 있다. 그러나, 명령어의 상이한 그룹은 상이한 수의 추적된 명령어 또는 상이한 타겟을 포함할 수도 있다. 특정한 예로서, 명령어 블록은 레지스터 1, 6 및 8에 기록될 수도 있다. 술어적 명령어의 제1 그룹은, 레지스터 1 및 6에 기록되는 명령어를 포함할 수 있고, 술어적 명령어의 제2 그룹은, 레지스터 8에 기록되는 명령어를 포함할 수 있다. 제1 그룹과 제2 그룹은 상호 배타적일 수 있고, 따라서, 제1 그룹이 실행되면, 레지스터 1과 6만이 기록되고 제2 그룹이 실행되면, 레지스터 8만이 기록된다. 레지스터 1, 6 및 8 모두가 기록될 것을 예상한 추적 로직은, 매치하지 않는 값에 입각하는 레지스터는 실행되지 않을 것이다는 것을 추적 로직에게 통지하기 위한 추가적인 액션이 취해지지 않는 한, 영원히(또는 타임아웃까지) 대기할 것이다.
예컨대 명령어가 매치하지 않는 값에 입각하는 경우, 로드 또는 저장 명령어 또는 레지스터 판독 또는 기록이 실행되지 않을 것이다는 것을 나타내기 위해 무효화 명령어(nullify instruction)가 사용될 수 있다. 구체적으로, 무효화 명령어는, 특정한 LSID 또는 IID에 대응하는 로드 또는 저장 명령어를 취소하는 효과를 가질 수 있다. 예를 들면, 무효화 명령어는, 그들의 LSID 또는 IID에 의해 식별되는 하나 이상의 로드 명령어를 타겟으로 할 수 있다. 따라서, 무효화 명령어는 특정한 LSID 또는 IID를 갖는 로드 또는 저장 명령어를 실행하기 위한 대용물(substitute)일 수 있다. 추가적으로, 무효화 명령어는 특정한 RID에 대응하는 타겟을 갖는 명령어를 취소하는 효과를 가질 수 있다. 예를 들면, 무효화 명령어는, 그들의 RID 또는 IID에 의해 식별되는 하나 이상의 명령어를 타겟으로 할 수 있다. 따라서, 무효화 명령어는 특정한 RID를 타겟으로 하는 명령어를 실행하기 위한 대용물일 수 있다.
하나의 예로서, 무효화 명령어는 일반적 블록 명령어(520)의 포맷을 사용하여 인코딩될 수 있다. 무효화 명령어는, 실행되지 않을 명령어를 타겟으로 할 수 있다. 비실행 명령어(non-executing instruction)가 무효화 명령어로부터 널 피연산자를 수신하는 경우, 제어 로직은, 마치 비실행 명령어가 실행된 것처럼 업데이트될 수 있다. 예를 들면, 대안적 술어 값(대안적 술어적 명령어 경로)을 갖는 명령어는, 하나의 경로(예를 들면, 참 경로(true path)) 상에서 레지스터 1 및 6에 기록하는 명령어 및 다른 경로(예를 들면, 거짓 경로(false path)) 상에서 레지스터 8에 기록하는 명령어를 포함할 수 있다. 참 경로는, 그것이 레지스터 1, 6 및 8 모두가 기록된 제어 로직에게 보이게 되도록, 레지스터 8에 기록되는 명령어를 타겟으로 하는 무효화 명령어를 포함할 수 있다. 거짓 경로는, 그것이 레지스터 1, 6 및 8 모두가 기록된 제어 로직에게 보이게 되도록, 레지스터 1 및 6에 기록되는 명령어를 타겟으로 하는 하나 이상의 무효화 명령어를 포함할 수 있다. 따라서, 어떤 술어 값이 계산되고 어떤 명령어가 실행되는지에 관계 없이, 그것은, 마치 모든 레지스터가 작성된 것처럼, 나타날 수 있다.
32 비트 저장 명령어의 특정한 예로서, 연산코드 필드는 비트 [31:25]에서 인코딩될 수 있고; 술어 필드는 비트 [24:23]에서 인코딩될 수 있고; 브로드캐스트 식별자 필드는 비트 [22:21]에서 인코딩될 수 있고; 제1 타겟 필드 필드는 비트 [17:9]에서 인코딩될 수 있고; 그리고 제2 타겟 필드는 비트 [8:0]에서 인코딩될 수 있다. ISA에 따라, 타겟 필드는 특정한 IID, LSID, 또는 RID를 구비하는 명령어를 타겟으로 할 수 있다. 비트 [20:18]은 추가적인 기능을 위해 또는 미래의 사용을 위해 예약될 수 있다. 다른 예로서, 벌크 무효화 명령어(bulk-nullify instruction)는, 로드-저장 또는 레지스터 기록 명령어의 그룹을, 무효화된 명령어를 식별하기 위한 비트마스크를 사용하여, 벌크 단위로 무효화하기 위해, 마스크를 사용할 수 있다. 로드 및 저장 명령어를 무효로 할 때, 비트마스크는 비트마스크의 각각의 비트가 상이한 LSID에 대응하도록 인코딩될 수 있다. 명령어 블록이 벌크 무효화 명령어의 단일의 비트마스크 필드에 의해 지원될 수 있는 것보다 더 많은 LSID를 포함할 수 있는 경우, 벌크 무효화 명령어는 LSID의 전체 범위에 걸쳐 비트마스크를 시프트하기 위해 사용될 수 있는 마스크 시프트 필드를 포함할 수 있다. 예를 들면, 2 비트 마스크 시프트 필드 및 8 비트 비트마스크가 사용되어 32 개의 LSID의 범위를 커버할 수 있다. 특히, 각각의 명령어는 여덟 개의 LSID를 무효화할 수 있고 네 개의 상이한 명령어는 모든 32 개의 LSID를 무효화할 수 있는데, 이 경우, 각각의 명령어는 마스크 시프트 필드에서 상이한 값을 사용한다. 레지스터 파일에 대한 기록을 무효화하는 경우, 비트마스크 필드는, 비트마스크의 각각의 비트가 상이한 RID에 대응하도록 인코딩될 수 있다. 로드-저장 비트마스크에서와 같이, 레지스터 기록 비트마스크(register-write bitmask)는 비트마스크 범위를 초과하는 RID 범위를 포괄하도록 시프트될 수 있다. 32 비트 벌크 무효화 명령어의 특정한 예로서, 연산코드 필드는 비트 [31:25]에서 인코딩될 수 있고; 술어 필드는 비트 [24:23]에서 인코딩될 수 있고; 브로드캐스트 식별자 필드는 비트 [22:21]에서 인코딩될 수 있고; 레지스터 기록 마스크 시프트 필드는 비트 [20:18]에서 인코딩될 수 있고; 레지스터 기록 마스크 필드는 비트 [17:10]에서 인코딩될 수 있고; 로드-저장 마스크 시프트 필드는 비트 [9:8]에서 인코딩될 수 있고; 그리고 로드-저장 마스크 필드는 비트 [7:0]에서 인코딩될 수 있다.
VIII. 프로세서 코어의 예시적인 상태
도 6은 블록 기반의 컴퓨터의 프로세서 코어의 상태(600)의 진행의 예를 예시하는 플로우차트이다. 블록 기반의 컴퓨터는, 소프트웨어 프로그램을 실행하기(run) 위해 또는 실행하기(execute) 위해 일괄적으로 사용되는 다수의 프로세서 코어로 구성된다. 상이한 프로세서 코어는 글로벌 또는 블록 간 레지스터 파일 및/또는 메모리를 통해 값을 전달하는 것에 의해 통신할 수 있다. 프로그램은 다양한 하이 레벨 언어로 작성될 수 있고, 그 다음, 블록 기반의 프로세서를 타겟으로 하는 컴파일러를 사용하여 블록 기반의 프로세서용으로 컴파일될 수 있다. 컴파일러는, 블록 기반의 프로세서 상에서 실행될(run) 때 또는 실행될(executed) 때, 하이 레벨 프로그램에 의해 명시되는 기능성을 수행할 코드를 생성할 수 있다. 컴파일된 코드는 블록 기반의 프로세서에 의해 액세스될 수 있는 컴퓨터 판독 가능 메모리에 저장될 수 있다. 컴파일된 코드는 일련의 명령어 블록으로 그룹화되는 명령어 스트림을 포함할 수 있다. 실행(execution) 동안, 명령어 블록 중 하나 이상은 블록 기반의 프로세서에 의해 실행되어 프로그램의 기능성을 수행할 수 있다. 통상적으로, 프로그램은, 임의의 한 번에 코어 상에서 실행될 수 있는 것보다 더 많은 명령어 블록을 포함할 것이다. 따라서, 프로그램의 블록은 각각의 코어에 매핑되고, 코어는 블록에 의해 명시되는 작업을 수행하고, 그 다음, 프로그램이 완료될 때까지 각각의 코어 상의 블록은 상이한 블록으로 대체된다. 하나의 예로서, 단일의 코어가 사용되어 프로그램의 모든 블록을 실행할 수 있다. 명령어 블록 중 몇몇은, 예컨대 프로그램의 루프 또는 서브루틴 동안, 한 번보다 더 많이 실행될 수도 있다. 명령어 블록의 "인스턴스"는, 명령어 블록이 실행될 때마다 생성될 수 있다. 따라서, 명령어 블록의 각각의 반복은, 명령어 블록의 상이한 인스턴스를 사용할 수 있다. 프로그램이 실행됨에 따라, 각각의 명령어 블록은, 아키텍쳐 제약, 이용 가능한 하드웨어 리소스, 및 프로그램의 동적 플로우에 기초하여, 프로세서 코어로 매핑될 수 있고 프로세서 코어 상에서 실행될 수 있다. 프로그램의 실행 동안, 각각의 프로세서 코어는, 하나의 코어가 하나의 상태에 있을 수 있고 다른 코어가 상이한 상태에 있을 수 있도록, 상태(600)의 진행을 통해 전이할 수 있다.
상태(605)에서, 각각의 프로세서 코어의 상태는 매핑 해제될 수 있다. 매핑 해제된 프로세서 코어는, 명령어 블록의 인스턴스를 실행하도록 현재 할당되지 않은 코어이다. 예를 들면, 프로세서 코어는, 프로그램이 블록 기반의 컴퓨터 상에서 실행을 시작하기 이전에, 매핑 해제될 수 있다. 다른 예로서, 프로세서 코어는, 모든 코어가 사용되고 있는 것은 아니지만 그러나 프로그램이 실행을 시작한 이후, 매핑 해제될 수 있다. 특히, 프로그램의 명령어 블록은, 적어도 부분적으로, 프로그램의 동적 흐름에 따라 실행된다. 프로그램의 몇몇 부분은, 일반적으로는, 예컨대 더 나중의 명령어 블록이 더 이전의 명령어 블록으로부터의 결과에 의존하는 경우에, 연속적으로 또는 순차적으로 흐를 수도 있다. 프로그램의 다른 부분은, 예컨대 병렬로 실행되는 다른 블록의 결과를 사용하지 않으면서 다수의 명령어 블록이 동시에 실행될 수 있는 경우, 더 많은 병렬 흐름을 가질 수도 있다. 프로그램의 더욱 순차적인 스트림 동안 프로그램을 실행하기 위해 더 적은 코어가 사용될 수 있고 프로그램의 더 많은 병렬 스트림 동안 프로그램을 실행하기 위해 더 많은 코어가 사용될 수 있다.
상태(610)에서, 각각의 프로세서 코어의 상태는 매핑될 수 있다. 매핑된 프로세서 코어는, 명령어 블록의 인스턴스를 실행하도록 현재 할당되는 코어이다. 명령어 블록이 특정한 프로세서 코어로 매핑되는 경우, 명령어 블록은 비행 중이다. 비행 중 명령어 블록(in-flight instruction block)은, 블록 기반의 프로세서의 특정한 코어를 타겟으로 하는 블록이며, 블록은 특정 프로세서 코어 상에서, 투기적으로 또는 비투기적으로, 실행되고 있을 것이거나 또는 실행되고 있다. 특히, 비행 중 명령어 블록은, 상태(610-650)에서 프로세서 코어에 매핑되는 명령어 블록에 대응한다. 비투기적 블록은, 프로그램이 실행 명령어 블록에 의해 제공되는 작업을 사용할 것이다는 것이 블록의 매핑 동안 알려지는 경우 매핑될 수 있다. 투기적 블록은, 매핑 동안, 실행 명령어 블록에 의해 제공되는 작업을 프로그램이 사용할지 또는 사용하지 않을지의 여부가 알려지지 않는 경우에 매핑될 수 있다. 투기적으로 블록을 실행하는 것은, 예컨대, 블록의 작업이 사용될 것이다는 것이 알려진 이후 또는 알려지는 때 블록이 시작되는 경우보다 더 이전에 투기적 블록이 시작되는 경우, 성능을 잠재적으로 증가시킬 수 있다. 그러나, 투기적으로 실행하는 것은, 예컨대 투기적 작업이 프로그램에 의해 사용되지 않는 경우, 프로그램을 실행할 때 사용되는 에너지를 잠재적으로 증가시킬 수 있다.
블록 기반의 프로세서는 유한한 수의 동종 또는 이종 프로세서 코어를 포함한다. 통상적인 프로그램은, 프로세서 코어 상으로 들어갈 수 있는 것보다 더 많은 명령어 블록을 포함할 수 있다. 따라서, 프로그램의 각각의 명령어 블록은, 일반적으로, 프로그램의 다른 명령어 블록과 프로세서 코어를 공유할 것이다. 다시 말해서, 주어진 코어는 프로그램의 실행 동안 여러 개의 상이한 명령어 블록의 명령어를 실행할 수도 있다. 유한한 수의 프로세서 코어를 갖는 것은 또한, 모든 프로세서 코어가 명령어 블록을 실행하면서 사용 중이고 어떠한 새로운 코어도 디스패치에 이용 가능하지 않은 경우, 프로그램 실행이 중지될 수도 있거나 또는 지연될 수도 있다는 것을 의미한다. 프로세서 코어가 이용 가능하게 되는 경우, 명령어 블록의 인스턴스가 프로세서 코어로 매핑될 수 있다.
명령어 블록 스케줄러는, 어떤 프로세서 코어 상에서 어떤 명령어 블록이 실행될 것인지 그리고 명령어 블록이 언제 실행될 것인지를 할당할 수 있다. 매핑은 다양한 요인, 예컨대 실행을 위해 사용될 타겟 에너지, 프로세서 코어의 수 및 구성, 프로세서 코어의 현재 및/또는 이전 사용량, 프로그램의 동적 플로우, 투기적 실행이 가능하게 되었는지의 여부, 투기적 블록이 실행될 신뢰도 레벨, 및 다른 요인에 기초할 수 있다. 명령어 블록의 인스턴스는, 현재 이용 가능한 프로세서 코어(예컨대, 어떠한 명령어 블록도 그 상에서 현재 실행되고 있지 않은 경우)로 매핑될 수 있다. 하나의 실시형태에서, 명령어 블록의 인스턴스는 현재 사용 중인 프로세서 코어(예컨대, 코어가 명령어 블록의 상이한 인스턴스를 실행하고 있는 경우)로 매핑될 수 있고, 더 나중에 매핑된 인스턴스는, 더 이전 매핑된 인스턴스가 완료되는 경우에 시작할 수 있다. 하나의 실시형태에서, 명령어 블록 스케줄러의 기능성은 프로세서 코어 사이에서 분산될 수 있다.
상태(620)에서, 각각의 프로세서 코어의 상태는 페치될 수 있다. 예를 들면, 프로세서 코어의 IF 파이프라인 스테이지는 페치 상태 동안 액티브일 수 있다. 명령어 블록을 페치하는 것은, 메모리(예를 들면, L1 캐시, L2 캐시, 또는 메인 메모리)로부터 프로세서 코어로 블록의 명령어를 전송하는 것, 및 명령어가 디코딩될 수 있도록 프로세서 코어의 로컬 버퍼로부터 명령어를 판독하는 것을 포함할 수 있다 . 예를 들면, 명령어 블록의 명령어는 명령어 캐시, 버퍼, 또는 프로세서 코어의 레지스터로 로딩될 수 있다. 명령어 블록의 다수의 명령어는 동일한 클록 사이클 동안 병렬로(예를 들면, 동시에) 페치될 수 있다. 페치 상태는 다수의 사이클 길이일 수 있고 프로세서 코어가 파이프라인식으로 연결될 때 디코드(630) 및 실행(640) 상태와 중첩할 수 있다.
명령어 블록의 명령어가 프로세서 코어 상으로 로딩되는 경우, 명령어 블록은 프로세서 코어 상에서 상주한다. 명령어 블록은, 명령어 블록의, 전부는 아닌, 몇몇 명령어 블록의 명령어가 로딩될 때, 부분적으로 상주한다. 명령어 블록의 모든 명령어가 로딩되는 경우, 명령어 블록은 완전히 상주한다. 명령어 블록은, 프로세서 코어가 리셋되거나 또는 상이한 명령어 블록이 프로세서 코어 상으로 페치될 때까지, 프로세서 코어 상에 상주할 것이다. 특히, 명령어 블록은 코어가 상태(620-670)에 있을 때 프로세서 코어에서 상주한다.
상태(630)에서, 각각의 프로세서 코어의 상태는 디코딩될 수 있다. 예를 들면, 프로세서 코어의 DC 파이프라인 스테이지는 디코드 상태 동안 액티브일 수 있다. 디코드 상태 동안, 명령어 블록의 명령어는, 그들이 프로세서 코어의 명령어 윈도우의 메모리 저장소 내에 저장될 수 있도록, 디코딩되고 있다.> 특히, 명령어는 상대적으로 콤팩트한 머신 코드로부터, 프로세서 코어의 하드웨어 리소스를 제어하기 위해 사용될 수 있는 덜 콤팩트한 표현으로 변환될 수 있다. 디코드 상태 동안, 술어적 로드 및 술어적 저장 명령어가 식별될 수 있다. 디코드 상태는 다수의 사이클 길이일 수 있으며 프로세서 코어가 파이프라인식으로 연결될 때 페치(620) 및 실행(640) 상태와 중첩할 수 있다. 명령어 블록의 명령어가 디코딩된 이후, 그것은, 명령어의 모든 의존성이 충족되는 경우에 실행될 수 있다.
상태(640)에서, 각각의 프로세서 코어의 상태는 실행될 수 있다. 실행 상태 동안, 명령어 블록의 명령어가 실행되고 있다. 특히, 프로세서 코어의 EX 및/또는 LS 파이프라인 스테이지는 실행 상태 동안 액티브일 수 있다. 로드 및/또는 저장 명령어와 관련되는 데이터는 실행 상태 동안 페치 및/또는 프리페치될 수 있다. 데이터는 실행 상태 동안 판독될 수 있고 및/또는 레지스터 파일에 기록될 수 있다. 명령어 블록의 개개의 명령어는 프로그램 순서를 벗어나 실행될 수 있다. 예를 들면, 스케줄러 로직 또는 발행 로직(issue logic)은, 명령어의 피연산자가 이용 가능하게 됨에 따라, 데이터플로우 순서대로 실행될 명령어의 각각을 발행할 수 있다. 명령어를 발행하는 것은, 예컨대 명령어의 피연산자를 하나 이상의 레지스터, 실행 유닛, 또는 로드-저장 큐로 라우팅하는 것에 의해, 명령어의 실행을 시작하는 것이다.
명령어 블록은 프로세서 코어 상에서 투기적으로 또는 비투기적으로 실행될 수 있다. 비투기적 블록은, 취해진 제어 경로를 따라 실행되고 있는 (프로그램 순서에서) 가장 오래된 커밋되지 않은(non-committed) 명령어 블록이다. 비병렬(예를 들면, 단일의 스레드) 코드의 경우, 단지 하나의 비투기적 명령어 블록이 존재할 수 있다. 병렬(예를 들면, 멀티 스레드) 코드의 경우, 스레드당 하나의 비투기적 명령어 블록이 존재할 수 있다. 비투기적 블록이 완료될 수 있으면, 비투기적 블록으로부터의 작업이 사용될 것이다. 예를 들면, 블록의 명령어 중 하나에서 예외 처리(예컨대, 제로에 의한 제산 또는 페이지 오류(page-fault))가 있는 경우, 비투기적 블록이 완료되지 못할 수도 있다. 비투기적 명령어 블록이 예외 처리로 인해 종료되는 경우, 프로세서는 중단 상태(abort state)로 전환될 수 있다.
투기적 블록은, 자신의 작업이 프로그램에 의해 사용될 수도 있는 또는 사용되지 않을 수도 있는 커밋되지 않은 명령어 블록이다. 예를 들면, 투기적 블록은, 프로그램의 예측된 제어 플로우에 기초하여 매핑 및 실행될 수 있다. 투기적 블록을 포함하는 제어 경로가 잘못 예측되면, 투기적 블록은 종료될 수 있고(블록의 작업은 폐기될 수 있고), 프로세서 코어는 중단 상태로 전환될 수 있다. 그러나, 제어 경로가 정확하게 예측되면, 투기적 블록은, (프로그램 순서에서) 선행하는 명령어 블록이 커밋 단계로 전환될 때, 비투기적 블록으로 변환될 수 있다. 블록을 투기적으로 실행하는 것은, 프로그램을 실행하는 속도를 증가시킬 수도 있지만 그러나 비투기적 실행만이 사용되는 경우보다 더 많은 에너지를 또한 사용할 수도 있다.
명령어 블록은 다양하고 상이한 조건이 충족되는 경우에 완료될 수 있다. 예를 들면, 블록의 모든 레지스터 기록이 버퍼링되고, 메모리에 대한 모든 기록이 로드-저장 큐에 버퍼링되고, 그리고 분기 타겟이 계산된다는 것이 결정되는 경우, 명령어 블록이 완료될 수 있다. 실행 상태는 다수의 사이클 길이일 수 있으며 프로세서 코어가 파이프라인식으로 연결될 때 페치(620) 및 디코드(630) 상태와 중첩할 수 있다. 명령어 블록이 완료되고 비투기적인 경우, 프로세서는 완료 상태로 전이할 수 있다. 명령어 블록이 비투기적이다는 것(예를 들면, 블록의 작업이 사용될 것이다는 것) 및 명령어 블록이 완료된다는 것이 결정되는 경우 명령어 블록이 커밋될 수 있다.
상태(650)에서, 각각의 프로세서 코어의 상태는 커밋 또는 중단될 수 있다. 커밋 동안, 명령어 블록의 명령어의 작업은, 다른 블록이 명령어의 작업을 사용할 수 있도록, 원자적으로 커밋될 수 있다. 특히, 커밋 상태는, 로컬하게 버퍼링된 아키텍쳐 상태가 다른 프로세서 코어에게 보이는 또는 다른 프로세서 코어에 의해 액세스 가능한 아키텍쳐 상태로 작성되는 커밋 단계를 포함할 수 있다. 하나의 예로서, 메모리로의 저장은 블록의 실행 동안 로드-저장 큐에 버퍼링될 수 있고, 저장물은 커밋 단계 동안 메모리에 기록될 수 있다. 가시적인 아키텍쳐 상태가 업데이트되면, 커밋 신호가 발행될 수 있고 프로세서 코어는, 다른 명령어 블록이 프로세서 코어 상에서 실행될 수 있도록, 해제될 수 있다. 대안적으로, 커밋 단계는 다음 블록의 실행과 중첩될 수 있고 로드-저장 큐는 메모리의 일관된 뷰를 유지하기 위해 사용될 수 있다. 예를 들면, 메모리 일관성은, 심지어, 커밋된 블록으로부터의 저장물이 메모리에 여전히 기록되고 있는 동안에도, (로드-저장 큐에 버퍼링되어 있는) 저장 데이터를 커밋된 블록으로부터 실행 블록으로 포워딩하는 것에 의해 유지될 수 있다.
중단 상태 동안, 임의의 커밋되지 않은 상태가 커밋된 상태로 롤백될 수 있다. 코어의 파이프라인의 전체 또는 일부는 동적 전력 손실을 감소시키기 위해 정지될 수 있다. 몇몇 애플리케이션에서, 코어는 정적 전력 소비를 감소시키도록 전력이 게이트 제어될 수 있다. 커밋/중단 상태의 종결과 또는 종결에서 중첩하면, 프로세서 코어는 프로세서 코어 상에서 실행될 새 명령어 블록을 수신할 수 있거나, 코어는 리프레시될 수 있거나, 코어는 아이들 상태로 될 수 있거나, 또는 코어는 리셋될 수 있다.
상태(660)에서, 프로세서 코어 상에 상주하는 명령어 블록이 리프레시될 수 있는지가 결정될 수 있다. 본원에서 사용될 때, 명령어 블록 리프레시 또는 프로세서 코어 리프레시는, 프로세서 코어가, 프로세서 코어 상에 상주하는 하나 이상의 명령어 블록을 재실행하는 것을 가능하게 하는 것을 의미한다. 하나의 실시형태에서, 코어를 리프레시하는 것은 하나 이상의 명령어 블록에 대한 액티브 준비 상태를 리셋하는 것을 포함할 수 있다. 명령어 블록이 루프 또는 반복된 서브루틴의 일부인 경우 또는 투기적 블록이 종료되어 재실행되어야 하는 경우, 동일한 프로세서 코어 상에서 명령어 블록을 재실행하는 것이 바람직할 수도 있다. 리프레시하려는 결정은, 프로세서 코어 그 자체에 의해(연속적인 재사용) 또는 프로세서 코어 외부에 의해(비연속적인 재사용) 이루어질 수 있다. 예를 들면, 리프레시하려는 결정은 명령어 블록 스케줄링을 수행하는 제어 코어 또는 다른 프로세서 코어로부터 유래할 수 있다. 상이한 코어 상에서 명령어 블록을 실행하는 것과는 대조적으로 이미 명령어를 실행한 코어 상에서 명령어 블록이 리프레시되는 경우 잠재적인 에너지 절약이 있을 수 있다. 에너지는 명령어 블록의 명령어를 페치 및 디코딩하기 위해 사용되지만, 그러나 리프레시된 블록은 이들 상태를 우회하는 것에 의해 페치 및 디코드 상태에서 사용되는 에너지의 대부분을 절약할 수 있다. 특히, 리프레시된 블록은, 명령어가 코어에 의해 이미 페치되고 디코딩되었기 때문에, 실행 상태(640)에서 재시작할 수 있다. 블록이 리프레시되는 경우, 디코딩된 명령어 및 디코딩된 준비 상태는, 액티브 준비 상태가 클리어되는 동안, 유지될 수 있다. 명령어 블록을 리프레시하려는 결정은 커밋 동작의 일부로서 또는 더 나중에 발생할 수 있다. 명령어 블록이 리프레시되지 않으면, 프로세서 코어는 아이들 상태로 될 수 있다.
상태(670)에서, 각각의 프로세서 코어의 상태는 아이들 상태일 수 있다. 블록 기반의 프로세서의 성능 및 전력 소비는, 주어진 시간에 액티브인 프로세서 코어의 수에 기초하여 부분적으로 조정 또는 절충될 수 있다. 예를 들면, 동시에 실행하는 코어 상에서 투기적 작업을 수행하는 것은 계산의 속도를 증가시킬 수도 있지만 그러나 투기적인 오예측률이 높으면 전력을 증가시킬 수도 있다. 다른 예로서, 더 이전에 실행된 명령어 블록을 커밋하거나 또는 중단한 이후 즉시 새로운 명령어 블록을 프로세서에 할당하는 것은, 동시에 실행하는 프로세서의 수를 증가시킬 수도 있지만, 그러나 프로세서 코어 상에 상주한 명령어 블록을 재사용할 기회를 감소시킬 수도 있다. 아이들 상태의 프로세서 코어의 캐시 또는 풀이 유지되면, 재사용은 증가될 수도 있다. 예를 들면, 프로세서 코어가 공통적으로 사용되는 명령어 블록을 커밋하는 경우, 프로세서 코어는, 동일한 명령어 블록이 실행되어야 하는 다음 시간에 코어가 리프레시될 수 있도록, 아이들 풀(idle pool) 내에 배치될 수 있다. 상기에서 설명되는 바와 같이, 프로세서 코어를 리프레시하는 것은, 상주 명령어 블록을 페치 및 디코딩하기 위해 사용되는 시간 및 에너지를 절약할 수 있다. 아이들 캐시에 배치할 명령어 블록/프로세서 코어는, 컴파일러에 의해 수행되는 정적 분석 또는 명령어 블록 스케줄러에 의해 수행되는 동적 분석에 기초하여 결정될 수 있다. 예를 들면, 명령어 블록의 잠재적 재사용을 나타내는 컴파일러 힌트가 블록의 헤더 내에 배치될 수 있고, 명령어 블록 스케줄러는, 명령어 블록을 커밋한 이후 블록이 아이들 상태로 될 것인지 또는 상이한 명령어 블록에 재할당될 것인지를 결정하기 위해 힌트를 사용할 수 있다. 아이들 상태인 경우, 프로세서 코어는, 예를 들면, 동적 전력 소비를 감소시키기 위해 저전력 상태에 놓일 수 있다.
상태(680)에서, 아이들 상태 프로세서 코어 상에 상주하는 명령어 블록이 리프레시될 수 있는지가 결정될 수 있다. 코어가 리프레시되어야 하면, 블록 리프레시 신호는 어써트될(asserted) 수 있고 코어는 실행 상태(640)로 전이할 수 있다. 코어가 리프레시되지 않을 것이면, 블록 리셋 신호는 어써트될 수 있고, 코어는 매핑되지 않은 상태(605)로 전이할 수 있다. 코어가 리셋되는 경우, 명령어 블록 스케줄러가 새로운 명령어 블록을 코어에 할당할 수 있도록, 코어는 다른 매핑되지 않은 코어와 함께 풀에 놓일 수 있다.
IX. 트랜잭션 레지스터 파일을 포함하는 예시적인 아키텍쳐
도 7은 블록 기반의 프로세서에 대한 프로그램의 명령어(700)의 예시적인 스니펫을 예시한다. 프로그램은, 명령어 블록(710-712)과 같은 명령어의 다수의 블록을 포함할 수 있다. 명령어 블록(710-712)의 프로그램 순서는, 프로세서 상태 및 프로그램의 제어 명령문(control statement)에 기초하여 런타임에서 동적으로 결정된다. 예시되는 바와 같이, 블록(710) 다음에는 블록(711)이 후속되고, 블록(711) 다음에는 712가 후속된다. 명령어 블록은, 그룹으로서 실행될 명령어를 포함할 수 있다. 예를 들면, 주어진 명령어 블록은, 타겟으로 된 컴퓨터의 하드웨어 리소스 및 ISA의 제약 내에서 명령어 블록이 실행될 수 있는 한, 단일의 기본 블록, 기본 블록의 일부분, 또는 다수의 기본 블록을 포함할 수 있다. 기본 블록은, 제어가 블록의 제1 명령어에서만 블록에 진입할 수 있고 제어가 기본 블록의 마지막 명령어에서만 블록을 떠날 수 있는 코드의 블록이다. 따라서, 기본 블록은 함께 실행되는 명령어의 시퀀스이다. 다수의 기본 블록은, 명령어 블록 내 분기(intra-instruction-block branch)가 데이터플로우 명령어로 변환될 수 있도록, 술어적 명령어를 사용하여 단일의 명령어 블록으로 결합될 수 있다.
프로그램 순서에서 더 이전의 명령어 블록은, 메모리로 또는 글로벌 또는 트랜잭션 레지스터 파일로 데이터를 기록하는 것에 의해, 프로그램 순서에서 더 나중의 명령어 블록으로 정보를 전달할 수 있다. 예를 들면, 레지스터 파일은, 인덱스 또는 레지스터 식별자(RID)를 사용하여 액세스될 수 있는 다수의 레지스터를 포함할 수 있다. 특정한 예로서, 레지스터 파일은 32 개의 레지스터를 포함할 수 있고, 레지스터는 인덱스 0 내지 31을 사용하여 액세스될 수 있다. 특정한 인덱스를 갖는 레지스터는 인덱스와 사슬 연결되는 "R"로서 칭해질 수 있고, 그 결과 인덱스 0에서의 레지스터는 R0으로서 칭해질 수 있다. 명령어 블록(710-712)의 각각은, 레지스터를 판독하기 위한 그리고 레지스터에 기록하기 위한 명령어를 포함할 수 있다. 예시된 ISA에서, "판독" 명령어는, 글로벌 또는 블록 간 레지스터 파일로부터 판독하는 유일한 명령어이지만; 그러나 임의의 명령어는 글로벌 레지스터 파일의 레지스터를 타겟으로 삼을 수 있다(예를 들면, 그 레지스터에 기록할 수 있다). 레지스터 파일의 레지스터 X에 대한 기록은, 명령어의 타겟 필드에서 "W[RX]"를 갖는 것에 의해 나타내어지는데, 여기서 X는 레지스터의 인덱스이다. 더 이전 명령어는 특정 레지스터에 기록하는 것에 의해 더 나중의 명령어 블록에 값을 전달할 수 있고, 더 나중의 명령어 블록은 특정한 레지스터를 판독하는 것에 의해 값을 수신할 수 있다. 특정한 예로서, 명령어 블록(710)의 명령어(720)는 레지스터(R0)를 사용하여 명령어 블록(711)의 명령어(721)에 값을 전달할 수 있다. 값은, 전송기(sender)와 수신기 사이 내에서 명령어 블록을 사용하지 않고도 더 나중의 명령어 블록으로 전달될 수 있다. 예를 들면, 명령어 블록(710)의 명령어(730)는 레지스터(R6)를 사용하여 (명령어 블록(711)을 스킵하면서) 명령어 블록(712)의 명령어(731)로 값을 전달할 수 있다. 명령어 블록(710-712)의 샘플 런(sample run)으로부터의 예시적인 값이 설명의 목적을 위해 제공된다. 도 7에서 예시되는 바와 같이, 레지스터로부터 판독될 예상 데이터는 "=>" 심볼 이후에 제시되고, 레지스터에 기록될 데이터는 "=" 심볼 이후에 제시된다.
EDGE ISA는, 명령어 블록 내의 모든 명령어가 그룹으로서 실행되도록, 프로그램의 각각의 명령어 블록이 원자적으로 실행되어야 한다는 것을 명시한다. 프로그램이 중지되거나 또는 프로그램이 인터럽트를 서비스하는 경우, 중지 지점은 블록 경계에 있을 것이고 중지 지점에서의 가시적인 아키텍쳐 상태는 완전히 완료된 명령어 블록으로부터의 업데이트만을 포함할 것이다. 따라서, EDGE ISA의 원자적 실행 모델 하에서는 명령어 블록의 부분 실행으로 인한 가시적인 아키텍쳐 상태에 대한 업데이트가 허용되지 않는다.
마이크로아키텍쳐는, 프로세서 상에서 ISA를 구현하기 위해 사용되는 하드웨어 리소스 및 동작을 명시한다. 원자 실행 모델을 구현하기 위해 사용될 수 있는 하나의 마이크로아키텍쳐는, 선행하는 명령어 블록이 완료될 때까지 하나의 명령어 블록이 실행을 시작하지 않도록, 명령어 블록이 연속적으로 실행되는 프로세서이다. 다시 말하면, 주어진 시간에 단지 하나의 명령어 블록만이 실행될 수 있다. 특히, 주어진 명령어 블록의 명령어는 주어진 프로세서 코어 상에서 실행될 수 있고 가시적인 아키텍쳐 상태는 로컬하게 버퍼링될 수 있고 그 다음 원자 트랜잭션에서 업데이트될 수 있다. 그러나, 이러한 타입의 마이크로아키텍쳐는, 다수의 명령어 블록이 동시에 실행되고 있을 수 있는 마이크로아키텍쳐와 비교하여 감소된 성능을 가질 수도 있다.
잠재적으로 더 높은 성능의 마이크로아키텍쳐는 다수의 프로세서 코어를 구비하는 프로세서를 포함할 수 있는데, 여기서 상이한 프로세서 코어는 상이한 명령어 블록을 동시에 실행할 수 있다. 예를 들면, 제1 프로세서 코어는 비투기적 명령어 블록을 실행하고 있을 수 있고, 다른 코어는 비투기적 명령어 블록보다 프로그램 순서에서 더 나중인 투기적 명령어 블록을 실행하고 있을 수 있다. 특정한 예로서, 명령어 블록(710)은 제1 프로세서 코어 상에서 실행되는 비투기적 명령어 블록일 수 있고, 명령어 블록(711-712)은 프로세서의 상이한 프로세서 코어 상에서 실행되는 투기적 명령어 블록일 수 있다. 일반적으로, 상이한 명령어 블록의 명령어는 병렬로 실행될 수 있다. 그러나, 상이한 블록 내의 몇몇 명령어는, 명령어 사이의 임의의 의존성이 충족되도록, 순서화될 수도 있다. 예를 들면, 블록이 가시적인 아키텍쳐 상태를 사용하여 통신하는 경우 블록 사이에서 의존성이 발생할 수 있다. 프로그램 순서에서 더 나중인 명령어는 의존성을 만족하는 값이 생성될 때까지 지연될 수 있다. 특정한 예로서, 더 이전의 명령어 블록 내의 명령어에 의해 기록되는 레지스터를 판독하는 명령어는, 레지스터가 기록될 때까지 지연될 수 있다. 의존성은, 명령어가 올바른 프로그램 순서로 발행되도록, 마이크로아키텍쳐의 리소스에 의해 추적될 수 있다. ISA는, 마이크로아키텍쳐를 단순화하기 위해 가시적인 아키텍쳐 상태의 액세스 패턴을 제한할 수 있다. 하나의 실시형태에서, 레지스터 파일의 주어진 레지스터는, 명령어 블록 동안 단 한번만 기록될 수 있고 주어진 레지스터의 모든 판독은 명령어 블록의 실행 이전에 저장되는 값을 리턴한다. 따라서, 레지스터 파일의 레지스터는, 단일의 명령어 블록 내의 명령어 사이에서가 아니라 명령어 블록 사이에서 값을 전달하기 위해서만 사용된다.
주어진 레지스터에 대한 판독 및 기록은, 기록 이후 판독(read-after-write; RAW), 판독 이후 기록(write-after-read; WAR), 및 기록 이후 기록(write-after-write; WAW) 의존성과 같은 데이터 의존성을 생성할 수 있다. 기록 이후 판독 의존성의 경우, 더 이전 명령어 블록 내의 레지스터에 기록되는 값은, 레지스터에 대한 중간 기록이 없는 경우, 더 나중의 명령어 블록 내의 판독 명령어에 의해 검색되어야 한다. 판독 이후 기록 의존성의 경우, 더 나중의 명령어 블록 내의 동일한 레지스터에 기록하는 명령어보다 더 이전 명령어 블록에서 발생하는 레지스터 판독 명령어는, 레지스터가 더 나중의 기록으로부터의 값으로 업데이트되기 이전에 레지스터에 저장되어 있는 값을 리턴해야만 한다. 기록 이후 기록 의존성의 경우, 더 이전의 명령어 블록 내의 제1 명령어에 의해 레지스터에 기록되는 데이터는, 더 나중의 명령어 블록 내의 제2 저장 명령어에 의해 동일한 레지스터에 기록되는 데이터에 의해 덮어쓰기되어야 한다. 하나의 실시형태에서, 명령어 블록 내에서의 판독은, 명령어 블록 내의 동일한 레지스터에 대한 판독과 기록 사이에 의존성이 없도록, 더 이전의 명령어 블록에 의해서만 생성되는 값을 사용한다. 특정한 예로서, 레지스터(RX)의 판독 명령어 및 새로운 상이한 값을 가지고 RX를 타겟으로 하는 명령어를 포함하는 블록의 경우, RX를 판독하는 명령어는, 두 개의 명령어가 메모리에서 나타나는 순서 또는 블록의 실행 동안 두 개의 명령어가 실행되는 순서에 관계 없이, 자신의 원래의 RX의 값(더 이전의 블록에 의해 생성되는 RX의 값)을 항상 획득할 것이다.
마이크로아키텍쳐는, 단일의 스레드의 다수의 명령어 블록이, 상이한 명령어 블록 사이의 의존성을 추적하면서, 동시에 실행되는 것을 가능하게 할 수 있다. 예를 들면, 명령어 블록(710)은 제1 프로세서 코어 상에서 실행되는 비투기적 명령어 블록일 수 있고, 명령어 블록(711-712) 각각은 상이한 프로세서 코어 상에서 실행되는 투기적 명령어 블록일 수 있고, 명령어 블록 모두는 동시에 실행되고 있을 수 있다. 시각적인 아키텍쳐 상태(예를 들면, 메모리 및 레지스터 파일)는, 더 이전의 명령어 블록으로부터 더 나중의 명령어 블록으로 값을 전달하기 위해 사용될 수 있다. 구체적으로, 명령어 블록(710)은 레지스터(R0, R2 및 R4)를 사용하여 명령어 블록(711)에 값을 전달할 수 있고; 명령어 블록(710)은 레지스터(R6)를 사용하여 명령어 블록(712)에 값을 전달할 수 있고; 그리고 명령어 블록(711)은 레지스터(R5 및 R7)를 사용하여 값을 명령어 블록(712)에 값을 전달할 수 있다. 비투기적 블록이 완료되고 커밋되기를 대기하는 대신, 하드웨어 리소스가 사용되어, 가시적인 아키텍쳐 상태의 초기 커밋되지 않은 값을 더 나중에 실행되는 투기적 명령어 블록으로 포워딩할 수 있다. 잘못된 투기에 기인하여 또는 예외 처리에 기인하여 명령어 블록이 중단되는 경우, 가시적인 아키텍쳐 상태가 원자 실행 모델에 따른 값만을 포함하도록, 커밋되지 않은 값은 롤백될 수 있다.
도 8 내지 도 10은, 프로그램의 명령어 블록을 실행하기 위한 다수의 프로세서 코어 및 트랜잭션 레지스터 파일을 포함하는 예시적인 컴퓨팅 시스템의 다양한 양태를 예시한다. 특히, 도 8은 트랜잭션 레지스터 파일(830A-830D)을 갖는 다수의 블록 기반의 프로세서 코어(820A-820D)를 포함하는 예시적인 컴퓨팅 시스템(800)을 예시한다. 도 9는 블록 기반의 프로세서 코어(820A-820D) 및 트랜잭션 레지스터 파일(830A-830D)의 추가적인 세부 사항을 예시한다. 도 10은 블록 기반의 프로세서 코어(820A-820D)의 예시적인 상태도를 예시한다.
도 8은 다수의 블록 기반의 프로세서 코어(820A-820D)를 포함하는 예시적인 컴퓨팅 시스템(800)을 예시한다. 컴퓨팅 시스템(800)은 블록 기반의 프로세서 코어 상에서 프로그램을 실행하기 위해 사용될 수 있다. 예를 들면, 프로그램은 명령어 블록(A-E)(또는 도 7로부터의 명령어 블록(710-712))을 포함할 수 있다. 명령어 블록(A-E)은, 프로세서(805)에 의해 액세스될 수 있는 메모리(810)에 저장될 수 있다. 프로세서(805)는, 복수의 블록 기반의 프로세서 코어(블록 기반의 프로세서 코어(820A-820D)를 포함함), 옵션 사항인 메모리 컨트롤러 및 레벨 2(L2) 캐시(840), 캐시 일관성 로직(845), 제어 유닛(850), 입력/출력(I/O) 인터페이스(860), 및 로드-저장 큐(870)를 포함할 수 있다. 예시의 용이함을 위해, 프로세서(805)의 모든 컴포넌트 사이의 모든 연결이 도시되지는 않는다는 것을 유의해야 한다. 컴포넌트 사이의 추가적인 연결이 가능하다(예를 들면, 제어 유닛(850)은 모든 프로세서 코어(820A-820D)와 통신할 수 있다). 네 개의 프로세서 코어가 도시되지만, 더 많은 또는 더 적은 프로세서 코어가 가능하다는 것을 또한 유의해야 한다. 블록 기반의 프로세서 코어(820)는, 프로그램의 명령어 및 데이터를 저장 및 검색하기 위해 사용되는 메모리 계층 구조(memory hierarchy) 또는 메모리 서브시스템과 통신할 수 있다.
메모리 계층 구조는, 메인 또는 시스템 메모리(810)에 저장되는 데이터에 액세스하는 속도를 잠재적으로 증가시키기 위해 사용될 수 있다. 일반적으로, 메모리 계층 구조는, 상이한 속도 및 사이즈를 갖는 다수의 레벨의 메모리를 포함한다. 프로세서 코어 내의 또는 프로세서 코어에 더 가까운 레벨은, 일반적으로, 프로세서 코어로부터 더 먼 레벨보다 빠르고 더 작다. 예를 들면, 메모리 계층 구조는, 프로세서 코어 내의 레벨 1(L1) 캐시, 다수의 프로세서 코어에 의해 공유되는 프로세서 내의 레벨 2(L2) 캐시, 프로세서 외부에 있는 또는 오프칩(off-chip)인 메인 또는 시스템 메모리, 및 하드 디스크 드라이브와 같은 스토리지 디바이스 상에 위치되는 백킹 저장소(backing store)를 포함할 수 있다. 메모리 계층 구조가 액세스되는 경우, 메모리 계층 구조의 더 빠른 그리고 더 가까운 레벨은, 메모리 계층 구조의 더 느린 그리고 더 먼 레벨 이전에 액세스될 수 있다. 하나의 예로서, 메모리 계층 구조는 레벨 1(L1) 캐시(828), 메모리 컨트롤러 및 레벨 2(L2) 캐시(840), 및 메모리(810)를 포함할 수 있다. 메모리 컨트롤러 및 레벨 2(L2) 캐시(840)는, 메모리(810)와 통신하기 위한 제어 신호를 생성하기 위해 그리고 메모리(810)로부터 들어오는 또는 메모리(810)로 나가는 정보에 대한 일시적 저장을 제공하기 위해 사용될 수 있다. 도 8에서 예시되는 바와 같이, 메모리(810)는 프로세서(805) 외부에 있거나 또는 오프칩이다. 그러나, 메모리(810)는 프로세서(805) 내에 완전히 또는 부분적으로 통합될 수 있다.
제어 유닛(850)은 프로그램에 대한 런타임 환경의 전부 또는 일부분을 구현하기 위해 사용될 수 있다. 런타임 환경은 블록 기반의 프로세서 코어 및 메모리(810)의 사용량을 관리하기 위해 사용될 수 있다. 예를 들면, 메모리(810)는, 명령어 블록(A-E)을 포함하는 코드 세그먼트(812) 및 정적 섹션, 힙 섹션(heap section) 및 스택 섹션을 포함하는 데이터 세그먼트(815)로 분할될 수 있다. 다른 예로서, 제어 유닛(850)은 프로세서 코어를 할당하여 명령어 블록을 실행하기 위해 그리고 블록 식별자를 명령어 블록의 각각에 할당하기 위해 사용될 수 있다. 옵션 사항인 I/O 인터페이스(860)는, 프로세서(805)를, 다양한 입력 디바이스(예컨대 입력 디바이스(866)), 다양한 출력 디바이스(예컨대, 디스플레이(864)), 및 스토리지 디바이스(862)에 연결하기 위해 사용될 수 있다. 몇몇 예에서, 프로세서 코어(820), 메모리 컨트롤러 및 L2 캐시(840), 캐시 일관성 로직(845), 제어 유닛(850), I/O 인터페이스(860), 및 로드-저장 큐(870)의 컴포넌트는 다음 중 하나 이상을 사용하여 적어도 부분적으로 구현된다: 하드웨어에 내장된 유한 상태 머신, 프로그래밍 가능한 마이크로코드, 프로그래밍 가능한 게이트 어레이, 또는 다른 적절한 제어 회로. 몇몇 예에서, 캐시 일관성 로직(845), 제어 유닛(850), 및 I/O 인터페이스(860)는, 적어도 부분적으로, 외부 컴퓨터(예를 들면, 제어 코드를 실행하며 통신 인터페이스(도시되지 않음)를 통해 프로세서(805)와 통신하는 오프칩 프로세서)를 사용하여 구현된다.
프로그램의 전부 또는 일부는 프로세서(805) 상에서 실행될 수 있다. 구체적으로, 제어 유닛(850)은, 프로그램을 실행하기 위해, 프로세서 코어(820A-820D)와 같은 하나 이상의 블록 기반의 프로세서 코어를 할당할 수 있다. 프로세서 코어(820A-820D)의 공통적인 양태를 설명할 때, 코어는 프로세서 코어(820)로서 칭해질 수도 있다는 것을 유의해야 한다. 제어 유닛(850) 및/또는 프로세서 코어(820A-820D) 중 하나는, 명령어 블록이 메모리(810)의 코드 세그먼트(812)로부터 페치될 수 있도록, 명령어 블록의 시작 어드레스를 각각의 프로세서 코어(820)에 전달할 수 있다. 구체적으로, 프로세서 코어(820)는, 명령어 블록을 포함하는 메모리 블록에 대해 메모리 컨트롤러 및 L2 캐시(840)에게 판독 요청을 발행할 수 있다. 메모리 컨트롤러 및 L2 캐시(840)는 명령어 블록을 프로세서 코어(820)로 리턴할 수 있다. 제어 유닛(850)은, 명령어 블록의 프로그램 순서가 식별될 수 있도록, 각각의 프로세서 코어(820)에 할당되는 명령어 블록의 블록 식별자를 전달할 수 있다. 제어 유닛(850)은 또한, 명령어 블록을 비투기적인 것으로 또는 투기적인 것으로 지정할 수 있다. 추가적으로 또는 대안적으로, 다음 명령어 블록을 선택하고 명령어 블록이 투기적인지 또는 비투기적인지의 여부를 결정하기 위한 로직은 프로세서 코어(820A-820D) 사이에서 분산될 수 있다.
가시적인 아키텍쳐 상태는 메모리(예를 들면, 메모리 계층 구조) 및 글로벌 레지스터 파일의 레지스터를 포함한다. 프로세서(805)의 마이크로아키텍쳐는, 가시적인 아키텍쳐 상태를 유지하고 가시적인 아키텍쳐 상태의 투기적인 사본을 프로세서 코어(820)에 제공하기 위한 하드웨어 리소스를 포함할 수 있다. 특히, 프로세서(805)는 메모리 계층 구조로의 투기적 및 비투기적 비행 중인 로드 및 저장 명령어를 버퍼링하기 위한 그리고 순차적인 메모리 의미를 강제하기 위한 로드-저장 큐(870)를 포함할 수 있다. 구체적으로, 로드-저장 큐(870)는 로드 명령어와 저장 명령어 사이의 잠재적인 의존성을 검출할 수 있고, 명령어 사이의 임의의 의존성이 충족되도록, 부분적인 또는 전체 프로그램 순서에서 명령어를 시퀀스화할 수 있다. 저장 명령어에 대한 데이터는, 저장 명령어가 커밋된 이후 저장 데이터를 메모리로 배출하도록 메모리 계층 구조와 인터페이싱할 수 있는 로드-저장 큐(870)에 버퍼링될 수 있다. 로드 응답 데이터(load response data)는, 저장 명령어로부터의 버퍼링된 데이터 및/또는 메모리 계층 구조로부터 검색되는 데이터를 사용하여 로드-저장 큐(870)에서 생성될 수 있다. 이러한 방식에서, 로드-저장 큐(870)는, 프로세서 코어(820A-820D)가 잠재적으로 더 많은 명령어를 병렬로 실행할 수 있도록, 투기적 메모리 값을 프로세서 코어(820A-820D)로 제공하는 동안 ISA의 원자 블록 실행 모델을 따르는 메모리를 유지하기 위해 사용될 수 있다.
프로세서 코어(820A-820D)는, 레지스터에 대응하는 가시적인 아키텍쳐 상태를 유지하기 위한 분산된 트랜잭션 레지스터 파일(Xact RF)(830A-830D)을 포함할 수 있다. 구체적으로, 트랜잭션 레지스터 파일(830)은, 프로그래머가 볼 수 있는 커밋된 레지스터 값 및 계산의 속도를 잠재적으로 증가시키기 위해 투기적 명령어 블록에 의해 사용될 수 있는 커밋되지 않은 투기적 레지스터 값을 저장할 수 있다. 트랜잭션 레지스터 파일(830)은 프로세서 코어(820A-820D) 사이에서 코어간 통신 시스템(inter-core communication system)을 사용하여 업데이트될 수 있다. 통신 시스템은 트랜잭션 레지스터 파일(830) 내에 통합될 수 있거나 또는 트랜잭션 레지스터 파일(830)과 통신할 수 있다.
하나의 예로서, 통신 시스템은 메시지 송신기(message transmitters; Msg Xmit)(822A-822D) 및 메시지 수신기(message receivers; Msg Rev)(824A-824D)를 포함할 수 있다. 예시되는 바와 같이, 메시지 송신기(822A-822D) 및 메시지 수신기(824A-824D)는, 코어(820A-820D)가 일반적으로 단방향 링을 형성하고 메시지가 링을 통해 전송될 수 있도록 연결될 수 있다. 메시지는 일반적으로 링을 통해 한 방향으로 흐를 수 있지만, 그러나, 몇몇 실시형태에서는, 배압 신호 또는 다른 타입의 메시지가 주 흐름의 반대 방향으로 흐를 수도 있다. 다른 실시형태에서, 코어(820A-820D)는 다른 배치로 연결될 수 있다. 메시지가 하나의 프로세서 코어로부터 다른 프로세서 코어로 전달될 수 있다. 메시지는, 수신 코어(receiving core)에 의해 소비될 수 있고 및/또는 다음 하류 프로세서 코어로 송신될 수 있다(수정되거나 또는 수정되지 않음). 프로그램 순서에서 더 이전의 명령어 블록을 실행하는 코어는, 프로그램 순서에서 더 나중의 명령어 블록을 실행하고 있는 코어의 상류인 것으로 칭해진다. 특정한 예로서, 메시지는 코어(820A)로부터 하류의 코어(820B)로 전송될 수 있는데, 코어(820B)는 메시지를 코어(820C)로 포워딩할 수 있고, 코어(820C)는 메시지를 코어(820D)로 포워딩할 수 있고 코어(820D)는 메시지를 코어(820A)로 포워딩할 수 있다. 따라서, 메시지를 전송하는 코어는 자신이 전송한 메시지를 수신할 수 있다. 메시지는, 링을 돌아서 주행하여 소스 코어로 리턴하는 메시지를 소스 코어가 종료시킬 수 있도록, 메시지의 소스를 나타내는 코어 식별자를 포함할 수 있다.
융합 실행 모드에서, 프로세서 코어(820A-820D)는 스레드의 명령어 블록을 실행하기 위해 사용될 수 있다. 스레드 내에서, 명령어 블록은 프로그램 순서를 가지는데, 여기서 하나의 명령어 블록은 비투기적일 수 있고 프로그램 순서에서 나중인 명령어 블록은 투기적일 수 있다. 특정한 예로서, 주어진 시점에서, 코어(820A)는 비투기적 명령어 블록을 실행하고 있을 수 있고, 하류의 코어(820B-820C)는 프로그램 순서에서 더 나중에 투기적 명령어 블록을 실행 중일 수 있고, 코어(820D)는, 어떠한 명령어 블록도 아직 자신에게 할당되지 않은 아이들 상태에 있을 수 있다. 더 나중의 명령어 블록은 더 이전의 명령어 블록으로부터의 계산에 의존할 수 있다. 더 이전의 또는 상류의 명령어 블록은, 통신 시스템을 사용하여 메시지를 전송하는 것에 의해, 결과 및 다른 정보를 더 나중의 또는 하류의 명령어 블록으로 전송할 수 있다. 특정한 예로서, 코어(820A)는 송신기(822A)를 사용하여 메시지를 송신하는 것에 의해 메시지를 하류의 코어(820B)로 전송할 수 있고, 코어(820B)는 수신기(824B)를 사용하여 그 메시지를 수신할 수 있다.
트랜잭션 레지스터 파일(830)은 다양한 기능을 수행할 수 있다. 예를 들면, 트랜잭션 레지스터 파일(830)은 레지스터의 커밋된 값 및 커밋되지 않은(예를 들면, 투기적인) 값 둘 모두를 저장할 수 있다. 커밋된 값을 저장하는 것에 의해, 가시적인 아키텍쳐 상태는 원자 실행 모델에 따라 유지될 수 있다. 커밋되지 않은 값을 저장하는 것에 의해, 프로세서 코어(820A-820D)는, 다음 명령어 블록이 시작될 수 있기 이전에 각각의 명령어 블록이 커밋되어야 하는 경우보다 더 이전에 작업을 수행할 수 있다. 구체적으로, (프로그램 순서에서) 더 이전에 계산된 레지스터의 값은, 프로그램 순서에서 더 나중에 발생하는 명령어 블록으로 포워딩될 수 있다. 트랜잭션 레지스터 파일(830)은 (예컨대 레지스터 기록 마스크를 사용하는 것에 의해) 명령어 블록 사이의 의존성을 추적할 수 있고 의존성이 충족될 때까지 의존성 명령어의 실행이 지연되게 할 수 있다. 잘못 투기되는 것에 기인하여 또는 블록 내에서 발생하는 예외 처리에 기인하여 명령어 블록이 중단되는 경우, 트랜잭션 레지스터 파일(830)은, 커밋된 값만이 아키텍쳐적으로 가시적이도록, 레지스터에 대해 저장되는 임의의 투기적 값을 롤백하기 위해 사용될 수 있다.
비융합 또는 멀티 스레드 실행 모드에서, 프로세서 코어(820A-820D)의 각각은 상이한 스레드를 실행하도록 사용될 수 있다. 예를 들면, 프로세서 코어의 메시지 송신기는, 예컨대 구성 가능한 로직(도시되지 않음)을 사용하는 것에 의해, 동일한 프로세서 코어의 메시지 수신기로 다시 라우팅될(routed back) 수 있다. 특정한 예로서, 프로세서 코어(820A)는, 메시지 송신기(822A)를 메시지 수신기(824A)에 연결하는 것에 의해 비융합 모드에서 구성될 수 있다. 따라서, 프로세서 코어(820A)가 비융합 실행 모드에서 구성되는 경우, 트랜잭션 레지스터 파일(830A)의 값은 프로세서 코어(820A)로 국소화될 수 있다. 따라서, 프로세서(805)는 (비융합 실행 모드를 사용하여) 네 개의 코어(820A-820D) 상에서 네 개의 스레드를 실행하도록, 또는 (융합 실행 모드를 사용하여) 네 개의 코어(820A-820D)에 걸쳐 투기적 블록 실행을 사용하여 하나의 스레드를 실행하도록 구성될 수도 있다. 추가적으로 또는 대안적으로, 메시지 송신기와 수신기 사이의 통신 경로는, 상이한 수 및 조합의 코어가 융합될 수 있도록, (예컨대, 프로그래밍 가능한 다중화 통신 경로를 사용하는 것에 의해) 재라우팅될 수 있다. 특정한 예로서, 송신기(822B)로부터의 경로는 수신기(824A)로 재라우팅될 수 있고, 송신기(822D)로부터의 경로는, 두 개의 스레드가 프로세서 쌍(820A-820B 및 820C-820D) 상에서 실행될 수 있도록, 수신기(824C)로 라우팅될 수 있다. 상이한 수의 코어 및 라우팅 배열이 사용되어 융합 및 비융합 구성의 상이한 조합을 생성할 수 있다.
상이한 프로세서 코어(820A-820D)는, 레지스터 값 및 제어 정보를 전달하기 위해 서로 사이에서 메시지를 전송할 수 있다. 표 1은 프로세서 코어(820A-820D) 사이에서 전송될 수 있는 메시지의 예시적인 세트 및 메시지의 각각을 수신하는 것과 관련될 수 있는 액션을 제공한다:
도 9는 프로그램의 명령어 블록을 실행하기 위한 다수의 프로세서 코어(820A-820D) 및 트랜잭션 레지스터 파일(830A-830D)을 포함하는 예시적인 프로세서의 추가적인 양태를 예시한다. 예를 들면, 도 9는 상이한 프로세서 코어(820A-820D)가 서로 어떻게 통신할 수 있는지 및 트랜잭션 레지스터 파일(830A-830D)이 원자 실행 모델을 지원하기 위해 어떻게 사용될 수 있는지의 예를 예시하기 위해 사용된다. 이 예에서, 프로세서 코어(820A-820D)는 동종이지만, 다른 예에서, 프로세서 코어(820A-820D)는 다양한 공통 컴포넌트를 갖는 이종일 수 있다. 예시의 용이함을 위해, 첨자(subscript)가 추가적인 명확성을 제공할 수 있지 않는 한, 다음의 설명에서는 알파벳 첨자는 일반적으로 생략된다는 것을 유의해야 한다(예를 들면, 코어(820A)가 코어(820)로 칭해질 수 있고, 및 등등일 수 있다).
명령어 블록은, 메시지 수신기(824)에 의해 "분기" 메시지를 수신하는 것에 응답하여 프로세서 코어(820) 상에서 페치, 디코딩, 및 실행될 수 있다. 분기 메시지는 페치할 명령어 블록의 어드레스를 포함할 수 있다. 페치 로직(902)은, 분기 메시지에 의해 제공되는 어드레스에서 메모리로부터 명령어 블록을 페치하기 위해 사용될 수 있다. 페치된 명령어 블록은 명령어 헤더 및 명령어를 포함할 수 있다. 개개의 명령어는 디코드 로직(904)에 의해 디코딩될 수 있고, 디코딩된 명령어로부터의 정보는 하나 이상의 명령어 윈도우(906-907)에 저장될 수 있다. 명령어 헤더는 디코드 로직(904)에 의해 디코딩되어, 명령어 블록에 관한 정보, 예컨대 명령어 블록의 저장 마스크 및/또는 기록 마스크를 결정할 수 있다. 저장 마스크는 명령어 블록의 저장 명령어를 식별할 수 있고, 기록 마스크는 명령어 블록에 의해 어떤 레지스터가 기록되는지를 식별할 수 있다. 저장 마스크 및 기록 마스크는 다른 정보와 조합하여 사용되어, 이들 명령어가 명령어 스케줄러(908)에 의해 발행될 수 있도록 몇몇 명령어의 의존성이 충족되는지의 여부를 결정할 수 있다. 실행 동안, 명령어 블록의 명령어는, 명령어 피연산자가 언제 이용 가능하게 되는지에 기초하여, 명령어 스케줄러(908)에 의한 실행을 위해 동적으로 발행 또는 스케줄링된다. 따라서, 명령어의 발행된 또는 실행 순서는 명령어의 프로그램 순서와는 상이할 수 있다. 명령어는 (산술 로직 유닛과 같은) 실행 로직(910)을 사용하여 완전히 또는 부분적으로 실행될 수 있다.
실행된 명령어의 결과는 트랜잭션 레지스터 파일(830)의 다른 명령어, 메모리, 또는 레지스터를 타겟으로 할 수 있다. 명령어가 다른 명령어를 타겟으로 하는 경우, 명령어의 결과는 명령어 윈도우(906-907)의 피연산자 버퍼로 다시 기록될(written back) 수 있다. 명령어가 메모리를 타겟으로 하는 경우, 명령어의 결과는 로드-저장 큐(예컨대, 도 8의 로드-저장 큐(870))에 기록될 수 있다. 명령어가 레지스터를 타겟으로 하는 경우, 명령어의 결과는 트랜잭션 레지스터 파일(830)에 기록될 수 있다. 로드-저장 큐는 저장 명령어의 결과에 대한 중간 버퍼링을 제공하고, 트랜잭션 레지스터 파일(830)은 레지스터에 기록되고 있는 명령어의 결과에 대한 중간 버퍼링을 제공한다. 중간 결과는, 실행 명령어 블록이 비투기적이며 커밋될 때까지 완전히 릴리스되지 않는다(아키텍쳐적으로 보이게 되지 않는다).
커밋 로직(912)은 명령어 블록의 커밋 조건을 모니터링할 수 있고, 조건이 충족될 때 명령어 블록을 커밋할 수 있다. 예를 들면, 커밋 조건은, 트랜잭션 레지스터 파일(830)로의 모든 저장 명령어 및 모든 기록을 완료하는 것, 다음 명령어 블록으로의 분기 어드레스를 계산하는 것, 및 명령어 블록이 비투기적인 것을 포함할 수 있다. 커밋 로직(912)은, 디코딩된 저장 마스크를, 명령어 블록의 발행된 저장 명령어의 목록 또는 벡터에 비교하는 것에 의해 모든 저장 명령어가 발행되었다는 것을 결정할 수 있다. 커밋 로직(912)은, 디코딩된 기록 마스크를, 명령어 블록의 실행 동안 발생한 레지스터 기록의 목록 또는 벡터에 비교하는 것에 의해 레지스터에 대한 모든 기록이 발생했다는 것을 결정할 수 있다. 커밋 로직(912)은, 명령어 블록의 분기 명령어가 실행되는 경우 분기 어드레스가 계산되었다는 것을 결정할 수 있다. 커밋 로직(912)은, 메시지 수신기(824)가 "커밋" 메시지 또는 커밋 토큰을 수신하는 경우 명령어 블록이 비투기적이다는 것을 결정할 수 있다. 커밋 토큰을 수신하는 것은, 현재 명령어 블록에 선행하는 명령어 블록이 비투기적이었고 커밋되었다는 것을 나타내며, 따라서 현재 실행되는 명령어 블록은 이제 비투기적인 명령어 블록이다. 커밋 메시지는 분기 메시지 수신과 동시에 또는 상이한 시간에 수신될 수 있다.
커밋 조건이 충족될 때, 가시적인 아키텍쳐 상태는 원자 트랜잭션에서 업데이트될 수 있다. 예를 들면, 로드-저장 큐의 저장 엔트리는 커밋된 것으로 마킹될 수 있고, 저장 데이터는 메모리 계층 구조로 다시 기록되기 시작할 수 있다. 다른 예로서, 그리고 하기에서 더 설명되는 바와 같이, 트랜잭션 레지스터 파일(830)의 레지스터의 커밋된 값은 업데이트될 수 있다. 커밋 로직(912)은 또한, 메시지 송신기(822)로 하여금, 하류의 프로세서 코어에 "커밋" 메시지를 전송하게 할 수 있다.
프로세서 코어(820)는 추가적인 제어 로직(920), 예컨대 더 나중의 명령어 블록의 분기 어드레스를 예측하기 위한 분기 예측 로직, 프로세서 코어(820)의 전부 또는 일부분에 전력을 공급하거나 또는 전력을 차단하기 위한 전력 제어 로직, 및 잘못 투기된 상태를 정리하기 위한 중단 관리 로직을 포함할 수 있다. 특정한 예로서, 추가적인 제어 로직(920)은, 명령어 블록이 여전히 실행되고 있는 동안 그리고 커밋 조건이 충족되기 이전에 더 나중의 명령어 블록의 분기 어드레스를 예측할 수 있는 분기 예측 로직을 포함할 수 있다. 현재 실행되는 명령어 블록이 커밋되기 이전에 프로세서 코어가 예측된 명령어 블록의 투기적 실행을 시작할 수 있도록, 분기 예측 로직은 분기 메시지로 하여금 하류의 프로세서 코어로 전송되게 할 수 있다. 따라서, 다수의 명령어 블록이 병렬로 실행될 수 있는데, 이것은 프로세서의 성능을 잠재적으로 증가시킬 수 있다.
트랜잭션 레지스터 파일(830)은 원자적으로 커밋된 레지스터 값을 유지하기 위해 그리고 투기적 명령어 블록에 레지스터의 초기 투기 버전을 제공하기 위해 사용될 수 있다. 트랜잭션 레지스터 파일(830A-830D)에 저장되는 값은 모든 프로세서 코어(820A-820D)에 걸쳐 분산될 수 있다. 커밋된 레지스터 값은 비투기적 명령어 블록에 대응하는 트랜잭션 레지스터 파일에 저장될 수 있고, 이들 값은 다른 프로세서 코어 상의 트랜잭션 레지스터 파일로 송신될 수 있다. 투기적 레지스터 값은 개개의 트랜잭션 레지스터 파일(830A-830D) 중 하나 이상에 저장될 수 있다. 투기적 레지스터 값 업데이트는 명령어 블록이 커밋될 때 커밋된다. 투기적 레지스터 값 업데이트는 명령어 블록이 중단될 때 무시된다. 블록 중단의 원인은 분기 오정렬, 부동 소수점 예외 처리, 또는 블록에서 또는 이전 블록에서 발생하는 다른 이벤트를 포함할 수도 있다.
트랜잭션 레지스터 파일(830)은 개별적으로 주소 지정 가능한 레지스터에 대응하는 복수의 엔트리를 포함할 수 있다. 예를 들면, w 엔트리(w-entry) 트랜잭션 레지스터 파일(830)은, n 개의 상이한 레지스터에 대응하는 n 개의 상이한 엔트리(도 9에서 0 내지 (n-1)로 라벨링됨)를 포함할 수 있다. 트랜잭션 레지스터 파일(830)은, 트랜잭션 레지스터 파일(830)에 정보를 저장하기 위한 RAM 및/또는 플립플롭 또는 래치를 사용하여 구현될 수 있다. 트랜잭션 레지스터 파일(830)의 각각의 엔트리는, 엔트리에 대응하는 레지스터에 대한 레지스터 값(930) 및 레지스터 상태(940)를 저장하기 위한 다양하고 상이한 필드를 포함할 수 있다. 구체적으로, 레지스터 값(930)은 이전 값(932) 및 다음 값(934)을 저장하기 위한 필드를 포함할 수 있다. 이전 값(932)은 더 이전 명령어 블록에 의해 계산되는 값을 저장하기 위해 사용될 수 있고 다음 값(934)은 더 나중의 명령어 블록에 의해 계산되는 값을 저장하기 위해 사용될 수 있다. 따라서, 트랜잭션 레지스터 파일(830)의 각각의 엔트리는 주어진 레지스터와 관련되는 다수의 값 및 상태를 저장할 수 있다.
레지스터 상태(940)는, 아직 기록되지 않은 더 이전의 블록으로부터의 레지스터, 이 코어 상에서 실행되는 명령어 블록에 의해 기록될 수도 있는 레지스터, 및 이 코어에 의해 기록된 레지스터를 추적하기 위해 사용될 수 있다. 하나의 예로서, 레지스터 상태(940)는 기록 마스크(write-mask; W-M) 상태(942), 펜딩 상태(pending state)(944), 및 기록 상태(written state)(946)를 저장하기 위한 필드를 포함할 수 있다. 기록 마스크 상태(942)는, 프로세서 코어 상에서 실행되는 명령어 블록에 의해 실행될 수도 있는 모든 레지스터 기록을 추적하기 위해 사용될 수 있다. 예를 들면, 기록 마스크 상태(942)는, 명령어 블록의 명령어 헤더로부터 디코딩되는 기록 마스크의 사본일 수 있다. 펜딩 상태(944)는, 기록될 수도 있지만 그러나 아직 기록되지 않은 그리고 명령어 블록 내의 의존성을 생성할 수도 있는 더 이전의 블록으로부터의 레지스터를 추적하기 위해 사용될 수 있다. 기록 상태(946)는 코어에 의해 기록된 레지스터를 추적하기 위해 사용될 수 있다.
트랜잭션 레지스터 파일(830)은 상태 머신(950)을 포함할 수 있다. 레지스터 상태(940)와 결합한 상태 머신(950)의 현재 상태는, 트랜잭션 레지스터 파일(830) 내의 어떤 레지스터 값이 커밋된 값이고 어떤 레지스터 값이 투기적 값인지를 결정하기 위해 사용될 수 있다. 하나의 예로서, 상태 머신(950)은 코어 상에서 실행되는 명령어 블록이 비투기적으로 실행되고 있다는 것을 나타내는 비투기적 상태를 포함할 수 있다. 상태 머신(950)이 비투기적인 상태에 있는 경우, 이전 값(932)은 레지스터의 커밋된 값을 유지할 수 있다. 상태 머신의 다른 상태는 투기적 상태, 아이들 상태, 중단 상태, 및 일시 정지 상태를 포함할 수 있다. 상태 머신(950)은 도 10과 관련하여 하기에서 더 상세하게 논의된다. 상태 머신(950)의 상태는, 메시지가 통신 시스템 상에서 수신될 때 트랜잭션 레지스터 파일(830)이 어떻게 업데이트되는지 및 메시지에 기초하여 수행될 다른 액션을 결정하기 위해 사용될 수 있다.
"기록 마스크" 메시지는 메시지 수신기(824)에 의해 수신되어 디코딩될 수 있다. 기록 마스크 메시지(write-mask message)는 더 이전의 커밋되지 않은 명령어 블록의 명령어에 의해 기록될 수도 있는 모든 레지스터를 나타낼 수 있다. 예를 들면, 각각의 명령어 블록의 명령어 헤더는, 명령어 블록의 명령어에 의해 기록될 수도 있는 모든 레지스터를 나타내는 기록 마스크 필드를 포함할 수 있다. 실행 명령어 블록에 후속하는 명령어 블록은 레지스터에 대한 기록에 의존할 수 있다. 비투기적 명령어 블록은 하류의 프로세서 코어로 기록 마스크 메시지를 전송할 수 있다. 기록 마스크 메시지를 수신하는 코어는, 각각의 명시된 레지스터에 대한 펜딩 상태(944)를 어써트하는 것에 의해(예를 들면, 1의 값을 할당 또는 설정하는 것에 의해) 메시지에서 명시되는 레지스터를 펜딩하는 것으로 마킹할 수 있다. 레지스터가 더 이전의 명령어 블록으로부터 펜딩 중인 경우, 펜딩 중인 레지스터를 판독하는 임의의 명령어는 레지스터가 업데이트된 이후까지 지연될 수 있다. 도 7로부터의 특정한 예로서, 블록(710)으로부터의 기록 마스크의 하위 8 비트는 "0101_0101"인데, 레지스터(R0, R2, R4 및 R6)가 기록될 것이다는 것을 나타낸다. 실행 명령어 블록에 대한 기록 마스크는 기록 마스크 상태(942)에 기록될 수 있다. 이 예에서, 블록(710)은 코어(820A) 상에서 비투기적으로 실행되고 있을 수 있다. 코어(820A)는 송신기(822A)를 사용하여 기록 마스크 메시지를 코어(820B) 상의 수신기(824B)로 전송할 수 있다. 기록 마스크 메시지는 블록(710)으로부터의 기록 마스크를 포함할 수 있고, 펜딩 상태(944)는 수신된 기록 마스크 값으로 업데이트될 수 있다. 구체적으로, 펜딩 상태(944)의 하위 8 비트는 "0101_0101"로 업데이트될 수 있다.
펜딩 상태(944)는 명령어 스케줄러(908)로 전달될 수 있다. 명령어 스케줄러(908)는, 펜딩 상태(944)에 의해 나타내어지는 바와 같이, 아직 기록되지 않은 레지스터를 판독하는 명령어를 지연시킬 수 있다. 도 7로부터의 특정한 예로서, 코어(820B)는 명령어 블록(711)을 투기적으로 실행되고 있을 수 있다. 레지스터(R0)는 명령어(720)에 의해 블록(710)에 기록되고 명령어(721)에 의해 블록(711)에서 판독된다. 명령어 스케줄러(908)는, 명령어(721)의 의존성이 충족될 때까지(예를 들면, 명령어(720)가 레지스터(R0)에 기록된 이후까지) 명령어(721)를 지연시킬 수 있다. 대조적으로, 레지스터(R3)는 블록(710)에 의해 기록되지 않는다. 블록(710)이 비투기적 블록인 경우, 레지스터(R3)는 더 이전 블록에서 커밋되었을 것이다. 레지스터(R3)(비트 3)에 대응하는 펜딩 상태(944)의 비트는 어써트되지 않으며, 따라서, 명령어 스케줄러(908)는, 하드웨어 리소스가 명령어를 실행하는 데 이용 가능하자마자, 명령어(722)를 발행할 수 있다.
복합 기록 마스크 메시지는 투기적인 또는 아이들 상태의 코어에 의해 포워딩될 수 있다. 예를 들면, 더 나중의 명령어 블록은 모든 더 이전의 커밋되지 않은 명령어 블록으로부터의 레지스터 기록에 의존할 수 있다. 따라서, 기록 마스크 메시지가 모든 커밋되지 않은 블록에 대한 정보와 함께 포워딩될 수 있다. 도 7로부터의 특정한 예로서, 코어(820B)는 명령어 블록(711)을 투기적으로 실행되고 있을 수 있다. 펜딩 상태(944) 및 블록(711)로부터의 기록 마스크 정보를 결합하는 기록 마스크 메시지가 생성될 수 있다. 블록(711)로부터의 기록 마스크의 하위 8 비트는 "1010_0001"인데, 레지스터(R0, R5 및 R7)가 블록(711)에 의해 기록될 것이다는 것을 나타낸다. 기록 마스크 메시지는 펜딩 상태(944) 및 기록 마스크 상태(942)에 대해 비트 단위 or 함수(bit-wise-or function)를 수행하여, 블록(710 및 711)에 의해 기록될 수도 있는 모든 레지스터를 나타내는 "1111_0101"의 복합 기록 마스크를 생성할 수 있다. 복합 기록 마스크는 송신기(822B)에 의해 코어(820C) 상의 수신기(824C)로 송신될 수 있다.
"레지스터-기록" 메시지가 생성될 수 있고, 기록 상태(946)는, 명령어가 실행되어 레지스터에 기록되는 것에 응답하여, 업데이트될 수 있다. 특히, 명령어 스케줄러(908)는 디코딩된 명령어를 실행 로직(910)으로 발행할 수 있는데, 여기서 디코딩된 명령어는 실행 로직(910)으로부터 결과를 기록할 레지스터를 명시한다. 실행 로직(910)은 기록되고 있는 레지스터에 대응하는 기록 상태(946)로 하여금 어써트되게 할 수 있는데, 레지스터가 기록되었다는 것을 나타낸다. 실행 로직(910)은, 레지스터 기록 메시지가 송신기(822)에 의해 송신되게 그리고 메시지 수신기(824)에 의해 수신 및 디코딩되게 할 수 있다. 도 7로부터의 특정한 예로서, 코어(820A)는 명령어 블록(710)을 실행하고 있을 수 있고 명령어(720)는 실행될 수 있다. 명령어(720)로부터의 결과는 레지스터(R0)를 타겟으로 한다. 명령어(720)가 실행되는 것에 응답하여, 기록 상태(946)의 비트 0은 코어(820A)에서 어써트될 수 있고(예를 들면, 1로 설정됨), 레지스터 기록 메시지는 송신기(822A)로부터 전송되어 수신기(824B)에 의해 수신될 수 있다. 레지스터 기록 메시지는, 기록된 레지스터(예를 들면, R0) 및 기록된 값(예를 들면, 8)을 나타낼 수 있다.
레지스터 기록 메시지를 수신하는 투기적 또는 아이들 상태의 코어는, 이전 레지스터 값(932)을 업데이트할 수 있고 기록된 레지스터에 대응하는 펜딩 레지스터 상태(944)를 디어써트(deassert)(예를 들면, 클리어, 무효화 또는 제로화)할 수 있다. 도 7의 예를 가지고 계속하면, 코어(820B)는, 명령어(720)에 의해 코어(820A)에 기록되고 있는 레지스터(R0)에 대응하는 레지스터 기록 메시지를 수신할 수 있다. 코어(820B) 내에서, 레지스터(R0)에 대한 이전 레지스터 값(932)은 8로 기록될 수 있고, 레지스터(R0)에 대한 펜딩 레지스터 상태(944)는 디어써트될 수 있는데(예를 들면, 0으로 클리어될 수 있음), 레지스터(R0)가 더 이전의 명령어 블록에 의해 기록되었다는 것을 나타낸다.
레지스터 기록 메시지를 수신하는 투기적인 또는 아이들 상태의 코어는, 레지스터가 수신 코어에서 기록되는지의 여부에 기초하여, 하류의 코어로 레지스터 기록 메시지를 선택적으로 포워딩할 수 있다. 레지스터가 수신 코어에 기록되지 않으면(예를 들면, 레지스터에 대응하는 기록 마스크 상태(942)의 비트가 디어써트됨), 레지스터 기록 메시지는 하류의 코어로 포워딩될 수 있다. 그러나, 레지스터가 수신 코어에 기록된다면(예를 들면, 레지스터에 대응하는 기록 마스크 상태(942) 내의 비트가 어써트됨), 레지스터 기록 메시지는 하류의 코어로 포워딩되지 않을 것이다. 도 7의 예를 가지고 계속하면, 레지스터(R0)는 명령어 블록(710 및 711) 둘 모두에 기록된다. 따라서, 명령어(720)에 응답하여 전송되는 레지스터 기록 메시지가 코어(820B)에서 수신되는 경우, 레지스터 기록 메시지는 코어(820C)로 포워딩되지 않을 것이다. 그러나, 레지스터(R6)는 블록(710)에서만 기록된다. 명령어(730)가 실행되는 경우, 기록 상태(946)의 비트 6이 코어(820A)에서 어써트되고, 레지스터(R6)가 값 11로 기록되었다는 것을 나타내는 기록 메시지가 송신기(822A)로부터 코어(820B) 상의 수신기(824B)로 송신될 수 있다. 코어(820B) 상에서 실행되는 명령어 블록(711)은, 레지스터 기록 메시지가 송신기(822B)에 의해 코어(820C) 상의 수신기(824C)로 포워딩될 수 있도록, 레지스터(R6)에 기록하지 않는다(예를 들면, 기록 마스크 상태(942)의 비트 6이 디어써트된다). 레지스터(R6)에 대응하는 이전 값(932)은 코어(820B 및 820C) 둘 모두에서 값 11로 업데이트될 수 있다.
레지스터 기록 메시지를 수신하는 비투기적 코어는, 기록된 레지스터에 대응하는 다음 레지스터 값(934)을 업데이트할 수 있다. 레지스터 기록 메시지는 비투기적 코어에서 시작될 수 있고(예를 들면, 그것은 비투기적 코어 상에서 실행되는 명령어에 의해 야기될 수 있음), 하류의 코어에 의해 발신 코어(originating core)로 다시 포워딩될 수 있다. 메시지가 발신 코어에 의해 수신되는 경우, 이전 레지스터 값(932) 보다는 다음 레지스터 값(934)이 업데이트된다. 추가적으로, 레지스터 기록 메시지는 투기적 코어에서 시작될 수 있고(예를 들면, 그것은 투기적 코어 상에서 실행되는 명령어에 의해 야기될 수 있음), 하류의 코어에 의해 비투기적 코어로 다시 포워딩될 수 있다. 비투기적 코어에 의해 메시지가 수신되는 경우, 이전 레지스터 값(932)보다는 다음 레지스터 값(934)이 업데이트된다. 도 7로부터의 예를 가지고 계속하면, 코어(820A)는 (명령어(730)를 사용하여) 레지스터(R6)에 기록하는 유일한 코어이다. 명령어(730)가 실행되는 경우, 레지스터 기록 메시지는 코어(820A)에서 시작될 것이고, 레지스터 기록 메시지는 하류의 코어(820B, 820C 및 820D)에 의해 발신 코어(820A)로 다시 포워딩될 것이다. 레지스터 기록 메시지가 코어(820A)에 의해 수신되는 경우, 레지스터(R6)에 대한 다음 레지스터 값(934)은 11로 기록될 수 있다. 블록(711)의 명령어(750)는 블록(710-712)으로부터 레지스터(R5)에 기록하는 유일한 명령어이다. 명령어(750)가 실행되는 경우, 레지스터(R5)에 대한 레지스터 기록 메시지가 생성되어 코어(820B)로부터 코어(820C)로 코어(820D)로 비투기적 코어(820A)로 송신된다. 레지스터 기록 메시지가 코어(820A)에 의해 수신되는 경우, 레지스터(R5)에 대한 다음 레지스터 값(934)은 12로 기록될 수 있다. 하나의 실시형태에서, 레지스터 기록 메시지는 코어(820A)로부터 코어(820B)로 포워딩될 수 있고 레지스터(R5)에 대한 다음 레지스터 값(934)은 코어(820B) 상의 12로 또한 기록될 수 있다.
기록 마스크는 명령어 블록에 의해 실제로 기록되는 것보다 더 많은 레지스터가 기록될 것이다는 것을 나타낼 수 있다. 예를 들면, 기록 마스크는 술어적 명령어에 의해 기록되는 레지스터를 포함할 수 있다. 명령어 블록의 실행 동안 계산되는 술어 값에 따라, 레지스터는 작성될 수도 있거나 또는 작성되지 않을 수도 있다. 실행되지 않은 레지스터 기록을 고려하기 위해, 무효화 명령어가 추가될 수 있다. 예를 들면, 제1 술어 값(예를 들면, 참 값)이 계산되는 경우, 제1 술어적 명령어가 제1 레지스터에 기록할 수 있다. 상이한 술어 값(예를 들면, 거짓 값)이 계산될 때 제1 레지스터가 기록되지 않으면, 제1 레지스터에 대한 기록은 무효화 명령어를 사용하여 취소될 수 있다.
무효화 명령어는 레지스터 기록 메시지로 하여금 생성되게 그리고 하류의 코어로 송신되게 할 수 있다. 특히, 레지스터 기록 메시지는 기록되지 않은 레지스터, 및 이전 명령어 블록으로부터의 레지스터의 값(예를 들면, 이전 값(932))을 나타낼 수 있다. 도 7로부터의 특정한 예로서, 명령어(740)는, 술어 값이 참인 경우, 레지스터(R3)에 대한 기록을 무효화하기 위해 사용될 수 있다. 무효화 명령어는, 술어 값이 거짓이고 명령어(741)가 실행된 경우 실행될 레지스터(R3)에 대한 기록을 취소하기 위해 사용된다. 예시되는 바와 같이, 무효화 명령어(740)의 실행은, 레지스터(R3)가 1의 값(이전 값(932)에 저장되는 값)을 갖는다는 것을 나타내는 레지스터 기록 메시지가 생성되게 할 것이다.
비투기적 코어는 성공적으로 완료되어 커밋될 수 있거나 또는 비투기적 코어는 예외 처리에 기인하여 중단될 수 있다. 레지스터 기록 메시지를 수신하는 비투기적 코어는, 기록된 레지스터에 대응하는 다음 레지스터 값(934)을 업데이트할 수 있다. 따라서, 비투기적 코어는 이전 값 레지스터(932)에서 커밋된 값을 그리고 다음 레지스터 값(934)에서 투기적 값을 가질 수 있다. 비투기적 코어가 성공적으로 완료되어 커밋되는 경우, 이전 값 레지스터(932)가 투기적 레지스터 값을 포함하도록, 코어(820)는 각각의 다음 레지스터 값(934)을 각각의 대응하는 이전 값 레지스터(932)에 복사할 수 있다. 커밋된 레지스터 값은 새로운 비투기적 코어가 될 하류의 코어의 이전 값 레지스터(932)에 저장될 것이다. 커밋 코어(committing core)는, 하류의 코어가 비투기적 코어가 되는 것으로 전이할 수 있도록, 커밋 메시지를 하류의 코어로 전송할 수 있다. 커밋 코어는, 커밋 메시지가 전송되는 경우, 아이들 상태로 전이할 수 있다. 그러나, 비투기적 코어가 예외 처리를 검출하면(예컨대, 실행 로직(910)이 예외 처리를 검출하는 경우), 코어는 중단 상태로 전이할 수 있고, 임의의 투기적으로 기록된 레지스터는 커밋된 값으로 되돌려질 수 있다.
몇몇 실시형태에서, 예컨대 레지스터 값(930)이 별개의 레지스터 또는 플립플롭에 상주하는 경우, 각각의 이전 값(932)에 대한 각각의 다음 값(934)의 복사는 하나의 사이클에서 달성될 수 있다. 몇몇 실시형태에서, 예컨대 레지스터 값(930)이 하나 이상의 RAM에 상주하는 경우, 각각의 이전 값(932)에 대한 각각의 다음 값(934)의 복사는, 예를 들면, 각각의 레지스터에 대해 하나의 사이클씩, 여러 개의 클록 사이클에 걸쳐 반복될 수 있다. 몇몇 실시형태에서, 이 코어(820)의 최종 커밋 이후 기록된 또는 다르게는 업데이트된 그들 레지스터 값만이 복사될 것이다. 몇몇 실시형태에서, 이전(932) 및 다음(934) 어레이보다는, 두 개의 n 엔트리 RAM에서 구현되는 두 개의 레지스터 파일 "사본0" 및 "사본1"이 있고, 엔트리 단위 기반으로, 레지스터 #X에 대해, 사본0[X] 또는 사본1[X] 중 어떤 것이 대응하는 이전 값 또는 다음 값을 포함하는지를 결정하는, 본원에서 PREV[] 및 NEXT[]로 칭해지는 n 플립플롭의 두 개의 벡터(즉, 두 개의 n 비트 레지스터)가 있다. 즉, 레지스터 #X에 대한 '이전(prev)' 값은, 'if (PREV[X] == 0) then copy0[X] else copy1 [X]'으로서 획득되고 레지스터 #X에 대한 '다음(next)' 값은 'if (NEXT[X] == 0) then copy0[X] else copy1[X]'이다. 그 다음, 블록을 커밋하기 위해, 레지스터 NEXT[]는 레지스터 PREV[]로 복사될 수 있고; 블록을 초기화 또는 중단하기 위해, 레지스터 PREV[]는 레지스터 EXT[]로 복사될 수 있고, 다음 레지스터 #X 값을 기록하기 위해, 먼저 NEXT[X]를 not(PREV[X])로 설정한다. 두 개의 레지스터 및 두 개의 값 어레이의 이 배열을 사용하는 것에 의해, 배열은, 플립플롭의 하나의 벡터를 다른 것으로 단순히 복사하는 것에 의해 트랜잭션 레지스터 파일의 단일 사이클 커밋 및 단일 사이클 중단을 잠재적으로 달성하면서, 레지스터 파일 내용이 RAM 어레이에서 유지되는 것을 가능하게 할 수 있다. 몇몇 실시형태에서, 어레이 이전(932) 및 다음(934) 또는 어레이 사본0[] 및 사본1[]은 FPGA LUT RAM 또는 FPGA 블록 RAM 메모리를 사용하여 구현된다.
하류의 코어가 사용되지 않을 투기적 명령어의 발행을 중지할 수 있도록, 중단 코어(aborting core)는 "일시 정지" 메시지를 하류의 코어에 전송할 수 있다. 명령어가 발행되는 것을 중지시키는 것에 의해, 레지스터 및/또는 메모리에 대한 더 적은 투기적 변경이 수행될 수도 있는데, 이것은, 프로세서가 중단 조건으로부터 보다 신속하게 복구하는 것을 잠재적으로 허용할 수 있고 프로세서의 성능을 증가시킬 수 있다. 일시 정지 메시지를 수신하는 코어는, 클록을 게이트 제어할(gate) 수 있는 저전력 모드에 진입할 수 있거나 또는 코어의 에너지 소비가 감소될 수 있도록 코어의 전력을 감소시킬 수 있는 다른 액션을 수행할 수 있다.
중단 코어는 코어에 의해 기록된 레지스터의 각각에 대한 레지스터 기록 메시지를 전송할 수 있다. 예를 들면, 중단 코어는 기록 상태(946)를 분석하는 것에 의해 기록된 모든 레지스터를 결정할 수 있다. 기록 상태(946)는, 기록 마스크에 의해 식별되는 레지스터의 서브세트인, 코어에 의해 기록된 레지스터의 각각에 대한 어써트된 비트를 포함할 것이다. 중단 코어는 이전 레지스터 값(932)으로부터 각각의 레지스터에 대한 마지막 커밋된 값을 검색할 수 있고 이전 레지스터 값(932)으로부터의 값과 함께 레지스터 기록 메시지를 하류로 전송할 수 있다. 따라서, 하류의 코어 내의 이전 레지스터 값(932) 모두는 레지스터의 최종 커밋된 값으로 업데이트될 수 있다.
중단 코어는, 하류의 코어가 임의의 투기적으로 기록된 레지스터를 커밋된 값으로 다시 되돌릴 수 있도록, "중단" 메시지를 하류의 코어에 전송할 수 있다. 특히, 중단 코어는, 투기적으로 기록된 레지스터에 대응하는 모든 레지스터 기록 메시지가 전송된 이후, 하류의 코어로 중단 메시지를 전송할 수 있다. 중단 메시지가 전송되는 경우 중단 코어는 아이들 상태로 전이할 수 있다. 추가적으로, 비투기적인 코어를 커밋하는 것은, 하류의 코어가 잘못 예측되었다는 것을 검출할 수 있고 중단 메시지를 하류의 코어로 전송할 수 있다. 특히, 분기 예측기에 의해 생성되는 (그리고 분기 메시지에서 송신되는) 분기 어드레스는, 실행 로직(910)에 의해 생성되는 분기 어드레스에 비교될 수 있다. 계산된 분기 어드레스가 상이한 경우, 커밋 코어는 중단 메시지를 하류의 코어로 전송할 수 있다.
중단 메시지를 수신하는 코어는 중단 상태로 전이할 수 있고, 임의의 투기적으로 기록된 레지스터를 커밋된 값으로 되돌리기 시작할 수 있다. 코어가 아직 어떠한 레지스터에도 기록하지 않았다면(예를 들면, 레지스터 기록 상태(946)에 어써트된 비트가 없음), 코어는 중단 메시지를 다음 하류의 코어로 포워딩할 수 있고 아이들 상태로 전이할 수 있다. 아이들 상태의 코어가 중단 메시지를 수신하면 아이들 상태의 코어는 제어 유닛 또는 프로세서 코어 중 하나에 의해 프로그램 실행을 다시 시작할 수 있는 완료된 중단 신호를 생성할 수 있다. 따라서, 상류의 코어에서의 중단 메시지는, 하류의 코어에서 중단 메시지의 종속 접속(cascade)을 야기할 수 있는데, 여기서 각각의 하류의 코어는, 자신의 하류의 코어로 중단 메시지를 전송하기 이전에, 임의의 투기적 업데이트를 롤백할 수 있다.
도 7로부터의 특정한 예로서, 블록(710-712)은 코어(820A-820C) 상에서 각각 실행되고 있을 수 있고, 코어(820D)는 아이들 상태일 수 있다. 이 예에서, 코어(820A)는 비투기적으로 실행되고 있고 코어(820B-C)는 투기적으로 실행되고 있다. 코어(820A)는, 코어(820A)가 레지스터(R0 및 R2)에 대한 레지스터 기록을 전송하였고, 코어(820B)가 레지스터(R5)에 대한 레지스터 기록을 전송하였고, 그리고 코어(820C)가 어떠한 레지스터 기록도 전송하지 않은 이후에, 중단 조건을 검출한다. 중단이 검출되는 경우, 어떠한 더 많은 투기적 레지스터 기록도 발생하지 않도록, 코어(820A)는 일시 정지 메시지를 하류의 코어(820B)로 전송할 수 있는데, 코어(820B)는 일시 정지 메시지를 코어(820C)로 전송하고, 코어(820C)는 일시 정지 메시지를 코어(820D)로 전송한다. 코어(820A)는 4의 커밋된 값을 갖는 레지스터(R0)에 대한 레지스터 기록 메시지를 코어(820B)에 전송할 수 있고; 코어(820B)는 이전 레지스터 값(932)을 레지스터(R0)에 대한 4로 업데이트하고; 레지스터 기록 메시지는, 레지스터(R0)에 대한 기록 마스크가 어써트되지만 그러나 레지스터(R0)가 코어(820B)에 의해 기록되지 않았기 때문에, 코어(820B)로부터 포워딩되지 않는다. 코어(820A)는 7의 커밋된 값을 갖는 레지스터(R2)에 대한 레지스터 기록 메시지를 코어(820B)에 전송할 수 있고; 코어(820B)는 이전 레지스터 값(932)을 레지스터(R2)에 대한 7로 업데이트하고; 레지스터 기록 메시지는, 레지스터(R0)에 대한 기록 마스크가 코어(820B)에 어써트되지 않기 때문에, 코어(820B)로부터 코어(820C)로 포워딩되고; 코어(820C)는 이전 레지스터 값(932)을 레지스터(R2)에 대한 7로 업데이트한다. 모든 레지스터 기록 메시지가 코어(820A)로부터 전송되는 경우, 코어(820A)는 중단 메시지를 코어(820B)로 전송하고 코어(820A)는 아이들 상태로 전이한다. 코어(820B)가 중단 메시지를 수신하는 경우, 코어(820B)는 중단 상태로 진입한다. 코어(820B)는 커밋된 값을 갖는 레지스터(R5)에 대한 레지스터 기록 메시지를 코어(820C)로 전송할 수 있고; 코어(820C)는 이전 레지스터 값(932)을 레지스터(R5)에 대한 커밋된 값으로 업데이트하고; 레지스터 기록 메시지는 코어(820C)로부터 포워딩되고, 및 등등이다. 모든 레지스터 기록 메시지가 코어(820B)로부터 전송되는 경우, 코어(820B)는 중단 메시지를 코어(820C)로 전송하고 코어(820B)는 아이들 상태로 전이한다. 코어(820C)가 중단 메시지를 수신하는 경우, 코어(820C)는 중단 상태로 진입한다. 어떠한 레지스터도 코어(820C)에 의해 기록되지 않았기 때문에, 코어(820C)는 중단 메시지를 코어(820D)로 전송할 수 있고 코어(820C)는 아이들 상태로 전이할 수 있다. 코어(820D)가 중단 메시지를 수신하는 경우, 코어(820D)는 완료된 중단 신호를 생성할 수 있고 트랜잭션 레지스터 파일(830) 내의 모든 레지스터 값이 커밋된 값인 상태에서 실행이 재시작될 수 있다. 이러한 방식에서, 초기 투기적 값이 사용되어 단일의 스레드의 병렬 계산을 잠재적으로 증가시키는 것을 허용하면서, 원자 실행 모델이 지원될 수 있다.
분산된 트랜잭션된 레지스터 파일의 다른 실시형태에서, 각각의 트랜잭션된 레지스터 파일 인스턴스(830B)는 상기에서 설명되는 바와 같은 엔트리마다의 필드(940)(942, 944, 946을 포함함), 및 이전 값(932)만을 포함하는(그러나 다음 값(934)을 포함하지 않음) 레지스터 값(930)을 포함할 수 있다. 각각의 송신기(822)-수신기(824) 쌍(예를 들면, 822D-824A)은, 코어(820)가 비투기적 실행 상태(1020)에 있는 경우에 발생할 수도 있는 바와 같이 코어 사이의 코어간 메시지가 일시적으로 버퍼링될(큐잉될) 수 있도록, 또는 코어(820)가 비투기적 실행 상태(1020) 이외의 상태에 있는 경우에 발생할 수도 있는 바와 같이 통상적으로 즉시 프로세싱될 수도 있도록, 메시지의 선입선출 탄성 버퍼(first-in first-out elastic buffer)(FIFO)를, 그들 사이에 또는 그들 중에 포함할 수 있다. 이러한 대안적인 실시형태에서, FIFO 큐는, 레지스터 기록 업데이트가 비투기적 블록의 레지스터 파일 상태를 조기에 업데이트하지 않도록, 레지스터 기록 업데이트를 미루도록(hold-off) 기능한다. 일단 비투기적 블록이 커밋되면, 그것의 상태는 아이들 상태(1010)로 전이하고, 이 모드에서 FIFO에 큐잉되어 있는 레지스터 기록 메시지는, 그 코어의 레지스터 파일의 이전 값(들)(932)을 업데이트하는 것을 제외하면, 상기에서 설명되는 바로 그대로 최종적으로 프로세싱된다.
도 10은 블록 기반의 프로세서 코어에 대한 예시적인 상태도(1000)를 예시한다. 예를 들면, 상태도(1000)는 도 9의 상태 머신(950)의 상태 및 상태 전이를 나타낼 수 있다. 상태도(1000)에 대응하는 상태 머신은 다음 중 하나 이상을 사용하여 적어도 부분적으로 구현될 수 있다: 하드웨어에 내장된 유한 상태 머신, 프로그래밍 가능한 마이크로코드, 프로그램 가능 게이트 어레이, 또는 다른 적절한 제어 회로. 상태 머신의 상태는, 프로세서 코어에 의해 다양한 동작 조건이 검출되는 경우 및/또는 프로세서 코어에서 메시지가 수신되는 경우 수행할 액션을 결정하기 위해 사용될 수 있다. 예를 들면, 트랜잭션 레지스터 파일이, 수신된 메시지 및 상태 머신의 상태에 기초하여 업데이트될 수 있다. 도 10의 상태의 각각은, 도 6의 상태 중 하나 이상에 추가될 수 있거나 또는 그 하나 이상과 잠재적으로 중첩될 수 있다는 것을 유의해야 한다. 특정한 예로서, 아이들 상태(1010)는 도 6의 매핑되지 않은 상태(605), 매핑된 상태(610) 및 아이들 상태(670)를 포함할 수 있다. 다른 특정한 예로서, 투기적 실행 상태(1030) 및 비투기적 실행 상태(1020)는, 도 6으로부터의 페치 상태(620), 디코드 상태(630), 및 실행 상태(640)를 포함할 수 있다.
아이들 상태(1010)에서, 프로세서 코어는 아이들 상태일 수 있다. 아이들 상태(1010) 동안, 프로세서 코어는 명령어 블록을 실행하고 있지 않고 저전력 상태에 있을 수 있다. 프로세서 코어를 저전력 상태로 두는 것은, 예컨대 프로세서 코어의 하나 이상의 클록을 게이트 제어하는 것, 프로세서 코어의 전압을 감소시키는 것 또는 프로세서 코어의 하나 이상의 전압 아일랜드(voltage island)의 전력을 차단하는 것, 및/또는 프로세서 코어의 하나 이상의 클록의 주파수를 감소시키는 것에 의해, 프로세서 코어의 로직의 적어도 일부분의 전력을 감소시키는 것을 포함할 수 있다. 하나의 예에서, 프로세서 코어가 링 상에서 메시지를 수신 및 송신할 수 있도록 그리고 프로세서 코어가 아이들 상태에 있는 경우에 트랜잭션 레지스터 파일의 상태 및 값이 업데이트될 수 있도록, 메시징 시스템 및 트랜잭션 레지스터 파일은 프로세서 코어가 저전력 모드에 있는 경우에 전력이 차단되지 않는다. 아이들 상태 프로세서 코어는 통신 링 상에서 송신될 메시지를 일반적으로 소싱하지 않지만, 그러나 아이들 상태의 프로세서 코어는 상류의 프로세서 코어로부터 메시지를 수신할 수 있고 메시지를 하류의 프로세서 코어로 포워딩할 수 있다. 미래에 코어 상에서 실행될 수도 있는 명령어 블록이 최신의 커밋된 또는 투기된 레지스터 값에 액세스할 수 있도록, 아이들 상태의 프로세서 코어는, 메시지를 수신하는 것에 응답하여, 자신의 트랜잭션 레지스터 파일을 업데이트할 수 있다.
아이들 상태의 프로세서 코어에 의해 수신되는 비분기(non-branch) 메시지는, 프로세서 코어로 하여금 새로운 상태로 전이하게 하지 않고도, 아이들 상태의 프로세서 코어의 트랜잭션 레지스터 파일과 관련되는 상태에 영향을 끼칠 수 있다. 예를 들면, 펜딩 레지스터 상태는 기록 마스크 메시지를 수신하는 것에 응답하여 업데이트될 수 있다. 아이들 상태의 프로세서 코어와 관련되는 어떠한 기록 마스크도 없기 때문에, 기록 마스크 메시지는 수정 없이 하류의 코어로 포워딩될 수 있다. 다른 예로서, 트랜잭션 레지스터 파일의 이전 레지스터 값은, 레지스터 기록 메시지를 수신하는 것에 응답하여 업데이트될 수 있고, 펜딩 레지스터 상태는 레지스터 기록 메시지에 의해 기록되고 있는 레지스터에 대해 디어써트될 수 있다. 레지스터 기록 메시지는 다음 하류의 코어로 포워딩될 수 있다. 아이들 상태의 코어에 의해 수신되는 일시 정지 메시지는 아이들 상태의 코어에 의해 포워딩 또는 드랍될 수 있다. 아이들 상태의 코어가 저전력 모드에 있지 않은 경우, 수신된 일시 정지 메시지는 아이들 상태의 코어로 하여금 저전력 모드로 진행하게 할 수 있다. 아이들 상태의 코어에 의해 수신되는 중단 메시지는 아이들 상태의 코어에 의해 포워딩 또는 드랍될 수 있다. 하나의 예로서, 중단 메시지는, 펜딩 레지스터 상태로 하여금, 트랜잭션 레지스터 파일에 대해 플래시 클리어되게(flash-cleared) 또는 디어써트되게 할 수 있다.
아이들 상태의 프로세서 코어에 의해 수신되는 분기 메시지는 프로세서 코어로 하여금 실행 상태로 전이되게 할 수 있다. 특히, 아이들 상태의 코어가 커밋 또는 가장 오래된 토큰(상류 분기(1012))이 없는 상류의 프로세서 코어로부터 분기 메시지를 수신하는 경우, 아이들 상태의 코어는 투기적 실행 상태(1030)로 전이할 수 있다. 대안적으로, 아이들 상태의 코어가 커밋 토큰(업스트림 분기 및 커밋 토큰(1014))을 갖는 상류의 프로세서 코어로부터 분기 메시지를 수신하는 경우, 아이들 상태의 코어는 비투기적 실행 상태(1020)로 전이할 수 있다.
비투기적 실행 상태(1020)에서, 프로세서 코어는 비투기적 명령어 블록의 명령어를 실행할 수 있다. 예를 들면, 프로세서 코어는 분기 메시지에서 제공되는 어드레스를 사용하여 명령어 블록을 페치할 수 있고 명령어 블록은 디코딩되어 실행될 수 있다. 명령어 블록은, 명령어 블록에 의해 기록될 수 있는 모든 레지스터를 식별하는 기록 마스크를 갖는 명령어 헤더를 포함할 수 있다. 기록 마스크는 비투기적 코어의 트랜잭션 레지스터 파일의 레지스터 상태에 저장될 수 있다. 비투기적 코어에 의해 어떤 레지스터가 기록될 수도 있는지의 표시를 하류의 코어가 수신하도록, 비투기적 코어는 디코딩된 기록 마스크로부터의 정보를 갖는 기록 마스크 메시지를 하류의 코어로 전송할 수 있다. 비투기적 코어 상에서 실행되는 명령어는 레지스터에 기록될 수 있고, 각각의 레지스터 기록은 하류의 코어에 대한 레지스터 기록 메시지를 생성할 수 있다. 비투기적 코어가 성공적으로 완료될 수 있고 가시적인 아키텍쳐 상태가 커밋될 수 있다. 비투기적 코어가 성공적으로 완료되는 경우(내부 커밋(1022)), 프로세서 코어는 아이들 상태(1010)로 전이할 수 있다. 그러나, 비투기적 코어가 중단되는 경우(내부 중단 1024), 프로세서 코어는 중단 상태(1050)로 전이할 수 있다. 이러한 방식에서, 하나의 명령어 블록이 하나의 코어 상에서 실행되어 커밋되고 다음 블록이 다른 코어 상에서 실행되어 커밋되기 때문에, 계산은 다수의 프로세서 코어에 걸쳐 분산될 수 있다. 도 8로부터의 특정 예에서, 계산은, 일련의 블록이 커밋됨에 따라, 시간에 걸쳐 상이한 코어 상에서 호스팅되는 가장 오래된 비투기적 블록이 발견될 수도 있도록, 예컨대 820A, 그 다음 820B, 그 다음 820C, 그 다음 820D, 그 다음 다시 820A 및 계속 이런 식으로 진행될 수 있다.
투기적 실행 상태(1030)에서, 프로세서 코어는 투기적 명령어 블록의 명령어를 투기적으로 실행할 수 있다. 예를 들면, 프로세서 코어는 분기 메시지에서 제공되는 어드레스를 사용하여 명령어 블록을 페치할 수 있고 명령어 블록은 디코딩되어 실행될 수 있다. 명령어 블록은, 명령어 블록에 의해 기록될 수 있는 모든 레지스터를 식별하는 기록 마스크를 갖는 명령어 헤더를 포함할 수 있다. 기록 마스크는 비투기적 코어의 트랜잭션 레지스터 파일의 기록 마스크 레지스터 상태에 저장될 수 있다. 투기적 코어는, 어떤 레지스터가 상류의 코어(예컨대 비투기적 코어)에 의해 기록될 수도 있는지를 나타내는 하나 이상의 기록 마스크 메시지를 수신할 수 있다. 기록 마스크 메시지로부터의 정보는, 더 이전의 블록으로부터의 명령어에 의존하는, 투기적 코어 내의 명령어를 결정하기 위해 사용될 수 있다. 기록 마스크 메시지의 정보는 트랜잭션 레지스터 파일의 펜딩 상태에 저장될 수 있다. 비투기적 코어는 복합 기록 마스크 메시지를 하류의 코어로 전송할 수 있다. 복합 기록 마스크 메시지는, 펜딩 상태와 기록 마스크 레지스터 상태를 결합하여, 상류의 코어에 의해 어떤 레지스터가 기록될 수도 있는지의 표시를 제공할 수 있다. 투기적 코어 상에서 실행되는 명령어는 레지스터에 기록될 수 있고, 각각의 레지스터 기록은 하류의 코어에 대한 레지스터 기록 메시지를 생성할 수 있다. 투기적 코어는, 상류의 코어가 비투기적이고 성공적으로 완료한(상류의 커밋(1032)) 이후 비투기적 상태(1020)로 전이할 수 있다. 그러나, 상류의 코어가 중단되는 경우, 투기적 코어가 잘못 투기되는 경우, 또는 예외 처리에 기인하여 투기가 자체 중단되는 경우, 투기적 코어 상에서 실행되는 명령어 블록은 중단될 수 있다. 하나의 예로서, 투기적 코어가 롤백될 상태의 업데이트를 중지할 수 있도록, 업스트림 중단 코어는 일시 정지 메시지를 투기적 코어로 전송할 수 있다. 특히, 투기적 코어는 일시 정지 메시지(일시 정지(1034)) 수신할 수 있고 일시 정지 상태(1040)로 전이할 수 있다. 다른 예로서, 투기적 코어는 중단 메시지(상류 중단(1036))를 수신할 수 있고 중단 상태(1050)로 전이할 수 있다.
일시 정지 상태(1040)에서, 프로세서 코어는 일시 정지될 수 있다. 하나의 예로서, 명령어 스케줄러는 코어에 의해 실행될 명령어 발행을 중지할 수 있다. 명령어가 발행되는 것을 중지시키는 것에 의해, 코어가 일시 정지되지 않는 경우보다 더 빨리 아키텍쳐 상태가 커밋된 상태로 롤백될 수 있도록, 비발행 명령어에 의해 야기되는 아키텍쳐 상태에 대한 추가의 투기적인 변경이 방지될 수 있다. 추가적으로, 비발행 명령어를 실행하는 것과 관련되는 에너지가 잠재적으로 감소 또는 제거될 수 있다. 상기에서 설명되는 바와 같이 프로세서 코어를 저전력 모드에 두는 것에 의해 에너지는 추가로 감소될 수 있다. 일시 정지 상태(1040)에 있는 코어는, 트랜잭션 레지스터 파일의 레지스터 값이 커밋된 값으로 리턴될 때 상류의 코어로부터 레지스터 기록 메시지를 수신할 수 있다. 일시 정지된 코어는 레지스터 기록 메시지에서 식별되는 이전 레지스터 값을 업데이트할 수 있고, 레지스터 기록 메시지는, 레지스터 기록 메시지에 대응하는 기록 마스크가 일시 정지된 코어에 대해 어써트되지 않는 한, 하류의 코어로 포워딩될 수 있다. 프로세서 코어는, 일시 정지된 코어가 중단 메시지를 수신하는 경우(업스트림 중단(1042)) 중단 상태(1050)로 전이할 수 있다.
중단 상태(1050)에서, 프로세서 코어는 프로세서 코어에 의해 업데이트된 임의의 아키텍쳐 상태를 롤백할 수 있다. 하나의 예로서, 프로세서 코어에 의해 투기적으로 기록된 임의의 레지스터는 레지스터의 커밋된 상태로 리턴될 수 있다. 프로세서 코어에 의해 투기적으로 기록된 레지스터는 트랜잭션 레지스터 파일의 기록 상태에 의해 식별된다. 프로세서 코어가 중단 상태(1050)에 있을 때, 트랜잭션 레지스터 파일의 이전 레지스터 값은 각각의 레지스터에 대한 커밋된 값을 유지한다. 따라서, 프로세서 코어는, (이전 레지스터 값으로부터 판독되는 바와 같은) 커밋된 값을 갖는 레지스터 기록 메시지를 하류의 코어에 전송하는 것에 의해 하류의 프로세서 코어 내의 투기적으로 기록된 레지스터를 업데이트할 수 있다. 프로세서 코어는, 프로세서 코어에 의해 투기적으로 기록된 레지스터의 각각을 통해 시퀀스화될 수 있어서, 투기적으로 기록된 레지스터의 각각에 대한 레지스터 기록 메시지를 전송할 수 있다. 프로세서 코어는, 투기적으로 기록된 레지스터 모두가 그들의 커밋된 값으로 리턴되고 임의의 다른 중단 정리 조건(abort clean-up condition)이 완료되는 경우, 중단 상태(1050)로 종료될 수 있다. 중단 정리 조건이 완료되면(내부 완료), 프로세서 코어는 아이들 상태(1010)로 전이할 수 있다.
X. 트랜잭션 레지스터 파일을 사용하는 예시적인 방법
도 11은 프로세서 코어 상에서 프로그램의 명령어 블록을 실행하는 예시적인 방법(1100)을 예시하는 플로우차트이다. 예를 들면, 방법(1100)은 도 8 및 도 9의 프로세서 코어(820A-820D)에 의해 수행될 수 있다. 프로세서 코어는, 각각의 프로세서 코어가 상류의 프로세서 코어로부터 메시지를 수신할 수 있고 하류의 프로세서 코어로 메시지를 전송할 수 있도록, 링에서 연결될 수 있다. 프로세서 코어는 트랜잭션 레지스터 파일 및 실행 유닛을 포함할 수 있다. 트랜잭션 레지스터 파일은 복수의 레지스터를 포함할 수 있는데, 각각의 레지스터는 이전 값 필드(previous value field) 및 다음 값 필드(next value field)를 포함한다. 실행 유닛은 명령어 블록의 명령어를 실행하도록 구성될 수 있다.
프로세스 블록(1110)에서, 레지스터 기록 메시지는 프로세서 코어에서 수신될 수 있고 트랜잭션 레지스터 파일의 레지스터는 수신된 레지스터 기록 메시지에 기초하여 업데이트될 수 있다. 레지스터 기록 메시지는 프로세서 코어 또는 명령어 블록 식별자, 레지스터 식별자, 및 레지스터 값을 포함할 수 있다. 프로세서 코어 또는 명령어 블록 식별자는 레지스터 기록 메시지의 소스를 식별할 수 있다. 트랜잭션 레지스터 파일의 레지스터는, 레지스터 기록 메시지의 소스 및 프로세서 코어의 상태에 기초하여 상이한 방식으로 업데이트될 수 있다. 하나의 예로서, 프로세서 코어는 투기적 실행 상태에 있을 수 있고 레지스터 기록 메시지는, 프로세서 코어 상에서 투기적으로 실행되는 명령어 블록보다 프로그램 순서에서 더 이전의 명령어 블록을 실행하는 상이한 프로세서 코어에 의해 생성될 수 있다. 이 경우, 트랜잭션 레지스터 파일 내의 레지스터 엔트리의 이전 값 필드는, 레지스터 기록 메시지의 레지스터 값을 사용하여 업데이트될 수 있다. 구체적으로, 레지스터 기록 메시지에 의해 식별되는 레지스터는, 프로세서 코어 상에서의 명령어 블록의 실행 이전의 상태에 대응하는 값을 저장하기 위해 사용될 수 있다. 다른 예로서, 프로세서 코어는 비투기적 실행 상태에 있을 수 있다. 이 경우, 트랜잭션 레지스터 파일의 다음 값 필드는, 레지스터 기록 메시지의 레지스터 값을 사용하여 업데이트될 수 있다. 구체적으로, 레지스터 기록 메시지에 의해 식별되는 레지스터는, 명령어 블록이 프로세서 코어에 의해 실행되어 커밋된 이후의 상태에 대응하는 값을 저장하기 위해 사용될 수 있다.
프로세스 블록(1120)에서, 명령어 블록의 명령어가 실행되고 명령어가 레지스터에 기록되는 경우 레지스터 기록 메시지가 전송될 수 있다. 실행 로직은 명령어가 실행되는 경우 결과를 생성할 수 있다. 하나의 예로서, 명령어의 결과는 명령어 블록의 다른 명령어에 의해 사용되지 않고, 대신, 실행 로직은 결과로 하여금 레지스터 기록 메시지를 사용하여 하류의 프로세서 코어로 전송되게 할 수 있다. 구체적으로, 레지스터 기록 메시지는 소스 프로세서 코어 또는 명령어 블록 식별자, 타겟으로 된 레지스터 식별자, 및 생성된 결과를 포함할 수 있다.
프로세싱 블록(1130)에서, 더 이전의 명령어 블록에 의해 아직 기록되지 않은 레지스터를 나타내는 기록 마스크 메시지가 수신될 수 있다. 하나의 예로서, 기록 마스크 메시지는 비트 벡터를 포함할 수 있는데, 이 경우, 벡터의 각각의 비트는 트랜잭션 레지스터 파일의 레지스터 중 하나에 대응한다. 비트 벡터의 비트는, 대응하는 레지스터가 더 이전의 명령어 블록에 의해 기록될 것이지만, 그러나 레지스터가 아직 기록되지 않은 경우에 어써트될 수 있고(예를 들면, 1로 설정됨); 비트 벡터의 비트는, 대응하는 레지스터가 더 이전 명령어 블록에 의해 기록되지 않을 경우에 디어써트될 수 있다(예를 들면, 0으로 설정됨). 수신된 기록 마스크 메시지로부터의 정보는 각각의 레지스터에 대한 펜딩 상태로서 저장될 수 있다. 구체적으로, 각각의 레지스터에 대한 펜딩 상태는, 대응하는 비트가 수신된 기록 마스크 메시지에서 어써트되는 경우에 어써트될 수 있다. 각각의 레지스터에 대한 펜딩 상태는, 레지스터에 대응하는 레지스터 기록 메시지가 수신되는 경우에 디어써트될 수 있다.
프로세싱 블록(1140)에서, 명령어 블록에 의해 기록될 수도 있는 레지스터를 나타내는 기록 마스크 메시지가 전송될 수 있다. 예를 들면, 각각의 명령어 블록은, 명령어 블록에 의해 기록될 수도 있는 모든 레지스터를 식별하는 기록 마스크를 갖는 명령어 헤더를 포함할 수 있다. 기록 마스크는 술어적 및/또는 비술어적 명령어에 의해 기록되는 레지스터를 포함할 수 있다. 기록 마스크 메시지는, 예를 들면, 명령어 헤더의 기록 마스크가 디코딩된 이후 전송될 수 있다.
프로세싱 블록(1150)에서, 명령어 블록의 명령어는, 로컬 코어의 트랜잭션 레지스터 파일에 저장되는 레지스터 값을 사용하여 실행될 수 있다. 명령어는, 명령어의 피연산자가 이용 가능하게 될 때 데이터플로우 순서대로 발행될 수 있다. 예를 들면, 명령어 중 몇몇은 상이한 명령어 블록(예를 들면, 프로그램 순서에서 더 이전의 명령어 블록)에 의해 생성되는 그리고 트랜잭션 레지스터 파일에 저장되는 레지스터 값을 사용할 수 있다. 각각의 레지스터에 대한 펜딩 상태는, 레지스터 값이 레지스터에 여전히 기록되어 있는지 따라서 명령어가 발행할 준비가 되어 있는지를 결정하기 위해 사용될 수 있다. 구체적으로, 레지스터를 판독하는 명령어의 실행은, 레지스터에 대한 펜딩 상태가 디어써트된 이후까지, 지연될 수 있다. 펜딩 상태가 디어써트된 이후, 레지스터의 이전 값 필드는 명령어를 실행하기 위한 실행 로직에 의해 사용될 수 있다.
프로세스 블록(1160)에서, 레지스터 기록 메시지는 명령어 블록의 무효화 명령어가 실행되는 경우에 전송될 수 있다. 상기에서 설명되는 바와 같이, 기록 마스크는, 술어적 및/또는 비술어적 명령어에 의해 기록되는 레지스터를 포함할 수 있다. 술어적 명령어는 계산된 술어 값에 따라 실행될 수도 있거나 또는 실행되지 않을 수도 있다. 하나의 예에서, 술어 값은 참일 수도 있거나 또는 거짓일 수 있다. 발생하지 않은 술어 값(예를 들면, 참 값)에 대해서만 주어진 레지스터가 기록되는 경우, 무효화 명령어가 사용되어, 발생하는 술어 값(예를 들면, 거짓 값)에 대한 레지스터의 펜딩 상태를 해제할 수 있다. 무효화 명령어를 실행하는 것에 응답하여 전송되는 레지스터 기록 메시지는, 소스 프로세서 코어 또는 명령어 블록 식별자, 타겟으로 된 레지스터 식별자, 및 이전 값 필드로부터의 값을 포함할 수 있다.
프로세스 블록(1170)에서, 중단 조건은, 중단 메시지를 수신하는 것에 기초하여 또는 실행 로직에 의해 검출되는 조건에 기초하여 검출될 수 있다. 중단 조건이 감지되는 경우, 임의의 투기적 상태는, 실행을 재시작하기 이전에 중단 조건 이전의 커밋된 상태만이 존재하도록, 롤백될 수 있다. 중단 조건은 중단 메시지를 전송할 수 있는 상류의 프로세서 코어에 의해 검출될 수 있거나 또는 중단 조건은, 예를 들면, 예컨대 예외 처리가 발생하는 경우(예컨대, 제로에 의한 제산), 실행 로직에 의해 검출될 수 있다. 중단 조건이 감지되는 경우, 프로세서 코어는 중단 상태로 전이할 수 있다. 하나의 예로서, 중단 상태에 진입하는 것에 응답하여, 일시 정지 메시지가 송신될 수 있다. 일시 정지 메시지를 수신하는 것은, 프로세서 코어로 하여금, 명령어 발행을 중지하게 할 수 있고, 그 결과, 투기적 실행이 중지할 것이다. 일시 정지 메시지를 수신하는 것은, 프로세서 코어로 하여금, 다른 프로세서 코어가 투기적 상태로 롤백하는 동안 프로세서 코어의 일부분이 클록 게이트 제어되거나 또는 전력 차단되어 전력 소비를 감소시키는 저전력 모드에 진입하게 할 수 있다.
프로세스 블록(1180)에서, 중단 조건이 검출된 이후 투기적 레지스터 기록을 롤백하거나 또는 원상태로 돌리기(undo) 위해 레지스터 기록 메시지가 전송될 수 있다. 예를 들면, 프로세서 코어는, 명령어 블록의 명령어에 의해 투기적으로 기록되는 트랜잭션 레지스터 파일의 모든 레지스터의 모두를 결정할 수 있다. 프로세서 코어는, 레지스터 기록 메시지로 하여금, 명령어 블록의 명령어에 의해 투기적으로 기록되는 각각의 레지스터에 대해 송신되게 할 수 있다. 레지스터 기록 메시지는, 소스 프로세서 코어 또는 명령어 블록 식별자, 타겟으로 된 레지스터 식별자, 및 타겟으로 된 레지스터의 이전 값 필드로부터의 값을 포함할 수 있다. 프로세서 코어는, 중단 조건이 검출된 이후 그리고 명령어 블록의 명령어에 의해 투기적으로 기록되는 각각의 레지스터에 대한 모든 레지스터 기록 메시지가 프로세서 코어로부터 전송된 이후, 중단 메시지로 하여금 송신되게 할 수 있다.
프로세스 블록(1190)에서, 커밋 조건이 검출될 수 있고, 커밋 또는 중단 메시지가 프로세서 코어로부터 전송될 수 있다. 하나의 예로서, 커밋 조건은, 명령어 블록의 모든 레지스터 기록이 완료되는 것, 메모리에 대한 모든 저장이 완료되는 것, 및 분기 어드레스가 계산되는 것을 포함할 수 있다. 커밋 조건이 감지되는 경우, 프로세서 코어는 트랜잭션 레지스터 파일의 레지스터의 이전 값 필드와 다음 값 필드를 스왑할 수 있다. 프로세서 코어는 또한, 계산된 분기 어드레스를, 더 이전에 예측된 분기 어드레스에 비교할 수 있다. 예를 들면, 프로세서 코어의 분기 예측기는 분기 어드레스를 예측할 수 있고, 분기 메시지로 하여금 하류의 코어에 전송되게 하여, 하류의 코어로 하여금 예측된 분기 어드레스에서 명령어 블록의 투기적 실행을 시작하게 할 수 있다. 예측된 분기 어드레스가 잘못 예측되는 경우, 프로세서 코어는 중단 메시지를 하류의 코어로 송신할 수 있다. 예측된 분기 어드레스가 정확하게 예측되는 경우, 프로세서 코어는 커밋 메시지를 하류의 코어로 송신할 수 있다.
도 12는 프로세서 코어 상에서 프로그램의 명령어 블록을 실행하는 예시적인 방법(1200)을 예시하는 플로우차트이다. 예를 들면, 방법(1200)은 도 8 및 도 9의 프로세서 코어(820A-820D) 중 하나 이상에 의해 수행될 수 있다.
프로세스 블록(1210)에서, 레지스터 기록 메시지는 프로세서 코어에서 수신될 수 있다. 레지스터 기록 메시지는 레지스터 값을 포함할 수 있다.
프로세스 블록(1220)에서, 프로세서 코어의 상태에 기초하여 업데이트할, 트랜잭션 레지스터 파일의 엔트리의 이전 레지스터 값 필드 또는 다음 레지스터 값 필드가 선택될 수 있다. 예를 들면, 프로세서 코어 상태는, 아이들 상태, 투기적 실행, 비투기적 실행, 중단 및 일시 정지를 포함할 수 있다.
프로세스 블록(1230)에서, 트랜잭션 레지스터 파일의 엔트리의 선택된 필드가 레지스터 값으로 업데이트될 수 있다. 하나의 예로서, 다음 레지스터 값 필드는 프로세서 코어의 상태가 비투기적인 경우에 레지스터 값으로 업데이트될 수 있다. 다른 예로서, 이전의 레지스터 값 필드는 프로세서 코어의 상태가 비투기적이지 않은 경우에 레지스터 값으로 업데이트될 수 있다.
XI. 예시적인 컴퓨팅 환경
도 13은, 설명된 실시형태, 기법 및 기술이 구현될 수 있는 적절한 컴퓨팅 환경(1300)의 일반화된 예를 예시한다.
기술이 다양한 범용 또는 특수 목적 컴퓨팅 환경에서 구현될 수도 있기 때문에, 컴퓨팅 환경(1300)은 기술의 기능성 또는 사용의 범위에 관하여 어떠한 제한도 제시하도록 의도되는 것은 아니다. 예를 들면, 개시된 기술은, 핸드헬드 디바이스, 멀티 프로세서 시스템, 프로그래밍 가능한 소비자 전자장치, 네트워크 PC, 미니 컴퓨터, 메인프레임 컴퓨터, 및 등등을 비롯한, 다른 컴퓨터 시스템 구성으로 구현될 수도 있다. 개시된 기술은, 통신 네트워크를 통해 연결되는 원격 프로세싱 디바이스에 의해 작업이 수행되는 분산 컴퓨팅 환경에서도 또한 실시될 수도 있다. 분산 컴퓨팅 환경에서, 프로그램 모듈(블록 기반의 명령어 블록에 대한 실행 가능 명령어를 포함함)은 로컬 및 원격 메모리 스토리지 디바이스 둘 모두에 위치될 수도 있다.
도 13을 참조하면, 컴퓨팅 환경(1300)은 적어도 하나의 블록 기반의 프로세싱 유닛(1310) 및 메모리(1320)를 포함한다. 도 13에서, 이러한 가장 기본적인 구성(1330)은 점선 내에 포함된다. 블록 기반의 프로세싱 유닛(1310)은 컴퓨터 실행 가능 명령어를 실행하며, 실제의 또는 가상의 프로세서일 수도 있다. 다중 프로세싱 시스템에서, 다수의 프로세싱 유닛은 컴퓨터 실행 가능 명령어를 실행하여 프로세싱 능력을 증가시키고, 그러한 만큼, 다수의 프로세서가 동시에 실행되고 있을 수 있다. 메모리(1320)는 휘발성 메모리(예를 들면, 레지스터, 캐시, RAM), 불휘발성 메모리(예를 들면, ROM, EEPROM, 플래시 메모리, 등등), 또는 이들의 어떤 조합일 수도 있다. 메모리(1320)는, 예를 들면, 본원에서 설명되는 기술을 구현할 수 있는 소프트웨어(1380), 이미지, 및 비디오를 저장한다. 컴퓨팅 환경은 추가적인 피쳐를 구비할 수도 있다. 예를 들면, 컴퓨팅 환경(1300)은 스토리지 디바이스(1340), 하나 이상의 입력 디바이스(1350), 하나 이상의 출력 디바이스(1360), 및 하나 이상의 통신 연결(1370)을 포함한다. 버스, 컨트롤러, 또는 네트워크와 같은 상호 접속 메커니즘(interconnection mechanism)(도시되지 않음)은 컴퓨팅 환경(1300)의 컴포넌트를 인터커넥트한다. 통상적으로, 오퍼레이팅 시스템 소프트웨어(도시되지 않음)는, 컴퓨팅 환경(1300)에서 실행되는 다른 소프트웨어에 대한 동작 환경을 제공하고, 컴퓨팅 환경(1300)의 컴포넌트의 활동을 조정한다.
스토리지(1340)는 착탈식일 수도 있거나 또는 비착탈식일 수도 있고, 자기 디스크, 자기 테이프 또는 카세트, CD-ROM, CD-RW, DVD, 또는 정보를 저장하기 위해 사용될 수 있고 컴퓨팅 환경(1300) 내에서 액세스될 수 있는 임의의 다른 매체를 포함한다. 스토리지(1340)는, 소프트웨어(1380)에 대한 명령어, 플러그인 데이터, 및 메시지를 저장하는데, 이들은 본원에서 설명되는 기술을 구현하기 위해 사용될 수 있다.
입력 디바이스(들)(1350)는, 터치 입력 디바이스, 예컨대 키보드, 키패드, 마우스, 터치 스크린 디스플레이, 펜, 또는 트랙볼, 음성 입력 디바이스, 스캐닝 디바이스, 또는 컴퓨팅 환경(1300)에 입력을 제공하는 다른 디바이스일 수도 있다. 오디오의 경우, 입력 디바이스(들)(1350)는, 아날로그 또는 디지털 형태로 오디오 입력을 수용하는 사운드 카드 또는 유사한 디바이스일 수도 있거나, 또는 컴퓨팅 환경(1300)에 오디오 샘플을 제공하는 CD-ROM 리더일 수도 있다. 출력 디바이스(들)(1360)는 디스플레이, 프린터, 스피커, CD 라이터(CD-writer), 또는 컴퓨팅 환경(1300)으로부터의 출력을 제공하는 다른 디바이스일 수도 있다.
통신 연결(들)(1370)은 통신 매체(예를 들면, 연결 네트워크)를 통한 다른 컴퓨팅 엔티티로의 통신을 가능하게 한다. 통신 매체는, 컴퓨터 실행 가능 명령어, 압축된 그래픽 정보, 비디오 또는 다른 데이터와 같은 정보를 변조된 데이터 신호에서 전달한다. 통신 연결(들)(1370)은 유선 연결(예를 들면, 메가비트 또는 기가비트 이더넷, 인피니밴드(Infiniband), 전기 또는 광섬유 연결을 통한 파이버 채널(Fibre Channel))로 제한되는 것이 아니라, 무선 기술(예를 들면, 블루투스, 와이파이(WiFi)(IEEE 802.11a/b/n), 와이맥스(WiMax), 셀룰러, 위성, 레이저, 적외선을 통한 RF 연결) 및 개시된 에이전트, 브리지, 및 에이전트 데이터 소비자에 대한 네트워크 연결을 제공하기 위한 다른 적절한 통신 연결을 또한 포함한다. 가상 호스트 환경에서, 통신 연결(들)은 가상 호스트에 의해 제공되는 가상화된 네트워크 연결일 수 있다.
개시된 방법의 몇몇 실시형태는, 컴퓨팅 클라우드(1390)에서 개시된 기술의 전부 또는 일부를 구현하는 컴퓨터 실행 가능 명령어를 사용하여 수행될 수 있다. 예를 들면, 개시된 컴파일러 및/또는 블록 기반의 프로세서 서버는 컴퓨팅 환경(1330) 내에 위치되거나, 또는 개시된 컴파일러는 컴퓨팅 클라우드(1390)에 위치되는 서버 상에서 실행될 수 있다. 몇몇 예에서, 개시된 컴파일러는 전통적인 중앙 프로세싱 유닛(예를 들면, RISC 또는 CISC 프로세서) 상에서 실행된다.
컴퓨터 판독 가능 매체는 컴퓨팅 환경(1300) 내에서 액세스될 수 있는 임의의 이용 가능한 매체이다. 제한이 아닌 예로서, 컴퓨팅 환경(1300)에서, 컴퓨터 판독 가능 매체는 메모리(1320) 및/또는 스토리지(1340)를 포함한다. 쉽게 이해되어야 하는 바와 같이, 용어 컴퓨터 판독 가능 저장 매체는, 메모리(1320) 및 스토리지 디바이스(1340)와 같은 데이터 저장을 위한 매체를 포함하고, 변조된 데이터 신호와 같은 송신 매체는 포함하지 않는다.
XII. 개시된 기술의 추가적인 예
개시된 주제의 추가적인 예는 상기에서 논의되는 예에 따라 본원에서 논의된다.
하나의 실시형태에서, 프로세서는 복수의 블록 기반의 프로세서 코어를 포함할 수 있다. 블록 기반의 프로세서 코어는 명령어 블록을 실행하는 데 사용될 수 있다. 프로세서 코어는 트랜잭션 레지스터 파일 및 실행 유닛을 포함한다. 트랜잭션 레지스터 파일은 복수의 레지스터를 포함하는데, 각각의 레지스터는 이전 값 필드 및 다음 값 필드를 포함한다. 이전 값 필드는, 프로세서 코어 상에서의 명령어 블록의 실행 이전의 상태에 대응하는 값을 저장하는 데 사용될 수 있다. 다음 값 필드는, 프로세서 코어 상에서의 명령어 블록의 실행 이후의 상태에 대응하는 값을 저장하는 데 사용될 수 있다. 다음 값 필드는, 레지스터 기록 메시지가 수신되고 프로세서 코어가 비투기적으로 실행되고 있는 경우에 업데이트된다. 이전 값 필드는, 레지스터 기록 메시지가 수신되고 프로세서 코어가 투기적으로 실행되고 있는 경우에 업데이트된다. 실행 유닛은 명령어 블록의 명령어를 실행하도록 구성된다. 실행 유닛은 또한, 트랜잭션 레지스터 파일의 이전 값 필드로부터 레지스터 값을 판독하도록 그리고 명령어 블록의 명령어가 레지스터에 기록되는 경우에 레지스터 기록 메시지로 하여금 프로세서 코어로부터 송신되게 하도록 구성된다. 실행 유닛은 또한, 무효화 명령어가 실행되는 것에 응답하여 레지스터 기록 메시지로 하여금 프로세서 코어로부터 송신되게 하도록 구성될 수 있는데, 무효화 명령어는, 명령어 블록에 의해 기록되지 않은 레지스터를 나타낸다. 레지스터 기록 메시지는, 명령어 블록에 의해 기록되지 않은 레지스터에 대한 이전 값 필드에 저장되는 값을 포함할 수 있다.
트랜잭션 레지스터 파일은 복수의 레지스터의 각각의 레지스터에 대한 펜딩 상태를 더 포함할 수 있다. 펜딩 상태는, 프로세서 코어 상에서 실행되는 명령어 블록보다 프로그램 순서에서 더 이전의 명령어 블록의 명령어에 의해 레지스터가 기록된다는 것을 나타내는 기록 마스크 메시지를 수신하는 것에 응답하여, 어써트될 수 있다. 프로세서 코어는, 트랜잭션 레지스터 파일의 각각의 레지스터에 대한 펜딩 상태에 적어도 부분적으로 기초하여 데이터플로우 순서로 명령어 블록의 명령어를 실행 로직으로 발행하도록 구성되는 명령어 스케줄러 로직을 더 포함할 수 있다. 프로세서 코어는, 명령어 블록의 명령어에 의해 기록될 레지스터를 결정하도록 그리고 기록 마스크 메시지로 하여금 프로세서 코어로부터 송신되게 하도록 구성되는 디코드 로직을 더 포함할 수 있다. 기록 마스크 메시지는, 명령어 블록의 명령어에 의해 기록될 레지스터를 적어도 나타낼 수 있다. 예를 들면, 기록 마스크 메시지는, 명령어 블록의 명령어에 의해 기록될 레지스터 및 어써트된 펜딩 상태를 갖는 레지스터를 나타낼 수 있다.
실행 로직은 또한, 명령어 블록의 명령어의 중단 조건을 검출하도록 그리고 중단 조건이 검출되는 경우에 일시 정지 메시지로 하여금 프로세서 코어로부터 송신되게 하도록 구성될 수 있다. 프로세서 코어는, 명령어 블록의 명령어에 의해 투기적으로 기록되는 트랜잭션 레지스터 파일의 모든 레지스터를 결정하도록 그리고 명령어 블록의 명령어에 의해 투기적으로 기록되는 각각의 레지스터의 값을 복원하는 롤백 액션을 수행하도록 구성되는 중단 관리 로직을 더 포함할 수 있다. 예를 들면, 롤백 액션은, 명령어 블록의 명령어에 의해 투기적으로 기록되는 각각의 레지스터에 대해, 레지스터 기록 메시지로 하여금, 프로세서 코어로부터 송신되게 하는 것일 수 있다. 레지스터 기록 메시지는 각각의 레지스터에 대한 이전 값 필드에 저장되는 값을 포함할 수 있다. 중단 관리 로직은 또한, 중단 조건이 검출된 이후 그리고 명령어 블록의 명령어에 의해 투기적으로 기록되는 각각의 레지스터에 대한 모든 레지스터 기록 메시지가 프로세서 코어로부터 송신된 이후, 중단 메시지로 하여금 프로세서 코어로부터 송신되게 하도록 구성될 수 있다.
대안적인 실시형태에서, 각각의 프로세서 코어는 n 개의 명령어 윈도우를 포함할 수 있고, 각각의 명령어 윈도우는 트랜잭션 레지스터 파일을 포함할 수 있다. 상이한 명령어 윈도우의 트랜잭션 레지스터 파일은, 상이한 프로세서 코어 사이의 연결과 유사하게 연결될 수 있다. 여전히 다른 대안적인 실시형태에서, 프로세서는 단일의 프로세서 코어를 포함할 수 있고 메시지 송신기는 메시지 수신기에 연결될 수 있다. 프로세서 중 임의의 것은, (예컨대, FPGA 내에서) 프로그래밍 가능한 또는 구성 가능한 로직을 사용하여 구현될 수 있다.
프로세서 중 하나 이상은, 다양하고 상이한 컴퓨팅 시스템에서 사용될 수 있다. 예를 들면, 서버 컴퓨터는, 불휘발성 메모리 및/또는 스토리지 디바이스; 네트워크 연결; 하나 이상의 명령어 블록을 저장하는 메모리; 및 명령어 블록을 실행하기 위한 블록 기반의 프로세서 코어를 포함하는 프로세서를 포함할 수 있다. 다른 예로서, 디바이스는, 유저 인터페이스 컴포넌트; 불휘발성 메모리 및/또는 스토리지 디바이스; 셀룰러 및/또는 네트워크 연결; 명령어 블록 중 하나 이상을 저장하는 메모리; 및 명령어 블록을 실행하기 위한 블록 기반의 프로세서 코어를 포함하는 프로세서를 포함할 수 있다. 유저 인터페이스 컴포넌트는 다음 중 적어도 하나 이상을 포함할 수 있다: 디스플레이, 터치스크린 디스플레이, 햅틱 입력/출력 디바이스, 모션 감지 입력 디바이스, 및/또는 음성 입력 디바이스.
하나의 실시형태에서, 명령어 블록을 실행하는 방법은, 프로세서 코어에서 제1 레지스터 기록 메시지를 수신하는 것을 포함하는데, 제1 레지스터 기록 메시지는 레지스터 값을 포함한다. 방법은, 프로세서 코어의 상태에 기초하여 업데이트할, 트랜잭션 레지스터 파일의 엔트리의 이전 레지스터 값 필드 또는 다음 레지스터 값 필드를 선택하는 것을 더 포함한다. 방법은, 트랜잭션 레지스터 파일의 엔트리의 선택된 필드를 레지스터 값으로 업데이트하는 것을 더 포함한다. 다음 레지스터 값 필드는, 프로세서 코어의 상태가 비투기적 실행 상태인 경우에 업데이트하기 위해 선택될 수 있다. 이전 레지스터 값 필드는, 프로세서 코어의 상태가 비투기적 실행 상태가 아닌 경우에 업데이트하기 위해 선택될 수 있다.
방법은, 명령어 블록에 의해 기록될 트랜잭션 레지스터 파일의 레지스터를 결정하는 것 및 프로세서 코어로부터 기록 마스크 메시지를 송신하는 것을 더 포함할 수 있는데, 기록 마스크 메시지는 명령어 블록에 의해 기록될 트랜잭션 레지스터 파일의 레지스터를 나타낸다. 방법은 프로세서 코어에서 기록 마스크 메시지를 수신하는 것을 더 포함할 수 있는데, 기록 마스크 메시지는, 명령어 블록보다 프로그램 순서에서 더 이전의 하나 이상의 명령어 블록에 의해 기록될 트랜잭션 레지스터 파일의 레지스터를 나타낸다. 방법은, 수신된 기록 마스크 메시지에 적어도 부분적으로 기초하여 데이터플로우 순서로 실행하기 위해 명령어 블록의 명령어를 발행하는 것을 더 포함할 수 있다.
방법은, 명령어 블록보다 프로그램 순서에서 더 이전의 하나 이상의 명령어 블록에 의해 기록될 트랜잭션 레지스터 파일의 레지스터를 결정하는 것을 더 포함할 수 있다. 방법은 명령어 블록에 의해 기록될 트랜잭션 레지스터 파일의 레지스터를 결정하는 것을 더 포함할 수 있다. 방법은 프로세서 코어로부터 기록 마스크 메시지를 송신하는 것을 더 포함할 수 있다. 기록 마스크 메시지는, 명령어 블록에 의해 그리고 명령어 블록보다 프로그램 순서에서 더 이전의 하나 이상의 명령어 블록에 의해 기록될 트랜잭션 레지스터 파일의 레지스터를 나타낼 수 있다.
방법은, 명령어 블록의 명령어를 실행하여 명령어의 결과를 생성하는 것, 및 기록할 트랜잭션 레지스터 파일의 레지스터를 명령어가 명시하는 경우 명령어를 실행하는 것에 응답하여 프로세서 코어로부터 제2 레지스터 기록 메시지를 송신하는 것을 더 포함할 수 있다. 제2 레지스터 기록 메시지는 레지스터의 레지스터 식별자 및 명령어의 결과를 포함할 수 있다. 방법은, 프로세서 코어의 중단 상태 동안, 제3 레지스터 기록 메시지로 하여금, 프로세서 코어로부터 송신되게 하는 것을 더 포함할 수 있다. 제3 레지스터 기록 메시지는, 레지스터의 레지스터 식별자 및 레지스터의 이전 값 필드에 저장되는 값을 포함한다.
방법은, 명령어 블록의 무효화 명령어를 실행하는 것을 더 포함할 수 있는데, 무효화 명령어는 트랜잭션 레지스터 파일의 레지스터가 명령어 블록에 의해 기록되지 않는다는 것을 명시한다. 방법은, 무효화 명령어를 실행하는 것에 응답하여 프로세서 코어로부터 제2 레지스터 기록 메시지를 송신하는 것을 더 포함할 수 있다. 제2 레지스터 기록 메시지는 무효화된 레지스터에 대한 이전 레지스터 값 필드에 저장되는 값을 포함할 수 있다.
하나 이상의 컴퓨터 판독 가능 저장 매체는, 컴퓨터에 의해 실행될 때, 컴퓨터로 하여금 방법을 수행하게 하는 컴퓨터 판독 가능 명령어를 저장할 수 있다.
하나의 실시형태에서, 블록 기반의 프로세서 코어는 명령어 블록의 명령어를 실행하기 위해 사용될 수 있다. 프로세서 코어는 통신 시스템, 트랜잭션 레지스터 파일, 및 실행 로직을 포함한다. 통신 시스템은 메시지를 수신 및 송신하도록 구성된다. 예를 들면, 통신 시스템은, 상류의 프로세서 코어로부터 메시지를 수신하도록 그리고 하류의 프로세서 코어로 메시지를 송신하도록 구성될 수 있다. 트랜잭션 레지스터 파일은 복수의 레지스터를 포함하는데, 각각의 레지스터는 이전 값 필드 및 다음 값 필드를 포함한다. 이전 값 필드는, 프로세서 코어가 제1 동작 상태에 있는 경우 통신 시스템이 레지스터 기록 메시지를 수신하는 것에 기초하여 업데이트되도록 구성된다. 다음 값 필드는, 상태 머신이 제1 동작 상태와는 상이한 제2 동작 상태에 있는 경우 통신 시스템이 레지스터 기록 메시지를 수신하는 것에 기초하여 업데이트되도록 구성된다. 예를 들면, 프로세서 코어의 동작 상태는 상태 머신에 의해 유지될 수 있다. 특히, 상태 머신은, 통신 시스템에 의해 수신된 메시지 및 명령어 블록의 명령어를 실행하는 결과에 기초하여 프로세서 코어의 동작 상태를 추적하도록 구성될 수 있다. 실행 로직은 명령어 블록의 명령어를 실행하도록 구성된다. 실행 로직은 또한, 트랜잭션 레지스터 파일의 이전 값 필드로부터 레지스터 값을 판독하도록 그리고 명령어 블록의 명령어가 레지스터에 기록되는 경우 레지스터 기록 메시지로 하여금 통신 시스템에 의해 송신되게 하도록 구성된다.
프로세서는, 통신 시스템이 중단 메시지를 수신하는 것에 기초하여 중단 조건을 검출하도록 그리고 명령어 블록의 실행된 명령어에 의해 투기적으로 기록되는 각각의 레지스터에 대해 레지스터 기록 메시지로 하여금 통신 시스템에 의해 송신되게 하도록 구성되는 중단 관리 로직을 더 포함할 수 있다.
개시된 주제의 원리가 적용될 수도 있는 많은 가능한 실시형태를 고려하면, 예시된 실시형태는 단지 바람직한 예에 불과하며, 청구범위의 범위를 이들 바람직한 예로 제한하는 것으로 해석되지 않아야 한다는 것이 인식되어야 한다. 오히려, 청구된 주제의 범위는 다음의 청구범위에 의해 정의된다. 따라서, 이들 청구범위의 범위 내에 속하는 모든 것을 본 발명으로서 주장한다.
Claims (15)
- 명령어 블록을 실행하기 위한 블록 기반의 프로세서 코어로서,
복수의 레지스터 - 각각의 레지스터는 이전 값 필드(previous value field) 및 다음 값 필드(next value field)를 포함하고, 상기 이전 값 필드는 상기 프로세서 코어 상에서의 상기 명령어 블록의 실행 이전의 상태에 대응하는 값을 저장하기 위한 것이고, 상기 다음 값 필드는 상기 프로세서 코어 상에서의 상기 명령어 블록의 실행 이후의 상태에 대응하는 값을 저장하기 위한 것이고, 상기 다음 값 필드는, 레지스터 기록 메시지(register-write message)가 수신되고 상기 프로세서 코어가 비투기적으로(non-speculatively) 실행되고 있는 경우 업데이트되고, 상기 이전 값 필드는, 레지스터 기록 메시지가 수신되고 상기 프로세서 코어가 투기적으로(speculatively) 실행되고 있는 경우 업데이트됨 - 를 포함하는 트랜잭션 레지스터 파일; 및
상기 명령어 블록의 명령어를 실행하도록 구성되는 실행 유닛 - 상기 실행 유닛은 상기 트랜잭션 레지스터 파일의 상기 이전 값 필드로부터 레지스터 값을 판독하도록 그리고 상기 명령어 블록의 상기 명령어가 상기 레지스터에 기록되는 경우 레지스터 기록 메시지로 하여금 상기 프로세서 코어로부터 송신되게 하도록 구성됨 - 을 포함하는,
명령어 블록을 실행하기 위한 블록 기반의 프로세서 코어. - 제1항에 있어서,
상기 트랜잭션 레지스터 파일은 상기 복수의 레지스터의 각각의 레지스터에 대한 펜딩 상태를 더 포함하고, 상기 펜딩 상태는, 상기 프로세서 코어 상에서 실행되고 있는 명령어 블록보다 프로그램 순서에서 더 이전의 명령어 블록의 명령어에 의해 상기 레지스터가 기록된다는 것을 나타내는 기록 마스크 메시지(write-mask message)를 수신하는 것에 응답하여 어써트되는,
명령어 블록을 실행하기 위한 블록 기반의 프로세서 코어. - 제2항에 있어서,
상기 트랜잭션 레지스터 파일의 각각의 레지스터에 대한 상기 펜딩 상태에 적어도 부분적으로 기초하여 데이터플로우 순서로 상기 명령어 블록의 상기 명령어를 상기 실행 유닛으로 발행하도록 구성되는 명령어 스케줄러 로직을 더 포함하는,
명령어 블록을 실행하기 위한 블록 기반의 프로세서 코어. - 제1항 내지 제3항 중 어느 한 항에 있어서,
상기 명령어 블록의 상기 명령어에 의해 기록될 레지스터를 결정하도록 그리고 기록 마스크 메시지로 하여금 상기 프로세서 코어로부터 송신되게 하도록 구성되는 디코드 로직을 더 포함하되, 상기 기록 마스크 메시지는 상기 명령어 블록의 상기 명령어에 의해 기록될 적어도 상기 레지스터를 나타내는,
명령어 블록을 실행하기 위한 블록 기반의 프로세서 코어. - 제1항 내지 제4항 중 어느 한 항에 있어서,
상기 실행 유닛은 또한, 상기 명령어 블록의 명령어의 중단 조건을 검출하도록 그리고 상기 중단 조건이 검출되는 경우 일시 정지 메시지로 하여금 상기 프로세서 코어로부터 송신되게 하도록 구성되는,
명령어 블록을 실행하기 위한 블록 기반의 프로세서 코어. - 제5항에 있어서,
상기 명령어 블록의 상기 명령어에 의해 투기적으로 기록되는 상기 트랜잭션 레지스터 파일의 모든 레지스터를 결정하도록 그리고 상기 명령어 블록의 상기 명령어에 의해 투기적으로 기록되는 각각의 레지스터의 값을 복원하는 롤백 액션을 수행하도록 구성되는 중단 관리 로직을 더 포함하는,
명령어 블록을 실행하기 위한 블록 기반의 프로세서 코어. - 제6항에 있어서,
상기 중단 관리 로직은 또한, 상기 중단 조건이 검출된 이후 그리고 상기 명령어 블록의 상기 명령어에 의해 투기적으로 기록되는 각각의 레지스터에 대한 상기 레지스터 기록 메시지 모두가 상기 프로세서 코어로부터 송신된 이후, 중단 메시지로 하여금 상기 프로세서 코어로부터 송신되게 하도록 구성되는,
명령어 블록을 실행하기 위한 블록 기반의 프로세서 코어. - 제1항에 있어서,
상기 실행 유닛은 또한, 무효화 명령어(nullify instruction)가 실행되는 것에 응답하여 레지스터 기록 메시지로 하여금 상기 프로세서 코어로부터 송신되게 하도록 구성되되, 상기 무효화 명령어는, 상기 명령어 블록에 의해 기록되지 않은 레지스터를 나타내고, 상기 레지스터 기록 메시지는, 상기 명령어 블록에 의해 기록되지 않은 상기 레지스터에 대한 상기 이전 값 필드 내에 저장되는 상기 값을 포함하는,
명령어 블록을 실행하기 위한 블록 기반의 프로세서 코어. - 명령어 블록을 실행하는 방법으로서,
프로세서 코어에서 제1 레지스터 기록 메시지 - 상기 제1 레지스터 기록 메시지는 레지스터 값을 포함함 - 를 수신하는 단계;
상기 프로세서 코어의 상태에 기초하여 업데이트할, 트랜잭션 레지스터 파일의 엔트리의 이전 레지스터 값 필드 또는 다음 레지스터 값 필드를 선택하는 단계; 및
상기 트랜잭션 레지스터 파일의 상기 엔트리의 상기 선택된 레지스터 값 필드를 상기 레지스터 값으로 업데이트하는 단계를 포함하는,
명령어 블록을 실행하는 방법. - 제9항에 있어서,
상기 이전 레지스터 값 필드는, 상기 프로세서 코어의 상기 상태가 비투기적 실행 상태가 아닌 경우 업데이트하기 위해 선택되는,
명령어 블록을 실행하는 방법. - 제9항 또는 제10항에 있어서,
상기 프로세서 코어에서 기록 마스크 메시지 - 상기 기록 마스크 메시지는, 상기 명령어 블록보다 프로그램 순서에서 더 이전의 하나 이상의 명령어 블록에 의해 기록될 상기 트랜잭션 레지스터 파일의 상기 레지스터를 나타냄 - 를 수신하는 단계; 및
상기 수신된 기록 마스크 메시지에 적어도 부분적으로 기초하여 데이터플로우 순서로 실행하기 위해 상기 명령어 블록의 상기 명령어를 발행하는 단계를 더 포함하는,
명령어 블록을 실행하는 방법. - 제9항 내지 제11항 중 어느 한 항에 있어서,
상기 명령어 블록의 명령어를 실행하여 상기 명령어의 결과를 생성하는 단계; 및
기록할 상기 트랜잭션 레지스터 파일의 레지스터를 상기 명령어가 명시하는 경우 상기 명령어를 실행하는 것에 응답하여 상기 프로세서 코어로부터 제2 레지스터 기록 메시지 - 상기 제2 레지스터 기록 메시지는 상기 레지스터의 레지스터 식별자 및 상기 명령어의 상기 결과를 포함함 - 를 송신하는 단계를 더 포함하는,
명령어 블록을 실행하는 방법. - 제9항 내지 제12항 중 어느 한 항에 있어서,
상기 명령어 블록의 무효화 명령어 - 상기 무효화 명령어는 상기 트랜잭션 레지스터 파일의 레지스터가 상기 명령어 블록에 의해 기록되지 않는다는 것을 명시하고, 그에 의해 상기 레지스터가 무효화된 레지스터이다는 것을 명시함 - 를 실행하는 단계; 및
상기 무효화 명령어를 실행하는 것에 응답하여 상기 프로세서 코어로부터 제2 레지스터 기록 메시지 - 상기 제2 레지스터 기록 메시지는 상기 무효화된 레지스터에 대한 상기 이전 레지스터 값 필드 내에 저장되는 상기 값을 포함함 - 를 송신하는 단계를 더 포함하는,
명령어 블록을 실행하는 방법. - 명령어 블록의 명령어를 실행하기 위한 블록 기반의 프로세서 코어로서,
메시지를 수신 및 송신하도록 구성되는 통신 시스템;
복수의 레지스터 - 각각의 레지스터는 이전 값 필드 및 다음 값 필드를 포함하고, 상기 이전 값 필드는, 상기 프로세서 코어가 제1 동작 상태에 있는 경우 상기 통신 시스템이 레지스터 기록 메시지를 수신하는 것에 기초하여 업데이트되도록 구성되고, 상기 다음 값 필드는, 상기 프로세서 코어가 상기 제1 동작 상태와는 상이한 제2 동작 상태에 있는 경우 상기 통신 시스템이 레지스터 기록 메시지를 수신하는 것에 기초하여 업데이트되도록 구성됨 - 를 포함하는 트랜잭션 레지스터 파일; 및
상기 명령어 블록의 상기 명령어를 실행하도록 구성되는 실행 로직 - 상기 실행 로직은 상기 트랜잭션 레지스터 파일의 상기 이전 값 필드로부터 레지스터 값을 판독하도록 그리고 상기 명령어 블록의 상기 명령어가 상기 레지스터에 기록되는 경우 레지스터 기록 메시지로 하여금 상기 통신 시스템에 의해 송신되게 하도록 구성됨 - 을 포함하는,
명령어 블록의 명령어를 실행하기 위한 블록 기반의 프로세서 코어. - 제14항에 있어서,
상기 통신 시스템은 상류의 프로세서 코어로부터 메시지를 수신하도록 그리고 하류의 프로세서 코어로 메시지를 송신하도록 구성되는,
명령어 블록의 명령어를 실행하기 위한 블록 기반의 프로세서 코어.
Applications Claiming Priority (3)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| US15/224,593 | 2016-07-31 | ||
| US15/224,593 US20180032335A1 (en) | 2016-07-31 | 2016-07-31 | Transactional register file for a processor |
| PCT/US2017/043187 WO2018026539A1 (en) | 2016-07-31 | 2017-07-21 | Transactional register file for a block-based processor |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| KR20190031494A true KR20190031494A (ko) | 2019-03-26 |
Family
ID=59416864
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| KR1020197003192A KR20190031494A (ko) | 2016-07-31 | 2017-07-21 | 블록 기반의 프로세서에 대한 트랜잭션 레지스터 파일 |
Country Status (5)
| Country | Link |
|---|---|
| US (1) | US20180032335A1 (ko) |
| EP (1) | EP3491514A1 (ko) |
| KR (1) | KR20190031494A (ko) |
| CN (1) | CN109564508A (ko) |
| WO (1) | WO2018026539A1 (ko) |
Families Citing this family (12)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| WO2019173135A1 (en) * | 2018-03-08 | 2019-09-12 | quadric.io, Inc. | A machine perception and dense algorithm integrated circuit |
| WO2019190707A1 (en) | 2018-03-28 | 2019-10-03 | Quadric.I0, Inc. | System and method for implementing a machine perception and dense algorithm integrated circuit |
| US11042381B2 (en) | 2018-12-08 | 2021-06-22 | Microsoft Technology Licensing, Llc | Register renaming-based techniques for block-based processors |
| US10761822B1 (en) * | 2018-12-12 | 2020-09-01 | Amazon Technologies, Inc. | Synchronization of computation engines with non-blocking instructions |
| US11392537B2 (en) * | 2019-03-18 | 2022-07-19 | Microsoft Technology Licensing, Llc | Reach-based explicit dataflow processors, and related computer-readable media and methods |
| US11409560B2 (en) * | 2019-03-28 | 2022-08-09 | Intel Corporation | System, apparatus and method for power license control of a processor |
| US11307791B2 (en) * | 2019-05-24 | 2022-04-19 | Texas Instruments Incorporated | Quick clearing of registers |
| CN111124496B (zh) * | 2019-12-25 | 2022-06-21 | 合肥中感微电子有限公司 | 一种多周期指令处理方法、处理器和电子设备 |
| US11689478B2 (en) * | 2020-05-19 | 2023-06-27 | Achronix Semiconductor Corporation | Wide elastic buffer |
| CN111857823A (zh) * | 2020-07-15 | 2020-10-30 | 北京百度网讯科技有限公司 | 用于写回指令执行结果的装置和方法、处理装置 |
| CN114281412A (zh) * | 2021-12-24 | 2022-04-05 | 中电信数智科技有限公司 | 一种消息处理方法、装置、电子设备及存储介质 |
| CN117331720B (zh) * | 2023-11-08 | 2024-02-23 | 瀚博半导体(上海)有限公司 | 用于多核间通信的方法、寄存器组、芯片及计算机设备 |
Family Cites Families (7)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US6021500A (en) * | 1997-05-07 | 2000-02-01 | Intel Corporation | Processor with sleep and deep sleep modes |
| US7069189B2 (en) * | 2002-12-31 | 2006-06-27 | Intel Corporation | Method and apparatus for controlling multiple resources using thermal related parameters |
| US7496735B2 (en) * | 2004-11-22 | 2009-02-24 | Strandera Corporation | Method and apparatus for incremental commitment to architectural state in a microprocessor |
| US8631223B2 (en) * | 2010-05-12 | 2014-01-14 | International Business Machines Corporation | Register file supporting transactional processing |
| US9690620B2 (en) * | 2011-12-01 | 2017-06-27 | National University Of Singapore | Polymorphic heterogeneous multi-core architecture |
| US20160179532A1 (en) * | 2014-12-22 | 2016-06-23 | Qualcomm Incorporated | Managing allocation of physical registers in a block-based instruction set architecture (isa), and related apparatuses and methods |
| US9946549B2 (en) * | 2015-03-04 | 2018-04-17 | Qualcomm Incorporated | Register renaming in block-based instruction set architecture |
-
2016
- 2016-07-31 US US15/224,593 patent/US20180032335A1/en not_active Abandoned
-
2017
- 2017-07-21 KR KR1020197003192A patent/KR20190031494A/ko unknown
- 2017-07-21 CN CN201780047328.0A patent/CN109564508A/zh not_active Withdrawn
- 2017-07-21 EP EP17745629.0A patent/EP3491514A1/en not_active Withdrawn
- 2017-07-21 WO PCT/US2017/043187 patent/WO2018026539A1/en unknown
Also Published As
| Publication number | Publication date |
|---|---|
| EP3491514A1 (en) | 2019-06-05 |
| CN109564508A (zh) | 2019-04-02 |
| WO2018026539A1 (en) | 2018-02-08 |
| US20180032335A1 (en) | 2018-02-01 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| KR20190031494A (ko) | 블록 기반의 프로세서에 대한 트랜잭션 레지스터 파일 | |
| CN108027769B (zh) | 使用寄存器访问指令发起指令块执行 | |
| US10871967B2 (en) | Register read/write ordering | |
| EP3314437B1 (en) | Verifying branch targets in a block based processor | |
| CN108027773B (zh) | 存储器访问指令顺序编码的生成和使用 | |
| US10452399B2 (en) | Broadcast channel architectures for block-based processors | |
| CN108027770B (zh) | 用于数据流isa的密集读取编码 | |
| US10198263B2 (en) | Write nullification | |
| US11977891B2 (en) | Implicit program order | |
| CN108027734B (zh) | 空指令的动态生成 | |
| CN108027733B (zh) | 在目标字段中存储无效 | |
| KR20180021812A (ko) | 연속하는 블록을 병렬 실행하는 블록 기반의 아키텍쳐 | |
| US10031756B2 (en) | Multi-nullification | |
| US20170083331A1 (en) | Memory synchronization in block-based processors | |
| US20180329708A1 (en) | Multi-nullification | |
| EP3350690B1 (en) | Implicit program order |