KR20210116444A

KR20210116444A - 재구성가능한 데이터 프로세서의 구성 로드

Info

Publication number: KR20210116444A
Application number: KR1020217019007A
Authority: KR
Inventors: 마니쉬 케이 샤; 람 시바라마크리쉬난; 마크 러트렐; 데이비드 브라이언 잭슨; 라구 프라바카르; 숨티 자이라트; 그레고리 프레데릭 그로호스키; 프라모드 나타라자
Original assignee: 삼바노바 시스템즈 인코포레이티드
Priority date: 2018-11-21
Filing date: 2019-11-19
Publication date: 2021-09-27
Also published as: CA3120683A1; JP2022510852A; CN113383327A; US11609769B2; WO2020106768A1; US20200159544A1; CA3120683C; CN113383327B; US10831507B2; US20210055940A1; EP3884394A1

Abstract

재구성가능한 데이터 프로세서는 버스 시스템, 및 버스 시스템에 접속된 구성가능한 유닛들의 어레이를 포함하고, 어레이에서의 구성가능한 유닛들은 대응하는 구성가능한 유닛들에 특정한 구성 데이터의 복수의 서브-파일들을 포함하는 유닛 파일들을 저장하기 위한 구성 데이터 저장소들을 포함한다. 복수의 구성가능한 유닛들에서의 구성가능한 유닛들은 각각, 버스 시스템을 통해, 구성가능한 유닛에 특정한 유닛 파일의 서브 파일을 수신하는 것, 및 수신된 서브 파일들을 구성가능한 유닛의 구성 저장소에 로딩하는 것을 포함하는, 유닛 구성 로드 프로세스를 실행하기 위한 로직을 포함한다. 버스 시스템에 접속된 구성 로드 제어기는, 어레이에서의 복수의 구성가능한 유닛들에 대한 유닛 파일들을 포함하는 구성 파일을 분배하는 것을 포함하는, 어레이 구성 로드 프로세스를 실행하기 위한 로직을 포함한다.

Description

재구성가능한 데이터 프로세서의 구성 로드

우선권 적용

이 출원은 2018년 11월 21일자로 출원된 미국 비-가 출원 제 16/197,826 호 (대리인 문서 번호 SBNV 1001-1A) 의 이익을 주장하고, 이 출원은 참조에 의해 본원에 통합된다.

기술 분야

본 기술은 재구성가능한 아키텍처들의 구성에 관한 것이고, 코어스-그레인 재구성가능한 아키텍처들의 구성에 특히 적용될 수 있다.

관련 기술의 설명

필드 프로그래머블 게이트 어레이 (FPGA) 들을 포함하는 재구성가능한 프로세서들은 컴퓨터 프로그램을 실행하는 범용 프로세서를 사용하여 달성될 수 있는 것보다 더 효율적이거나 더 빠르게 다양한 기능들을 구현하도록 구성될 수 있다. 어레이에서의 구성가능한 유닛들이 전형적이고 더 세밀한 FPGA들에서 사용되는 것보다 더 복잡하고, 다양한 클래스들의 기능들의 더 빠르거나 더 효율적인 실행을 가능하게 할 수도 있는 소위 코어스-그레인 재구성가능한 아키텍처들 (coarse-grain reconfigurable architectures) (예컨대, CGRA들) 이 개발되고 있다. 예를 들어, 머신 러닝 및 인공 지능 워크로드를 위한 에너지 효율적인 가속기들의 구현을 가능하게 할 수 있는 CGRA들이 제안되었다. Prabhakar 등의 “Plasticine: A Reconfigurable Architecture for Parallel Patterns,” ISCA ’17, June 24-28, 2017, Toronto, ON, Canada 참조.

재구성가능한 프로세서들의 구성은, 때때로 비트스트림 또는 비트 파일로서 지칭되는 구성 파일을 생성하기 위한 구성 디스크립션의 컴파일, 및 구성 파일을 프로세서 상의 구성가능한 유닛들에 분배하는 것을 수반한다. 프로세스를 시작하기 위해, 그 프로세스에 대해 구성 파일이 로드되어야만 한다. 프로세스를 변경하기 위해, 구성 파일은 새로운 구성 파일로 대체되어야만 한다.

구성 파일을 분배하고 로드하기 위한 프로시저들 및 지원 구조들은 복잡할 수 있으며, 그 프로시저들의 실행은 시간 소비적일 수 있다.

동작 효율을 최대화하고 재구성가능한 프로세서 상에서 프로그램들을 스왑 (swap) 할 수 있도록 하기 위해, 구성 상태를 효율적으로 로딩하고 구성 및 프로그램 상태를 저장하는 수단이 필요하다.

요약

그리드 또는 타일 내에 배열된 프로그래머블 엘리먼트들 및 다른 타입들의 재구성가능한 프로세서들 (reconfigurable processors) 을 포함하는 코어스-그레인 재구성가능한 어레이 (Coarse-Grained Reconfigurable Array) 프로세서에 대한 구성 (configuration) 및 제어 상태 (control state) 의 효율적인 로딩 (loading) 및 언로딩 (unloading) 을 가능하게 하는 기술이 설명된다.

본 명세서에 설명된 기술은 메모리에 저장된, 그리고 병렬 및 직렬 기법들의 조합을 통해 재구성가능한 프로세서로 전송된, 포맷된 구성 파일로부터 구성 데이터를 로드 (load) 하는 능력을 제공한다. 또한, 본 명세서에 설명된 기술은 프로그램 제어 및 데이터 상태를 유사하게 포맷된 언로드 (unload) 구성 파일로 언로딩하는 효율적인 수단을 제공한다. 조합하여, 로드 및 언로드 기술들은 시간-공유 및 다른 가상화 기법들을 가능하게 하기 위해 재구성가능한 프로세서 내로 그리고 그 재구성가능한 프로세서 밖으로 프로그램들을 신속하게 스왑하기 위한 프로토콜들을 지원할 수 있다.

구성 및 재구성 프로시저들 (procedures) 및 구조들 (structures) 은 버스 시스템, 및 버스 시스템에 접속된 구성가능한 유닛들 (configurable units) 의 하나 이상의 어레이들을 포함하는 재구성가능한 프로세서에 대해 본 명세서에서 사용가능한 것으로 설명된다. 하나 이상의 어레이들에서의 구성가능한 유닛들은 본 명세서에서 유닛 파일들로서 지칭되는 구성 데이터를 저장하기 위해, 예를 들어 래치들의 직렬 체인들 (serial chains) 을 사용하여 구현되는 구성 데이터 저장소들 (configuration data stores) 을 포함한다. 구성가능한 유닛에 특정한 유닛 파일은 구성 데이터의 복수의 서브-파일들 (sub-files) 을 포함할 수 있다. 본 명세서에 설명된 예들에서, 서브-파일들은 버스 시스템을 사용하여 효율적인 분배 (distribution) 에 적합한 사이즈를 갖는 데이터의 "청크 (chunk)"로 이루어진다.

복수의 구성가능한 유닛들에서의 구성가능한 유닛들은 각각, 버스 시스템을 통해, 구성가능한 유닛에 특정한 유닛 파일의 서브 파일을 수신하는 것, 및 수신된 서브 파일들을 구성가능한 유닛의 구성 저장소에 로딩하는 것을 포함하는, 유닛 구성 로드 프로세스 (unit configuration load process) 를 실행하기 위한 로직 (logic) 을 포함한다. 일부 실시형태들에서, 복수의 구성가능한 유닛들에서의 구성가능한 유닛들은 구성 로드 프로세스에서 또한 사용되는 구성 후의 실행 동안 버스 시스템에서의 루트들 (routes) 을 사용한다.

어레이 구성 로드 프로세스 (array configuration load process) 를 실행하기 위한 로직을 포함하는 구성 로드 제어기 (configuration load controller) 가 설명된다. 어레이 구성 로드 프로세스는 머신 (machine) 을 구현하기 위해 어레이에서의 복수의 구성가능한 유닛들에 대한 유닛 파일들을 포함하는 구성 파일을 분배하는 것을 포함한다.

본 기술의 일 양태에서, 유닛 파일들은 복수의 순서화된 서브-파일들 (ordered sub-files) 을 포함하도록 조직될 수 있다. 일부 실시형태들에서, 상이한 구성가능한 유닛들에 특정한 유닛 파일들은 상이한 수들의 순서화된 서브-파일들을 가질 수도 있다. 구성가능한 유닛들의 어레이에 대한 구성 파일은, 유닛 파일들의 서브-파일들이 다른 유닛 파일들에 대해 동일한 순서의 다른 서브-파일들과 인터리빙되도록 배열되고, 구성 파일에서의 서브-파일의 로케이션 (location) 이 서브-파일의 어레이에서의 구성가능한 유닛 및 구성가능한 유닛에 특정한 유닛 파일에서의 그 순서를 암시하도록 배열된다.

본 명세서에 설명된 어레이 구성 로드 프로세스의 일례는, N 라운드들 (i = 0 내지 N-1 에 대해 라운드 R(i)) 의 분배 시퀀스로, 어레이에서의 복수의 구성가능한 유닛들에 서브 파일들을 전송함으로써 실행된다. 각 라운드 R(i) 에서, 프로세스는 순서 (i) 의 하나의 서브-파일을 버스 시스템을 통해 최대 (i+1) 개의 서브-파일들을 포함하는 유닛 파일들을 갖는 구성가능한 유닛들로 전송한다.

복수의 구성가능한 유닛들에서의 구성가능한 유닛들에서의 구성 데이터 저장소들은 직렬 체인들을 포함할 수 있고, 유닛 구성 로드 프로세스는, 하나의 버스 사이클에서, 분배 시퀀스의 한 라운드 (round) 에서 버스 시스템으로부터 구성가능한 유닛에 특정적인 유닛 파일의 제 1 서브-파일의 전부 또는 일부를 수신하는 것, 및 분배 시퀀스의 다음 라운드에서 제 2 서브-파일을 수신하기 전에 후속 버스 사이클 동안, 수신된 제 1 서브-파일을 직렬 체인 내로 푸시 (push) 하기 시작하는 것, 및 나중의 버스 사이클에서 버스 시스템으로부터 분배 시퀀스의 다음 라운드에서 제 2 서브-파일을 수신하는 것, 및 더 일찍 수신된 서브-파일들을 직렬 체인 내로 푸시한 후 버스 사이클들 동안, 수신된 제 2 서브-파일을 직렬 체인내로 푸시하기 시작하는 것에 의해 실행될 수 있다.

분배 시퀀스의 일부 라운드들에서, 제 1 서브-파일은 복수의 순서화된 서브-파일에서의 제 2 서브-파일이 구성가능한 유닛에 의해 수신되기 전에 구성가능한 유닛에서의 유닛 구성 로드 프로세스에 의해 소비된다.

어레이는 하나보다 많은 타입의 구성가능한 유닛을 포함할 수 있고, 상이한 타입들의 구성가능한 유닛들에 대한 유닛 파일들은 구성 데이터의 상이한 수들의 서브 파일들을 포함할 수 있다. 예를 들어, 제 1 타입의 구성가능한 유닛에 대한 유닛 파일들은 Z1 청크들을 포함하고, 제 2 타입의 구성가능한 유닛에 대한 유닛 파일들은 Z2 청크들을 포함하며, 여기서 Z1 은 Z2 보다 적다. 0 에서 Z1-1 로 진행하는 (i) 에 대해 라운드 R(i) 에서 분배될 제 1 타입 및 제 2 타입의 구성가능한 유닛들의 모두에 대해 유닛 파일들의 서브-파일 (i) 을 포함하는 구성 파일의 세그먼트들을 취출하고, 그 다음에, Z1 에서 Z2-1 로 진행하는 (i) 에 대해 라운드 R(i) 에서 분배될 제 2 타입의 구성가능한 유닛들의 모두에 대해 유닛 파일들의 서브-파일 (i) 을 포함하는 구성 파일의 세그먼트들을 취출하는 것을 포함할 수 있다. 이 프로토콜은 유닛 파일들에서 상이한 수들의 서브-파일들을 갖는 구성가능한 유닛들의 임의의 수의 타입들로 확장될 수 있다.

어레이 구성 로드 프로세스를 개시하기 위한 하나의 기법에서, 구성 파일의 메모리에서의 로케이션을 식별하는 구성 로드 커맨드 (configuration load command) 는 호스트 프로세스 (host process) 로부터 수신될 수 있고, 그 커맨드에 응답하여, 프로세스는 하나 이상의 메모리 액세스 요청들을 생성한다. 구성 파일의 요청된 부분이 반환됨에 따라 분배 시퀀스 (distribution sequence) 가 실행될 수 있다.

복수의 유닛 파일들의 서브-파일들은 분배 시퀀스에 매칭하는 인터리빙된 방식 (interleaved fashion) 으로 구성 파일에 배열될 수 있다. 구성 파일들의 이러한 배열 (arrangement) 은 구성 로드 프로세스가 구성가능한 유닛, 및 구성 파일에서의 서브-파일의 로케이션에 의해 각각의 서브-파일의 복수의 순서화된 서브-파일들에서의 포지션으 암시 (imply) 할 수 있게 한다. 어레이 구성 로드 프로세스는 구성 파일에서의 서브-파일들의 로케이션들에 기초하여 구성가능한 유닛들로 서브-파일들을 라우팅 (routing) 하는 것을 포함할 수 있다.

어레이 구성 로드 프로세스에 의해 구성 데이터를 수신하는 복수의 구성가능한 유닛들은 구성가능한 유닛들의 어레이에서의 모든 구성가능한 유닛들을 포함할 수 있다. 구성 파일에 의해 구현되는 머신이 구성가능한 유닛들 모두를 활용하지 않는 경우들에서, 미사용된 구성가능한 유닛들 중 하나 이상에 대한 유닛 파일은 비-동작 구성 (no-operation configuration) 을 구현할 수 있다. 또한, 어레이 구성 로드 프로세스는, 어레이 구성 로드 프로세스에 의해 구성 데이터를 수신하는 복수의 구성가능한 유닛들이 구성가능한 유닛들의 어레이에서의 구성가능한 유닛들의 전부보다 더 적게 포함하도록 구성될 수 있다.

본 명세서에 설명된 예에서의 구성가능한 유닛들의 어레이에서의 구성가능한 유닛들은 어레이 구성 로드 로직에서 시작하고 종료하는 데이지 체인 (daisy chain) 으로 접속된 각각의 로드 완료 상태 로직을 포함한다. 데이지 체인을 사용하여 구성 파일의 성공적인 로딩을 확인하기 위한 프로시저에서, 어레이 구성 로드 로직은 구성 파일이 분배된 후에 데이지 체인 상에 구성 로드 완료 신호를 포워딩하고, 어레이에서의 각각의 구성가능한 유닛에서, 구성 로드 완료 상태 로직은 체인의 이전 멤버로부터의 구성 로드 완료 신호가 수신되고 그 자신의 유닛 파일의 로딩이 완료될 때 데이지 체인 상에 구성 로드 완료 신호를 포워딩한다.

구성가능한 유닛들의 복수의 어레이들을 지원하는 버스 시스템이 본 명세서에서 설명되며, 여기서 각각의 어레이는 타일 (tile) 로 지칭될 수 있다. 설명된 버스 시스템은 외부 데이터 인터페이스 (예컨대, 하나 이상의 PCIE 또는 DDR 타입 인터페이스들) 에 그리고 각각의 타일에 대한 어레이 인터페이스에 접속된 최상위 레벨 네트워크 (top level network), 및 대응하는 타일에 대한 어레이 인터페이스에 그리고 구성가능한 유닛들의 어레이에서의 구성가능한 유닛들에 접속된 어레이 레벨 네트워크를 포함한다. 어레이 구성 로드 프로세스는, 호스트 프로세스로부터, 구성 파일의 메모리에서의 로케이션을 식별하는 구성 로드 커맨드를 수신하는 것, 및 외부 데이터 인터페이스를 통해 구성 파일을 취출 (retrieve) 하기 위해 커맨드에 응답하여 최상위 레벨 네트워크를 통해 하나 이상의 메모리 액세스 요청들을 생성하는 것을 포함할 수 있다. 어레이 구성 로드 프로세스는 구성 파일에서의 서브-파일들의 로케이션에 의해 암시되는 어드레스들을 사용하여 어레이 레벨 네트워크를 통해 구성가능한 유닛들로 서브-파일들을 라우팅할 수 있다.

어레이 구성 언로드 프로세스를 실행하기 위한 로직을 포함하는 구성 언로드 제어기가 설명되며, 이 어레이 구성 언로드 프로세스는, 대응하는 구성가능한 유닛들에 특정한 유닛 파일들을 언로드하기 위해 어레이에서의 복수의 구성가능한 유닛들에 언로드 커맨드를 분배하는 것을 포함하고, 여기서 유닛 파일들은 각각 복수의 순서화된 서브-파일들을 포함하고, 구성 언로드 제어기에서 구성가능한 유닛들의 어레이로부터 서브-파일들을 수신하는 것을 포함한다. 구성 언로드 파일은 서브 파일이 일부인 유닛 파일 (unit file) 의 구성가능한 유닛, 및 유닛 파일에서의 서브 파일의 순서 (order) 에 따라 메모리에 수신된 서브 파일들을 배열함으로써 어셈블링된다. 구성 언로드 파일의 구조는 상기 설명된 구성 파일의 구조와 동일할 수 있다. 복수의 구성가능한 유닛들에서의 구성가능한 유닛들은, 구성가능한 유닛의 구성 저장소로부터 서브-파일들을 언로딩하는 것 및 버스 시스템을 통해 (예를 들어, 어레이 레벨 네트워크를 통해) 구성가능한 유닛에 특정한 유닛 파일의 서브-파일들을 구성 언로딩 제어기로 송신하는 것을 포함하는, 유닛 구성 언로드 프로세스를 실행하기 위한 로직을 포함할 수 있다. 언로드된 서브-파일들은 구성 언로드 제어기에 의해 임의의 특정 순서로 수신될 필요는 없다. 그 후, 구성 언로드 제어기는 버스 시스템을 통해 (예를 들어, 최상위 레벨 네트워크를 통해) 메모리에 유닛 서브 파일들을 송신한다.

재구성가능한 데이터 프로세서를 구성하기 위한 방법들이 또한 제공된다.

본 명세서에 설명된 기술의 다른 양태들 및 이점들은 이하의 도면들, 상세한 설명 및 청구항들의 검토에서 알 수 있다.

도면들의 간단한 설명
도 1 은 호스트, 메모리, 및 재구성가능한 데이터 프로세서를 포함하는 시스템을 나타내는 시스템도이다.
도 2 는 CGRA ((Coarse Grain Reconfigurable Architecture) 의 최상위 레벨 네트워크 및 컴포넌트들의 간략화된 블록도이다.
도 3 은 도 2 의 구성에서 사용할 수 있는 타일 및 어레이 레벨 네트워크의 간략화된 다이어그램이고, 여기서 어레이의 구성가능한 유닛들은 어레이 레벨 네트워크의 노드들이다.
도 3a 는 어레이 레벨 네트워크에서 엘리먼트들을 접속하는 예시적인 스위치 유닛을 나타낸다.
도 4 는 예시적인 구성가능한 유닛을 나타내는 블록도이다.
도 5 는 구성가능한 유닛에서 유닛 구성 로드 프로세스를 제어하기 위해 사용될 수 있는 상태 머신 다이어그램의 일 예를 나타낸다.
도 6 은 구성가능한 유닛에서의 구성 저장소의 로드를 지원하는 구조의 논리적 표현이다.
도 7 은 재구성가능한 데이터 프로세서에 커플링된 호스트의 동작들을 나타내는 흐름도이다.
도 8 은 마스터 AGCU 의 일부일 수 있거나 그 외에 타일에서의 구성가능한 유닛들의 어레이와 통신할 수 있는 구성 로드 제어기의 동작들을 나타내는 흐름도이다.
도 9 는 구성 파일의 예시적인 조직을 나타낸다.
도 10 은 도 2 및 도 3 의 것과 같은 시스템에 대한 어레이 구성 로드 프로세스를 실행하기 위한 로직의 일 예를 나타내는 상태 머신 다이어그램이다.
도 11 은 도 10 의 것과 같은 분배 시퀀스의 조기 라운드들의 타이밍을 나타내는 타이밍도이다.
도 12 는 구성가능한 유닛에서의 유닛 구성 로드 프로세스를 나타내는 흐름도이다.
도 13 은 도 2 및 도 3 의 것과 같은 시스템에 대한 어레이 구성 언로드 프로세스를 실행하기 위한 로직의 일 예를 도시하는 상태 머신 다이어그램이다.
도 14 는 구성가능한 유닛에서의 유닛 구성 언로드 프로세스를 나타내는 흐름도이다.

상세한 설명

이하의 설명은 전형적으로 특정 구조적 실시형태들 및 방법들을 참조할 것이다. 본 기술을 구체적으로 개시된 실시형태들 및 방법들로 제한하려는 의도는 없고, 본 기술은 다른 특징들, 엘리먼트들, 방법들 및 실시형태들을 사용하여 실시될 수도 있다는 것이 이해되어야 한다. 바람직한 실시형태들은 청구항들에 의해 정의되는 그것의 범위를 제한하지 않고 본 기술을 예시하기 위해 설명된다. 당업자는 다음의 설명에 대한 다양한 등가의 변형들을 인식할 것이다.

도 1 은 호스트(120), 메모리(140), 및 재구성가능한 데이터 프로세서 (110) 를 포함하는 시스템을 나타내는 시스템도이다. 도 1 의 예에 도시된 바와 같이, 재구성가능한 데이터 프로세서(110)는 구성가능한 유닛들의 어레이(190) 및 구성 로드/언로드 제어기(195)를 포함한다. 구문 “구성 로드/언로드 제어기” 는, 본 명세서에서 사용된 바와 같이, 구성 로드 제어기 및 구성 언로드 제어기의 조합을 지칭한다. 구성 로드 제어기 및 구성 언로드 제어기는 별개의 로직 및 데이터 경로 리소스들 (resources) 을 사용하여 구현될 수도 있거나, 특정 실시형태에 적합하게 공유 로직 및 데이터 경로 리소스들을 사용하여 구현될 수도 있다. 일부 실시형태들에서, 시스템은 본 명세서에 설명된 타입들의 구성 로드 제어기만을 포함할 수도 있다. 일부 실시형태들에서, 시스템은 본 명세서에 설명된 타입들의 구성 언로드 제어기만을 포함할 수도 있다.

프로세서(110)는 호스트(120)에 접속된 외부 I/O 인터페이스(130) 및 메모리(140)에 접속된 외부 I/O 인터페이스(150)를 포함한다. I/O 인터페이스들(130, 150)은 버스 시스템(115)을 통해 구성가능한 유닛들의 어레이(190)에 그리고 구성 로드/언로드 제어기(195)에 접속된다. 버스 시스템(115)은 데이터의 하나의 청크를 운반하는 버스 폭을 가질 수도 있으며, 이는 이 예에 대해 128 비트일 수 있다 (전체적으로 128 비트에 대한 참조는 보다 일반적으로 예시적인 청크 사이즈로서 고려될 수 있다). 일반적으로, 구성 파일의 청크는 수 N 의 비트들의 데이터를 가질 수 있고, 버스 시스템은 하나의 버스 사이클에서 N 비트의 데이터를 전송하도록 구성될 수 있으며, 여기서 N 은 임의의 실제 버스 폭이다. 분배 시퀀스에서 분배된 서브-파일은 특정 실시형태에 적합한 하나의 청크, 또는 다른 양들의 데이터로 이루어질 수 있다. 프로시저들은 각각 하나의 데이터 청크로 이루어진 서브-파일들을 사용하는 것으로 본 명세서에서 설명된다. 물론, 본 기술은 예를 들어, 2 개의 버스 사이클들에서 분배된 2 개의 청크들로 이루어질 수도 있는 서브-파일들을 포함하여, 상이한 사이즈들의 서브-파일들을 분배하도록 구성될 수 있다.

구성가능한 유닛들의 어레이(190)에서의 구성가능한 유닛들을 구성 파일로 구성하기 위해, 호스트(120)는 구성 파일을 재구성가능한 데이터 프로세서(110) 내의 인터페이스(130), 버스 시스템(115) 및 인터페이스(150)를 통해 메모리(140)에 전송할 수 있다. 구성 파일은 구성가능한 프로세서(110) 외부의 데이터 경로들에서를 포함하여, 특정 아키텍처에 맞는 많은 방식들로 로딩될 수 있다. 구성 파일은 메모리 인터페이스(150)를 통해 메모리(140)로부터 취출될 수 있다. 그 후, 구성 파일의 청크들은 재구성가능한 데이터 프로세서(110) 내의 구성가능한 유닛들의 어레이(190) 내의 구성가능한 유닛들로 본 명세서에 설명된 바와 같은 분배 시퀀스로 전송될 수 있다.

외부 클럭 생성기(170) 또는 다른 클럭 신호 소스들은, 구성가능한 유닛들의 어레이(190), 버스 시스템(115), 및 외부 데이터 I/O 인터페이스들을 포함하는, 재구성가능한 데이터 프로세서(110) 내의 엘리먼트들에 클럭 신호(175) 또는 클럭 신호들을 제공할 수 있다.

도 2 는 CGRA (Coarse Grain Reconfigurable Architecture) 프로세서의 컴포넌트들의 간략화된 블록도이다. 이 예에서, CGRA 프로세서는 2개의 타일들(Tile1, Tile2)을 갖는다. 타일은 이 예에서 어레이 레벨 네트워크들을 포함하는, 버스 시스템에 접속된 구성가능한 유닛들의 어레이를 포함한다. 버스 시스템은 타일들을 외부 I/O 인터페이스(205)(또는 임의의 수의 인터페이스들)에 접속하는 최상위 레벨 네트워크를 포함한다. 다른 실시형태들에서, 상이한 버스 시스템 구성들이 이용될 수도 있다. 각각의 타일에서의 구성가능한 유닛들은 본 실시형태에서 어레이 레벨 네트워크 상의 노드들이다.

4개의 타일들의 각각은 4개의 AGCU들(Address Generation and Coalescing Units)(예를 들어, MAGCU1, AGCU12, AGCU13, AGCU14)을 갖는다. AGCU들은 최상위 레벨 네트워크 상의 노드들 및 어레이 레벨 네트워크들 상의 노드들이고, 각 타일에 최상위 레벨 네트워크 상의 노드들 및 어레이 레벨 네트워크 상의 노드들 사이에 데이터를 라우팅하기 위한 리소스들을 포함한다.

이 예에서 최상위 레벨 네트워크 상의 노드들은 인터페이스(205)를 포함하는 하나 이상의 외부 I/O를 포함한다. 외부 디바이스들에 대한 인터페이스들은 최상위 레벨 네트워크 상의 노드들과 인터페이스들에 연결된 고용량 메모리, 호스트 프로세서들, 기타 CGRA 프로세서들, FPGA 디바이스들 등과 같은 외부 디바이스들 사이에서 데이터를 라우팅하기 위한 리소스들을 포함한다.

타일에서의 AGCU들 중 하나는 이 예에서 타일에 대한 어레이 구성 로드/언로드 제어기를 포함하는 마스터 AGCU가 되도록 구성된다. 다른 실시형태들에서, 하나보다 많은 어레이 구성 로드/언로드 제어기가 구현될 수 있고, 하나의 어레이 구성 로드/언로드 제어기가 하나보다 많은 AGCU 사이에 분산된 로직에 의해 구현될 수도 있다.

MAGCU1은 Tile1에 대한 구성 로드/언로드 제어기를 포함하고, MAGCU2는 Tile2에 대한 구성 로드/언로드 제어기를 포함한다. 다른 실시형태들에서, 구성 로드/언로드 제어기는 하나보다 많은 타일의 구성을 로딩 및 언로딩하도록 설계될 수 있다. 다른 실시형태들에서, 하나 초과의 구성 제어기가 단일 타일의 구성을 위해 설계될 수 있다. 또한, 구성 로드/언로드 제어기는 최상위 레벨 네트워크 및 어레이 레벨 네트워크 또는 네트워크들 상의 독립형 노드로서 포함하는, 시스템의 다른 부분들에서 구현될 수 있다.

최상위 레벨 네트워크는 AGCU들을 포함하는, 최상위 레벨 네트워크 상의 다른 노드들에 뿐만 아니라 서로 접속하는 최상위 레벨 스위치들(211-216) 및 I/O 인터페이스(205)를 사용하여 구성된다. 최상위 레벨 네트워크는 최상위 레벨 스위치들을 접속하는 링크들(예를 들어, L11, L12, L21, L22)을 포함한다. 데이터는 링크들 상의 최상위 레벨 스위치들 간에, 그리고 스위치들로부터 그 스위치들에 연결된 네트워크 상의 노드들로 패킷들에서 이동한다. 예를 들어, 최상위 레벨 스위치들(211 및 212)은 링크(L11)에 의해 연결되고, 최상위 레벨 스위치들(214, 215)은 링크(L12)에 의해 연결되고, 최상위 레벨 스위치들(211 및 214)은 링크(L13)에 의해 연결되고, 최상위 레벨 스위치들(212 및 213)은 링크(L21)에 의해 연결된다. 링크들은 하나 이상의 버스들 및 예를 들어 청크-와이드 버스(벡터 버스)를 포함하는 지원 제어 라인들을 포함할 수 있다. 예를 들어, 최상위 레벨 네트워크는 AXI 호환 프로토콜과 유사한 방식으로 데이터의 전송을 위해 협력하여 동작가능한 데이터, 요청 및 응답 채널들을 포함할 수 있다. AMBA® AXI and ACE Protocol Specification, ARM, 2017 참조.

최상위 레벨 스위치들은 AGCU들에 연결될 수 있다. 예를 들어, 최상위 레벨 스위치들(211, 212, 214 및 215)은 타일(Tile1) 내의 MAGCU1, AGCU12, AGC(U13) 및 AGCU14에 각각 접속된다. 최상위 레벨 스위치들(212, 213, 215 및 216)은 타일(Tile2)에서의 MAGCU2, AGCU22, AGCU23 및 AGCU24에 각각 접속된다.

최상위 레벨 스위치들은 하나 이상의 외부 I/O 인터페이스들(예를 들어, 인터페이스(205))에 접속될 수 있다.

도 3 은 도 2 의 구성에서 사용할 수 있는 타일 및 어레이 레벨 네트워크의 간략화된 다이어그램이고. 여기서 어레이에서의 구성가능한 유닛들은 어레이 레벨 네트워크 상의 노드들이다.

이 예에서, 구성가능한 유닛들의 어레이(300)는 복수의 타입들의 구성가능한 유닛들을 포함한다. 이 예에서 구성가능한 유닛들의 타입들은 패턴 계산 유닛(PCU), 패턴 메모리 유닛(PMU), 스위치 유닛(S), 및 어드레스 생성 및 병합 유닛(각각 2개의 어드레스 생성기(AG) 및 공유 CU를 포함)을 포함한다. 이들 타입들의 구성가능한 유닛들의 기능들의 예에 대해, Prabhakar 등의 "Plasticine: A Reconfigurable Architecture For Parallel Patterns", ISCA '17, June 24-28, 2017, Toronto, ON, Canada 을 참조하며, 이는 본원에 완전히 설명된 바와 같이 참조로 통합된다. 이들 구성가능한 유닛들의 각각은 프로그램을 실행하기 위한 셋업 (setup) 또는 시퀀스 (sequence) 중 어느 일방을 나타내는 레지스터들 또는 플립-플롭들의 세트를 포함하는 구성 저장소를 포함하고, 네스팅된 루프들의 수, 각각의 루프 반복기의 한계들, 각각의 스테이지에 대해 실행될 명령들, 피연산자들의 소스, 및 입력 및 출력 인터페이스들에 대한 네트워크 파라미터들을 포함할 수 있다.

추가적으로, 이들 구성가능한 유닛들의 각각은 네스팅된 루프들 또는 다른 것에서 프로그레스를 추적하는데 사용가능한 상태를 저장하는 레지스터들 또는 플립-플롭들의 세트를 포함하는 구성 저장소를 포함한다. 구성 파일은 프로그램을 실행하는 컴포넌트들 각각의 초기 구성 또는 시작 상태를 나타내는 비트-스트림을 포함한다. 이러한 비트-스트림은 비트-파일로서 지칭된다. 프로그램 로드는 모든 컴포넌트들이 프로그램(즉, 머신)을 실행하도록 허용하기 위해 비트 파일의 콘텐츠들에 기초하여 구성가능한 유닛들의 어레이에서 구성 저장소들을 셋업하는 프로세스이다. 프로그램 로드는 또한 모든 PMU 메모리들의 로드를 필요로 할 수도 있다.

어레이 레벨 네트워크는 어레이에서의 구성가능한 유닛들을 상호접속하는 링크들을 포함한다. 어레이 레벨 네트워크에서의 링크들은 하나 이상, 그리고 이 경우 3가지 종류의 물리적 버스들: 청크-레벨 벡터 버스(예를 들어, 128 비트의 데이터), 워드-레벨 스칼라 버스(예를 들어, 32 비트의 데이터), 및 다중 비트-레벨 제어 버스를 포함한다. 실례로, 스위치 유닛들(311 및 312) 사이의 상호접속부(321)는 128 비트의 벡터 버스 폭을 갖는 벡터 버스 상호접속부, 32 비트의 스칼라 버스 폭을 갖는 스칼라 버스 상호접속부, 및 제어 버스 상호접속부를 포함한다.

세 종류의 물리적 버스들은 전송되는 데이터의 입도(granularity)가 다르다. 일 실시형태에서, 벡터 버스는 그 페이로드로서 16-바이트(=128 비트)의 데이터를 포함하는 청크를 반송할 수 있다. 스칼라 버스는 32비트 페이로드를 가질 수 있고, 스칼라 피연산자들 또는 제어 정보를 반송할 수 있다. 제어 버스는 토큰들 및 다른 신호들과 같은 제어 핸드쉐이크들을 반송할 수 있다. 벡터 및 스칼라 버스들은 각각의 패킷의 목적지를 나타내는 헤더들, 및 패킷들이 비순차적으로 수신될 때 파일을 리어셈블링하는데 사용될 수 있는 시퀀스 넘버들과 같은 다른 정보를 포함하여, 패킷 스위칭될 수 있다. 각각의 패킷 헤더는 목적지 스위치 유닛의 지리적 좌표들(예를 들어, 어레이에서의 행 및 열)을 식별하는 목적지 식별자, 및 목적지 유닛에 도달하기 위해 사용되는 목적지 스위치 상의 인터페이스(예를 들어, North(북쪽), South(남쪽), East(동쪽), West(서쪽) 등)를 식별하는 인터페이스 식별자를 포함할 수 있다. 제어 네트워크는, 예를 들어, 디바이스 내의 타이밍 회로들에 기초하여 회로 스위칭될 수 있다. 구성 로드/언로드 제어기는 128 비트의 구성 데이터의 각각의 청크에 대한 헤더를 생성할 수 있다. 헤더는 헤더 버스 상에서 구성가능한 유닛의 어레이에서의 각각의 구성가능한 유닛으로 송신된다.

일 예에서, 128 비트의 데이터의 청크는, 구성가능한 유닛에 대한 벡터 입력들로서 청크를 제공하는 벡터 버스 상에서 송신된다. 벡터 버스는 128개의 페이로드 라인들, 및 헤더 라인들의 세트를 포함할 수 있다. 헤더는 다음을 포함할 수 있는 각각의 청크에 대한 시퀀스 ID를 포함할 수 있다:

청크가 스크래치패드 메모리인지 또는 구성 저장소 데이터인지를 나타내기 위한 비트.

청크 넘버를 형성하는 비트들.

열 식별자를 나타내는 비트들.

행 식별자를 나타내는 비트들.

컴포넌트 식별자를 나타내는 비트들.

로드 동작의 경우, 구성 로드 제어기는 N-1 에서 0 의 순서로 구성가능한 유닛에 N개의 청크들을 전송할 수 있다. 이 예에서, 6 개의 청크들은 청크 5->청크 4->청크 3->청크 2->청크 1-> 청크 0 의 최상위 비트 제 1 순서로 전송된다. (이 최상위 비트 제 1 순서는 청크 5 가 어레이 구성 로드 제어기로부터의 분배 시퀀스의 라운드 0 에 분배되는 것을 초래한다.) 언로드 동작의 경우, 구성 언로드 제어기는 순서의 언로드 데이터를 메모리에 기록할 수 있다. 로드 및 언로드 동작들 모두에 대해, 구성가능한 유닛에서의 구성 데이터 저장소에서의 구성 직렬 체인들에서의 시프팅은 LSB(최하위 비트)로부터 MSB(최상위 비트)로, 또는 MSB 아웃이 우선이다.

도 3a 는 어레이 레벨 네트워크에서 엘리먼트들을 접속하는 예시적인 스위치 유닛을 나타낸다. 도 3a의 예에 나타낸 바와 같이, 스위치 유닛은 8개의 인터페이스들을 가질 수 있다. 스위치 유닛의 North, South, East 및 West 인터페이스들은 스위치 유닛들 사이의 접속들을 위해 사용된다. 스위치 유닛의 Northeast(북동쪽), Southeast(남동쪽), Northwest(북서쪽) 및 Southwest(남서쪽) 인터페이스들은 PCU 또는 PMU 인스턴스들에 대한 연결을 만드는 데 각각 사용된다. 각 타일 사분면 내의 2개의 스위치 유닛들의 세트는, 다수의 어드레스 생성(address generation; AG) 유닛들 및 다수의 어드레스 생성 유닛들에 접속된 병합 유닛(coalescing unit; CU)을 포함하는 어드레스 생성 및 병합 유닛(Address Generation and Coalescing Unit; AGCU)에 대한 연결들을 갖는다. 병합 유닛(CU)은 AG들 사이를 중재하고 메모리 요청들을 처리한다. 스위치 유닛의 8개의 인터페이스들의 각각은 벡터 인터페이스, 스칼라 인터페이스, 및 벡터 네트워크, 스칼라 네트워크, 및 제어 네트워크와 통신하기 위한 제어 인터페이스를 포함할 수 있다.

구성 후 머신의 실행 동안, 데이터는 어레이 레벨 네트워크 상의 하나 이상의 스위치 유닛들의 벡터 버스 및 벡터 인터페이스(들)를 사용하여 하나 이상의 유닛 스위치들 및 유닛 스위치들 사이의 하나 이상의 링크들을 통해 구성가능한 유닛들로 전송될 수 있다.

본 명세서에 설명된 실시형태들에서, 타일의 구성 전에, 구성 파일 또는 비트 파일은, 어레이 레벨 네트워크 상의 하나 이상의 스위치 유닛들의 벡터 버스 및 벡터 인터페이스(들)를 사용하여 구성가능한 유닛에 대해, 유닛 스위치들 사이의 하나 이상의 링크들 및 하나 이상의 유닛 스위치들을 통해, 동일한 벡터 버스를 사용하여 구성 로드 제어기로부터 전송될 수 있다. 실례로, 구성가능한 유닛 PMU(341)에 특정한 유닛 파일에서의 구성 데이터의 청크는 구성 로드/언로드 제어기(301)와 스위치 유닛(311)의 West(W) 벡터 인터페이스 사이의 링크(320), 스위치 유닛(311), 및 스위치 유닛(311)의 Southeast(SE) 벡터 인터페이스와 PMU(341) 사이의 링크(331)를 통해 구성 로드/언로드 제어기(301)로부터 PMU(341)로 전송될 수 있다.

이 예에서, AGCU들 중 하나는 구성 로드/언로드 제어기(예를 들어, 301)를 포함하는 마스터 AGCU가 되도록 구성된다. 마스터 AGCU는 호스트(120, 도 1)가 레지스터를 통하여, 버스 시스템을 통해 마스터 AGCU에 커맨드들을 전송할 수 있는 그러한 레지스터를 구현한다. 마스터 AGCU는 타일 내의 구성가능한 유닛들의 어레이 상의 동작들을 제어하고, 레지스터에 대한 기록들을 통해 호스트로부터 수신하는 커맨드들에 기초하여 타일의 상태를 추적하기 위해 프로그램 제어 상태 머신을 구현한다. 매(every) 상태 전이에 대해, 마스터 AGCU는 데이지 체인드 커맨드 버스 (daisy chained command bus) 를 통해 타일 상의 모든 컴포넌트들에 커맨드들을 발행한다(도 4). 그 커맨드들은 타일 내의 구성가능한 유닛들의 어레이에서의 구성가능한 유닛들을 리셋하기 위한 프로그램 리셋 커맨드, 및 구성가능한 유닛들에 구성 파일을 로딩하기 위한 프로그램 로드 커맨드를 포함한다.

마스터 AGCU 내의 구성 로드 제어기는 메모리로부터 구성 파일을 판독하고, 구성 데이터를 타일의 매 구성가능한 유닛에 전송하는 것을 담당한다. 마스터 AGCU는 바람직하게는 최상위 레벨 네트워크의 최대 스루풋에서 메모리로부터 구성 파일을 판독할 수 있다. 메모리로부터 판독된 데이터는 본 명세서에 설명된 분배 시퀀스에 따라 어레이 레벨 네트워크 상의 벡터 인터페이스를 통해 마스터 AGCU에 의해 대응하는 구성가능한 유닛으로 전송된다.

일 실시형태에서, 구성가능한 유닛 내의 배선 요건들 (wiring requirements) 을 감소시킬 수 있는 방식으로, 구성 로드 프로세스에서 로딩되거나 구성 언로드 프로세스에서 언로딩될 유닛 파일들을 홀딩하는 구성 및 상태 레지스터들은 직렬 체인으로 연결되고, 그 직렬 체인을 통해 비트들을 시프팅하는 프로세스를 통해 로딩될 수 있다. 일부 실시형태들에서, 병렬로 또는 직렬로 배열된 하나 초과의 직렬 체인이 있을 수도 있다. 구성가능한 유닛이 하나의 버스 사이클에서 마스터 AGCU로부터 예를 들어 128 비트의 구성 데이터를 수신할 때, 구성가능한 유닛은 사이클 당 1 비트의 레이트로 그것의 직렬 체인을 통해 이 데이터를 시프트하고, 여기서 시프터 사이클들은 버스 사이클과 동일한 레이트로 실행될 수 있다. 구성가능한 유닛이 벡터 인터페이스를 통해 수신된 128 비트의 데이터로 128 구성 비트를 로딩하기 위해 128 시프터 사이클이 걸릴 것이다. 128 비트의 구성 데이터를 청크라고 지칭한다. 구성가능한 유닛은 모든 그것의 구성 비트를 로딩하기 위해 다수의 데이터 청크들을 요구할 수 있다. 예시적인 시프트 레지스터 구조가 도 6 에 도시되어 있다.

구성가능한 유닛들은 다수의 메모리 인터페이스들 (150, 도 1) 을 통해 메모리와 인터페이싱한다. 메모리 인터페이스들의 각각은 여러 AGCU들을 사용하여 액세스될 수 있다. 각각의 AGCU는 오프-칩 메모리에 대한 요청들을 생성하기 위해 재구성가능한 스칼라 데이터경로를 포함한다. 각각의 AGCU는 오프-칩 메모리로부터 발신 커맨드들, 데이터, 및 착신 응답들을 버퍼링하기 위한 FIFO들(데이터를 조직하기 위한 선입선출 버퍼들)을 포함한다.

AGCU들에서의 어드레스 생성기들(AG들)은 조밀 (dense) 또는 희소 (sparse) 중 어느 일방인 메모리 커맨드들을 생성할 수 있다. 조밀 요청들은 연속적인 오프-칩 메모리 영역들을 대량 전송하는 데 사용될 수 있고, 구성가능한 유닛들의 어레이에서의 구성가능한 유닛들로부터/로 데이터의 청크를 판독 또는 기록하는 데 사용될 수 있다. 조밀한 요청들은 AGCU들에서의 병합 유닛(CU)에 의해 다수의 오프-칩 메모리 버스트 요청들로 변환될 수 있다. 희소 요청들은 어드레스들의 스트림을 병합 유닛 내로 인큐(enqueue)할 수 있다. 병합 유닛은 발행된 오프-칩 메모리 요청들에 대한 메타데이터를 유지하기 위해 병합 캐시를 사용하고, 발행된 오프-칩 메모리 요청들의 수를 최소화하기 위해 동일한 오프-칩 메모리 요청에 속하는 희소 어드레스들을 결합한다.

도 4 는 패턴 계산 유닛(PCU)과 같은 예시적인 구성가능한 유닛(400)을 나타내는 블록도이다. 구성가능한 유닛들의 어레이에서의 구성가능한 유닛들은 대응하는 구성가능한 유닛들에 특정한 구성 데이터의 복수의 청크들(또는 다른 사이즈들의 서브-파일들)을 포함하는 유닛 파일들을 저장하기 위한 구성 데이터 저장소들(420)(예를 들어, 직렬 체인들)을 포함한다. 구성가능한 유닛들의 어레이에서의 구성가능한 유닛들 각각은 유닛 구성 로드 프로세스를 실행하기 위해 라인(422)을 통해 구성 데이터 저장소(420)에 연결된 유닛 구성 로드 로직(440)을 포함한다. 유닛 구성 로드 프로세스는 버스 시스템(예를 들어, 벡터 입력들)을 통해, 구성가능한 유닛에 특정한 유닛 파일의 청크들을 수신하는 것, 및 수신된 청크들을 구성가능한 유닛의 구성 데이터 저장소(420)에 로딩하는 것을 포함한다. 유닛 구성 로드 프로세스에 대해서는 도 5 를 참조하여 보다 상세히 설명된다.

복수의 구성가능한 유닛들에서의 구성가능한 유닛들에서의 구성 데이터 저장소들은 이 예에서 래치들의 직렬 체인들을 포함하고, 여기서 래치들은 구성가능한 유닛에서의 리소스들의 구성을 제어하는 비트들을 저장한다. 구성 데이터 저장소에서의 직렬 체인은 구성 데이터에 대한 시프트 레지스터 체인, 및 직렬로 연결된 상태 정보 및 카운터 값들에 대한 제 2 시프트 레지스터 체인을 포함할 수 있다. 구성 저장소에 대해서는 도 6 을 참조하여 추가로 설명된다.

구성가능한 유닛은 입력들 및 출력들 (IO) 의 3개의 대응하는 세트들: 스칼라 입력들/출력들, 벡터 입력들/출력들, 및 제어 입력들/출력들을 사용하여 스칼라, 벡터, 및 제어 버스들과 인터페이싱할 수 있다. 스칼라 IO들은 데이터의 단일 워드들(예를 들어, 32 비트)을 통신하기 위해 사용될 수 있다. 벡터 IO들은, 유닛 구성 로드 프로세스에서 구성 데이터를 수신하는 것, 및 다수의 PCU들 사이의 긴 파이프라인에 걸쳐 구성 후에 동작 동안 데이터를 송신 및 수신하는 것과 같은 경우들에서, 데이터의 청크들(예를 들어, 128 비트들)을 통신하기 위해 사용될 수 있다. 제어 IO들은 구성가능한 유닛의 실행의 시작 또는 종료와 같은 제어 신호들을 통신하기 위해 사용될 수 있다. 제어 입력들은 제어 블록(470)에 의해 수신되고, 제어 출력들은 제어 블록(470)에 의해 제공된다.

각각의 벡터 입력은 하나 이상의 벡터 FIFO들을 포함할 수 있는 벡터 FIFO 블록(460)에서의 벡터 FIFO를 사용하여 버퍼링된다. 각각의 스칼라 입력은 스칼라 FIFO(450)를 사용하여 버퍼링된다. 입력 FIFO들을 사용하는 것은 데이터 생산자들과 소비자들 사이의 타이밍을 디커플링하고, 입력 지연 불일치들에 대해 강건하게 함으로써 구성가능한 유닛 간 제어 로직을 단순화한다.

입력 구성 데이터(410)는 벡터 입력들로서 벡터 FIFO에 제공될 수 있고, 그 후, 구성 데이터 저장소(420)에 전송될 수 있다. 출력 구성 데이터(430)는 벡터 출력들을 사용하여 구성 데이터 저장소(420)로부터 언로딩될 수 있다.

CGRA는 로드/언로드 커맨드가 완료된 때를 나타내기 위해 데이지 체인드 완료 버스를 사용한다. 마스터 AGCU는 데이지 체인드 커맨드 버스를 통해 (S0에서 S1으로 전이하기 위해, 도 5) 구성가능한 유닛들의 어레이에서의 구성가능한 유닛들에 프로그램 로드 및 언로드 커맨드들을 송신한다. 도 4의 예에 도시된 바와 같이, 데이지 체인드 완료 버스(491) 및 데이지 체인드 커맨드 버스(492)는 유닛 구성 로드 로직(440)과 통신하는 데이지 체인 로직(493)에 연결된다. 데이지 체인 로직(493)은 아래에서 설명되는 바와 같이 로드 완료 상태 로직을 포함할 수 있다. 데이지 체인드 완료 버스는 아래에서 추가로 설명된다. 커맨드 및 완료 버스들에 대한 다른 토폴로지들은 분명히 가능하지만 여기서는 설명되지 않는다.

구성가능한 유닛은 블록(480)에서 다수의 재구성가능한 데이터경로들을 포함한다. 구성가능한 유닛에서의 데이터 경로는 다중-스테이지(스테이지 1 ... 스테이지 N), 재구성가능한 SIMD(Single Instruction, Multiple Data) 파이프 라인으로서 구성될 수 있다. 구성가능한 유닛에서의 구성 직렬 체인 내로 푸시된 데이터의 청크들은 구성가능한 유닛에서의 각각의 데이터 경로의 각각의 스테이지에 대한 구성 데이터를 포함한다. 구성 데이터 저장소(420)의 구성 직렬 체인은 라인들(421)을 통해 블록(480)의 다수의 데이터 경로들에 연결된다.

패턴 메모리 유닛(예를 들어, PMU)은 PCU에서 사용되는 버스 인터페이스들과 함께, 어드레스 계산을 위해 의도된 재구성가능한 스칼라 데이터 경로와 커플링된 스크래치패드 메모리를 포함할 수 있다. PMU들은 재구성가능한 유닛들의 어레이 전체에 걸쳐 온-칩 메모리를 분배하는데 사용될 수 있다. 일 실시형태에서, PMU들에서의 메모리 내의 어드레스 계산은 PMU 데이터 경로에 대해 수행되는 한편, 코어 계산은 PCU 내에서 수행된다.

도 5 는 구성가능한 유닛에서 유닛 구성 로드 프로세스를 제어하는 데 사용될 수 있는 상태 머신의 일 예를 나타낸다. 일반적으로, 유닛 구성 로드 프로세스는 하나의 버스 사이클에서 버스 시스템으로부터 구성가능한 유닛에 특정한 유닛 파일의 제 1 청크(또는 서브-파일)를 수신하고, 유닛 파일의 제 2 청크가 수신되기 전에, 버스 사이클들과 동일한 레이트로 발생하는 후속 시프터 사이클들 동안, 수신된 제 1 청크를 직렬 체인 내로 푸시하기 시작한다. 나중의 버스 사이클에서 버스 시스템으로부터 구성가능한 유닛에 특정한 유닛 파일의 제 2 청크를 수신 시, 프로세스는 이전에 수신된 청크를 직렬 체인 내로 푸시한 후에 사이클들 동안, 수신된 제 2 청크를 직렬 체인 내로 푸시하기 시작한다. 구성 로드 프로세스의 일부 또는 모든 라운드들에서, 복수의 순서화된 청크들에서의 (단위 파일의 청크들의 순서에서 다음인) 제 2 청크가 구성가능한 유닛에 의해 수신되기 전에, 제 1 청크가 구성가능한 유닛에서의 유닛 구성 로드 프로세스에 의해 소비될 수 있다.

도 5 의 상태 머신은 6개의 상태들(S0 내지 S5)을 포함한다. 상태 S0(유휴)에서, 유닛 구성 로드 프로세스는 마스터 AGCU의 구성 로드/언로드 제어기로부터 구성 로드/언로드 커맨드를 기다린다. 구성 로드/언로드 제어기는 구성가능한 유닛들의 오프-칩 메모리(140, 도 1)로부터/로 및 어레이(190, 도 1)로부터/로 구성 데이터의 로딩 및 언로딩을 담당한다. 구성 로드/언로드 제어기에서 로드 커맨드가 수신될 때, 유닛 구성 로드 프로세스는 상태 S1으로 진입한다.

상태 S1(정지상태 대기)에서, 다수의 데이터 경로들에서의 기능적 플롭들은 디스에이블되어 그 기능적 플롭들은 사이클링하지 않고, 스칼라 출력들, 벡터 출력들 및 제어 출력들이 턴 오프되어 출력들이 임의의 로드들을 구동하지 않는다. 로드 커맨드가 수신되는 경우에는, 유닛 구성 로드 프로세스는 상태 S2로 진입한다. 언로드 커맨드가 수신될 때, 유닛 구성 로드 프로세스는 상태 S4로 진입한다.

상태 S2(입력이 유효할 때까지 대기)에서, 유닛 구성 로드 프로세스는 입력 FIFO(610, 도 6)가 유효해질 때까지 대기한다. 입력 FIFO가 유효해질 때, 입력 FIFO는 버스 시스템을 통해 구성 파일의 구성 데이터의 청크를 수신하였다. 실례로, 구성 데이터의 청크는 128 비트의 로드 데이터를 포함할 수 있고, 이는 버스 시스템의 벡터 네트워크 상에서 수신되고, 벡터 네트워크는 128 비트의 벡터 버스 폭을 갖는다. 입력 FIFO가 유효하게 될 때, 유닛 구성 로드 프로세스는 상태 S3로 진입한다.

상태 S3(로드 시프트)에서, 128 비트의 구성 데이터의 청크는 입력 FIFO로부터 하나의 클럭 사이클에서 먼저 디큐잉되고, 그 다음에, 128 비트의 구성 데이터의 청크는 128 클럭 사이클에서 입력 시프트 레지스터(620, 도 6)내로 시프트된다. 입력 시프트 레지스터는 구성 데이터의 청크와 동일한 길이(예컨대, 128 비트)를 가질 수 있고, 구성 데이터의 청크를 구성 데이터의 청크의 길이로서 입력 시프트 레지스터로 시프트하기 위해 동일한 수의 시프터 클럭 사이클들(예컨대, 128)을 취한다. 전술한 바와 같이, 시프터 클럭 및 버스 클럭(또는 버스 사이클들)은 일부 실시형태들에서 동일한 레이트로 실행될 수 있다.

구성가능한 유닛에서의 구성 데이터 저장소는 구성가능한 유닛에 특정한 구성 데이터의 복수의 청크들을 포함하는 유닛 파일을 저장하기 위해 FIFO 체인으로서 구성될 수 있는 구성 직렬 체인(630, 640, 도 6)을 포함한다. 구성 데이터의 복수의 청크들은 구성 데이터의 제 1 청크 및 구성 데이터의 마지막 청크를 포함한다. 입력 시프트 레지스터에서의 구성 데이터의 청크는 후속 클럭 사이클들에서 구성 데이터 저장소로 추가로 직렬로 시프트된다. 구성 데이터 저장소는 도 6 을 참조하여 추가로 설명된다.

구성가능한 유닛에 특정한 유닛 파일의 제 1 청크가 상태 S3에서 입력 시프트 레지스터로 시프트된 후에, 유닛 구성 로드 프로세스는 구성 데이터의 제 1 청크가 구성가능한 유닛에 특정한 구성 데이터의 마지막 청크인지 여부를 결정한다. 만약 그렇다면, 구성가능한 유닛에 대한 유닛 파일의 로딩이 완료되고, 유닛 구성 로드 프로세스는 상태 S0로 진입한다. 그렇지 않다면, 유닛 구성 로드 프로세스는 상태 S2로 진입하고, 구성가능한 유닛에 특정한 구성 데이터의 제 2 청크에 대해 입력 FIFO가 유효해지기를 기다린다.

상태 S1에서 언로드 커맨드가 수신될 때, 유닛 구성 로드 프로세스는 상태 S4로 진입한다.

상태 S4(언로드 시프트)에서, 구성 데이터 저장소로부터의 구성 데이터의 청크는 출력 시프트 레지스터(650, 도 6) 내로 시프트된다. 구성 데이터의 청크는 128 비트의 언로드 데이터를 포함할 수 있다. 출력 시프트 레지스터는 구성 데이터의 청크와 동일한 길이(예를 들어, 128)를 가질 수 있고, 구성 데이터의 청크의 길이로서 구성 데이터의 청크를 구성 데이터 저장소로부터 출력 FIFO로 시프트하기 위해 동일한 수의 시프터 클럭 사이클(예를 들어, 128)이 걸린다. 구성 데이터의 청크가 출력 시프트 레지스터 내로 시프트될 때, 유닛 구성 로드 프로세스는 상태 S5 (출력 유효 대기)에 진입한다.

상태 S5(축력이 유효할 때까지 대기)에서, 유닛 구성 로드 프로세스는 출력 FIFO(660, 도 6)가 유효해질 때까지 대기한다. 출력 FIFO가 유효해질 때, 출력 시프트 레지스터로부터 128 비트를 갖는 구성 데이터의 청크는 하나의 클럭 사이클에서 출력 FIFO 내로 삽입된다. 출력 FIFO에서의 구성 데이터 청크는 그 다음에 버스 시스템으로 전송될 수 있다(도 3).

상태 S5에서 구성 데이터의 제 1 청크가 출력 FIFO로 시프트된 후에, 유닛 구성 로드 프로세스는 구성 데이터의 제 1 청크가 구성 데이터 저장소에서의 구성 데이터의 마지막 청크인지 여부를 결정한다. 만약 그렇다면, 구성가능한 유닛에 대한 구성 데이터의 언로딩이 완료되고, 유닛 구성 로드 프로세스는 상태 S0으로 진입한다. 그렇지 않다면, 유닛 구성 로드 프로세스는 상태 S4로 진입하고, 구성 데이터 저장소로부터의 구성 데이터의 제 2 청크는 출력 시프트 레지스터로 직렬로 시프트된다.

도 6 은 구성가능한 유닛에서의 구성 저장소의 논리적 표현이다. 구성가능한 유닛에서의 구성 데이터 저장소(420, 도 4)는 제 1 시프트 레지스터 체인(630) 및 제 2 시프트 레지스터 체인(640)을 포함하는, 본 실시형태에서의 구성 직렬 체인을 포함한다. 제 1 시프트 레지스터 체인(630)은 레지스터들 또는 래치들의 세트를 포함한다. 제 2 시프트 레지스터 체인(640)은 레지스터들 또는 래치들(플립-플롭들)의 다른 세트를 포함한다. 이 실시형태에서 제 1 시프트 레지스터 체인과 제 2 시프트 레지스터 체인은 직렬로 연결되어 단일의 체인을 형성한다.

구성 파일은 구성가능한 유닛들의 어레이에서의 복수의 구성가능한 유닛들에서의 각각의 구성가능한 유닛에 대한 구성 데이터의 복수의 청크들을 포함한다. 구성 데이터의 청크들은 각각의 구성가능한 유닛들의 초기 구성 또는 시작 상태를 나타낸다. 이 시스템에서의 구성 로드 동작은 모든 구성가능한 유닛들이 프로그램을 실행할 수 있도록 구성가능한 유닛들의 어레이에서 구성 데이터의 유닛 파일들을 셋업하는 프로세스이다.

제 1 시프트 레지스터 체인(630) 내의 레지스터들의 세트는, 레지스터들을 포함하는 구성가능한 유닛들의 동작의 정의를 포함하는, 프로그램을 실행하기 위한 셋업 또는 시퀀스 중 어느 일방을 나타낼 수 있다. 이들 레지스터들은 네스팅된 루프들의 수, 각각의 루프 반복기의 제한들, 각각의 스테이지에 대해 실행될 명령들, 피연산자들의 소스, 및 입력 및 출력 인터페이스들에 대한 네트워크 파라미터들을 등록할 수 있다. 제 2 시프트 레지스터 체인에서의 레지스터들의 세트는 구성가능한 유닛에서 로딩된 프로그램의 사이클-바이-사이클 실행 상태에 관한 데이터를 포함할 수 있다.

도 6 의 예에서 나타낸 바와 같이, 제 1 시프트 레지스터 체인(630) 및 제 2 시프트 레지스터 체인(640)은 직렬로 연결되어, 제 1 시프트 레지스터 체인의 MSB(최상위 비트)는 제 2 시프트 레지스터 체인의 LSB(최하위 비트)에 연결된다. 로드 신호 또는 언로드 신호는 제 1 시프트 레지스터 체인과 제 2 시프트 레지스터 체인에 대한 로드/언로드 동작을 제어하기 위해 제 1 시프트 레지스터 체인의 LSB와 제 2 시프트 레지스터 체인의 LSB에 커플링된 시프트 인에이블 신호로서 작용할 수 있다. 입력 FIFO(610)는 선택기(670)를 통해 입력 시프트 레지스터(620)에 커플링된다. 선택기(670)는, 로드 신호가 활성일 때, 입력 시프트 레지스터(620)를 구성 데이터 저장소(제 1 시프트 레지스터 체인(630)의 LSB)의 입력에 연결한다.

로드 신호가 활성일 때, 입력 시프트 레지스터(620) 내의 구성 데이터는 구성 직렬 체인에서의 제 1 시프트 레지스터 체인(630) 및 제 2 시프트 레지스터 체인(640) 내로 시프트될 수 있다. 여기서, 로드 신호는 입력 시프트 레지스터, 제 1 시프트 레지스터 체인, 및 제 2 시프트 레지스터 체인에 대해 인에이블 신호로서 작용할 수 있다. 로드 동작은 구성가능한 유닛에 대한 구성 데이터의 모든 청크들이 구성가능한 유닛에서의 구성 데이터 저장소 내로 로딩될 때까지 반복될 수 있다. 직렬 체인의 길이가 정수 개수의 청크들(또는 서브-파일들)의 길이와 상이할 때, 직렬의 제 1 청크는 그 차이로 패딩될 수 있고, 마지막 청크가 시프트인될 때 패드 비트들은 체인의 끝까지 시프트아웃될 것이다. 예를 들어, 구성가능한 유닛에서의 구성 데이터 저장소는 760 비트의 사이즈를 갖는 단위 파일을 저장할 수 있다. 유닛 구성 로드 프로세스는 정수 N개의 청크들을 로딩할 수 있다. 이 예에서, N=6이고, N개의 청크들은 청크 5, 청크 4, 청크 3, 청크 2, 청크 1 및 청크 0을 포함한다. 벡터 버스는 128 비트의 벡터 폭을 가지며, 구성 데이터의 청크는 128 비트를 가지며, 청크는 하나의 버스 클럭 사이클에서 구성가능한 유닛으로 전송될 수 있다. N개의 청크들은 N x 128 = 6 * 128 = 768비트의 사이즈를 가지며, 이는 760비트의 유닛 파일 사이즈에 매칭하는 8 패드 비트를 포함한다.

오류를 복구하기 위해, 언로드 동작은 각각의 구성가능한 유닛의 상태를 체크할 수 있다. 언로드 동작은 재시작을 위해 필요한 각각의 구성가능한 유닛의 실행 상태를 저장하고, 오류가 발생할 경우 애플리케이션이 재시작되도록 할 수 있다. 그것은 또한 구성가능한 유닛들의 상태가 저장되거나 디버그 목적들을 위해 전송되도록 허용한다. 저장될 필요가 있는 상태는 적어도 제 1 또는 제 2 시프트 레지스터들의 일부의 콘텐츠, 및 선택적으로 PMU 메모리들의 콘텐츠를 포함한다. 프로그램 언로드는 또한 제 1 및 제 2 시프트 레지스터들의 전부의 상태를 언로딩하는 것을 필요로 할 수도 있다.

출력 FIFO(660)는 출력 시프트 레지스터(650)에 커플링되고, 이는 차례로 구성 데이터 저장소(제 2 시프트 레지스터 체인(640)의 MSB)의 출력에 커플링된다. 언로드 동작을 위해, 언로드 신호가 활성일 때, 제 2 시프트 레지스터 체인(640) 및 제 1 시프트 레지스터 체인(630)에서의 구성 데이터는 출력 시프트 레지스터(650)로 시프트될 수 있다. 출력 FIFO(660)가 유효할 때, 출력 시프트 레지스터(650)에서의 구성 데이터(예를 들어, 128 비트)는 하나의 클럭 사이클에서 출력 FIFO(660)에 삽입될 수 있다. 구성가능한 유닛에서의 구성 데이터 저장소 내의 구성 데이터의 모든 청크들이 출력 FIFO로 언로딩될 때까지 언로드 동작은 반복될 수 있다.

MAGCU에서 구성 로드 제어기에 의해 발행된 구성 로드 커맨드들의 완료를 동기화하고 통신하기 위해, 단일 와이어 데이지 체인드 방식이 일 예에서 구현되고, 체인의 각각의 컴포넌트에서 데이지 체인 로직(예컨대, 도 4 에서의 데이지 체인 로직 (493))에 포함된 로직에 의해 지원된다. 이 방식은 매 컴포넌트가 다음의 2 포트들을 가질 필요가 있다:

1. PROGRAM_LOAD_DONE_IN 이라고 불리는 입력 포트

2. PROGRAM_LOAD_DONE_OUT 이라고 불리는 출력 포트

컴포넌트는, 그것이 MAGCU에 의해 발행된 커맨드의 실행을 완료하고 그것의 PROGRAM_LOAD_DONE_IN 입력이 하이로 구동될 때, 그것의 PROGRAM_LOAD_DONE_OUT 신호를 구동할 것이다. MAGCU는, 그것이 커맨드를 실행하기 위한 모든 필요한 단계들을 완료했을 때, 그것의 PROGRAM_LOAD_DONE_OUT을 구동함으로써 데이지 체인을 개시할 것이다. 체인에서의 마지막 컴포넌트는 MAGCU의 PROGRAM_LOAD_DONE_IN에 연결될 그것의 PROGRAM_LOAD_DONE_OUT을 구동할 것이다. MAGCU의 PROGRAM_LOAD_DONE_IN이 하이로 가는 것은 커맨드의 완료를 나타낸다. 모든 컴포넌트들의 모든 청크들에 대응하는 데이터를 전달한 후에, MAGCU는 그것의 PROGRAM_LOAD_DONE_OUT 포트를 하이로 구동한다. 모든 컴포넌트들은, 그것들이 모든 그들의 구성 비트들의 로딩을 완료했을 때, 그들의 각각의 PROGRAM_LOAD_DONE_OUT 포트들을 하이로 구동할 것이다.

MAGCUs 입력 포트 PROGRAM_LOAD_DONE_IN이 활성화될 때, 구성 파일 로드가 완료된다.

도 7 은 재구성가능한 데이터 프로세서에 커플링된 호스트의 동작들을 나타내는 흐름도이다. 단계(711)에서, 호스트(120, 도 1)는 PCIE 인터페이스(130, 도 1) 및 최상위 레벨 네트워크(115, 도 1)를 통해 구성가능한 유닛의 어레이에 대한 구성 파일을 오프-칩 메모리(140, 도 1)에 전송하거나, 그렇지 않으면, 구성가능한 프로세서에 액세스가능한 메모리에 그 구성 파일을 저장한다.

단계(712)에서, 메모리에 구성 파일을 로딩하는 것이 완료되면, 호스트(120)는 프로세서 내의 구성 로드 제어기(이 예에서 마스터 AGCU의 일부)에 구성 로드 커맨드를 전송한다. 마스터 AGCU는, 레지스터를 통해 호스트가 구성 로드 커맨드를 구성 로드 제어기에 전송할 수 있는 그러한 레지스터를 구현할 수 있다. 구성 로드 커맨드는 구성가능한 프로세서 상의 메모리 인터페이스를 통해 액세스가능한 메모리에서의 로케이션을 식별할 수 있다. 그 후, 구성 로드 제어기는 구성 파일을 취출하기 위한 커맨드에 응답하여 최상위 레벨 네트워크를 통해 하나 이상의 메모리 액세스 요청들을 생성할 수 있다. 그 다음에, 호스트는 구성 파일이 완전히 로딩되었다는 신호에 대해 구성가능한 프로세서를 모니터링할 수 있다(714). 파일 로딩이 완료되면, 호스트는 머신에 의해 실행될 기능을 개시할 수 있다(716).

도 8 은 MAGCU의 일부일 수 있거나 그 외에 타일에서의 구성가능한 유닛들의 어레이와 통신할 수 있는 구성 로드 제어기의 동작들을 나타내는 흐름도이다. 구성 로드 제어기는 오프-칩 메모리(140, 도 1)로부터 구성 파일을 판독하고 구성가능한 유닛들의 어레이에서의 매 구성가능한 유닛에 구성 데이터를 전송하는 것을 담당한다. 이 흐름도는 구성 로드 제어기가 구성 로드 커맨드를 기다리는 것으로 시작한다(810). 전술한 바와 같이, 구성 로드 커맨드는 구성 파일, 및 프로세서에 액세스가능한 메모리에서의 그것의 로케이션을 식별한다.

로드 커맨드를 수신 시, 단계 (811) 에서, 구성 로드 제어기는 재구성가능한 데이터 프로세서(110, 도 1)에 연결된 메모리(140, 도 1)에 로드 요청들을 발행한다. 단계(812)에서, 구성 로드 제어기는 메모리 인터페이스를 통해 최상위 레벨 네트워크 상의 구성 파일의 청크들을 취출한다. 단계(813)에서, 구성 로드 제어기는 어레이 레벨 네트워크 상에 어레이 내의 구성가능한 유닛들에 순서화된 라운드들에서 구성 파일의 청크들을 분배한다. 구성 파일의 모든 청크들이 수신되고 분배되었을 때, 구성 로드 제어기는 단계(814)에서 분배 완료 신호(예를 들어, 그것의 PROGRAM_LOAD_DONE_OUT)를 생성한다. 그 후, 구성 로드 제어기는, 예를 들어, 단계(815)에서 그것의 PROGRAM_LOAD_DONE_IN의 활성화에 의해 표시된, 그들의 각각의 유닛 파일들이 로드되었다는, 구성가능한 유닛들로부터의 확인을 대기한다. 성공적인 구성 로드의 확인시, 구성 로드 제어기는 호스트에 통지할 수 있다(816).

도 9 는 구성 파일의 하나의 예시적인 조직을 나타낸다. 구성 파일을 로드 및 언로드하기 위한 특정 프로토콜에 맞게 다른 조직들이 역시 배열될 수 있다. 도 9 를 참조하여 설명된 예에서, 구성가능한 유닛들의 어레이에서의 구성가능한 유닛들은 스위치, PCU, PMU, 및 AGCU를 포함한다. 이들 구성가능한 유닛 각각은 프로그램을 실행하기 위한 셋업 또는 시퀀스를 나타내는 레지스터들의 세트를 포함한다. 이들 레지스터들은 네스팅된 루프들의 수, 각각의 루프 반복기의 제한들, 각각의 스테이지에 대해 실행될 명령들, 피연산자들의 소스, 및 입력 및 출력 인터페이스들에 대한 네트워크 파라미터들과 같은, 그것을 포함하는 구성가능한 유닛의 동작을 정의하기 위한 데이터를 포함한다. 추가적으로, 각 구성 파일들은 각각의 네스팅된 루프에서 진행을 추적하는 카운터들의 세트에서 컨텍스트를 설정하기 위한 데이터를 포함할 수 있다.

프로그램 실행가능체는 프로그램을 실행하는 구성가능한 유닛들 각각의 초기 구성, 또는 시작 상태를 나타내는 비트-스트림을 포함한다. 이 비트-스트림은 비트-파일로서 지칭되거나, 또는 본 명세서에서 구성 파일로서 지칭된다. 프로그램 로드는 구성 파일의 콘텐츠에 기초하여 구성가능한 유닛들에서 구성 저장소들을 셋업하여 모든 구성가능한 유닛들이 프로그램을 실행할 수 있도록 하는 프로세스이다. 프로그램 언로드는 구성가능한 유닛들로부터 구성 저장소들을 언로딩하고, 본 명세서에서 언로드 구성 파일이라고 불리는 비트-스트림을 어셈블링(assembling)하는 프로세스이다. 언로드 구성 파일은, 본 명세서에 설명된 예들에서, 동일한 배열 청크들 또는 서브-파일들 및 프로그램 로드를 위해 사용되는 구성 파일을 갖는다.

구성 파일은 구성가능한 유닛들의 어레이에서 각각의 구성가능한 유닛에 대한 구성 데이터의 복수의 청크들을 포함하고, 그 청크들은 그들이 분배될 시퀀스와 매칭하는 방식으로 구성 파일에 배열된다. 이러한 구성 파일의 조직은 어레이 구성 로드 프로세스가 구성 파일에서의 청크의 로케이션들에 기초하여 청크를 구성가능한 유닛들로 라우팅하는 것을 가능하게 한다.

도 9 에서 예시된 바와 같이, 구성 파일(및 동일한 방식으로 배열된 언로드 구성 파일)은 복수의 구성가능한 유닛들에서의 각각의 구성가능한 유닛에 대한 유닛 파일들의 복수의 청크들을 포함하고, 유닛 파일들은 유닛 파일에서 순서 (i)를 갖는 M개(이 예에서 Z4 = 6)까지의 서브-파일들을 갖는다. 도 9 에서 M은 6이고, 청크들은 첫 번째부터 여섯 번째까지 순서화된다 (즉, 제 1 내지 제 6 청크들은 이 인덱싱에서 청크들 (0) 내지 (5) 와 대응한다). 청크들은, 로드 또는 언로드 구성 파일에서의 모든 유닛 파일들에 대해, 0 에서 M-1 로 진행하는 (i) 에 대한 순서 (i) 의 모든 서브-파일들이, 0 에서 M-1 로 진행하는 (i) 에 대해, 메모리에서의 어드레스 공간의 대응하는 블록 (i) 에 저장되도록 배열된다. 순서(0)의 청크들은 어드레스들(A0 내지 A1-1)을 포함하는 블록(0)에 저장된다. 이 예에서 스위치 유닛들에 대한 순서(0)의 청크들은 블록(0) 내의 연속적인 어드레스들의 그룹에 있다. PCU들에 대한 순서(0)의 청크들은 블록(0) 내의 연속적인 어드레스들의 그룹에 있다. PMU들에 대한 순서(0)의 청크들은 블록(0) 내의 연속적인 어드레스들의 그룹에 있다. AGCU들에 대한 순서(0)의 청크들은 연속적인 어드레스들의 그룹에 있다. 순서(1)의 청크들은 어드레스들(A1 내지 A2-1)을 포함하는 블록(1)에 저장된다. 이 예에서 스위치 유닛들에 대한 순서(1)의 청크들은 블록(1) 내의 연속적인 어드레스들의 그룹에 있다. PCU들에 대한 순서(1)의 청크들은 블록(1) 내의 연속적인 어드레스들의 그룹에 있다. PMU들에 대한 순서(1)의 청크들은 블록(1) 내의 연속적인 어드레스들의 그룹에 있다. AGCU들에 대한 순서(1)의 청크들은 블록(1) 내의 연속적인 어드레스들의 그룹에 있다. 3 내지 5 번 순서들의 청크들은 블록들 (2) 내지 (5) 의 패턴에 따라, 도 9 에 도시된 바와 같이 배열된다.

도시된 바와 같이, 선형 어드레스 공간은 이 예에서 라인 경계들 상의 구성 파일에 대해 블록들 내에 할당된다. 다른 실시형태들에서, 선형 어드레스 공간은 워드 경계들 또는 청크 경계들 상에 할당될 수 있다. 경계들은 사용될 메모리의 효율 특성들에 매칭하도록 선택될 수 있다. 따라서, 이 예에서의 구성 파일은 순차적인 라인 어드레스들을 갖는 메모리의 라인들을 포함한다.

또한, 어레이는 하나 초과의 타입의 구성가능한 유닛을 포함하고, 상이한 타입들의 구성가능한 유닛들에 대한 유닛 파일들은 구성 데이터의 상이한 수들의 서브-파일들을 포함하고, 어드레스 공간의 블록 (i) 내에서, 구성가능한 유닛의 각각의 타입에 대한 서브-파일들은 어드레스 공간의 블록 (i) 내의 연속적인 어드레스들의 대응하는 그룹에 저장된다.

어레이는 하나 초과의 타입의 구성가능한 유닛을 포함할 수 있고, 상이한 타입들의 구성가능한 유닛들에 대한 유닛 파일들은 구성 데이터의 상이한 수들의 청크들을 포함할 수 있다. 실례로, 도 3 에 도시된 바와 같이, 어레이에서의 구성가능한 유닛들의 타입들은 스위치 유닛들, PCU(패턴 계산 유닛), PMU(패턴 메모리 유닛) 및 AGCU(어드레스 생성 및 병합 유닛)를 포함할 수 있다.

예시적인 구성 파일 조직은 다음을 포함한다:

W (예컨대, 도 3 에서 28) 스위치 유닛들, 각 유닛은 구성 비트들의 Z1 청크들을 필요로 함;

X (예컨대, 9) PCU 유닛들, 각 유닛은 구성 비트들의 Z2 청크들을 필요로 함;

Y (예컨대, 9) PMU 유닛들, 각 유닛은 구성 비트들의 Z3 청크들을 필요로 함;

Z (예컨대, 4) AGCU 유닛들, 각 유닛은 구성 비트들의 Z4 청크들을 필요로 함.

따라서, 제 1 타입의 구성가능한 유닛에 대한 유닛 파일들은 Z1 청크들을 포함할 수 있고, 제 2 타입의 구성가능한 유닛에 대한 유닛 파일들은 Z2 청크들을 포함하고, 여기서 Z1은 Z2보다 적다. 어레이 구성 로드 프로세스는, 0 에서 Z1-1 로 진행하는 (i) 에 대한 Z1 라운드들에서 제 1 타입 및 제 2 타입의 구성가능한 유닛들의 모두에 대해 유닛 파일들의 청크 (i) 를 포함하는 구성 파일의 세그먼트들을 취출하고, 그 다음에, Z1 에서 Z2-1 로 진행하는 (i) 에 대한 Z2 라운드들에서 제 2 타입의 상기 구성가능한 유닛들의 모두에 대해 유닛 파일들의 청크 (i) 를 포함하는 구성 파일의 세그먼트들을 취출하는 것을 포함할 수 있다. 제 3 타입의 구성가능한 유닛에 대한 유닛 파일들은 Z3 청크들을 포함할 수 있고, 제 4 타입의 구성가능한 유닛에 대한 유닛 파일들은 Z4 청크들을 포함하며, 여기서 Z1은 Z2보다 적고, Z2는 Z3보다 적으며, Z3은 Z4보다 적다. (i+1) 초과의 청크들을 필요로 하는 모든 상이한 타입들의 구성가능한 유닛들에 대해 각 청크 (i) 에 대해 하나의 라운드로 분배 시퀀스가 이 모드에서 계속될 수 있다.

예시적인 구성 파일 조직에서 도시된 바와 같이, 구성 파일에서의 구성 데이터의 청크들은 인터리빙된 방식으로 배열된다:

라운드 R(i = 0)에 대한 스위치 유닛들의 각각에 대한 구성 비트들의 2 개의 청크들의 첫 번째;

라운드 R(i = 0)에 대한 PCU 유닛들의 각각에 대한 구성 비트들의 3 개의 청크들의 첫 번째;

라운드 R(i = 0)에 대한 PMU 유닛들의 각각에 대한 구성 비트들의 5 개의 청크들의 첫 번째;

라운드 R(i = 0)에 대한 AGCU 유닛들의 각각에 대한 구성 비트들의 6 개의 청크들의 첫 번째;

라운드 R(i = 1)에 대한 스위치 유닛들의 각각에 대한 구성 비트들의 2 개의 청크들의 두 번째;

라운드 R(i = 1)에 대한 PCU 유닛들의 각각에 대한 구성 비트들의 3 개의 청크들의 두 번째;

라운드 R(i = 1)에 대한 PMU 유닛들의 각각에 대한 구성 비트들의 5 개의 청크들의 두 번째;

라운드 R(i = 1)에 대한 AGCU 유닛들의 각각에 대한 구성 비트들의 6 개의 청크들의 두 번째;

라운드 R(i = 2)에 대한 PCU 유닛들의 각각에 대한 구성 비트들의 3 개의 청크들의 세 번째;

라운드 R(i = 2)에 대한 PMU 유닛들의 각각에 대한 구성 비트들의 5 개의 청크들의 세 번째;

라운드 R(i = 2)에 대한 AGCU 유닛들의 각각에 대한 구성 비트들의 6 개의 청크들의 세 번째;

라운드 R(i = 3)에 대한 PMU 유닛들의 각각에 대한 구성 비트들의 5 개의 청크들의 네 번째;

라운드 R(i = 3)에 대한 AGCU 유닛들의 각각에 대한 구성 비트들의 6 개의 청크들의 네 번째;

라운드 R(i = 3)에 대한 PMU 유닛들의 각각에 대한 구성 비트들의 5 개의 청크들의 다섯 번째;

라운드 R(i = 4)에 대한 AGCU 유닛들의 각각에 대한 구성 비트들의 6 개의 청크들의 다섯 번째;

라운드 R(i = 5)에 대한 4개의 AGCU 유닛들의 각각에 대한 구성 비트들의 6 개의 청크들의 여섯 번째.

유닛 파일들은 복수의 순서화된 청크들(또는 다른 사이즈의 서브-파일들)을 포함하도록 조직될 수 있다. 상이한 구성가능한 유닛들에 특정한 유닛 파일들은 일부 실시형태들에서 상이한 수들의 순서화된 청크들을 가질 수도 있다. 구성가능한 유닛들의 어레이에 대한 구성 파일은 유닛 파일들의 청크들이 다른 유닛 파일들에 대해 동일한 순서의 청크들로 그룹화되도록 배열된다. 또한, 구성 파일은 구성 파일에서의 청크의 로케이션이 청크의 어레이에서의 구성가능한 유닛 및 구성가능한 유닛에 특정한 유닛 파일에서의 그것의 순서를 의미하도록 배열된다.

어레이 구성 로드 프로세스는, 0에서 Z1-1(=1)로 진행하는 (i) 에 대해, 제 1 타입(스위치 타입), 제 2 타입(PCU 타입), 제 3 타입(PMU 타입) 및 제 4 타입(AGCU 타입) 의 구성가능한 유닛들의 모두에 대한 유닛 파일들의 청크 (i) 를 포함하는 구성 파일의 세그먼트들을 취출할 수 있다. 4가지 타입들의 구성가능한 유닛들의 모두에 대한 유닛 파일들의 청크들 (0) 은 제 1 라운드에서 취출되고, 4가지 타입들의 구성가능한 유닛들의 모두에 대한 유닛 파일들의 청크들 (1) 은 제 2 라운드에서 취출된다. 제 1 및 제 2 라운드 후에, 제 1 타입(스위치 타입)의 구성가능한 유닛들의 모두에 대한 유닛 파일들의 모든 (2) 청크들이 취출되었다. 제 1, 제 2, 제 3 및 제 4 타입들의 구성가능한 유닛들의 모두에 대한 유닛 파일들은 각각 0, 1, 3 및 4개의 청크들이 취출되도록 남아 있다.

그 후, 어레이 구성 로드 프로세스는 제 3 라운드에서 제 2, 제 3 및 제 4 타입들의 구성가능한 유닛들 모두에 대한 유닛 파일들의 청크 (i) 를 포함하는 구성 파일의 세그먼트들을 취출할 수 있다. 제 3 라운드 후에, 제 2 타입(PCU 타입)의 구성가능한 유닛들의 모두에 대한 단위 파일들의 모두 (3) 청크들이 취출되었다. 제 0, 제 2, 제 2 및 제 3 타입들의 구성가능한 유닛들의 모두에 대한 유닛 파일들은 각각 0, 0, 2 및 3 개의 청크들이 취출되도록 남아 있다.

그 후, 어레이 구성 로드 프로세스는 제 4 라운드에서 제 3 및 제 4 타입들의 구성가능한 유닛들 모두에 대한 유닛 파일들의 청크 (i) 를 포함하는 구성 파일의 세그먼트들을 취출할 수 있다. 제 4 라운드 후에, 제 3 타입(PMU 타입)의 구성가능한 유닛들의 모두에 대한 유닛 파일들의 모두 (4) 청크들이 취출되었다. 제 1, 제 2, 제 3 및 제 4 타입들의 구성가능한 유닛들의 모두에 대한 유닛 파일들은 각각 0, 0, 1 및 2 개의 청크들이 취출되도록 남아 있다.

그 후, 어레이 구성 로드 프로세스는 제 5 및 제 6 라운드들에서, Z3(=4)에서 Z4-1(5)로 진행하는 (i) 에 대해, 제 3 및 제 4 타입들의 구성가능한 유닛들의 모두에 대한 유닛 파일들의 청크 (i) 를 포함하는 구성 파일의 세그먼트들을 취출할 수 있다. 제 6 라운드 후에, 제 4 타입(AGCU 타입)의 구성가능한 유닛들의 모두에 대한 유닛 파일들의 모두 (6) 청크들이 취출되었다. 제 1, 제 2, 제 3 및 제 4 타입들의 구성가능한 유닛들의 모두에 대한 유닛 파일들은 각각 0, 0, 0 및 0 청크들이 취출되도록 남아 있다.

전술한 방식으로, 어레이 구성 로드 프로세스는, 제 1, 제 2, 제 3 및 제 4 타입들의 구성가능한 유닛들 모두에 대한 유닛 파일들이 취출될 남아있는 청크들을 갖지 않을 때까지 계속될 수 있다.

어레이 구성 로드 프로세스는 구성 파일에서의 청크들의 로케이션에 의해 암시되는 (implied) 어드레스들을 사용하여 어레이 레벨 네트워크를 통해 구성가능한 유닛들로 구성 데이터의 청크들을 라우팅한다. 실례로, 198개의 스위치 유닛들의 각각에 대한 구성 데이터의 2개의 청크들 중 제 1 청크는 선형 메모리 어드레스들 0-12288을 갖고, 198개의 스위치 유닛들의 각각에 대한 구성 데이터의 2개의 청크들 중 제 2 청크는 선형 메모리 어드레스들 33792-46080을 갖는다.

일부 실시형태들에서, 구성 파일의 청크들은 메모리로부터 구성 로드 제어기로 비순차적으로 리턴될 수 있다. 구성 파일에서의 청크들의 로케이션은 청크를 정확한 구성가능한 유닛으로 라우팅하는 데 사용될 수 있다. 배포 시퀀스에서의 라운드들의 조직 때문에, 구성가능한 유닛들은 그것들의 유닛 파일들의 청크들을 순서대로 수신하도록 보장된다.

도 10 은 도 2 및 도 3의 것과 같은 시스템에 대한 어레이 구성 로드 프로세스를 실행하기 위한 로직의 일 예를 나타내는 상태 머신 다이어그램이며, 구성 파일에서의 유닛 파일들이 복수의 구성가능한 유닛들에서의 구성가능한 유닛들로 분배될 때까지, N 라운드들(i = 0 내지 N-1 에 대해 R(i))의 시퀀스로 순서 (i) 의 하나의 유닛 청크를 버스 시스템을 통해 복수의 구성가능한 유닛들에서 최대 N개의 서브-파일들을 포함하는 구성가능한 유닛들의 모두에 전송함으로써, 어레이에서의 복수의 구성가능한 유닛들에 대한 유닛 파일들을 포함하는 구성 파일을 분배하는 것을 포함하고, 유닛 파일들 각각은 복수의 순서화된 청크들(또는 서브-파일들)을 포함한다.

이 예에서, 상태 머신은 6개의 상태들(S1~S6)을 포함한다. 상태 S1(유휴)에서, 구성 로드 제어기는 호스트로부터의 구성 로드 커맨드를 대기한다. 구성 로드 커맨드가 수신될 때, 로드 프로세스는 분배 시퀀스의 제 1 라운드 R(0)의 실행을 시작하기 위해 상태 S2로 진입한다. 각각의 라운드는 상태들 S2 내지 S6을 가로지른다. 본 명세서에 설명된 예에서, 어레이에서의 구성가능한 유닛에 분배될 청크들의 최대 수가 6개이기 때문에 6 라운드들이 존재한다.

상태 S2(스위치 요청)에서, 구성 로드 제어기는 각각의 스위치 유닛들에 대한 구성 유닛 파일들의 라운드 R(i)의 상태 S2에 대한 청크들을 취출하기 위해 최상위 레벨 네트워크를 통해 메모리 액세스 요청들을 생성하고, 취출된 청크들을 각각의 스위치 유닛들에 분배한다. i=0에 대해, 라운드 R(0)에서, 구성 로드 제어기는 각각의 스위치 유닛들에 대한 다수의 청크들에서 청크(0)에 대한 메모리 액세스 요청들을 생성하고, 청크들(0)을 각각의 스위치 유닛들에 전송한다. i=1에 대해, 라운드 R(1)에서, 구성 로드 제어기는 각각의 스위치 유닛들에 대한 다수의 청크들에서 청크(1)에 대한 메모리 액세스 요청들을 생성하고, 청크들을 각각의 스위치 유닛들에 전송한다. 라운드 R(i)에서, 구성 로드 제어기가 각각의 스위치 유닛들에 대한 다수의 청크들에서의 청크들 (i) 에 대한 메모리 액세스 요청들을 생성하고, 모든 스위치 유닛들에 대한 청크들을 분배했을 때, 로드 프로세스는 상태 S3으로 진입한다.

상태 S3(PCU 요청)에서, 구성 로드 제어기는 각각의 PCU 유닛들(패턴 계산 유닛들)에 대한 구성 유닛 파일들의 라운드 R(i)에 대한 청크들을 취출하기 위해 최상위 레벨 네트워크를 통해 메모리 액세스 요청들을 생성하고, 취출된 청크들을 각각의 PCU 유닛들에 분배한다. 라운드 R(i)의 상태 S3에서, 구성 로드 제어기는 각각의 PCU 유닛들에 대한 다수의 청크들에서의 청크들(i)에 대한 메모리 액세스 요청들을 생성하고, 그 청크들(i)을 각각의 PCU 유닛에 전송한다. 라운드 R(i)에서, 구성 로드 제어기가 각각의 PCU 유닛들에 대한 다수의 청크들에서의 청크(i)에 대한 메모리 액세스 요청들을 생성하고 청크들을 분배했을 때, 로드 프로세스는 상태 S4로 진입한다.

상태 S4(PMU 요청)에서, 구성 로드 제어기는 구성가능한 유닛들의 어레이에서의 각각의 PMU 유닛들(패턴 메모리 유닛들)에 대한 구성 유닛 파일들의 청크들을 취출하기 위해 최상위 레벨 네트워크를 통해 메모리 액세스 요청들을 생성하고, 취출된 청크들을 각각의 PMU 유닛들에 전송한다. 라운드 R(i)의 상태 S4에서, 구성 로드 제어기는 각각의 PMU 유닛들에 대한 다수의 청크들에서의 청크들(i)에 대한 메모리 액세스 요청들을 생성하고, 그 청크들(i)을 각각의 PMU 유닛들에 전송한다. 실례로, i=0에 대해, 라운드 R(0)에서, 구성 로드 제어기는 각각의 PMU 유닛들에 대한 다수의 청크들에서의 청크들(0)에 대한 메모리 액세스 요청들을 생성하고, 청크들(0)을 각각의 PMU 유닛들에 전송한다. i=1에 대해, 라운드 R(1)에서, 구성 로드 제어기는 각각의 PMU 유닛들에 대한 다수의 청크들에서의 청크들(1)에 대한 메모리 액세스 요청들을 생성하고, 청크들(1)을 각각의 PMU 유닛들에 전송한다. 라운드 R(i)에서, 구성 로드 제어기가 각각의 PMU 유닛들에 대한 다수의 청크들에서의 청크들(i)에 대한 메모리 액세스 요청들을 생성하고 청크들을 분배했을 때, 로드 프로세스는 상태 S5로 진입한다.

상태 S5(AGCU 요청)에서, 구성 로드 제어기는 구성가능한 유닛들의 어레이에서의 각각의 AGCU들(어드레스 생성 및 병합 유닛들)에 대한 구성 유닛 파일들의 청크들을 취출하기 위해 최상위 레벨 네트워크를 통해 메모리 액세스 요청들을 생성하고, 취출된 청크들을 각각의 AGCU 유닛들로 전송한다. 라운드 R(i)의 상태 S5에서, 구성 로드 제어기는 각각의AGCU 유닛들에 대한 다수의 청크들에서의 청크들(i)에 대한 메모리 액세스 요청들을 생성하고, 그 청크들(i)을 각각의 AGCU 유닛들에 전송한다. 라운드 R(i)의 상태 S5 에서, 구성 로드 제어기가 각각의 AGCU 유닛들에 대한 다수의 청크들에서의 청크들(i)에 대한 메모리 액세스 요청들을 생성하고 청크들을 분배했을 때, 로드 프로세스는 라운드 R(i)의 상태 S6로 진입한다.

상태 S6(응답 대기)에서, 구성 로드 제어기는 어레이에서의 구성가능한 유닛들(스위치, PCU, PMU, AGCU 유닛들)이 다음 라운드에서 구성 데이터의 더 많은 청크들을 수신할 준비가 되는 것을 보장하기 위해 대기한다. 스위치 유닛들에 대한 모든 청크들이 전송되지 않으면, 로드 프로세스는 증분(i)하고, 상태 S2로 진행하여 다음 라운드 R(i+1)을 시작한다. 스위치 유닛들에 대한 모든 청크들이 전송되지만 PCU 청크들에 대한 모든 청크들이 전송되지 않으면, 로드 프로세스는 증분(i)하고, 다음 라운드 R(i+1)를 시작하기 위해 상태 S3으로 진행한다. 스위치 유닛들 및 PCU 유닛들에 대한 모든 청크들이 전송되지만 PMU 청크들에 대한 모든 청크들이 전송되지 않으면, 로드 프로세스는 증분(i)하고, 다음 라운드 R(i+1)를 시작하기 위해 상태 S4로 진행한다. 스위치 유닛들, PCU 유닛들, 및 PMU 유닛들에 대한 모든 청크들이 전송되지만 AGCU 청크들에 대한 모든 청크들이 전송되지 않는 경우, 로드 프로세스는 증분(i)하고 상태 S5로 진행하여 다음 라운드 R(i+1)를 시작한다. 모든 구성가능한 유닛들(스위치, PCU, PMU, AGCU 유닛들)에 대한 모든 청크들이 전송되면(즉, 모든 라운드들이 완료되면), 로드 프로세스는 상태 S1으로 진행한다.

도 11 은 도 10 의 것과 같은 분배 시퀀스의 조기 라운드들의 타이밍을 나타내는 타이밍도이다. 이 예에서, 구성 유닛 파일의 청크는 데이터의 비트 수 B(예를 들어, B=128)를 갖고, 분배 시퀀스에서의 라운드는 구성가능한 유닛들의 수 X를 포함할 수 있고, 구성가능한 유닛들의 어레이는 구성가능한 유닛들의 수 Y(예컨대, Y=148)를 포함할 수 있다. 라운드 R(0)에 대해, X는 Y와 동일할 수 있다. 후속 라운드들에서, X는 Y 이하일 수 있다.

이 예에서, 라운드 R(0)은 Y = 148 개의 구성가능한 유닛들을 포함한다. 라운드들 R(0) 및 R(1)의 경우, X=Y이다. 처음 두 라운드들 R(0) 및 R(1) 후에, 스위치 유닛들은 모두 (2) 의 그것들의 청크들을 수신하였고, 따라서 제 3 라운드 R(2)는 128개 보다 적은 구성가능한 유닛들을 포함한다.

도 11의 예에서 도시된 바와 같이, 라운드 R(0), 구성 유닛 파일의 제 1 청크(P11)는 제 1 버스 사이클(C0)에서 버스 시스템을 통해 구성가능한 유닛에서 수신된다. 그 후, 제 1 청크는, 라운드의 다른 청크들이 구성 로드 제어기에 의해 다른 구성가능한 유닛들로 분배되는 동안 구성가능한 유닛에서 병렬 태스크(parallel task)로 직렬로 시프팅함으로써, 제 1 구성가능한 유닛 "유닛 1"의 구성 저장소에 로딩되고, 제 1 청크(P11) 내의 데이터의 B 비트들은 B 클럭 사이클들(버스 클럭과 동일한 레이트로 실행될 수 있음)로 시프팅된다. 구성 파일의 제 2 청크(P21)는 제 2 버스 사이클(C1)에서 버스 시스템을 통해 수신된다. 제 2 청크(P21)의 데이터의 B 비트를 B 클럭 사이클들로 직렬로 시프팅함으로써, 제 2 청크는 병렬 태스크로 제 2 구성가능한 유닛 "유닛 2" 의 구성 저장소에 로딩된다. 구성 파일의 제 3 청크(P31)는 제 3 버스 사이클(C2)에서 버스 시스템을 통해 수신된다. 그 후, 제 3 청크(P31)는 제 3 청크(P31)에서의 B 비트의 데이터를 B 클럭 사이클로 직렬로 시프팅함으로써 제 3 구성가능한 유닛 "유닛 3" 의 구성 저장소에 로딩된다. 이 라운드는 모든 구성가능한 유닛들이 그것들에 특정적인 유닛 파일의 제 1 청크를 수신할 때까지 진행된다.

라운드 R(0)은 어레이에서의 Y개의 각각의 구성가능한 유닛들(유닛 1 ... 유닛 Y)에서 구성 파일(P11, P21, P31 ... PY1)의 Y개의 청크들의 제 1 세트를 분배하는 것을 포함한다. 구성 파일의 청크는 데이터의 비트 수 B를 갖고, 구성가능한 유닛들의 어레이는 구성가능한 유닛들의 수 Y를 갖는다. 라운드 R(0)가 완료되면, 제 1 세트에서의 구성 파일(P11, P21, P31 ... PY1)의 Y개의 청크들은 Y개의 버스 사이클들(C0 내지 CY-1)에서 어레이에서의 Y개의 구성가능한 유닛들로 수신되었고, 제 1 청크(P11)는 B개의 클럭 사이클들에서 제 1 구성가능한 유닛 "유닛 1"의 구성 저장소로 로딩되거나 직렬로 시프트되었다. B 클럭 사이클들은 제 1 청크(P11)가 수신되는 제 1 클럭 사이클(C0)에 후속한다.

다음 라운드 R(1)은 어레이에서의 Y개의 각각의 구성가능한 유닛들(유닛 1... 유닛 Y)에서 구성 파일(P12, P22, P32... Py2)의 Y개의 청크들의 제 2 세트를 수신하는 것을 포함한다. 라운드 R(1)이 완료되면, 제 2 세트에서의 구성 파일(P12, P22, P32 ... Py2)의 Y 청크들은 Y 클럭 사이클(Cy 내지 C2y-1)에서 어레이에서의 Y개의 각각의 구성가능한 유닛들로 수신되었다. 라운드 R(1)이 완료되면, 라운드 R(1)에서 제 1 클럭 사이클(Cy)에 후속하는 B 클럭 사이클들에서 제 1 구성 유닛 "유닛 1" 에 대한 제 2 청크(P12)가 제 1 구성가능한 유닛 "유닛 1" 의 구성 저장소에 로딩되거나 직렬로 시프트되었다. 또한, 제 2 라운드가 완료되면, 라운드 R(0)에서 수신된 구성 파일의 Y 청크들의 제 1 세트 내의 마지막 청크 PY1은 마지막 구성가능한 유닛 "유닛 Y"의 구성 저장소로 로딩되거나 직렬로 시프트된다.

청크 내의 비트 수 B(128)가 라운드에서의 구성가능한 유닛들의 수 X보다 적은 한, 구성가능한 유닛은 이전 청크가 로딩된 후에 유닛 구성 파일의 다음 청크를 수신할 것이어서, 구성가능한 유닛들은 시퀀스를 스톨할 필요 없이 준비되어야 한다. 이 예에서, 청크 내의 비트의 수 B는 128이고, 라운드 R(0)에서의 구성가능한 유닛들의 수 X는 X=Y=148이다. 청크 내의 128 비트를 구성가능한 유닛의 구성 데이터 저장소로 직렬로 시프트하는 데 128 클럭 사이클들이 필요하기 때문에, 시프팅이 수행된 후에 효과적으로 20(Y-B = 148-128) 버퍼 사이클들이 있을 수 있고, 이는 제 1 구성가능한 유닛 "유닛 1"이 다음 라운드 R(1)에서 다음 청크(P12)를 수용할 준비가 됨을 보장한다. 청크의 비트 수 B가 라운드에서의 구성가능한 유닛들의 수 X보다 큰 경우, 이전 청크가 소비되는 동안 다음 청크가 수신될 수 있다. 여기서 소모된다는 것은 청크 내의 비트들을 구성가능한 유닛의 구성 데이터 저장소 내로 직렬로 시프트하는 것을 지칭한다.

일반적으로, 유닛 구성 로드 프로세스는, 하나의 버스 사이클에서 버스 시스템으로부터 구성가능한 유닛에 특정한 유닛 파일의 제 1 청크(또는 서브-파일)를 수신하고, 다음 라운드에 대한 유닛 파일의 제 2 청크가 수신되기 전에 후속 버스 사이클들 동안, 수신된 제 1 청크를 직렬 체인 내로 푸시하기 시작하고, 나중의 버스 사이클에서 시퀀스의 다음 라운드에 대해 버스 시스템으로부터 구성가능한 유닛에 특정한 유닛 파일의 제 2 청크를 수신하고, 이전에 수신된 청크를 직렬 체인 내로 푸시한 후에 시퀀스의 사이클들 동안, 수신된 제 2 청크를 직렬 체인 내로 푸시하기 시작한다. 일부 라운드들에서, 수신된 모든 청크는 다음 청크가 수신되기 전에 소비될 수 있다.

상이한 타입들의 구성가능한 유닛들은 상이한 수의 구성 비트들을 가질 수도 있기 때문에, 구성가능한 유닛들은 다양한 수의 청크들을 필요로할 수도 있다. 더 적은 수의 청크들을 필요로 하는 구성가능한 유닛들이 그것들의 구성 비트들의 모두를 일단 로드했으면, 구성 로드 제어기는 그것들에 데이터를 전송하는 것을 중지한다. 이렇게 하면 더 적은 구성가능한 유닛들(X개)이 인터리빙되는 것을 초래할 수 있고, 구성가능한 유닛들이 이전 청크를 프로세싱하기 전에 새로운 청크를 수신하는 것을 초래할 수 있다. 이는 어레이 레벨 네트워크에 대한 배압(back-pressure)으로 이어질 수 있다.

배압은 어레이 레벨 네트워크 상의 크레딧 메커니즘을 통해 핸들링될 수 있다. 실례로, 각각의 입력 FIFO는 홉-투-홉 크레딧(hop-to-hop credit)을 가질 수 있어서, PCU의 입력 FIFO가 채워지면, 그 PCU의 입력 FIFO에 구성 데이터를 전송하려고 시도하는 어레이 레벨 네트워크의 어떤 스위치도 입력 FIFO가 하나의 엔트리를 비우고 전송 스위치에 크레딧을 리턴할 때까지 데이터를 전송할 수 없다. 결국, 배압은 링크들이 분주함에 따라 AGCU가 데이터를 전송하는 것을 정지시킬 수 있다. 그러나, 일단 구성가능한 유닛이 청크의 128 비트 모두를 소비하면, 그것은 하나의 입력 FIFO 엔트리를 비우고, 크레딧이 해제되고, 그 후 전송기는 이용가능한 경우 새로운 청크를 전송할 수 있다.

도 12 는 구성가능한 유닛에서의 유닛 구성 로드 프로세스를 나타내는 흐름도이다. 단계(1221)에서, 유닛 구성 로드 프로세스는 입력 FIFO(610, 도 6)가 유효해질 때까지 대기한다. 유효할 때, 입력 FIFO는 구성가능한 유닛을 구성하기 위해 버스 시스템을 통해 구성 파일의 구성 데이터의 청크를 수신했다. 입력 FIFO가 유효한 경우, 플로우는 단계(1222)로 진행한다.

단계(1222)에서, 입력 FIFO는 디큐잉된다. 단계(1223)에서, 입력 FIFO로부터의 구성 데이터의 청크는 입력 시프트 레지스터(620, 도 6)에 병렬로 로딩된다. 단계(1224)에서, 입력 시프트 레지스터 내의 구성 데이터의 청크는 구성가능한 유닛의 구성 데이터 저장소에서의 구성 직렬 체인으로 시프트된다.

단계(1225)에서, 유닛 구성 로드 프로세스는 구성 데이터의 로딩된 청크가 구성가능한 유닛에 대한 구성 데이터의 마지막 청크인지 여부를 결정한다. 그러한 경우, 구성가능한 유닛에 대한 구성 데이터 로드가 완료된다. 그렇지 않다면, 플로우는 단계(1221)로 진행하고, 유닛 구성 로드 프로세스는 구성 데이터의 다음 청크에 대해 입력 FIFO가 유효해질 때까지 대기한다. 구성가능한 유닛에서의 유닛 구성 로드 프로세스는 도 5 및 도 6을 참조하여 추가로 설명된다.

도 13은 도 2 및 도 3의 것과 같은 시스템에 대한 어레이 구성 언로드 프로세스를 실행하기 위한 로직의 일 예에 대한 상태 머신 다이어그램이다.

이 예에서, 상태 머신은 3개의 상태들(S1 내지 S3)을 포함한다. 상태 S1(유휴)에서, 구성 언로드 제어기는 호스트로부터 구성 언로드 커맨드를 기다린다. 구성 언로드 제어기는 어레이 구성 언로드 프로세스를 위해 2 개의 카운트들 "next_unld_req_count" 및 "next_unld_resp_count" 을 구현한다. "next_unld_req_count"는 다음 언로드 요청 카운트를 추적하는 것을 유지한다. "next_unld_resp_count"는 다음 언로드 응답 카운트의 추적을 유지한다. 상태 S1에서, 양 카운트들은 0과 같은 초기 값으로 리셋된다. 구성 언로드 커맨드가 수신되면, 언로드 프로세스는 상태 S2로 진입한다.

상태 S2(요청 생성)에서, 구성 언로드 제어기는, 어레이에서의 스위치 유닛들, PCU들, PMU들 및 AGCU들을 포함하는 구성가능한 유닛들의 어레이에서의 구성가능한 유닛들의 각각에 대해 언로드 요청들을 생성한다. 카운트 "next_unld_req_count"는 생성된 각 언로드 요청에 대해 증분된다. 카운트 "next_unld_req_count"는 구성가능한 유닛들의 어레이에서의 구성가능한 유닛들의 총 수를 나타내는 미리 결정된 수 PROGRAM_UNLOAD_REQ_COUNT에 대해 비교된다. 카운트 "next_unld_req_count"가 PROGRAM_UNLOAD_REQ_COUNT보다 적은 한, 언로드 프로세스는 상태 S2에 머무른다. 카운트 "next_unld_req_count"가 PROGRAM_UNLOAD_REQ_COUNT와 동일할 때, 언로드 요청들은 어레이에서의 구성가능한 유닛들 각각에 대해 생성되었고, 언로드 프로세스는 상태 S3로 진입한다.

상태 S3(응답 대기)에서, 구성 언로드 제어기는 어레이에서의 구성가능한 유닛들로부터 수신된 각각의 응답에 대한 카운트 "next_unld_resp_count"를 증분시킨다. 응답은 구성가능한 유닛에 대한 구성 데이터의 유닛 파일에 청크(서브 파일)를 포함한다. 응답은 또한 일부 예들에서 PMU 스크래치패드 데이터를 포함할 수 있다. 언로드 프로세스 동안, 응답은 구성가능한 유닛의 벡터 출력에 제공되고, 벡터 버스 상에서 구성 로드 제어기에 전송된다. 카운트 "next_unld_resp_count"가 PROGRAM_UNLOAD_REQ_COUNT보다 적은 한, 언로드 프로세스는 상태 S3에 머무른다.

상태 S3에서, 언로드 프로세스는 수신된 각각의 응답에 대한 메모리 어드레스를 생성하고, 최상위 레벨 네트워크 상에서 생성된 메모리 어드레스와 함께 수신된 각각의 응답을 삽입한다. 각 응답은 언로드 청크 및 시퀀스 ID를 포함한다. 메모리 어드레스는, 시퀀스 ID에서의 청크 넘버, 열 식별자, 행 식별자, 및 컴포넌트 식별자를 포함하는, 어레이 레벨 네트워크에서 청크들을 반송하는 패킷들을 수반하는 헤더들로부터 생성된다. 컴포넌트 식별자는 구성가능한 유닛이 스위치 유닛, PCU 유닛, PMU 유닛 또는 AGCU 유닛인지 여부를 나타낼 수 있다. 시퀀스 ID는 도 3을 참조하여 추가로 설명된다.

카운트 "next_unld_resp_count"가 PROGRAM_UNLOAD_REQ_COUNT와 동일할 때, 응답들은 어레이에서의 구성가능한 유닛들 각각으로부터 수신되고 최상위 레벨 네트워크 상에 삽입되었고, 언로드 프로세스는 상태 S1로 다시 천이한다.

일 실시형태에서, 스위치 유닛들에서의 구성 데이터에 대한 선형 메모리 어드레스에 대한 순서는, 스위치 유닛들의 제 1 열 내의 각각의 행의 제 1 청크들, 이어서 스위치 유닛들의 제 2 열 내의 각각의 행의 제 1 청크들, 이어서 스위치 유닛들의 제 3 열 내의 각각의 행의 제 1 청크들, ... 마지막 열 내의 각각의 행의 제 1 청크들까지이다. 이것은 선형 어드레스 공간 내의 모든 스위치 유닛들의 제 1 청크를 그룹화한다. 다른 타입들의 구성가능한 유닛들에 대한 제 1 청크들은 인접한 어드레스 공간의 그룹들에 로딩된다. 그 다음, 순서는, 구성가능한 유닛들의 모든 타입들의 제 2 청크들에 대해, 그 다음에 스위치 유닛들의 제 1 열 내의 각 행의 제 2 청크들, 그 다음에 스위치 유닛들의 제 2 열 내의 각 행의 제 2 청크들, 그 다음에 제 3 열 내의 각 행의 제 2 청크들, 그 다음에 스위치 유닛들의 마지막 열 내의 마지막 행에서의 마지막 청크까지 등이 이어진다.

전술한 바와 같이 스위치 유닛들에서의 구성 데이터에 대한 메모리 어드레스에 대한 순서를 사용하여, 아래의 의사 코드는 스위치 유닛에 대한 선형 메모리 어드레스(comp_switch)를 생성하는 방법을 예시한다. 의사 코드에서는 4개의 입력들을 사용한다:

comp_id: 컴포넌트 식별자;

comp_ col : 열 식별자;

comp_row: 행 식별자;

comp_chunk: 청크 넘버;

그리고 다음과 같이 출력을 생성한다:

linear_address: 언로드 청크에 대한 선형 메모리 어드레스;

스위치 유닛의 특정 언로드 청크에 대한 선형 메모리 어드레스를 생성하기 위한 의사 코드는 다음과 같다:

If (comp_id==comp_switch) begin

comp_num = comp_col*NUM_ROW_SW + comp_row;

linear_comp_num = comp_num + (comp_chunk * COMP_COUNT_ALL);

linear_address = linear_comp_num * 16;

end

여기서,

comp_switch 는 스위치 유닛을 나타내고;

NUM _ROW_SW 는 모든 스위치 유닛들의 행들의 수이고;

COMP_COUNT_ALL 은 모든 구성가능한 단위들의 합이다.

PCU, PMU, 또는 AGCU 유닛의 특정 언로드 청크에 대한 선형 메모리 어드레스를 생성하기 위해, 유사한 코드가 사용될 수 있다. 한 가지 차이점은 모든 스위치 유닛들의 행들의 수가 모든 PCU들의 행들의 수, 모든 PMU들의 행들의 수, 및 모든 AGCU들의 행들의 수와 다르다는 것이다. 또 다른 차이점은 스위치 유닛들에 대한 선형 메모리 어드레스들이 베이스 어드레스(예를 들어, 0)에서 시작할 수 있는 반면, PCU들, PMU들 및 AGCU들에 대한 선형 메모리 어드레스들은 각각 스위치 유닛들, PCU들 및 PMU들에 대한 마지막 청크 후의 어드레스에서 시작할 수 있다는 것이다.

도 14 는 구성가능한 유닛에서의 유닛 구성 언로드 프로세스를 나타내는 흐름도이다. 단계(1431)에서, 구성 데이터 저장소에서의 구성 직렬 체인으로부터의 구성 데이터의 청크는 출력 시프트 레지스터(650, 도 6)로 직렬로 시프트된다. 플로오는 단계 1432로 진입한다.

단계(1432)에서, 유닛 구성 언로드 프로세스는 출력 FIFO(660, 도 6) 또는 다른 타입의 출력 버퍼 회로가 유효해지기를 기다린다. 단계(1433)에서, 출력 FIFO가 유효해질 때, 출력 시프트 레지스터로부터의 구성 데이터의 청크가 출력 FIFO에 삽입된다. 단계(1434)에서, 출력 FIFO 에서의 구성 데이터의 청크는 버스 시스템에 기입된다(도 3).

단계(1435)에서, 유닛 구성 언로드 프로세스는 구성 데이터의 제 1 청크가 구성 데이터 저장소 내의 구성 데이터의 마지막 청크인지 여부를 결정한다. 그러한 경우, 구성가능한 유닛에 대한 구성 데이터의 언로드가 완료된다. 그렇지 않은 경우, 플로우는 단계(1431)로 다시 천이하고, 구성 데이터 저장소로부터의 구성 데이터의 제 2 청크는 출력 시프트 레지스터로 직렬로 시프트된다.

본 발명이 위에서 설명된 바람직한 실시형태들 및 예들을 참조하여 개시되지만, 이러한 예들은 제한적인 의미보다는 예시적인 것으로 의도되는 것으로 이해되어야 한다. 변형들 및 조합들은 당업자에게 용이하게 일어날 것이며, 이러한 변형들 및 조합들은 본 발명의 사상 및 다음의 청구항들의 범위 내에 있을 것이다.

Claims

재구성가능한 데이터 프로세서로서,
버스 시스템;
상기 버스 시스템에 접속된 구성가능한 유닛들의 어레이로서, 상기 어레이에서의 구성가능한 유닛들은 대응하는 구성가능한 유닛들에 특정한 구성 데이터의 복수의 서브-파일들을 포함하는 유닛 파일들을 저장하기 위한 구성 데이터 저장소들을 포함하고, 복수의 상기 구성가능한 유닛들에서의 구성가능한 유닛들은 각각, 상기 버스 시스템을 통해, 상기 구성가능한 유닛에 특정한 유닛 파일의 서브-파일들을 수신하는 것, 및 수신된 상기 서브-파일들을 상기 구성가능한 유닛의 구성 저장소에 로딩하는 것을 포함하는, 유닛 구성 로드 프로세스를 실행하기 위한 로직을 포함하는, 상기 구성가능한 유닛들의 어레이; 및
상기 버스 시스템에 접속된 구성 로드 제어기로서, 상기 구성 로드 제어기는 어레이 구성 로드 프로세스를 실행하는 로직을 포함하고, 상기 어레이 구성 로드 프로세스는, 상기 버스 시스템을 통해 상기 복수의 구성가능한 유닛들에서의 (i+1) 까지의 서브-파일들을 포함하는 상기 구성가능한 유닛들 모두에 N 라운드들 (i = 0 내지 N-1 에 대해 R(i)) 의 시퀀스로 순서 (i) 의 하나의 유닛 서브-파일을 전송함으로써, 상기 어레이에서의 복수의 상기 구성가능한 유닛들에 대한 유닛 파일들을 포함하는 구성 파일을 분배하는 것을 포함하고, 상기 유닛 파일들 각각은 복수의 순서화된 서브-파일들을 포함하는, 상기 구성 로드 제어기를 포함하는, 재구성가능한 데이터 프로세서.
제 1 항에 있어서,
상기 복수의 구성가능한 유닛들은 상기 구성가능한 유닛들의 어레이에서의 모든 상기 구성가능한 유닛들을 포함하고, 상기 구성가능한 유닛들 중 하나 이상에 대한 상기 유닛 파일은 비-동작 구성을 구현하는, 재구성가능한 데이터 프로세서.
제 1 항에 있어서,
상기 복수의 구성가능한 유닛들에서의 구성가능한 유닛들에서의 상기 구성 데이터 저장소들은 직렬 체인들을 포함하고, 상기 유닛 구성 로드 프로세스는 하나의 버스 사이클에서 상기 버스 시스템으로부터 상기 구성가능한 유닛에 특정한 상기 유닛 파일의 제 1 서브-파일을 수신하고, 상기 유닛 파일의 제 2 서브-파일이 수신되기 전에 후속 버스 사이클들 동안, 수신된 상기 제 1 서브-파일을 상기 직렬 체인 내로 푸시하기 시작하고, 나중의 버스 사이클에서 상기 시퀀스의 다음 라운드 동안 상기 버스 시스템으로부터 상기 구성가능한 유닛에 특정한 상기 유닛 파일의 상기 제 2 서브-파일을 수신하고, 그리고, 이전에 수신된 서브-파일들을 상기 직렬 체인 내로 푸시한 후에 상기 시퀀스의 사이클들 동안, 수신된 상기 제 2 서브-파일들을 상기 직렬 체인 내로 푸시하기 시작하는, 재구성가능한 데이터 프로세서.
제 3 항에 있어서,
상기 제 1 서브-파일은 상기 복수의 순서화된 서브-파일들에서의 상기 제 2 서브-파일이 상기 구성가능한 유닛에 의해 수신되기 전에 상기 구성가능한 유닛에서의 상기 유닛 구성 로드 프로세스에 의해 소비되는, 재구성가능한 데이터 프로세서.
제 1 항에 있어서,
상기 어레이 구성 로드 프로세스는, 호스트 프로세스로부터, 상기 구성 파일의 메모리 내의 로케이션을 식별하는 구성 로드 커맨드를 수신하는 단계, 및 상기 구성 파일을 취출하기 위해 상기 커맨드에 응답하여 하나 이상의 메모리 액세스 요청들을 생성하는 단계를 포함하는, 재구성가능한 데이터 프로세서.
제 1 항에 있어서,
상기 구성 파일은 복수의 구성가능한 유닛들에서의 각각의 구성가능한 유닛에 대한 유닛 파일들의 복수의 서브-파일들을 포함하고, 상기 서브-파일들은 상기 시퀀스와 매칭하는 인터리빙된 방식으로 상기 구성 파일에 배열되고, 상기 어레이 구성 로드 프로세스는 상기 구성 파일에서의 상기 서브-파일들의 로케이션들에 기초하여 상기 서브-파일들을 구성가능한 유닛들로 라우팅하는 것을 포함하는, 재구성가능한 데이터 프로세서.
제 1 항에 있어서,
서브-파일은 N 비트의 데이터를 갖고, 상기 버스 시스템은 하나의 버스 사이클에서 N 비트의 데이터를 전송하도록 구성되는, 재구성가능한 데이터 프로세서.
제 7 항에 있어서,
상기 복수의 구성가능한 유닛들에서의 구성가능한 유닛들에서의 상기 구성 데이터 저장소들은 직렬 체인들을 포함하고, 상기 유닛 구성 로드 프로세스는 하나의 버스 사이클에서 상기 버스 시스템으로부터 상기 구성가능한 유닛에 특정한 상기 유닛 파일의 제 1 서브-파일을 수신하고, N 개의 후속 버스 사이클들 동안, 수신된 상기 제 1 서브-파일을 상기 직렬 체인 내로 푸시하고, 그리고 나중의 버스 사이클에서 상기 버스 시스템으로부터 상기 구성가능한 유닛에 특정한 상기 유닛 파일의 제 2 서브-파일을 수신하고, 그리고, 이전에 수신된 서브-파일들을 상기 직렬 체인 내로 푸시한 후에 N 개의 후속 버스 사이클들 동안, 수신된 상기 제 2 서브-파일들을 상기 직렬 체인 내로 푸시하는, 재구성가능한 데이터 프로세서.
제 8 항에 있어서,
상기 어레이는 N 개 초과의 구성가능한 유닛들을 포함하는, 재구성가능한 데이터 프로세서.
제 1 항에 있어서,
상기 어레이는 하나 초과의 타입의 구성가능한 유닛을 포함하고, 상이한 타입들의 구성가능한 유닛들에 대한 상기 유닛 파일들은 구성 데이터의 상이한 수들의 서브-파일들을 포함하는, 재구성가능한 데이터 프로세서.
제 1 항에 있어서,
제 1 타입의 구성가능한 유닛에 대한 상기 유닛 파일들은 Z1 서브-파일들을 포함하고, 제 2 타입의 구성가능한 유닛에 대한 상기 유닛 파일들은 Z2 서브-파일들을 포함하며, 여기서 Z1은 Z2보다 적고, 상기 어레이 구성 로드 프로세스는:
0 에서 Z1-1 로 진행하는 (i) 에 대해 제 1 타입 및 제 2 타입의 상기 구성가능한 유닛들의 모두에 대해 상기 유닛 파일들의 서브-파일 (i) 을 포함하는 상기 구성 파일의 세그먼트들을 취출하고, 그 다음에, Z1 에서 Z2-1 로 진행하는 (i) 에 대해 상기 제 2 타입의 상기 구성가능한 유닛들의 모두에 대해 상기 유닛 파일들의 서브-파일 (i) 을 포함하는 상기 구성 파일의 세그먼트들을 취출하는 것을 포함하는, 재구성가능한 데이터 프로세서.
제 1 항에 있어서,
상기 구성가능한 유닛들의 어레이에서의 구성가능한 유닛들은 어레이 구성 로드 로직에서 시작하고 종료하는 데이지 체인으로 접속된 각각의 로드 완료 상태 로직을 포함하는, 재구성가능한 데이터 프로세서.
제 12 항에 있어서,
상기 어레이 구성 로드 로직은 상기 구성 파일이 분배된 후에 상기 데이지 체인 상에 로드 완료 신호를 포워딩하고, 상기 어레이에서의 각각의 구성가능한 유닛에서, 상기 로드 완료 상태 로직은 상기 데이지 체인의 이전 멤버로부터의 상기 로드 완료 신호가 수신되고 그 유닛 파일의 로딩이 완료될 때 상기 데이지 체인 상에 상기 로드 완료 신호를 포워딩하는, 재구성가능한 데이터 프로세서.
제 1 항에 있어서,
상기 버스 시스템은 외부 데이터 인터페이스 및 어레이 인터페이스를 포함하는 최상위 레벨 네트워크, 및 상기 어레이 인터페이스에 그리고 상기 구성가능한 유닛들의 어레이에서의 상기 구성가능한 유닛들에 접속된 어레이 레벨 네트워크를 포함하는, 재구성가능한 데이터 프로세서.
제 14 항에 있어서,
상기 어레이 구성 로드 프로세스는, 호스트 프로세스로부터, 상기 구성 파일의 메모리에서의 로케이션을 식별하는 구성 로드 커맨드를 수신하는 것, 및 상기 외부 데이터 인터페이스를 통해 상기 구성 파일을 취출하기 위해 상기 커맨드에 응답하여 상기 최상위 레벨 네트워크를 통해 하나 이상의 메모리 액세스 요청들을 생성하는 것을 포함하는, 재구성가능한 데이터 프로세서.
제 15 항에 있어서,
상기 어레이 구성 로드 프로세스는 상기 구성 파일에서의 상기 서브-파일들의 로케이션에 의해 암시되는 어드레스들을 사용하여 상기 어레이 레벨 네트워크를 통해 상기 구성 데이터의 상기 서브-파일들을 구성가능한 유닛들로 라우팅하는, 재구성가능한 데이터 프로세서.
제 1 항에 있어서,
상기 복수의 구성가능한 유닛들에서의 구성가능한 유닛들은 상기 구성 로드 프로세스에서 또한 사용되는 구성 후의 실행 동안 상기 버스 시스템에서의 루트들을 사용하는, 재구성가능한 데이터 프로세서.
버스 시스템 및 상기 버스 시스템에 접속된 구성가능한 유닛들의 어레이를 포함하는 재구성가능한 데이터 프로세서를 동작시키는 방법으로서, 상기 어레이에서의 구성가능한 유닛들은 대응하는 구성가능한 유닛들에 특정한 구성 데이터의 복수의 서브-파일들을 포함하는 유닛 파일들을 저장하기 위한 구성 데이터 저장소들을 포함하고, 상기 방법은:
상기 버스 시스템을 통해 상기 복수의 구성가능한 유닛들에서의 (i+1) 까지의 서브-파일들을 포함하는 상기 구성가능한 유닛들 모두에 N 라운드들 (i = 0 내지 N-1 에 대해 R(i)) 의 시퀀스로 순서 (i) 의 하나의 유닛 서브-파일을 전송함으로써, 상기 어레이에서의 복수의 상기 구성가능한 유닛들에 대한 유닛 파일들을 포함하는 구성 파일을 분배하는 단계로서, 상기 유닛 파일들 각각은 복수의 순서화된 서브-파일들을 포함하는, 상기 구성 파일을 분배하는 단계; 및
상기 구성가능한 유닛들에서, 상기 구성가능한 유닛에 특정한 유닛 파일의 상기 서브-파일들을 수신하고, 수신된 상기 서브-파일들을 상기 구성가능한 유닛의 구성 저장소에 로딩하는 단계를 포함하는, 재구성가능한 데이터 프로세서를 동작시키는 방법.
제 18 항에 있어서,
상기 복수의 구성가능한 유닛들은 상기 구성가능한 유닛들의 어레이에서의 모든 상기 구성가능한 유닛들을 포함하고, 상기 구성가능한 유닛들 중 하나 이상에 대한 상기 유닛 파일은 비-동작 구성을 구현하는, 재구성가능한 데이터 프로세서를 동작시키는 방법.
제 18 항에 있어서,
상기 복수의 구성가능한 유닛들에서의 구성가능한 유닛들에서의 상기 구성 데이터 저장소들은 직렬 체인들을 포함하고,
상기 방법은, 하나의 버스 사이클에서 특정 구성가능한 유닛에서의 상기 유닛 파일의 제 1 서브-파일을 수신하는 단계, 및 상기 유닛 파일의 제 2 서브-파일이 수신되기 전에 후속 버스 사이클들 동안, 수신된 상기 제 1 서브-파일을 상기 직렬 체인 내로 푸시하기 시작하는 단계, 및 나중의 버스 사이클에서 상기 시퀀스의 다음 라운드 동안 상기 특정 구성가능한 유닛에서의 상기 유닛 파일의 상기 제 2 서브-파일을 수신하는 단계, 및 상기 직렬 체인 내로 이전에 수신된 서브-파일들을 푸시하는 것을 완료한 후에 상기 시퀀스의 사이클들 동안, 수신된 상기 제 2 서브-파일들을 상기 직렬 체인 내로 푸시하기 시작하는 단계를 포함하는, 재구성가능한 데이터 프로세서를 동작시키는 방법.
제 20 항에 있어서,
상기 제 1 서브-파일은 상기 복수의 순서화된 서브-파일들에서의 상기 제 2 서브-파일이 상기 구성가능한 유닛에 의해 수신되기 전에 상기 구성가능한 유닛에서의 유닛 구성 로드 프로세스에 의해 소비되는, 재구성가능한 데이터 프로세서를 동작시키는 방법.
제 18 항에 있어서,
상기 분배하는 단계 전에, 호스트 프로세스로부터, 상기 구성 파일의 메모리 내의 로케이션을 식별하는 구성 로드 커맨드를 수신하는 단계, 및 상기 구성 파일을 취출하기 위한 상기 커맨드에 응답하여 하나 이상의 메모리 액세스 요청들을 생성하는 단계를 포함하는, 재구성가능한 데이터 프로세서를 동작시키는 방법.
제 18 항에 있어서,
상기 구성 파일은 복수의 구성가능한 유닛들에서의 각각의 구성가능한 유닛에 대한 유닛 파일들의 복수의 서브-파일들을 포함하고, 상기 서브-파일들은 인터리빙된 방식으로 상기 구성 파일에 배열되고,
상기 방법은, 상기 구성 파일에서의 상기 서브-파일들의 로케이션들에 기초하여 상기 서브-파일들을 구성가능한 유닛들로 라우팅하는 단계를 포함하는, 재구성가능한 데이터 프로세서를 동작시키는 방법.
제 23 항에 있어서,
서브-파일은 N 비트의 데이터를 갖고, 상기 버스 시스템은 하나의 버스 사이클에서 N 비트의 데이터를 전송하도록 구성되는, 재구성가능한 데이터 프로세서를 동작시키는 방법.
제 24 항에 있어서,
상기 복수의 구성가능한 유닛들에서의 구성가능한 유닛들에서의 상기 구성 데이터 저장소들은 직렬 체인들을 포함하고,
상기 방법은, 구성가능한 유닛에서, 하나의 버스 사이클에서 상기 구성가능한 유닛에 특정한 상기 유닛 파일의 제 1 서브-파일을 수신하는 단계, 및 N 개의 후속 버스 사이클들 동안, 수신된 상기 제 1 서브-파일을 상기 직렬 체인 내로 푸시하는 단계, 및 나중의 버스 사이클에서 상기 구성가능한 유닛에 특정한 상기 유닛 파일의 제 2 서브-파일을 수신하는 단계, 및 이전에 수신된 서브-파일들을 상기 직렬 체인 내로 푸시한 후에 N 개의 후속 버스 사이클들 동안, 수신된 상기 제 2 서브-파일들을 상기 직렬 체인 내로 푸시하는 단계를 포함하는, 재구성가능한 데이터 프로세서를 동작시키는 방법.
제 25 항에 있어서,
상기 어레이는 N 개 초과의 구성가능한 유닛들을 포함하는, 재구성가능한 데이터 프로세서를 동작시키는 방법.
제 18 항에 있어서,
상기 어레이는 하나 초과의 타입의 구성가능한 유닛을 포함하고, 상이한 타입들의 구성가능한 유닛들에 대한 상기 유닛 파일들은 구성 데이터의 상이한 수들의 서브-파일들을 포함하는, 재구성가능한 데이터 프로세서를 동작시키는 방법.
제 18 항에 있어서,
제 1 타입의 구성가능한 유닛에 대한 상기 유닛 파일들은 Z1 서브-파일들을 포함하고, 제 2 타입의 구성가능한 유닛에 대한 상기 유닛 파일들은 Z2 서브-파일들을 포함하며, 여기서 Z1은 Z2보다 적고,
상기 방법은:
0 에서 Z1-1 로 진행하는 (i) 에 대해 제 1 타입 및 제 2 타입의 상기 구성가능한 유닛들의 모두에 대해 상기 유닛 파일들의 서브-파일 (i) 을 포함하는 상기 구성 파일의 세그먼트들을 취출하고, 그 다음에, Z1 에서 Z2-1 로 진행하는 (i) 에 대해 상기 제 2 타입의 상기 구성가능한 유닛들의 모두에 대해 상기 유닛 파일들의 서브-파일 (i) 을 포함하는 상기 구성 파일의 세그먼트들을 취출하는 단계를 포함하는, 재구성가능한 데이터 프로세서를 동작시키는 방법.
제 18 항에 있어서,
구성가능한 유닛들의 데이지 체인에서 로드 완료 상태를 패스하는 단계를 포함하는, 재구성가능한 데이터 프로세서를 동작시키는 방법.
제 29 항에 있어서,
상기 구성 파일이 분배된 후에 상기 데이지 체인 상의 제 1 노드로부터 로드 완료 신호를 포워딩하는 단계, 및 상기 어레이에서의 각각의 구성가능한 유닛에서, 상기 데이지 체인의 이전 노드로부터 상기 로드 완료 신호가 수신되고 그 유닛 파일의 로딩이 완료될 때 상기 데이지 체인 상에 상기 로드 완료 신호를 포워딩하는 단계를 포함하는, 재구성가능한 데이터 프로세서를 동작시키는 방법.
제 18 항에 있어서,
호스트 프로세스로부터, 상기 구성 파일의 메모리에서의 로케이션을 식별하는 구성 로드 커맨드를 수신하는 단계, 및 상기 구성 파일을 취출하기 위해 상기 커맨드에 응답하여 최상위 레벨 네트워크를 통해 하나 이상의 메모리 액세스 요청들을 생성하는 단계를 포함하는, 재구성가능한 데이터 프로세서를 동작시키는 방법.
제 31 항에 있어서,
상기 어레이 구성 로드 프로세스는 상기 구성 파일에서의 상기 서브-파일들의 로케이션에 의해 암시되는 어드레스들을 사용하여 상기 어레이 레벨 네트워크를 통해 상기 구성 데이터의 서브-파일들을 구성가능한 유닛들로 라우팅하는, 재구성가능한 데이터 프로세서를 동작시키는 방법.
제 18 항에 있어서,
상기 분배를 위해 또한 사용되는, 구성 후의 실행 동안 상기 버스 시스템에서의 경로들을 사용하는, 재구성가능한 데이터 프로세서를 동작시키는 방법.
재구성가능한 데이터 프로세서로서,
버스 시스템;
상기 버스 시스템에 접속된 구성가능한 유닛들의 어레이?로서, 유닛 파일들을 저장하기 위해 직렬 체인들로 배열된 구성 데이터 저장소들을 포함하는 상기 어레이에서의 구성가능한 유닛들은 대응하는 구성가능한 유닛들에 특정한 구성 데이터의 복수의 서브-파일들을 포함하는, 상기 구성가능한 유닛들의 어레이; 및
상기 버스 시스템에 접속된 구성 로드 제어기로서, 병렬 서브-파일들에서 상기 어레이에서의 복수의 상기 구성가능한 유닛들에 대한 유닛 파일들을 포함하는 구성 파일을 분배하기 위한 로직을 포함하는, 상기 구성 로드 제어기를 포함하는, 재구성가능한 데이터 프로세서.
버스 시스템 및 상기 버스 시스템에 접속된 구성가능한 유닛들의 어레이를 포함하는 재구성가능한 데이터 프로세서를 동작시키는 방법으로서, 상기 어레이에서의 구성가능한 유닛들은 대응하는 구성가능한 유닛들에 특정한 구성 데이터의 복수의 서브-파일들을 포함하는 유닛 파일들을 저장하기 위해 직렬 체인들로 배열된 구성 데이터 저장소들을 포함하고, 상기 방법은:
병렬 서브-파일들에서 상기 어레이에서의 복수의 상기 구성가능한 유닛들에 대한 유닛 파일들을 포함하는 구성 파일을 분배하는 단계를 포함하는, 재구성가능한 데이터 프로세서를 동작시키는 방법.