KR20220010035A - 이종 처리 시스템을 위한 데이터 흐름 그래프 프로그래밍 환경 - Google Patents

Abstract

본 명세서의 예는 커널 및 이러한 커널 간의 통신 링크를 규정하기 위한 소스 코드를 사용하여 데이터 흐름 그래프를 생성하는 기술을 설명한다. 일 실시예에서, 그래프는 에지(예를 들어, 커널들 사이의 통신 링크)에 의해 통신 가능하게 결합된 노드(예를 들어, 커널)를 사용하여 형성된다. 컴파일러는 소스 코드를 SoC의 이종 처리 시스템을 구성하는 비트 스트림 및/또는 2진 코드로 변환하여, 그래프를 실행한다. 컴파일러는 소스 코드로 표현된 그래프를 사용하여, 이종 처리 시스템에서 커널을 할당할 위치를 결정한다. 또한, 컴파일러는 특정 통신 기술을 선택하여 커널 간의 통신 링크를 설정하고 통신 링크에서 동기화를 사용해야 하는지 여부를 결정할 수 있다. 따라서, 프로그래머는 SoC에서 이종 하드웨어를 사용하여 연산자 그래프를 구현하는 방법에 대한 이해 없이 하이 레벨(소스 코드 사용함)에서 데이터 흐름 그래프를 표현할 수 있다.

Description

이종 처리 시스템을 위한 데이터 흐름 그래프 프로그래밍 환경

본 개시 내용의 예는 일반적으로 프로그램 가능한 및 소프트웨어 구성 가능한 강화 하드웨어 요소의 혼합을 포함하는 시스템에서 데이터 흐름 그래프를 생성하기 위해 객체 지향 프로그래밍 코드를 사용하는 것과 관련된다.

SoC(시스템 온 칩)에는 프로그램 가능한 로직(예를 들어, 프로그램 가능한 패브릭)과 처리 코어 또는 엔진과 같은 소프트웨어 구성 가능한 강화 로직이 혼합되어 포함될 수 있다. 일반적으로, 사용자는, 사용자 함수를 수행하도록 소프트웨어 구성 가능한 강화 로직을 구성하기 위한 2진 코드 및 프로그램 가능한 로직을 구성하기 위한 비트스트림으로 컴파일될 수 있는 프로그램을 기록하기 위하여, 프로그램 가능한 로직 및 소프트웨어 구성 가능한 강화 로직(및 이들이 통신하는 방법)을 상세히 이해해야 한다. 그러나, HDL(hardware description language) 또는 OpenCL(Open Computing Language)을 사용하여 프로그래밍 가능한 로직과 강화된 로직이 혼합된 SoC용 프로그램을 작성하는 것은, 번거롭고 병렬화하기 어렵다. 데이터 병렬 및 스레드 병렬은 또한, 프로세서의 어레이에 대한 계산을 표현하는 데 사용되지만, 이러한 기술은 인터페이스가 다른 이종 계산을 표현해야 하는 프로그램 가능한 로직으로 자연스럽게 확장되지 않는다.

이종 처리 시스템에서 데이터 흐름 그래프를 구현하는 기술이 설명된다. 일 예는 그래프 소스 코드를 수신하는 단계를 포함하는 방법이며, 상기 그래프 소스 코드는 복수의 커널 및 복수의 통신 링크를 규정하며, 여기서 복수의 통신 링크의 각각은 복수의 커널의 각각의 쌍을 결합하여 데이터 흐름 그래프를 형성한다. 이 방법은 또한 이종 처리 시스템의 시스템에서 데이터 흐름 그래프를 구현하기 위해 그래프 소스 코드를 컴파일하는 단계를 포함한다. 그래프 소스 코드를 컴파일하는 것은, 복수의 커널을 이종 처리 시스템의 프로그램 가능한 로직 및 데이터 처리 엔진(DPE)의 어레이에 할당하고, 통신 유형을 복수의 통신 링크에 할당하고, 복수의 통신 링크를 사용하여 복수의 커널 사이에 데이터를 전송하기 위한 동기화 기술을 선택하는 것을 포함한다.

일부 실시예에서, 복수의 커널을 이종 처리 시스템에 할당하는 단계는, 제1 커널 및 제2 커널이 그래프 소스 코드에 의해 규정된 바와 같은 복수의 통신 링크 중 제1 링크에 의해 통신 가능하게 결합된다는 것을 식별하는 단계, 제1 커널을 이종 처리 시스템의 제1 데이터 처리 엔진(DPE)에 할당하는 단계, 그리고 제1 DPE에 직접 이웃하는 이종 처리 시스템의 제2 DPE에 제2 커널을 할당하는 단계를 포함한다.

일부 실시예에서, 제1 DPE 및 제2 DPE는 둘 다 공유 메모리 모듈에 대한 직접 연결을 갖고, 방법은 제1 커널과 제2 커널 사이에서 데이터를 전송하기 위해 공유 메모리 모듈에 이중 버퍼를 할당하는 단계를 포함한다.

일부 실시예에서, 복수의 커널을 이종 처리 시스템에 할당하는 것은, 제1 커널 및 제2 커널이 그래프 소스 코드에 의해 규정된 바와 같은 복수의 통신 링크 중 제1 링크에 의해 통신 가능하게 결합된다는 것을 식별하는 것, 제1 커널을 이종 처리 시스템의 제1 DPE에 할당하는 것, 이종 처리 시스템의 프로그램 가능한 로직에 제2 커널을 할당하는 것, 제1 커널에 데이터를 전송하기 위해 인터커넥트를 사용하여 직접 메모리 액세스(DMA)를 수행하도록 제2 커널을 구성하는 것을 포함하고, 여기서 인터커넥트는 제1 DPE를 포함하는 DPE의 어레이를 서로 상호 연결하고, 프로그래밍 가능한 로직에 상호 연결한다.

일부 실시예에서, 복수의 커널을 이종 처리 시스템에 할당하는 것은, 제1 커널 및 제2 커널이 그래프 소스 코드에 의해 규정된 바와 같이 복수의 통신 링크 중 제1 링크에 의해 통신 가능하게 결합된다는 것을 식별하는 것, 제1 및 제2 커널이 제1 코어에 대한 사이클 버짓(budget)보다 작거나 동일한 결합된 사이클 카운트를 갖는다고 결정하는 것에 응답하여 이종 처리 시스템의 DPF의 어레이의 제1 코어에 제1 및 제2 커널을 클러스터링하는 것, 및 제1 커널과 제2 커널 사이에 데이터를 송신하기 위한 메모리 모듈에 버퍼를 할당하는 것을 포함하며, 상기 메모리 모듈은 제1 코어에 대한 직접 연결을 갖는다.

일부 실시예에서, 통신 유형을 복수의 통신 링크에 할당하는 것은, 그래프 소스 코드의 복수의 통신 링크의 규정에 기초하여 복수의 통신 링크의 각각에 대한 데이터를 송신하기 위해 스트리밍 및 윈도우잉 중 하나를 사용할지 여부를 선택하는 것을 포함한다.

일부 실시예에서, 윈도우잉은 수신된 데이터를 미리 규정되거나 파라미터화된 블록 크기를 갖는 개별 윈도우로 분할하는 것을 포함하고, 개별 윈도우를 수신하도록 구성된 복수의 커널의 각각은, 수신된 윈도우를 처리하기 전에 모든 호출에서 윈도우를 수신할 때까지 대기한다. 또한, 윈도우잉을 수행하는 통신 링크 중 적어도 하나에 대해, 개별 윈도우는 개별 윈도우를 수신하는 복수의 커널 중 수신 커널이 자신의 상태를 유지하도록, 이전에 송신된 윈도우의 끝과 중첩되는 데이터를 개별 윈도우의 시작 부분에 갖는다.

일부 실시예에서, 동기화 기술을 선택하는 것은, 복수의 통신 링크 중 제1 링크에 할당된 이중 버퍼를 식별하는 것, 복수의 통신 링크 중 제1 링크에 대응하는 제1 커널 및 제2 커널이 병렬로 이중 버퍼에 액세스할 수 있도록 잠금(locking) 프로토콜을 구성하는 것을 포함한다.

일부 실시예에서, 방법은 데이터 흐름 그래프를 실행하도록 이종 처리 시스템을 구성하는 그래프 소스 코드를 컴파일하는 것과 제어 프로그램을 사용하여 이종 처리 시스템에서 데이터 흐름 그래프의 실행을 제어하는 것에 기초하여 비트스트림 및 2진 코드를 송신하는 단계를 포함한다.

일부 실시예에서, 이종 처리 시스템은 제1 칩 및 제2 칩을 포함하고, 여기서 복수의 커널은 제1 칩에 할당되고, 그래프 소스 코드는 제2의 복수의 커널을 규정하고, 그래프 소스 코드를 컴파일하는 것은, 제2 칩에 제2 복수의 커널을 할당하는 것을 포함하고, 제2 칩에 할당된 제2 복수의 커널은, 제1 칩에 할당된 복수의 커널과 통신하도록 구성된다.

일부 실시예에서, 그래프 소스 코드는 이종 처리 시스템을 형성하는 SoC의 하드웨어 설계와 독립적이고, 컴파일러에 의해 각각이 상이한 하드웨어 설계를 갖는 복수의 상이한 유형의 SoC 상에 구현될 수 있다.

일부 실시예에서, 이종 처리 시스템은 프로그램 가능한 로직 및 DPE의 어레이를 포함하고, 여기서 복수의 커널 중 적어도 하나는, 프로그램 가능한 로직에 할당되고, 복수의 커널 중 적어도 하나는 DPE 중 하나에 할당된다.

일부 실시예에서, 방법은 하위-그래프를 데이터 흐름 그래프로 캡슐화하는 단계 - 상기 하위 그래프가 그래프 소스 코드와 별개의 그래프 클래스에 의해 규정됨 - 및 데이터 흐름 그래프 및 서브 그래프에 제약 조건을 추가하는 제약된 그래프를 생성하는 단계 - 제약된 그래프는 데이터 흐름 그래프의 래퍼(wrapper)로서 기능함 - 를 포함한다.

일부 실시예들에서, 복수의 커널들의 각각은 복수의 커널들의 각각이 데이터 흐름 그래프에서 또 다른 커널과 통신할 수 있게 하는 적어도 하나의 포트를 포함하고, 데이터 흐름 그래프에서, 복수의 통신 링크들의 각각의 링크는, 제1 커널의 제1 포트를 제2 커널의 제2 포트에 결합한다.

본 명세서에 설명된 한 예는, 프로세서, 복수의 커널을 규정하는 그래프 소스 코드 및 복수의 통신 링크를 포함하는 호스트 - 상기 복수의 통신 링크의 각각이 데이터 흐름 그래프를 형성하기 위해 복수의 커널의 각각의 쌍을 결함함 - 그리고, 이종 처리 시스템에서 데이터 흐름 그래프를 구현하기 위해 그래프 소스 코드를 컴파일하도록 구성된 컴파일러이다. 그래프 소스 코드를 컴파일하는 것은, 복수의 커널을 이종 처리 시스템의 프로그램 가능한 로직 및 DPE 어레이에 할당하는 것, 통신 유형을 복수의 통신 링크에 할당하는 것, 복수의 통신 링크를 사용하여 복수의 커널 간에 데이터를 전송하기 위한 동기화 기술을 선택하는 것을 포함한다.

위에서 인용된 특징들이 상세하게 이해될 수 있는 방식으로, 위에서 간략하게 요약된 보다 구체적인 설명은, 예시적인 구현들을 참조하여 행해질 수 있으며, 그 중 일부는 첨부된 도면에 예시되어 있다. 그러나, 첨부된 도면은 단지 일반적인 예시적 구현을 예시하고, 그 범위를 제한하는 것으로 간주되어서는 안 된다는 점에 유의해야 한다.
도 1은 일 예에 따른, 데이터 처리 엔진 어레이를 포함하는 SoC의 블록도이다.
도 2는 일 예에 따른, 데이터 처리 엔진 어레이의 데이터 처리 엔진의 블록도이다.
도 3a 및 도 3b는 일 예에 따른, DPE 어레이에서 복수의 DPE에 의해 공유되는 메모리 모듈을 도시한다.
도 4는 일 예에 따른, 도 1에 도시된 SoC에서 데이터 흐름 그래프를 구현하기 위한 컴퓨팅 시스템의 블록도이다.
도 5는 일 예에 따른, 프로그램 가능한 로직 및 프로그램 가능하지 않은 로직을 갖는 SoC 상의 데이터 흐름 그래프를 구현하기 위해 소스 코드를 컴파일하기 위한 흐름도이다.
도 6은 일 예에 따른, 데이터 흐름 그래프를 규정하기 위한 그래프 소스 코드이다.
도 7은 일 예에 따른, 도 6의 소스 코드에 의해 규정된 데이터 흐름 그래프를 도시한다.
도 8은 일 예에 따른, 데이터 흐름 그래프에서 커널을 규정하기 위한 커널 소스 코드이다.
도 9는 일 예에 따른, 도 7의 데이터 흐름 그래프를 구현하는 추상도이다.
도 10은 일 예에 따른, 도 7의 데이터 흐름 그래프를 구현하는 하드웨어 도면이다.
도 11은 일 예에 따른, 커널 간에 데이터를 송신할 때 사용되는 중첩 윈도우를 도시한다.
도 12는 일 예에 따른, 데이터 흐름 그래프에 대한 제어 프로그램을 규정하는 제어 소스 코드이다.
도 13은 일 예에 따른, 제약 조건을 사용하여 데이터 흐름 그래프를 구현하기 위해 소스 코드를 컴파일하기 위한 흐름도이다.
도 14는 일 예에 따른, 사용자 규정된 제약 조건을 사용하여 구현된 그래프 객체를 갖는 DPE 어레이이다.
도 15는 일 예에 따른, 이어 받기 가능한 추상 인터페이스(1505)이다.
도 16은 일 예에 따른, 복수의 서브 그래프를 갖는 데이터 흐름 그래프이다.
도 17은 일 예에 따른, 제약된 데이터 흐름 그래프이다.
도 18은 일 예에 따른, 복수의 소스로부터의 제약 조건을 병합하기 위한 제약 조건 처리 흐름이다.
도 19는 일 예에 따른, SoC 상에서 데이터 흐름 그래프를 구현하기 위한 컴퓨팅 시스템의 블록도이다.
도 20a 및 20b는 일 예에 따른, SoC 상에서 데이터 흐름 그래프의 실행을 제어하기 위한 제어 애플리케이션 프로그램 인터페이스들을 도시한다.
도 21은 일 예에 따른, 데이터 처리 엔진 어레이를 상이한 영역으로 논리적으로 분할하는 것을 도시한다.
도 22a 및 22b는 일 예에 따른, 데이터 흐름 그래프의 실행을 동적으로 변경하는 것을 도시한다.
도 23a 및 23b는 일 예에 따른, 트리거된 및 비동기 파라미터를 도시한다.
이해를 용이하게 하기 위해, 가능한 경우, 동일한 참조 번호를 사용하여, 도면에 공통적인 동일한 요소를 지정한다. 일 예의 요소가 다른 예에 유리하게 통합될 수 있음이 고려된다.

이하, 도면을 참조하여 다양한 특징을 설명한다. 도면은 축척에 맞게 그려질 수도 있고 그렇지 않을 수도 있으며 유사한 구조 또는 기능의 요소는 도면 전반에 걸쳐 유사한 참조 번호로 표시된다는 점에 유의해야 한다. 도면은 단지 특징의 설명을 용이하게 하기 위한 것임을 유의해야 한다. 이들은 완전한 설명이나 청구범위의 제한으로 의도되지 않는다. 또한, 예시된 예는 도시된 모든 양태 또는 이점을 가질 필요가 없다. 특정 예와 관련하여 설명된 양태 또는 이점은, 반드시 그 예에 제한되지 않으며, 그렇게 예시되지 않거나 그렇게 명시적으로 설명되지 않더라도 임의의 다른 예에서 실시될 수 있다.

본 명세서의 예는 커널 및 이러한 커널 간의 통신 링크를 규정하기 위한 소스 코드를 사용하여 데이터 흐름 그래프를 생성하기 위한 기술을 설명한다. 일 실시예에서, 그래프는 에지(예를 들어, 커널 사이의 통신 링크)에 의해 통신 가능하게 결합된 노드(예를 들어, 커널)를 사용하여 형성된다. 컴파일러는 그래프를 실행하기 위해 SoC의 이종 처리 시스템에서 소스 코드를 프로그램 가능한 로직 및 소프트웨어 구성 가능한 강화 로직을 구성하는 비트스트림 및 2진 코드로 변환한다. 프로그래머가 이종 처리 시스템에서 프로그램 가능하고 소프트웨어 구성 가능한 강화 하드웨어를 자세히 이해하도록 요구하기 보다, 컴파일러는 소스 코드로 표현된 그래프를 사용하여 프로그래밍 가능한 로직 블록에 할당할 커널과 강화된 로직 블록에 할당할 커널을 결정할 수 있다. 또한, 컴파일러는 그래프 소스 코드에 제공된 파라미터를 사용하여, 커널(예를 들어, 공유 메모리, 윈도우잉, DMA(직접 메모리 액세스) 등) 간의 통신 링크를 설정하도록 특정 통신 기술을 선택할 수 있다. 또한, 컴파일러는 통신 링크에서 동기화를 사용해야 하는지 여부를 자동으로 결정하고, 프로그래머로부터의 입력 없이 즉, 프로그래머가 그래프 소스 코드 내에서 동기화의 세부사항을 제공하지 않아도 그 동기화를 설정할 수 있다. 따라서, 프로그래머는 SoC에서 프로그래밍 가능하고 강화된 하드웨어를 사용하여 데이터 흐름 그래프가 구현되는 방식을 이해하지 않고도 하이 레벨(소스 코드를 사용함)에서 데이터 흐름 그래프를 표현할 수 있다. 결과적으로, 그래프 소스 코드는 특정 SoC의 하드웨어 설계와는 독립적이며, 각각이 상이한 하드웨어 설계를 가진 복수의 상이한 유형의 SoC에서 (컴파일러를 사용하여) 구현될 수 있다.

도 1은 일 예에 따른, 데이터 처리 엔진(data processing engine; DPE) 어레이(105)를 포함하는 SoC(100)의 블록도이다. DPE 어레이(105)는 SoC(100)에서 그리드, 클러스터, 또는 체커보드 패턴으로 배열될 수 있는 복수의 DPE(110)를 포함한다. 도 1은 행 및 열을 갖는 2D 어레이로 DPE(110)를 배열하는 것을 예시하지만, 실시예는 이러한 배열로 제한되지 않는다. 또한, 어레이(105)는 임의의 크기일 수 있고 DPE(110)에 의해 형성된 임의의 수의 행 및 열을 가질 수 있다.

일 실시예에서, DPE(110)는 동일하다. 즉, 각각의 DPE(110)(타일 또는 블록으로도 지칭됨)는 동일한 하드웨어 구성요소 또는 회로를 가질 수 있다. 또한, 본 명세서의 실시예는 DPE(110)로 제한되지 않는다. 대신, SoC(100)는 임의의 종류의 처리 요소의 어레이를 포함할 수 있으며, 예를 들어 DPE(110)는 디지털 신호 처리 엔진, 암호 엔진, FEC(Forward Error Correction), 또는 하나 이상의 특수 작업을 수행하기 위한 기타 특수 하드웨어일 수 있다.

도 1에서, 어레이(105)는 모두 동일한 유형(예를 들어, 동종 어레이)인 DPE(110)를 포함한다. 그러나, 다른 실시예에서, 어레이(105)는 상이한 유형의 엔진을 포함할 수 있다. 예를 들어, 어레이(105)는 디지털 신호 처리 엔진, 암호 엔진, 그래픽 처리 엔진 등을 포함할 수 있다. 어레이(105)가 동종 또는 이종인지에 관계없이, DPE(110)는, 아래에서 더 상세히 설명되는 바와 같이 DPE(110)가 데이터를 직접 전송할 수 있게 하는 DPE(110) 사이의 직접 연결을 포함할 수 있다.

일 실시예에서, DPE(110)는 소프트웨어 구성 가능한 강화 로직으로부터 형성 즉, 강화된다. 그렇게 하는 것의 한 가지 이점은, DPE(110)가 DPE(110)에서 하드웨어 요소를 형성하기 위해 프로그래밍 가능한 로직을 사용하는 것에 비해 SoC(100)에서 더 적은 공간을 차지할 수 있다는 것이다. 즉, 프로그램 메모리, 명령어 페치/디코드 유닛, 고정 소수점 벡터 유닛, 부동 소수점 벡터 유닛, 산술 논리 유닛(ALU), 곱셈 누산기(MAC) 등과 같은 DPE(110)의 하드웨어 요소를 형성하기 위해 강화된 논리 회로를 사용하는 것은, SoC(100)에서 어레이(105)의 풋프린트를 상당히 감소시킬 수 있다. DPE(110)가 강화될 수 있지만, 이것이 DPE(110)가 프로그래밍 가능하지 않다는 것을 의미하지는 않는다. 즉, DPE(110)는 SoC(100)가 파워 온되거나 재부팅될 때 다른 기능이나 작업을 수행하도록 구성될 수 있다.

DPE 어레이(105)는 또한 DPE(110)와 SoC(100)의 다른 하드웨어 구성요소 사이의 통신 인터페이스의 역할을 하는 SoC 인터페이스 블록(115)[심(shim)으로도 지칭됨]을 포함한다. 이 예에서, SoC(100)는 SoC 인터페이스 블록(115)에 통신 가능하게 결합된 NoC(Network on Chip)(120)를 포함한다. 도시되지는 않았지만, NoC(120)는 SoC(100) 내의 다양한 구성요소들이 서로 통신할 수 있도록 SoC(100) 전반에 걸쳐 확장될 수 있다. 예를 들어, 하나의 물리적 구현에서, DPE 어레이(105)는 SoC(100)를 형성하는 집적 회로의 상부 우측 부분에 배치될 수 있다. 그러나, NoC(120)를 사용하여, 어레이(105)는 그럼에도 불구하고 예를 들어 SoC(100) 전반에 걸쳐 상이한 위치에 배치될 수 있는 프로그램 가능한 로직(PL)(125), 프로세서 서브시스템(PS)(130) 또는 입/출력(I/O)(135)과 통신할 수 있다.

DPE(110)와 NoC(120) 사이에 인터페이스를 제공하는 것 외에, SoC 인터페이스 블록(115)은 또한 PL(125)의 통신 패브릭에 대한 직접 연결을 제공할 수 있다. 이 예에서, 데이터 흐름 그래프의 커널의 일부는 실행을 위해 DPE(110)에 할당되고 다른 커널은 PL(125)에 할당될 수 있기 때문에, PL(125) 및 DPE(110)는 이종 처리 시스템을 형성한다. 도 1은 SoC의 이종 처리 시스템을 도시하지만, 다른 예에서, 이종 처리 시스템은 복수의 디바이스 또는 칩을 포함할 수 있다. 예를 들어, 이종 처리 시스템은 2 개의 FPGA 또는 동일한 유형이거나 상이한 유형인 기타 특수 가속기 칩을 포함할 수 있다. 또한, 이종 처리 시스템은 2 개의 통신 가능하게 결합된 SoC를 포함할 수 있다.

이는 이종 또는 다른 처리 코어에 배치된 커널들 간의 통신이 NoC(120), SoC 인터페이스 블록(115)뿐만 아니라 어레이(105) 내의 DPE(110) 사이의 통신 링크(이는 도 2에 도시됨)와 같은 도 1에 도시된 다양한 통신 인터페이스를 사용하는 것을 포함할 수 있기 때문에, 프로그래머가 관리하기 어려울 수 있다.

일 실시예에서, SoC 인터페이스 블록(115)은, DPE(110)를 SoC(100)의 어레이(105) 근처에 배치된 NoC(120) 및 PL(125)에 통신 가능하게 결합하기 위한 개별 하드웨어 구성요소를 포함한다. 일 실시예에서, SoC 인터페이스 블록(115)은 PL(125)을 위한 패브릭으로 직접 데이터를 스트리밍할 수 있다. 예를 들어, PL(125)은 SoC 인터페이스 블록(115)이 NoC(120)를 사용하지 않고, 데이터를 스트리밍하고 데이터를 수신할 수 있는 FPGA 패브릭을 포함할 수 있다. 즉, 본 명세서에서 설명된 회로 스위칭 및 패킷 스위칭은, DPE(110)를 SoC 인터페이스 블록(115)에 그리고 또한 SoC(100)의 다른 하드웨어 블록에 통신 가능하게 결합하는 데 사용될 수 있다. 다른 예에서, SoC 인터페이스 블록(115)은 DPE(110)와 다른 다이에서 구현될 수 있다. 또 다른 예에서, DPE 어레이(105) 및 적어도 하나의 서브시스템은 동일한 다이에서 구현될 수 있는 반면, 다른 서브시스템 및/또는 다른 DPE 어레이는 다른 다이에서 구현될 수 있다. 또한, DPE 어레이(105)의 DPE(110)와 관련하여 본 명세서에서 설명된 스트리밍 인터커넥트 및 라우팅은 또한 SoC 인터페이스 블록(115)을 통해 라우팅되는 데이터에 적용할 수 있다.

도 1은 PL(125)의 하나의 블록을 예시하지만, SoC(100)는 SoC(100)의 상이한 위치에 배치될 수 있는 PL(125)의 복수의 블록(구성 논리 블록으로도 지칭됨)을 포함할 수 있다. 예를 들어, SoC(100)는 FPGA(field programmable gate array)를 형성하는 하드웨어 요소들을 포함할 수 있다. 그러나, 다른 실시예에서, SoC(100)는 임의의 PL(125)을 포함하지 않을 수 있으며 - 예를 들어, SoC(100)는 ASIC이다.

도 2는 일 예에 따른, 도 1에 도시된 DPE 어레이(105) 내의 DPE(110)의 블록도이다. DPE(110)는 인터커넥트(205), 코어(210), 및 메모리 모듈(230)을 포함한다. 인터커넥트(205)는 데이터가 코어(210) 및 메모리 모듈(230)로부터 어레이(105)의 상이한 코어로 전송되는 것을 허용한다. 즉, DPE(110) 각각의 인터커넥트(205)는, DPE(110)의 어레이 내에서 동서(예를 들어, 우측 및 좌측)뿐만 아니라 북쪽과 남쪽(예를 들어, 상하)으로 데이터가 전송될 수 있도록 서로 연결될 수 있다.

도 1을 다시 참조하면, 일 실시예에서, 어레이(105)의 상위(upper) 행에 있는 DPE(110)는, 하위(lower) 행에 있는 DPE(110)의 인터커넥트(205)에 의존하여 SoC 인터페이스 블록(115)과 통신한다. 예를 들어, 데이터를 SoC 인터페이스 블록(115)에 송신하기 위해, 상위 행의 DPE(110)의 코어(210)는, 데이터를 하위 행의 DPE(110)의 인터커넥트(205)에 차례로 통신 가능하게 결합된 인터커넥트(205)로 송신한다. 하위 행의 인터커넥트(205)는 SoC 인터페이스 블록(115)에 연결된다. 상위 행의 DPE(110)용으로 의도된 데이터가, 먼저 SoC 인터페이스 블록(115)으로부터 하위 행의 인터커넥트(205)로 송신된 후, 타겟 DPE(110)인 상위 행의 인터커넥트(205)로 송신되는 경우 프로세스가 반전될 수 있다. 이러한 방식으로, 상위 행의 DPE(110)는 하위 행의 DPE(110)의 인터커넥트(205)에 의존하여, SoC 인터페이스 블록(115)에 데이터를 송신하고 그로부터 데이터를 수신할 수 있다.

일 실시예에서, 인터커넥트(205)는 데이터가 인터커넥트(205)를 통해 라우팅되는 방법을 사용자가 결정할 수 있게 하는 구성 가능한 스위칭 네트워크를 포함한다. 일 실시예에서, 패킷 라우팅 네트워크와 달리, 인터커넥트(205)는 스트리밍 포인트-투-포인트 연결을 형성할 수 있다. 즉, 인터커넥트(205)의 스트리밍 연결 및 스트리밍 인터커넥트(도 2에 미도시)는, 코어(210) 및 메모리 모듈(230)로부터 이웃하는 DPE(110) 또는 SoC 인터페이스 블록(115)으로의 경로를 형성할 수 있다. 일단 구성되면, 코어(210) 및 메모리 모듈(230)은 이러한 경로를 따라 스트리밍 데이터를 송신 및 수신할 수 있다. 일 실시예에서, 인터커넥트(205)는 AXI(Advanced Extensible Interface) 4 스트리밍 프로토콜을 사용하여 구성된다.

스트리밍 네트워크를 형성하는 것에 더하여, 인터커넥트(205)는 DPE(110)에서 하드웨어 요소를 프로그래밍하거나 구성하기 위한 별도의 네트워크를 포함할 수 있다. 도시되지는 않았지만, 인터커넥트(205)는 스트리밍 네트워크, 코어(210), 및 메모리 모듈(230)의 기능을 변경하거나 설정하는 DPE(110) 내의 구성 레지스터의 값을 설정하는 데 사용되는 다른 연결 및 스위치 요소를 포함하는 메모리 매핑된 인터커넥트를 포함할 수 있다.

일 실시예에서, 인터커넥트(205)의 스트리밍 인터커넥트(또는 네트워크)는, 본 명세서에서 회로 스위칭 및 패킷 스위칭으로 지칭되는 2개의 상이한 동작 모드를 지원한다. 일 실시예에서, 이들 모드 모두는, 동일한 스트리밍 프로토콜의 일부이거나, 동일한 스트리밍 프로토콜 예를 들어 AXI 스트리밍 프로토콜과 호환된다. 회로 스위칭은 소스 DPE(110)에서 하나 이상의 목적지 DPE(110) 사이의 예약된 포인트-투-포인트 통신 경로에 의존한다. 일 실시예에서, 인터커넥트(205)에서 회로 스위칭을 수행할 때 사용되는 포인트-투-포인트 통신 경로는, (그 스트림들이 회로 스위칭이든 패킷 스위칭이든 상관없이) 다른 스트림들과 공유되지 않는다. 그러나, 패킷 스위칭을 이용하여 2 이상의 DPE(110) 사이에서 스트리밍 데이터를 송신할 때, 동일한 물리적 와이어가 다른 논리적 스트림과 공유될 수 있다.

코어(210)는 디지털 신호를 처리하기 위한 하드웨어 요소를 포함할 수 있다. 예를 들어, 코어(210)는 무선 통신, 레이더, 벡터 연산, 기계 학습 애플리케이션 등과 관련된 신호를 처리하는 데 사용될 수 있다. 이와 같이, 코어(210)는 프로그램 메모리, 명령어 페치/디코드 유닛, 고정 소수점 벡터 유닛, 부동 소수점 벡터 유닛, 산술 논리 유닛(ALU), 곱셈 누산기(MAC) 등을 포함할 수 있다. 그러나, 위에서 언급한 바와 같이, 본 개시 내용는 DPE(110)에 제한되지 않는다. 코어(210)의 하드웨어 요소는 엔진 타입에 따라 변경될 수 있다. 즉, 디지털 신호 처리 엔진, 암호화 엔진, 또는 FEC에서의 코어가 상이할 수 있다.

메모리 모듈(230)은 직접 메모리 액세스(DMA) 엔진(215), 메모리 뱅크(220), 및 하드웨어 동기화 회로(HSC)(225) 또는 다른 유형의 하드웨어 동기화 블록을 포함한다. 일 실시예에서, DMA 엔진(215)은 데이터가 인터커넥트(205)에 의해 수신 그리고 인터커넥트(205)로 송신될 수 있게 한다. 즉, DMA 엔진(215)은 DMA 판독을 수행하고 어레이의 다른 DPE(110) 또는 SoC 인터페이스 블록으로부터 인터커넥트(205)를 통해 수신된 데이터를 사용하여 메모리 뱅크(220)에 기록하는 데 사용될 수 있다.

메모리 뱅크(220)는 임의의 수의 물리적 메모리 요소(예를 들어, SRAM)를 포함할 수 있다. 예를 들어, 메모리 모듈(230)은 4, 8, 16, 32개 등의 상이한 메모리 뱅크(220)를 포함할 수 있다. 이 실시예에서, 코어(210)는 메모리 뱅크(220)에 대한 직접 연결(235)을 갖는다. 달리 말하면, 코어(210)는 인터커넥트(205)를 사용하지 않고 메모리 뱅크(220)에 데이터를 기록하거나 메모리 뱅크(220)로부터 데이터를 판독할 수 있다. 즉, 직접 연결(235)은 인터커넥트(205)로부터 분리될 수 있다. 일 실시예에서, 직접 연결(235)의 하나 이상의 와이어는, 차례로 메모리 뱅크(220)에 결합되는 메모리 모듈(230)의 메모리 인터페이스에 코어(210)를 통신 가능하게 결합한다.

일 실시예에서, 메모리 모듈(230)은 또한 이웃하는 DPE(110)의 코어에 대한 직접 연결(240)을 갖는다. 달리 말하면, 어레이의 이웃 DPE는, 도 2에 도시된 인터커넥트(205) 또는 이들의 인터커넥트에 의존하지 않고 직접 이웃 연결(240)을 사용하여 메모리 뱅크(220)로부터 데이터를 판독하거나 메모리 뱅크(220)에 데이터를 기록할 수 있다. HSC(225)는 메모리 뱅크(220)에 대한 액세스를 통제하거나 보호하는 데 사용될 수 있다. 일 실시예에서, 코어(210) 또는 이웃 DPE의 코어가, 메모리 뱅크(220)로부터 데이터를 판독하거나 메모리 뱅크(220)에 데이터를 기록할 수 있기 전에, HSC(225)는 메모리 뱅크(220)(“버퍼”로서 지칭됨)의 할당된 부분에 잠금(lock)을 제공한다. 즉, 코어(210)가 데이터를 기록하기를 원할 때, HSC(225)는 코어(210)에 메모리 뱅크(220)(또는 복수의 메모리 뱅크(220))의 일부를 할당하는 코어(210)에 잠금을 제공한다. 기록 완료되면, HSC(225)는 이웃 DPE의 코어가 데이터를 판독할 수 있게 하는 잠금을 해제할 수 있다.

코어(210) 및 이웃 DPE(110)의 코어는 메모리 모듈(230)에 직접 액세스할 수 있으므로, 메모리 뱅크(220)는 DPE(110) 간의 공유 메모리로 간주될 수 있다. 즉, 이웃 DPE는 메모리 뱅크(220)와 동일한 DPE(110)에 있는 코어(210)와 유사한 방식으로 메모리 뱅크(220)에 직접 액세스할 수 있다. 따라서, 코어(210)가 이웃 DPE의 코어로 데이터를 송신하기를 원하는 경우, 코어(210)는 데이터를 메모리 뱅크(220)에 기록할 수 있다. 이웃 DPE는 메모리 뱅크(220)로부터 데이터를 검색하고, 데이터 처리를 시작할 수 있다. 이러한 방식으로, 이웃 DPE(110)의 코어는 HSC(225)를 사용하여 데이터를 전송할 수 있는 반면에, 인터커넥트(205)를 사용할 때 도입되는 추가 지연을 방지할 수 있다. 대조적으로, 코어(210)가 어레이의 이웃하지 않은 DPE(즉, 메모리 모듈(230)에 대한 직접 연결(240)가 없는 DPE)로 데이터를 전송하기를 원하는 경우, 코어(210)는 인터커넥트(205)을 사용하여 데이터를 타겟 DPE의 메모리 모듈로 라우팅하며, 상기 메모리 모듈은, 인터커넥트(205)를 사용하는 대기 시간이 추가되기 때문에 그리고 데이터가 공유 메모리 모듈로부터 판독되기 보다는 타겟 DPE의 메모리 모듈로 복사되기 때문에, 완료하는 데 더 오래 걸릴 수 있다.

메모리 모듈(230)을 공유하는 것에 더하여, 코어(210)는 코어-투-코어 통신 링크(미도시)를 사용하여 이웃 DPE(110)의 코어(210)에 직접 연결을 가질 수 있다. 즉, 공유 메모리 모듈(230) 또는 인터커넥트(205)를 사용하는 대신에, 코어(210)는 메모리 모듈(230)에 데이터를 저장하지 않고 또는 인터커넥트(205)(이는 버퍼 또는 다른 대기열을 가질 수 있음)를 사용하여 어레이 내의 또 다른 코어에 데이터를 직접 송신할 수 있다. 예를 들어, 코어-투-코어 통신 링크를 사용하여 통신하는 것은, 보다 비용 효율적인 통신을 제공할 수 있는 인터커넥트(205) 또는 공유 메모리(이는 데이터를 기록하기 위해 코어를 필요로 하고, 데이터를 판독하기 위해 또 다른 코어를 필요로 함)를 사용하여 데이터를 송신하는 것보다 더 적은 대기 시간을 사용할 수 있다(또는 높은 대역폭을 가질 수 있다). 일 실시예에서, 코어-투-코어 통신 링크는 하나의 클록 사이클에서 2개의 코어(210) 사이에서 데이터를 송신할 수 있다. 일 실시예에서, 데이터는 코어(210) 외부의 임의의 메모리 요소에 저장되지 않고 링크 상의 코어들 사이에서 송신된다. 일 실시예에서, 코어(210)는 매 클록 사이클마다 링크를 사용하여 이웃 코어에 데이터 워드 또는 벡터를 송신할 수 있지만, 이것은 요구사항이 아니다.

일 실시예에서, 통신 링크는 코어(210)가 이웃 코어로 데이터를 스트리밍하도록 허용하는 스트리밍 데이터 링크이다. 또한, 코어(210)는 어레이의 상이한 코어로 확장될 수 있는 임의의 수의 통신 링크를 포함할 수 있다. 이 예에서, DPE(110)는 코어(210)의 좌우(동쪽 및 서쪽) 및 상하(북쪽 또는 남쪽)에 있는 어레이의 DPE에 위치한 코어에 대한 각각의 코어-투-코어 통신 링크를 갖는다. 그러나, 다른 실시예에서, 도 2에 예시된 DPE(110)의 코어(210)는 또한 코어(210)로부터 대각선으로 배치된 코어들에 대한 코어-투-코어 통신 링크를 가질 수 있다. 또한, 코어(210)가 어레이의 바닥 주변 또는 가장자리에 배치되는 경우, 코어는 코어(210)의 왼쪽, 오른쪽, 및 바닥에 있는 코어에만 코어-투-코어 통신 링크를 가질 수 있다.

그러나, 코어(210)에 의해 생성된 데이터의 목적지가 이웃 코어 또는 DPE인 경우에 메모리 모듈(230) 또는 코어-투-코어 통신 링크에서 공유 메모리를 사용하는 것이 가능할 수 있다. 예를 들어, 데이터가 이웃하지 않은 DPE(즉, DPE(110)가 직접 이웃 연결(240) 또는 코어-투-코어 통신 링크를 갖지 않는 임의의 DPE)로 향하는 경우, 코어(210)는 DPE는 데이터를 적절한 목적지로 라우팅하도록 DPE 내의 인터커넥트(205)를 사용한다. 위에서 언급한 바와 같이, DPE(110)의 인터커넥트(205)는, SoC가 부팅될 때, 코어(210)가 동작 동안 데이터를 송신할 이웃하지 않은 DPE에 대한 포인트-투-포인트 스트리밍 연결을 설정하도록 구성될 수 있다.

도 3a-3b는 일 예에 따른, DPE 어레이에서의 복수의 DPE(110)에 의해 공유되는 메모리 모듈(230A)을 예시한다. 도시된 바와 같이, 메모리 모듈(230A)은 4개의 코어, 즉 코어(210A-D)에 대한 직접 연결을 갖는다. 메모리 모듈(230A)은 코어(210A)와 동일한 DPE(즉, DPE(110A))에 있다. 이와 같이, 직접 연결(235)은 엔진내 연결이다. 그러나, 메모리 모듈(230A)은 코어(210B-D)와 다른 DPE에 있다. 이와 같이, 직접 이웃 연결(240A-C)은 이러한 연결(240)이 어레이의 DPE(110)들 사이의 인터페이스에 걸쳐 있기 때문에 엔진간 연결이다. 명료함을 위해, DPE(110) 각각의 인터커넥트는 생략되어 있다.

도 3a에서, DPE(110A)의 메모리 모듈(230A)은 코어(210A)의 우측에 배치된다. DPE(110A)의 오른쪽(즉, DPE(110A)의 동쪽)에 위치한 DPE(110D)에서도 마찬가지이다. 이와 같이, DPE(110D)의 코어(210D)는, 메모리 모듈(230D)이 코어(210D)의 왼쪽에 배치된 경우 즉, 메모리 모듈(230D)이 메모리 모듈(230A)과 코어(210D) 사이에 배치된 경우보다 메모리 모듈(230A)과 코어(210D) 사이에 직접 이웃 연결(240B)을 설정하는 것을 더 쉽게 만드는 메모리 모듈(230A)에 직접 인접한다.

DPE(110A 및 110D)와 달리, DPE(110B 및 110C)에서는, 메모리 모듈(230B 및 230C)의 우측에 코어(210B, 210C)가 배치된다. 그 결과, 코어(210B 및 210C)는 메모리 모듈(230A) 바로 위 그리고 바로 아래에 배치된다(즉, 코어(210B 및 210C)는 메모리 모듈(230A)의 북쪽과 남쪽에 있음). 그렇게 하면 코어(210B, 210C)가 메모리 모듈(230B, 230C)의 왼쪽에 배치되는 경우보다 공유 메모리 모듈(230A)과 코어(210B 및 210C) 사이에 직접 이웃 연결(240A 및 240C)을 설정하는 것이 더 쉬워진다. 도 3a에 도시된 배열을 사용하여, 메모리 모듈(230A)은 동일한 DPE 및 이웃 DPE에 위치하는 코어(210A-D)에 대한 직접 연결(235 및 240)을 가지며, 이는 메모리 모듈(230A)이 DPE(110A-D)를 위한 공유 메모리임을 의미한다. 도 3a는 4개의 코어(210) 사이에서 메모리 모듈(230A)을 공유하는 것을 예시하지만, 다른 실시예에서, 메모리 모듈(230A)은 더 많거나 더 적은 코어에 의해 공유될 수 있다. 예를 들어, 메모리 모듈(230A)은 또한 DPE(110A)에 대해 대각선으로 배열된 이웃 DPE에 대한 직접 연결을 가질 수 있다.

도 3a에 예시된 DPE(110)의 배열은, 이웃 코어(210)로부터 메모리 모듈(230A)로의 직접 연결을 제공하기 위한 DPE(110)의 적절한 배열의 일 예일 뿐이다. 도 3b에서, 상이한 행의 DPE(110)는 엇갈리게 배치되어 있다. 즉, 동일한 열의 DPE(110)가 정렬되는 대신에, DPE(110)가 오프셋된다. 이러한 배열에서, 코어(210B 및 210C)는 (도 3a에 도시된 것과는 달리) 메모리 모듈(230B 및 230C)의 왼쪽에 배치되고, 또한 DPE(110B 및 110C)를 DPE(110A)에 대해 오른쪽으로 이동시킴으로써, 공유 메모리 모듈(230A) 바로 위 및 아래에 있다. 이와 같이, 직접 연결(240A-C)은 메모리 모듈(230A)이 코어(210A-D)에 의해 공유될 수 있도록 SoC에 형성될 수 있다.

또한, 비록 도 3a 및 3b에 도시되지는 않았지만, 메모리 모듈(230B-D)은 또한 공유 메모리 모듈일 수 있다. 예를 들어, 메모리 모듈(230D)은 DPE(110D)의 위, 아래 및 오른쪽(즉, 북쪽, 남쪽 및 동쪽)에 배치된 DPE 내의 코어에 직접 연결될 수 있다. 이러한 방식으로, 메모리 모듈(230D)은 이웃 DPE의 코어와 공유될 수 있다. 그러나, 어레이의 가장자리 또는 주변부에 배치된 DPE의 메모리 모듈(230)은, 더 적은 수의 코어에 의해 공유될 수 있다(또는 전혀 공유되지 않을 수 있음).

도 4는 일 예에 따른, 도 1에 도시된 SoC(100) 상의 데이터 흐름 그래프(440)를 구현하기 위한 컴퓨팅 시스템(400)의 블록도이다. 시스템(400)은 프로세서(410) 및 메모리(415)를 포함하는 호스트(405)(예를 들어, 호스트 컴퓨팅 시스템)를 포함한다. 프로세서(410)는 각각이 임의의 수의 프로세싱 코어를 포함할 수 있는 임의의 수의 프로세싱 요소를 나타낸다. 메모리(415)는 휘발성 메모리 소자 및 비휘발성 메모리 소자를 포함할 수 있다. 또한, 메모리(415)는 동일한 장치(예를 들어, 서버) 내에 배치될 수 있거나, 컴퓨팅 시스템(400)(예를 들어, 클라우드 컴퓨팅 환경)에 걸쳐 분산될 수 있다.

메모리(415)는 그래프 소스 코드(420), 커널 소스 코드(425), 제어 소스 코드(430)를 생성하기 위한 이종 프로그래밍 환경(417)을 포함한다. 메모리(415)는 또한 컴파일러(435)를 포함한다. 그래프 소스 코드(420)는 다양한 유형의 객체 지향 프로그래밍 언어[예를 들어, C++, 파이톤(Python), 자바스크립트(Javascript), 스위프트(Swift), 고(Go), 랩뷰(LabView) 또는 시뮬링크(Simulink)]로 기록될 수 있다. 일반적으로, 그래프 소스 코드(420)는 통신 링크(예를 들어, 에지)를 통해 연결된 커널(예를 들어, 노드)을 규정한다. 커널과 통신 링크의 조합은 그래프(440)를 형성한다.

소스 코드(420)를 사용하여 데이터 흐름 그래프(440)를 규정하기 위한 이종 프로그래밍 환경(417)을 제공하는 것의 한 가지 이점은, 이종 처리 시스템에서 데이터 흐름 그래프를 컴파일하는 상이한 양태가 이종 프로그래밍 환경(417)에서 직접 표현되고 제어될 수 있다는 것이다. 프로그래머는 컴파일러(435)가 SoC(100)의 하드웨어에서 구현하는 병렬 해상도(parallel definition)(예를 들어, 그래프)로 시작할 수 있다. 그래프(440)는 데이터가 연속적인 파이프라인 방식으로 노드들(예를 들어, 커널들) 사이에서 흐를 수 있게 한다. 노드는 그 입력에서의 데이터를 사용할 수 있는 즉시 처리를 시작하고, 그렇지 않으면 중단된다. 더욱이, 그래프(440)는 프로그래머에게 계산 및 데이터 흐름을 SoC(100)의 DPE(110) 및 프로그램 가능한 로직(125)에 매핑하는 상당한 자유를 제공한다.

다양한 유형의 데이터 흐름 그래프가 사용될 수 있지만, 일 실시예에서, 그래프 소스 코드(420)에 의해 설정된 그래프(440)의 시맨틱스는, SoC 100의 이종 아키텍처(이는 프로그래밍 가능한 블록과 강화된 블록 모두 포함함)에 적용되는 결정론적 병렬 계산을 위한 계산 모델을 제공하는 칸(Kahn) 프로세스 네트워크스의 일반 이론에 기초한다. 더욱이, 그래프 소스 코드(420)는 그래프(440)의 노드들 간의 통신 지연에 대해 관대하며, 결과적으로, 복수의 슈퍼 로직 영역 및 복수의 SoC 디바이스(예를 들어, 복수의 FPGA)에 매핑되는 그래프로 자연스럽게 확장된다. 예를 들어, 그래프 소스 코드(420)는 컴파일러가 제1 칩(예를 들어, SoC, FPGA 등)에 할당하는 제1 복수의 커널 및 컴파일러가 제2 칩에 할당하는 제2 복수의 커널을 포함할 수 있다. 제1 및 제2 복수의 커널은 동일한 데이터 흐름 그래프의 일부일 수 있으며, 이에 따라 제1 및 제2 칩에서 실행될 때 서로 통신할 수 있다.

데이터 흐름 그래프를 규정하기 위해 소스 코드(420)를 사용하는 또 다른 이점은, 대조적으로, 순차 프로그램이 제어 흐름과 계산 순서를 고정한다는 것이다. 데이터 흐름 그래프를 사용할 때, 경쟁 조건 없이 입력에 대한 예측 가능하고 재현 가능한 응답을 얻을 수 있다. 교착 상태의 위험이 있지만, 각 노드 또는 커널에 할당된 저장소를 관리하여 이를 해결하거나 완화시킬 수 있다.

커널 소스 코드(425)는 다양한 유형의 객체 지향 프로그래밍 언어로 기록될 수 있다. 커널 소스 코드(425)는 데이터 흐름 그래프(440)에서 특정 커널 또는 노드의 속성을 규정한다. 일 실시예에서, 커널 소스 코드(425)는 그래프 소스 코드(420) 내의 각 커널의 동작을 규정한다.

제어 소스 코드(430)는 다양한 유형의 객체 지향 프로그래밍 언어로 작성될 수 있다. 일 실시예에서, 제어 소스 코드(430)는, 실행될 때, SoC(100) 상에서 구현될 때의 그래프(440)의 실행을 제어하는 제어 프로그램을 규정한다. 예를 들어, 제어 소스 코드(430)는 그래프(440)가 실행되는 시점, 그래프(440)가 실행하는 반복 횟수, 및 그래프(440)가 실행을 중지하는 시점을 제어할 수 있다. 제어 소스 코드(430)로부터 생성된 제어 프로그램은, 호스트(405) 상에서(예를 들어, 데이터 센터 솔루션에서) 또는 SoC(100) 내에서(예를 들어, PS(130)) 실행될 수 있다.

컴파일러(435)는 소스 코드(420, 425, 및 430)를 컴파일할 수 있는 소프트웨어 애플리케이션이다. 예를 들어, 그래프 소스 코드(420)(및 도 4에 도시되지 않은 다른 라이브러리)를 사용하여, 컴파일러(435)는 아래에서 더 상세히 설명될 SoC(100) 상에서 구현될 수 있는 그래프(440)를 생성할 수 있다. 일 실시예에서, 그래프(440)는 SoC(100)(예를 들어, PL(125), NoC(120), SoC 인터페이스 블록(115), 및 I/O(135))에서 프로그램 가능한 로직을 구성하는 비트스트림(445) 그리고 SoC(100) 내의 소프트웨어 구성 가능한 강화 로직(예를 들어, DPE(110) 및 PS(130))을 구성하는 2진 코드(447)[이는 많은 타겟 명령화된 커맨드를 포함할 수 있음]를 포함한다. 비트스트림(445) 및 2진 코드(447)는 그래프(440)를 실행하도록 SoC(100)를 구성하기 위해 메모리 버스를 통해 SoC(100)로 송신될 수 있다.

도 5는 일 예에 따른, 프로그램 가능한 로직 및 소프트웨어 구성 가능한 강화 로직를 갖는 SoC 상의 데이터 흐름 그래프를 구현하기 위해 소스 코드를 컴파일하기 위한 방법(500)의 흐름도이다. 블록 501에서, 호스트는 데이터 흐름 그래프를 객체 지향 소스 코드(예를 들어, C++, 파이톤(Python), 자바스크립트(Javascript), 스위프트(Swift), 고(Go), 랩(LabView) 또는 시뮬링크(Simulink))로서 규정하기 위한 이종 프로그래밍 환경을 제공한다. 즉, 프로그래머는, 이종 프로그래밍 환경(이는 도 6에서 더 상세히 설명됨)을 사용하여 데이터 흐름 그래프를 규정하는 소스 코드를 생성한다. 블록 505에서, 컴파일러는 커널 그리고 커널들 간의 통신 링크를 규정하는 데이터 흐름 그래프를 설정하는 소스 코드를 수신한다. 일 실시예에서, 컴파일러에 의해 수신된 소스 코드는 그래프 소스 코드를 포함한다.

명확성을 위해, 도 6-11은 방법(500)에 설명된 블록과 함께 논의된다.

도 6은 일 예에 따른, 데이터 흐름 그래프를 규정하기 위한 그래프 소스 코드(420)이다. 즉, 도 6은 프로그래머가 데이터 흐름 그래프를 설정하기 위한 복수의 커널 및 통신 링크를 규정할 수 있게 하는 이종 프로그래밍 환경에서 생성된 그래프 소스 코드(420)의 일 예이다. 소스 코드(420)는 소스 코드(420)에서 데이터 흐름 그래프를 규정하는 데 사용할 수 있는 하나 이상의 라이브러리를 참조할 수 있는 네임스페이스 "네임스페이스 A"를 사용한다. 일 실시예에서, 그래프 소스 코드(420)는 프로그래머가 커널(605) 및 통신 링크(620)를 사용하여 구축하는 이종 프로그래밍 환경에서 데이터 구조를 설정하는 것으로 생각할 수 있다.

이 예에서, 그래프 소스 코드(420)는 6개의 커널(605): a, b, c, d, e, f를 포함한다. 커널(605)은 "무선(radio)" 클래스 내에서 규정된다. 도 6은 무선 기능을 수행하기 위한 소스 코드(420)를 예시하지만, 위에서 언급된 바와 같이, 본 명세서에서 설명된 기술은 레이더, 벡터 연산, 머신 학습 애플리케이션 등과 같은 복수의 상이한 기능에 사용될 수 있다.

소스 코드(420)는 커널(605)의 각각에 의해 수행되는 기능 또는 동작을 규정하는 래퍼(610A-F)를 포함한다. 래퍼(610)는 대응하는 C++ 기능(예를 들어, 폴라클립(polarclip), 피드백, 이퀄라이저, fir_tap11, fir_tap7, 및 스케일(scale)을 호출하는 메커니즘을 생성한다. 즉, 래퍼(610)는 프로그래머가 다른 C++ 라이브러리의 일부일 수 있는 예시적인 함수를 사용하여 커널을 규정할 수 있게 한다. 이 예에서, 커널(605)은 단일 명령어가 아니라 함수 호출이다. 일 실시예에서, 커널(605)은 커널(605)이 모든 트리거링 입력으로부터 데이터를 수신할 때만 실행하고, 다운스트림 커널(605)에 송신될 수 있는 출력을 생성하기 위해 비차단 방식으로 실행한다. 액세스할 때 스트림 데이터가 없으면, 커널은 스트림 입력에서 실행하는 동안 차단될 수도 있다.

래퍼(610)를 사용하여 함수 호출로서 커널을 추상화하는 것의 한 가지 이점은, 이렇게 하는 것이 프로그래머가 동일한 균일 프레임워크에서 DPE 또는 프로그램 가능한 로직에서 실행될 커널을 표현할 수 있다는 것을 의미한다는 것이다. 프로그래머는 커널(605)을 다르게 기록하지만, 커널(605)은 동일한 방식으로 패키징되고 동일한 프레임워크로 표현될 수 있다. 프로그래머는 DPE에 할당된 커널을 PL 패브릭에 할당된 커널과 통합하는 것에 대해 걱정할 필요가 없다. 여기서, 프로그래머는 그래프 소스 코드(420)에서 통신 링크(620)의 유형을 선택하거나 나타내고, 이러한 유형의 통신 링크(620)를 사용하는 커널(605) 간의 모든 동기화는, 컴파일러에 의해 처리된다.

소스 코드(420)는 또한, 컴파일러가 소스 코드(420)(예를 들어, 커널(605) 및 통신 링크(620))에 규정된 객체를 SoC의 하드웨어에 매핑하는 방법을 제한하는 명령어를 포함하는 제약 조건(615)을 포함한다. 이 예에서, 제약 조건(615)은, 커널 a 및 f를 DPE에 할당하는 것이 아니라 컴파일러에게 커널 a 및 f를 SoC의 패브릭(예를 들어, 프로그램 가능한 로직)에 할당하도록 지시한다. 아래 설명된 이유로, 커널 a 및 f를 DPE가 아닌 패브릭에 할당하는 것은, 성능 향상을 제공할 수 있다. 따라서, 그래프 소스 코드(420)는 프로그래머가 커널(605)을 SoC의 하드웨어에 할당하도록 요구하지 않지만(따라서 프로그래머는 SoC의 기본 하드웨어 아키텍처를 이해할 필요가 없음), 프로그래머에게 제공된 네임스페이스는, 프로그래머가 이와 같이 행하는 것이 성능을 향상시킨다는 것을 알고 있는 경우, 컴파일러에게 커널(605) 중 하나 또는 전부를 할당하는 방법을 지시하기 위해 프로그래머로 하여금 제약 조건을 사용하게 한다.

통신 링크(620)는 커널(605) 사이에서 데이터가 통신되는 방식을 규정한다. 예를 들어, 통신 링크(620A)는 스트리밍 데이터가 길이가 64바이트인 윈도우 데이터로 변환됨을 나타낸다. 또한, 각 윈도우는 8바이트 중첩 상태로 송신된다. 그러나, 통신 링크(620B)에 대해, 길이 32바이트의 윈도우잉 데이터가, 어떤 중첩 데이터 없이 커널 b와 커널 c 사이에서 송신된다. 윈도우잉 데이터(및 윈도우의 중첩)에 대한 세부 사항은, 아래에서 더 상세히 설명된다.

또한, 각 통신 링크(620)는 업스트림 커널의 어느 포트가 다운스트림 커널의 어느 포트에 연결되는지를 규정한다. 예를 들어, 링크(620A)에서, 커널 a의 출력 포트 a.out[0]은, 커널 b의 입력 포트 b.in[0]에 결합된다. 각 커널은 복수의 입력 포트와 복수의 출력 포트를 가질 수 있다. 예를 들어, 통신 링크(620D)에서, 커널 d의 제1 출력 포트 d.out[1]은, 입력 포트 e.in[0]에 결합된다. 또한, 통신 링크(620F)에서, 커널 d의 제2 출력 포트 d.out[0]은, 입력 포트 f.in[0]에 결합된다.

그래프 소스 코드(420)가 커널(605)을 추상화하여 동일한 균일 프레임워크로 표현될 수 있는 것처럼, 소스 코드(420)는 프로그래머로부터 통신 링크(620)에 대한 동기화를 추상(또는 숨김)처리 할 수 있다. 아래에서 더 상세히 설명되는 바와 같이, 컴파일러는 커널(605)이 패브릭에 있는지 또는 DPE 어레이에 있는지, 또는 커널(605)이 DPE 어레이에서 이웃인지에 기초하여, 커널(605)들 사이에서 데이터를 송신하기 위한 최적의 통신 기술을 선택할 수 있다.

일 실시예에서, 그래프 소스 코드(420)의 커널(605), 래퍼(610), 제약 조건(615), 및 통신 링크(620)를 규정하는 능력은, 프로그래머로 하여금 데이터 흐름 그래프를 구현하는 객체 지향 소스 코드를 생성하게 하는 이종 프로그래밍 환경에 의해 제공되는(네임스페이스의 라이브러리에 의해 지원되는) 툴이다.

도 7은 일 예에 따른, 도 6의 소스 코드(420)에 의해 규정된 데이터 흐름 그래프(440)를 도시한다. 즉, 그래프(440)는 그래프 소스 코드(420)에 의해 규정된 그래프의 그래픽 표현이다. 도시된 바와 같이, 그래프(440)는 통신 링크(620A-E)를 사용하여 통신 가능하게 결합된 6개의 커널(a-f)을 포함한다. 또한, 그래프(440)는 데이터를 커널 a로 전송하는 입력(705) 및 커널 f의 출력으로부터 데이터를 수신하는 출력(710)을 포함한다. 입력(705)에서 수신된 데이터는, 예를 들어 호스트 상에서 실행되는 애플리케이션, 무선 송수신기, 카메라에 의해, 또는 파일 또는 데이터베이스로부터 제공될 수 있다. 출력(710)은 그래프(440)에 의해 처리된 데이터를 호스트 또는 파일 또는 데이터베이스로 송신할 수 있다.

도 7은 커널(예를 들어, 노드)이 각각의 입력 및 출력 포트에서 링크(620)에 의해 결합되는 그래프(440)의 추상도이다. 즉, 도 7은 링크(620A-F)를 사용하는 커널(a-f) 간의 데이터 흐름을 예시하지만, 커널이 실행되는 하드웨어 구현 또는 사용 중인 특정 유형의 통신 링크(620)(예를 들어, 공유 메모리, NoC, DMA 등)는 예시하지 않는다. 그럼에도 불구하고, 프로그래머는 도 7에 예시된 추상도에서 그래프(440)를 설계할 수 있고, 그 후 컴파일러는 SoC의 하드웨어에서 커널(a-f) 및 통신 링크(620)를 구현할 수 있다.

도 8은 일 예에 따른, 데이터 흐름 그래프에서 커널을 규정하기 위한 커널 소스 코드(425)이다. 일 실시예에서, 도 6의 소스 코드의 래퍼(610)는, 커널에 의해 규정된 함수의 인수가 포트로서 액세스되도록 허용한다. 도 8에서, 커널 소스 코드(425)는 입력 데이터에 대한 포인터(즉, ^*inputw) 그리고 출력 데이터에 대한 포인터(^*outputw)를 지정하는 인수(805)를 포함한다. 위에서 설명된 바와 같이 2 개의 커널이 링크에 의해 통신 가능하게 결합되면, 컴파일러는 커널이 호출될 때 커널(또는 커널에 의해 호출되는 함수)에 공급되는 데이터 메모리를 할당할 수 있다. 일 실시예에서, 커널은 API(application programming interface)를 사용하여 인수(805)에 의해 제공되는 입력 데이터에 대해 동작한다.

도 8에서, 커널 소스 코드(425)는 입력 데이터를 출력하기 전에 처리하기 위한 윈도우 API를 포함한다. 예를 들어, window_readincr은 포인터 inputw를 사용하여 다음 윈도우를 판독하는 API이다. 일반적으로 sbuff를 사용하여 수학을 수행하는 것으로 본 명세서에서 예시된 동작이 수행되면, 다른 API를 사용하여 처리된 데이터(예를 들어, window_writeincr)를 출력할 수 있다.

일 실시예에서, 프로그래머는 그래프 소스 코드에 규정된 각 커널에 대한 커널 소스 코드를 생성한다. 그러나, 그래프 소스 코드가 동일한 커널의 복수의 인스턴스를 가지는 경우, 동일한 커널 소스 코드를 사용하여 이러한 복수의 인스턴스를 규정할 수 있다.

방법(500)으로 돌아가서, 블록 510에서, 컴파일러는 소스 코드(예를 들어, 그래프, 커널, 및 제어 소스 코드)를 컴파일한다. 설명의 편의를 위해, 이러한 컴파일링은 적어도 3 개의 서브 블록으로 분할된다. 블록 515에서, 컴파일러는 커널을 SoC의 DPE 및 프로그램 가능한 로직에 할당한다. 컴파일러는 소스 코드에서 프로그래머에 의해 제공된 제약 조건(예를 들어, 도 6의 제약 조건(615))을 사용할 수 있지만, 제약 조건이 없으면, 그래프 소스 코드의 커널을 SoC의 DPE 및 프로그램 가능한 로직에 할당할 수 있다.

일 실시예에서, 컴파일러는 SoC의 하드웨어에 커널을 할당하는 방법을 결정하기 위해 그래프를 평가한다. 예를 들어, 그래프에서 2 개의 커널이 서로 통신 가능하게 결합되어 있는 경우, 컴파일러는 DPE 간의 공유 메모리와 같은 더 빠른 통신 프로토콜을 활용하기 위해 DPE 어레이의 이웃 DPE에 커널을 할당할 수 있다. 또한, 컴파일러는 복수의 커널이 동일한 DPE에 할당될 수 있는지 여부를 결정하기 위해, 커널들의 각각에 의해 사용되는 시간 비율 및 사이클 카운트를 결정할 수 있다.

도 9는 일 예에 따른, 도 7의 데이터 흐름 그래프(440)를 구현하는 추상도이다. 도 9는 통신 링크(620) 뿐만 아니라 커널(a-f)을 예시한다. 또한, 도 9는 SoC에서 커널이 할당된 하드웨어를 예시한다. 도시된 바와 같이, 커널 a 및 f는 PL(125)에 배치되고, 커널 b 및 c는 DPE(110A)에서 구현되고, 커널 d 및 e는 DPE(110B)에서 구현된다.

일 실시예에서, 컴파일러는 그래프 소스 코드에 제공된 제약 조건에 기초하여 PL(125)에 커널 a 및 f를 배치하도록 선택한다. 그러나, 다른 실시예에서, 컴파일러는 이러한 커널을, DPE보다 프로그램 가능한 로직으로 구현하기에 더 적합할 수 있는 입/출력 커널로서 인식할 수 있다.

컴파일러는 각 커널의 사이클 카운트의 추정된 부분을 사용하거나, 프로그래머로부터의 제약 조건에 응답하여 동일한 DPE(110A)에 커널 b 및 c를 할당할 수 있다. 이는 일반적으로 클러스터링으로서 지칭된다. 예를 들어, 커널 b가 DPE (110A)의 사이클 카운트의 40%만 사용하고, 커널 c가 사이클 카운트의 55%만 사용하는 경우, 컴파일러는 이를 동일한 DPE(110A)에 배치할 수 있다. 다른 예에서, 프로그래머는 동일한 DPE(110A) 상에 커널 b 및 c를 배치하도록 컴파일러에 지시하기 위해 제약 조건을 사용할 수 있다. 이렇게 하면, 프로그래머가 그래프를 병렬화된 데이터 구조로서 설명하지만, 프로그래머는 커널의 추정 사이클 수를 사용하여 일부 커널을 순차적이 되도록, 즉 동일한 DPE에 할당하도록 강제할 수 있다. 즉, 각 DPE는 한 번에 하나의 작업만 실행할 수 있으므로(즉, 병렬화되지 않음), 동일한 DPE에 2 개의 상이한 커널을 배치하는 것은, 커널이 자신의 DPE에 할당되는 시나리오가 아니라 한 번에 커널들 중 하나만 실행할 수 있다는 것을 의미한다. 그러나, 이 클러스터링은 여전히 전체 사이클 카운트를 충족한다.

방법(500)으로 돌아가서, 블록 520에서, 컴파일러는 커널들 사이의 연결을 스트리밍 또는 윈도우잉에 할당한다. 일 실시예에서, 이러한 연결은 그래프 소스 코드에 규정된 통신 링크에 의해 제어된다. 즉, 프로그래머는 각 커널 쌍 간에 데이터를 전달하는 방법을 나타낼 수 있다. 다른 예에서, 컴파일러는 인터커넥트(205)를 통해 메모리 뱅크(220)로부터 또 다른 DPE(110)로 윈도우 데이터를 전송하기 위해 하나의 DPE(110)의 메모리 모듈(230)에 DMA 엔진(215)을 할당한다. 또 다른 예에서, 컴파일러는 인터커넥트(205) 상의 스트림 채널 그리고 수신 코어(210) 또는 수신 DMA 엔진(215) 상의 스트림 채널을 할당한다.

블록 525에서, 컴파일러는 커널들 사이에서 데이터를 전송하기 위한 동기화 기술을 선택한다. 이는 통신 링크(620A-F)(이는 이 예에서, 윈도우잉을 사용함)가 커널들 사이에서 데이터를 송신하기 위해 이중 버퍼(905) 또는 단일 버퍼(910)를 포함하는 도 9에 예시되어 있다. 커널이 커널 a와 b 사이의 링크(620A)와 커널 d와 f 사이의 링크(620F)의 경우와 같이 다른(또는 이종) 처리 코어(예를 들어, PL(125) 대(versue) DPE(110))에 있으면, 컴파일러는 이중 버퍼(905)를 할당한다. 또한, 커널 c와 d 사이의 링크(620C) 및 커널 e와 b 사이의 링크(620E)의 경우와 같이 커널이 다른 DPE에 있는 경우, 컴파일러는 다시 이중 버퍼(905)를 사용한다. 그러나 커널 b와 c 사이의 링크(620B)와 커널 d와 e 사이의 링크(620D)의 경우와 같이 동일한 DPE 상의 커널들 사이에서 데이터를 전송하기 위해, 컴파일러는 단일 버퍼(910)를 할당할 수 있다. 아래에 설명된 바와 같이, 단일 버퍼링은 이중 버퍼링보다 낮은 대기 시간을 제공할 수 있다.

컴파일러는 또한 이중 또는 단일 버퍼링을 수행할 때 커널들 간의 동기화를 처리한다. 예를 들어, 이중 버퍼링을 수행할 때, 컴파일러는 단일 버퍼링을 수행할 때(예를 들어, 커널이 동일한 DPE(110)에 있을 때) 필요하지 않을 수 있는 이중 버퍼(905)에 액세스하기 위한 잠금 프로토콜을 설정할 수 있다. 다른 예에서, 컴파일러는 이중 버퍼(905)에 대한 핑/퐁(ping/pong) 동기화 기술을 선택할 수 있다. 어쨌든, 동기화는 소스 코드에서 프로그래머에 의해 제공된 파라미터를 사용하여 컴파일러에 의해 설정될 수 있다.

방법(500)으로 돌아가서, 블록 510에서, 컴파일러는 컴파일된 소스 코드를 사용하여 데이터 흐름 그래프를 실행하도록 SoC를 구성하기 위한 비트스트림 및/또는 2진 코드(예를 들어, 일련의 메모리 매핑된 저장 트랜잭션)를 송신한다. 즉, SoC는 비트스트림/2진 코드를 수신한 후, 컴파일러에 의해 규정된 하드웨어 요소를 사용하여 그래프를 실행할 수 있다. 컴파일러는 SoC에서 각 커널을 배치해야 하는 위치, 이들 커널 간의 통신 링크의 유형 및 통신 링크에 의해 사용되는 동기화를 결정할 수 있다.

도 10은 일 예에 따른, SoC에서 도 7의 데이터 흐름 그래프를 구현하는 하드웨어 뷰(1000)이다. 즉, 하드웨어 뷰(1000)는 도 7에 예시된 데이터 흐름 그래프를 구현하는 데 사용되는 SoC의 일부를 예시한다. 이 예에서, 도 7은 PL(125)을 포함하는 SoC의 일부 및 5 개의 코어(210) 및 5 개의 메모리 모듈(230)을 포함하는 DPE 어레이의 DPE들의 적어도 일부를 예시한다.

커널 a 및 f는 PL(125)의 구성 가능한 로직 블록(CLB)을 사용하여 형성된다. 커널 a는 인터커넥트(205)를 통해 메모리 모듈(230A)에 통신 가능하게 결합된다. 도시되지는 않았지만, 커널 a와 메모리 모듈(230A) 사이의 이러한 통신 링크는, DPE 어레이의 코어(210)가 SoC의 다른 하드웨어 모듈(예를 들어, PL(125))과 통신할 수 있게 하는 NoC 및 SoC 인터페이스 블록을 포함할 수도 있다. 이 실시예에서, 커널 a는, 수신된 데이터를 메모리 뱅크(220A)의 이중 버퍼(905A)에 저장하는 메모리 모듈(230A)의 DMA 엔진(215A)으로 데이터를 송신한다. 따라서, 컴파일러는 메모리 뱅크(220A)에 이중 버퍼(905A)를 할당함으로써, 도 9에 예시된 통신 링크(620A)를 구현하도록 결정하였다. DMA 기록을 사용하여, 커널 a는 이중 버퍼(905A)에 데이터를 저장할 수 있으며, 이 데이터는 코어(210B)에서 호스팅되는 커널 b에 의해 액세스될 수 있다.

이 예에서, 이중 버퍼(905A)는 메모리 뱅크(220A)의 4 개의 뱅크에 할당된다. 일 실시예에서, 각각의 메모리 뱅크는, 이중 버퍼(905A)의 총 크기가 512바이트임을 의미하는 128바이트를 보유한다. 그러나, 컴파일러는 커널 a 및 b의 예상된 필요성에 따라 이중 버퍼(905A)에 더 많은 메모리 뱅크를 할당하거나 더 적은 메모리 뱅크를 할당할 수 있다. 커널 a는 이중 버퍼(905A)의 메모리 뱅크(220A) 중 2 개의 뱅크에 데이터를 기록할 수 있는 반면에, 커널 b는 버퍼(905A)의 다른 2 개의 메모리 뱅크(220A)로부터 데이터를 판독할 수 있다. 일 실시예에서, 컴파일러는 커널이 동일한 쌍의 메모리 뱅크에 액세스하려고 시도하지 않도록, 커널 a와 b 사이에 핑/퐁 동기화 프로토콜을 설정한다. 위에서 언급한 바와 같이, 컴파일러는 동기화 프로토콜을 처리하여, PL(125)의 커널 a가 코어(210B)의 커널 b와 통신할 수 있도록 프로그래머만이 그래프 소스 코드에서 이러한 커널들 사이에 발생해야 하는 통신 유형(예를 들어, 윈도우잉 또는 스트리밍)을 표시할 수 있다.

일 실시예에서, 커널 b를 호스팅하는 코어(210B)가 메모리 모듈(230A)에 직접 인접하기 때문에, 커널 b는 (커널 a와 달리) 인터커넥트(205)를 사용할 필요 없이 이중 버퍼(905A)에 직접 액세스할 수 있다. 따라서, 컴파일러는, 이중 버퍼(905A)와 커널 b를 하드웨어 요소에 할당할 때, 서로 직접 이웃하는 메모리 모듈(230A)과 코어(210B)를 선택하여, 커널 b가 코어(210B)와 메모리 모듈(230A) 간의 직접 연결을 사용할 수 있게 하고, 이는 인터커넥트(205)를 사용하는 것보다 더 높은 처리량을 갖는다.

커널 b 및 c가 도 9에 도시된 바와 같이 동일한 코어(210B)에 호스팅되거나 할당되기 때문에, 컴파일러는 단일 버퍼(910A)를 이웃 메모리 모듈(230)에 할당하려고 시도한다. 이 경우에, 컴파일러는 단일 버퍼(910A)를 메모리 모듈(230C)에 할당했지만, 임의의 이웃 메모리 모듈(예를 들어, 모듈(230A 또는 230B))을 사용할 수 있었다. 컴파일러는 모듈(230A 또는 230B)보다 메모리 모듈(230C)을 선택하여 이러한 메모리 모듈이 어레이(도시되지 않음)에서 더 북쪽에 있는 코어에 의해 사용할 수 있는 더 이용가능한 공간을 가질 수 있다. 이유와 상관없이, 커널 b 및 c는, 코어(210B)와 메모리 모듈(230C) 사이의 직접 연결을 사용하여 단일 버퍼(910A) 안팎으로 데이터를 전송할 수 있다. 커널 b와 c는 동일한 코어(210B)에 할당되어, 결과적으로 병렬이 아닌 순차적으로 실행되기 때문에, 임의의 주어진 시점에서 커널들 중 하나만 코어(210B)에 의해 실행되기 때문에, 이중 버퍼보다는 단일 버퍼(910A)가 충분하다. 이 예에서, 단일 버퍼(910A)는 메모리 뱅크(220C)의 2 개의 뱅크를 포함하지만, 컴파일러는 커널 b 및 c의 예상되는 요구에 따라 더 많은 뱅크 또는 더 적은 뱅크를 할당할 수 있다.

커널 c와 커널 d 사이의 코어간 통신 링크(이는 도 9에서 통신 링크(620C)로서 예시됨)에 대해, 컴파일러는 메모리 모듈(230B) 내의 메모리 뱅크(220B)에 이중 버퍼(905B)를 할당한다. 위에서와 같이, 컴파일러는 이중 버퍼(905B)에서 메모리 뱅크(220B)의 2 개의 개별 쌍을 동시에 기록 및 판독하기 위해 커널 c 및 d에 대한 핑/퐁 동기화 프로토콜을 설정할 수 있다. 또한, 커널 c를 호스팅하는 코어(210B)와 커널 d를 호스팅하는 코어(210C) 모두에 인접한 메모리 모듈(230B)을 사용함으로써, 컴파일러는 이러한 코어(210B-C)가 이중 버퍼(905B)에 데이터를 판독 및 저장하기 위한 메모리 모듈(230B)을 갖도록 직접 연결을 이용한다.

커널 d와 e 사이의 코어내 통신 링크(이는 도 9에서 통신 링크(620D)로서 예시됨)에 대해, 컴파일러는 단일 버퍼(910B)를 메모리 모듈(230C)에 할당한다. 커널 b와 c 간의 통신 링크와 마찬가지로, 커널 d와 e가 코어(210C)에서 순차적으로 실행되기 때문에, 단일 버퍼(910B)로도 충분하다.

커널 e와 b 사이의 코어간 통신 링크(도 9에서 통신 링크(620E)로서 예시됨)에 대해, 컴파일러는 이중 버퍼(905D)를 단일 버퍼(910A 및 910B)에 의해 사용되고 있지 않는 메모리 모듈(230C) 내의 나머지 4 개의 메모리 뱅크(220C)에 할당한다. 컴파일러는 이중 버퍼(905D)에 액세스하기 위해 커널 b와 e 사이에 동기화 프로토콜을 다시 설정할 수 있다.

커널이 상이한 유형의 프로세싱 코어[예를 들어, 코어(210C)를 포함하는 PL(125) 및 DPE]에서 호스팅되는 커널 d와 f(이는 도 9에서 통신 링크(620F)로서 예시됨) 사이의 이종 통신 링크에 대해, 컴파일러는 메모리 모듈(230D) 내의 메모리 뱅크(220D)에 이중 버퍼(905C)를 할당한다. 커널 d는 코어(210C)와 메모리 모듈(230D) 간의 직접 연결을 이용하여 이중 버퍼(905C)에 액세스할 수 있다. 그러나, 커널 f는 코어(210)들 중 하나가 아닌 PL(125)에서 호스팅되기 때문에, 커널 f는 DMA 엔진(215D) 및 인터커넥트(또한 NoC 및 SoC 인터페이스 버퍼는 도시되지 않음)를 사용하여 이중 버퍼(905C)에 액세스할 수 있다. 컴파일러는 커널 d와 f 사이에 동기화 프로토콜을 다시 설정하여 커널이 이중 버퍼(905C)에 병렬로 액세스할 수 있도록 할 수 있다.

도 10은 동일한 코어(210) 또는 동일한 메모리 모듈에 대한 직접 연결을 갖는 코어(210)에서 서로 통신하는 DPE 어레이에 커널을 배치하는 것을 예시하지만, 다른 실시예에서 컴파일러는 동일한 메모리 모듈(230)에 직접 연결을 갖지 않는 코어에 2 개의 커널을 배치할 수 있다. 즉, 컴파일러는 그래프에서 직접 통신하는 2 개의 커널을 인접하지 않은 2 개의 코어(210)에 할당할 수 있다. 이 경우, 컴파일러는 공유 메모리를 사용하기 보다는 커널 간에 통신하기 위해 인터커넥트(205)(PL(125)에 위치하는 커널과 유사함)를 사용하여 DMA 판독/기록 또는 스트리밍 연결을 수행하도록 커널을 구성할 수 있다.

이러한 방식으로, 컴파일러는 이종 시스템에서 커널을 배치할 위치를 결정하고, 커널들 간의 통신 링크의 유형(이중 버퍼, 단일 버퍼, 윈도우잉 또는 스트리밍인지 여부)을 결정하고, 소스 코드에서 프로그래머에 의해 규정된 파라미터(예를 들어, 통신 링크를 규정하는 파라미터)를 사용하여 커널 간의 동기화 프로토콜을 설정할 수 있다. 그러나, 위에서 언급한 바와 같이, 프로그래머는 SoC에서 소스 코드에 규정된 그래프를 구현하기 위한 최적의 솔루션을 미리 알고 있으면, 제약 조건을 사용하여 컴파일러에 최적화 명령어를 제공할 수 있다.

도 11은 일 예에 따라, 커널 간에 데이터를 송신할 때 사용되는 중첩 윈도우(1100)를 예시한다. 일 실시예에서, 중첩 윈도우(1100)는 도 11에 예시된 중첩 윈도우(1100)를 생성하기 위해 데이터를 청크업(chunk up)하는 하나의 커널(예를 들어, 도 10의 커널 a)에서 수신된 스트리밍 데이터로부터 형성될 수 있다. 다른 예에서, 커널은 업스트림 커널로부터 중첩 윈도우를 수신한 후 중첩 윈도우를 다운스트림 커널로 송신할 수 있다. 일 실시예에서, 윈도우(1100A)는 이중 버퍼(905A-D) 중 하나에 저장되고, 윈도우(1100B)는 핑퐁(ping-pong) 동기화로 인해 다른 버퍼에 저장된다. 그 후, 컴파일러는 커널의 다음 호출 전에 중첩(1105)이 하나의 버퍼로부터 다른 버퍼로 복사된다는 것을 보장할 책임이 있다.

중첩 윈도우(1100)는 일부 실시예에서는 유용할 수 있지만 다른 실시예에서는 유용하지 않을 수 있다. 예를 들어, 중첩 윈도우(1100)는 무선 도메인에서 유용할 수 있으므로, SoC가 서로 다른 윈도우를 실행하는 사이에 커널의 상태를 유지할 수 있다. 일 실시예에서, 코어가 커널 실행을 완료한 후, 커널과 연관된 레지스터가 클리어되고 따라서 커널의 상태가 손실된다. 그러나, 중첩(1105)의 데이터가 동일한 윈도우(1100A 및 1100B) 사이에 중첩(1105)을 제공함으로써, 커널이 윈도우(1100B)에서 새로운 데이터를 처리하기 시작할 때, 커널은 윈도우(1100A) 처리를 완료한 상태를 회복할 수 있다. 달리 말하면, 윈도우(1100B)[윈도우(1100A)의 마지막 샘플을 포함함)에서 중첩(1105)을 처리함으로써, 커널은 윈도우(1100A) 처리가 끝날 때의 상태를 회복한다. 그 후, 커널은 윈도우(1100A)에 없었던 윈도우(1100B)의 새로운 데이터를 처리하기 시작할 수 있다. 따라서, 윈도우(1100B)의 블록 크기(1110)는 이전 윈도우(1100A)에 없었던 커널에 의해 처리되고 있는 새로운 데이터를 나타낸다. 이러한 방식으로, 그래프는 수신된 데이터를 처리하기 위해 윈도우(1100)(이는 스트리밍 데이터에 대해 커널에서 스톨(stall)을 감소시킬 수 있음)를 사용할 수 있지만, 여전히 중첩(1105)을 사용함으로써 무한 스트림 일루전(illusion)을 유지할 수 있다.

커널 간의 통신 링크가 (스트리밍이 아닌) 윈도우를 사용하는 경우, 일 실시예에서, 수신 커널은 데이터의 윈도우(1100)가 모든 입력으로부터 수신될 때까지 데이터를 처리하지 않으며, 이는 데이터를 처리하는 것을 비차단 상태로 만든다. 데이터의 모든 윈도우(1100)가 수신되면, 커널은 추가 데이터에 대해 지체되지 않고 데이터를 처리하고 윈도우를 다운스트림 커널 또는 커널들에 출력한다. 예를 들어, 도 9의 커널 d는 각각 통신 링크(620F 및 620D)를 사용하여 병렬로 커널 f 및 e 모두에 데이터의 윈도우(1100)를 출력한다. 커널 d에 의해 커널 f 및 e로 출력되는 데이터의 윈도우(1100)는 동일한 데이터일 수 있고 다른 데이터일 수 있다.

다른 실시예에서, 사용자는 모든 윈도우가 수신되거나 모든 데이터가 출력될 준비가 될 때까지 대기하기 보다 커널이 입력 데이터를 수신하거나 데이터를 출력할 때를 결정하도록 커널을 프로그래밍할 수 있다. 예를 들어, 도 6을 다시 참조하면, 통신 링크(620E)는 커널 b를 규정하는 소스 코드가 커널 e로부터 데이터를 수신할 때를 결정하는 비동기식이다.

방법(500)으로 돌아가서, 제어 프로그램은 SoC 상의 데이터 흐름 그래프의 실행을 제어한다. 즉, 커널과 통신 링크가 다양한 하드웨어 구성 요소에 할당되고 도 10에 예시된 바와 같이 구성되면, 제어 프로그램은 그래프 실행을 제어하기 위해 SoC에 명령어를 제공할 수 있다. 위에서 언급한 바와 같이, 제어 프로그램은 호스트 컴퓨팅 시스템(바람직하게는 데이터 센터에 있을 수 있음)에서 또는 SoC의 PS 내에서 실행할 수 있다. 일 실시예에서, 제어 프로그램은 제어 소스 코드를 사용하여 컴파일된다.

도 12는 일 예에 따른 데이터 흐름 그래프를 위한 제어 프로그램을 규정하는 제어 소스 코드(430)이다. 소스 코드(430)는 데이터가 그래프로 어떻게 읽혀져야 하고 그래프로부터 어떻게 판독되어야 하는지를 컴파일러에 지시하는 연결(1205)을 제공한다. 메인 클래스는 그래프를 초기화[예를 들어, init()], 그래프를 실행[예를 들어, run()] 및 그래프를 종료[예를 들어, end()]하기 위한 제어 API를 포함한다. 예를 들어, 프로그래머는 제어 소스 코드(430)를 사용하여 그래프가 중지되기 전에 실행되어야 하는 반복 횟수를 나타낼 수 있다. 이것은 디버그 목적으로 유용할 수 있다. 그러나, 다른 예에서, 제어 프로그램은 애플리케이션에 따라 그래프가 무한정 동작하도록 허용할 수 있다. 이러한 제어 API는 나중에 더 자세히 논의된다.

일 실시예에서, 프로그래머는 메모리 모듈의 크기를 초과하는 대형 룩업 테이블(LUT)을 원할 수 있다. 컴파일러가 DPE 어레이의 메모리 모듈에 비해 너무 큰 대형 LUT를 식별하면, 컴파일러는 LUT를 복수의 메모리 모듈에 걸쳐 분산시킬 수 있다. 컴파일러는 LUT를 어레이에 직접 할당할 수 있다. 프로그래머는 LUT를 정적 데이터 및 어레이 파라미터로서 선언하고, 정적 데이터와 어레이 파라미터를 커널에 연결할 수 있다. 컴파일러는 LUT를 커널에 대한 내부 데이터(계수 테이블과 유사함)로서 취급한다. 이 LUT 선언은 그래프에 있으며 그래프 구성 요소로서 할당된다. 일 실시예에서, 대형 LUT는 이중 버퍼링되지 않고, 한번에 하나의 커널에 의해서만 액세스 가능하다.

일 실시예에서, 커널은 DPE의 코어로부터 스트림에 직접 판독/기록할 수 있다. 커널 소스 코드에서, 스트림은 함수 파라미터로서 선언될 수 있다. 코어의 스트리밍 포트에서 데이터를 이용할 수 없으면, 커널이 중단될 수 있고(이에 따라, 잠금 메커니즘이 필요하지 않게 된다). 이는 스트림 자체의 하드웨어에 의해 구현되는 요소별 동기화이지만, 이용 가능한 입력 데이터가 없거나 뱅크에 메모리 충돌이 있거나 출력 버퍼가 가득 차서 코어가 멈출 수 있다.

일 실시예에서, 커널이 코어가 제공할 수 있는 것보다 더 많은 사이클 카운트를 필요로 하는 경우, 커널이 코어 간에 분할되고, 캐스케이드 스트림이 하위 분할된 커널을 연결하는 데 사용된다. 소스 코드에서, 프로그래머는 캐스케이드를 형성하기 위해 함께 연결된 복수의 커널을 표현한다. 전체 계산은 전체 체인의 누적 합계이다. 컴파일러는 캐스케이드화된 커널의 계산을 복수의 코어에 걸쳐 분산시킨다. 코어는 코어의 레지스터에 사이클별 누적을 수행하는데 즉, 코어의 내부 레지스터를 사용하고 메모리 모듈을 사용하지 않는다. 이와 같이, 코어는 레지스터 간 통신을 사용하여 메모리 모듈을 버퍼(예를 들어, 위에서 설명한 단일 및 이중 버퍼)로서 사용하지 않고 체인을 실행할 수 있다. 일 실시예에서, 캐스케이드를 형성하기 위해 프로그래머가 복수의 커널을 체이닝(chaining)하는 것보다, 컴파일러(또는 일부 다른 소프트웨어 애플리케이션)는 이 변환을 수행할 수 있고, 여기서 커널이 캐스케이드를 형성하기 위해 코어 사이에서 분할된다.

제약 조건

도 13은 예에 따른, 제약 조건을 사용하여 데이터 흐름 그래프를 구현하기 위해 소스 코드를 컴파일하는 방법(1300)의 흐름도이다. 블록(1305)에서, 컴파일러는 데이터 흐름 그래프를 설정하는 소스 코드에서 사용자 규정된 제약 조건을 식별한다. 예를 들어, 도 6을 참조하면, 프로그래머는 그래프 소스 코드(420)에 제약 조건(615)을 추가할 수 있다. 그러나, 다른 실시예에서, 프로그래머는 커널 소스 코드에 제약 조건을 배치한다. 또 다른 실시예에서, 프로그래머는 별도의 파일에서 제약 조건을 규정할 수 있다. 그래프 소스 코드는 데이터 흐름 그래프를 구현할 때 컴파일러가 제약 조건을 식별할 수 있도록, 파일을 참조하거나 링크할 수 있다.

사용자 규정된 제약 조건은 SoC에서 구현하기 위해 소스 코드를 컴파일할 때 컴파일러가 아닌 프로그래머에 의해 생성되기 때문에 외부 제약 조건이다. 일 실시예에서, 프로그래머에 의해 제공되는 외부 제약 조건의 수는, 컴파일러의 지능에 따라 변할 수 있다. 컴파일러가 데이터 흐름 그래프의 최적화된 구현을 초래하는 내부 제약 조건을 갖는 경우, 프로그래머는 몇 가지 제약 조건을 제공하도록 선택할 수 있다. 따라서, 컴파일러의 성능은 프로그래머가 사용하기로 결정한 외부 제약 조건의 수에 영향을 줄 수 있다. 최신 버전의 컴파일러를 사용할 수 있게 됨에 따라, 프로그래머는 더 적은 제약 조건을 제공할 수 있다.

제약 조건의 유형은 변할 수 있다. 또한, 프로그래머가 제공하는 제약 조건의 수는, 프로그래머가 SoC의 기본 하드웨어를 이해하는 정도와 상관 관계가 있을 수 있다. 프로그래머가 SoC의 하드웨어에 대해 거의 알지 못하는 경우, 제약 조건이 데이터 흐름 그래프의 전체 성능(예를 들어, 그래프의 사이클 시간 또는 대기 시간과 같은 데이터 흐름 그래프의 원하는 성능)에 영향을 끼칠 수 있다. 프로그래머가 SoC의 몇 가지 기본 하드웨어 구성(예를 들어, DPE, PL, 통신 링크 유형 등)을 이해하는 경우, 프로그래머는 이러한 특정 그래프 개체에 대한 제약 조건도 제공할 수 있다. 따라서, 일부 제약 조건은 하드웨어 애그노스틱 조건(예를 들어, 그래프 전체에 영향을 미치는 성능 제약 조건)일 수 있는 반면에, 다른 제약 조건은 하드웨어를 인식하고 데이터 흐름 그래프의 특정 그래프 개체(또는 그래프 개체의 그룹)에 영향을 준다.

하드웨어 인식 제약 조건의 예로서, 프로그래머는 DPE 어레이에서 특정 커널이 위치해야 하는 위치(예를 들어, 커널 위치 제약 조건)를 규정할 수 있다. 또한, 프로그래머는 2 개의 커널 간의 위치 관계를 규정할 수 있다(예를 들어, 2 개의 커널은 동일한 코어에서 호스팅되거나 이웃 코어에서 호스팅되어야 함). 다른 예에서, 제약 조건은 통신 링크에 대한 특정 버퍼(또는 커널에 대한 포트)가 DPE 어레이에 배치되어야 하는 위치를 규정할 수 있다. 버퍼의 위치 요건은 절대 어드레스 또는 메모리 뱅크, 또는 커널이 실행되는 프로세서와 연관되는 스택 또는 다른 버퍼 또는 커널에 대한 상대 위치일 수 있다. 다른 유형의 제약 조건은, 특정 버퍼가 특정 커널을 호스팅하는 코어에 이웃하는 메모리 모듈에 배치되어야 하는지 여부를 나타낼 수 있다. 데이터 흐름 그래프 전체에 또 다른 유형의 제약 조건이 적용될 수 있다. 이러한 유형의 제약 조건을 사용하여, 프로그래머는 컴파일러가 SoC에 그래프 객체(예를 들어, 커널, 포트, 통신 링크 등)를 배치하는 방법을 제어할 수 있다.

프로그래머는 하드웨어 애그노스틱일 수 있는 성능 제약 조건을 제공할 수도 있다. 예를 들어, 프로그래머는 그래프의 대기 시간이 특정 수의 처리 사이클보다 작게 되기를 원할 수 있다. 컴파일러는 그래프의 구현을 테스트하여 성능 제약 조건을 충족하는지 여부를 결정하고, 그렇지 않은 경우, 제약 조건이 충족될 때까지 그래프를 재구성할 수 있다. 예를 들어, 컴파일러는 이전에 동일한 코어에서 같은 위치에 있는 경우, 2 개의 커널을 2 개의 상이한 코어로 분할하거나, 버퍼를 공유 메모리 모듈로 이동시켜, 커널은 DPE 어레이에서 인터커넥트를 사용할 필요 없이 데이터에 직접 액세스할 수 있다.

다른 실시예에서, 제약 조건은 코어/포트/FIFO/메모리 모듈의 활용 또는 선호되는 FIFO 깊이를 규정할 수 있다. 컴파일러는 그래프의 구현을 테스트하여, 이것이 성능 제약 조건을 충족하는지 여부를 결정하고, 그렇지 않은 경우, 그래프를 재구성할 수 있다. 성능 제약 조건이 있는 경우, 컴파일러는 제약 조건이 충족되는지 여부를 결정하기 위해 종종 그래프를 테스트하므로, 이러한 제약 조건은 또한 파생된 제약 조건으로 지칭될 수 있다.

블록 1310에서, 컴파일러는 제약 조건에서의 고유한 이름을 사용하여 제약 조건에 대응하는 그래프 객체를 식별한다. 이 예에서, 그래프 객체의 각각에는 고유한 이름(예를 들어, 각 커널, 통신 링크, 포트 등)이 할당될 수 있다. 제약 조건을 포맷할 때, 프로그래머는 고유 이름을 사용하여 제약 조건이 적용되는 그래프 객체를 컴파일러에 알릴 수 있다.

일 실시예에서, 프로그래머는 인덱스의 각 그래프 객체에 고유한 이름을 제공할 수 있다. 그 후, 인덱스는 컴파일러에 액세스할 수 있다. 다른 실시예에서, 컴파일러는 고유한 이름을 그래프 객체에 할당한다. 예를 들어, 컴파일러는 그래프의 모든 그래프 객체의 계층적 트리를 형성하고 루트에서 잎까지 트리를 트래버싱하여 객체에 고유한 이름을 할당할 수 있다. 계층적 트리는 프로그래머에도 액세스할 수 있으므로, 고유한 이름을 사용하여 특정 객체에 제약 조건을 할당할 수 있다.

블록(1315)에서, 컴파일러는 소스 코드를 컴파일할 때 제약 조건을 만족하도록 그래프 객체를 구성한다. 제약 조건에 따라 그래프 객체를 배치하는 다양한 예가 도 14에 도시된다.

도 14는 일 예에 따른, 사용자 규정된 제약 조건을 사용하여 구현된 그래프 객체를 갖는 DPE 어레이(105)이다. 이 예에서, 그래프 객체는 커널 a-d와 버퍼(905)를 포함한다. 일 실시예에서, 컴파일러는 프로그래머에 의해 제공된 위치 제약 조건에 응답하여 커널 a를 코어(210H)에 배치한다. 예를 들어, 프로그래머는 코어(210)에 할당된 고유 어드레스(1405)를 사용하여 컴파일러에게 코어(210H)에 커널 a를 배치하도록 지시할 수 있다. 즉, 제약 조건은 코어(210H)에 커널 a를 배치하도록 컴파일러에게 지시하는 코어(210H)(즉, 2,1)의 어드레스(1405)를 포함할 수 있다.

도 14는 또한 커널 b 및 d가 동일한 코어(210E) 상에 공동 배치되어야 함을 나타내는 공동 배치 제약 조건(1415)을 예시한다. 프로그래머는 컴파일러가 코어(210E)에 커널 b와 d를 둘 다 배치하도록(예를 들어, 어드레스 1,1을 사용하여) 소스 코드에서 제약 조건을 포맷할 수 있지만, 다른 실시예에서, 제약 조건은 커널 b 및 d를 호스트하기 위한 최상의 코어(210)를 자체적으로 식별할 수 있는 컴파일러 프리덤(freedom)을 제공하는 특정 코어를 규정하지 않을 수 있다.

도 14는 또한 커널 c 및 커널 b를 인접 코어, 즉 코어(210D 및 210E)에 배치하도록 컴파일러에게 지시하는 상대 위치 제약 조건(1410)을 예시한다. 다시, 프로그래머는 DPE 어레이(105)의 코어(210) 중 어느 2개가 커널 c 및 b를 호스팅해야 하는지를 나타내기 위해 제약 조건을 포맷할 수 있지만, 다른 실시예에서, 컴파일러는 가용성과 같은 다른 메트릭에 기초하여 사용할 코어(210)를 선택할 자유를 갖는다.

또한, 도 14는 프로그래머에 의해 제공된 제약 조건에 따라 버퍼(905)를 배치하는 것을 예시한다. 일 실시예에서, 프로그래머는 버퍼(905)가 예를 들어 타일(0,1)의 어드레스를 사용하여 메모리 모듈(230B)에 배치되어야 한다는 제약 조건을 규정한다. 대안적으로, 제약 조건은 어레이(105)에서 메모리 모듈의 절대 위치를 제공하지 않을 수 있지만, 대신에 버퍼(905)가 커널 d에 대응하는 코어에 의해 직접 액세스될 수 있는 메모리 모듈(230)에 배치되도록 규정할 수 있다. 그렇게 함으로써 컴파일러는 코어(210E)를 둘러싸는 4 개의 메모리 모듈(230) 중 하나를 선택하여 가용성과 같은 메트릭을 사용하여 버퍼를 구현할 수 있다. 다른 실시예에서, 복수의 버퍼는 제약 조건에 의해 동일한 메모리 그룹으로 매핑될 수 있다(예를 들어, 커널 세트의 스택/예약된 메모리는 동일한 메모리 그룹으로 매핑된다).

도 14는 DPE 어레이(105)에 그래프 객체를 배치하는 데 사용될 수 있는 몇 가지 위치 제약 조건만을 예시한다. 위에서 언급한 바와 같이, 프로그래머는 프로그래머의 선호도에 따라 그래프를 커스터 마이징하는 데 사용될 수 있는 도 14에 예시되지 않은 다른 외부 제약 조건을 제공할 수 있다(또는 컴파일러가 다른 파생된 제약 조건을 식별할 수 있음). 추가 제약 조건 유형은, 경로가 한 지점에서 다른 지점으로 데이터를 전송하는 데 사용해야 하는 라우팅 리소스, 데이터 경로가 회선 교환 또는 패킷 교환인지 여부, 데이터 경로에 삽입되어야 하는 지연 시간을 포함할 수 있다. 일부 제약 조건은 컴파일러가 컴파일된 코드를 생성할 때 더 나은 결정을 내리는 데 도움을 줄 수 있다. 다른 제약 조건은 메모리 충돌을 피하기 위해 버퍼간 배치 제약 조건과 같은 SoC의 성능을 향상시킬 수 있다.

방법(1300)으로 돌아가서, 블록 1320에서, 컴파일러는 제약 조건에 따라 SoC의 이종 처리 시스템에서 데이터 흐름 그래프를 구현한다. 위에서 언급한 바와 같이, 컴파일러는 데이터 흐름 그래프를 실행하기 위해 SoC에서 이종 처리 시스템을 구성하는 비트스트림 및 2진 코드를 생성할 수 있다.

일 실시예에서, 데이터 흐름 그래프는 복수의 SoC(예를 들어, 복수의 FPGA)에 걸쳐 확장될 수 있다. 이 경우에, 그래프 소스 코드는, 제1 SoC의 이종 프로세싱 시스템에서 제1 그래프 객체를 구성하기 위해 사용되는 제1 제약 조건 그리고 제2 SoC의 이종 프로세싱 시스템에서 제2 그래프 객체를 구성하기 위해 사용되는 제2 제약 조건을 포함할 수 있다.

도 15는 일 예에 따른 유전되는 추상 인터페이스(1505)이다. 추상 인터페이스(1505)는 이 예에서, 포트(1515)를 포함하는 필터 체인(1510)에 대한 인터페이스를 규정한다. 인터페이스(1505)는 프로그래머에 의해 상이한 방식으로 구현될 수 있는 소프트웨어 클래스에 의해 규정될 수 있다. 예를 들어, 필터 체인(1520)은 추상 인터페이스(1505)를 이어 받고, 커널 a 및 b를 포함한다. 대조적으로, 필터 체인(1525)은 또한 추상 인터페이스(1505)를 이어 받지만, 커널 a, b 및 c를 포함한다. 예를 들어, 필터 체인(1525)은 필터 체인(1520)보다 더 세분화된 처리를 요구할 수 있다. 추상 인터페이스(1505)는 객체 지향 프로그래밍 언어를 사용하여 규정될 수 있기 때문에, 인터페이스(1505)는 이어 받게 되어 다른 구현을 위해 사용될 수 있습니다.

도 16은 일 예에 따른, 복수의 서브 그래프(1505)를 갖는 데이터 흐름 그래프(1600)이다. 도 16은 데이터 흐름 그래프(1600)에 대한 소스 코드가 서브 그래프의 두 가지 인스턴스 즉, 서브 그래프 1505A 및 1505B를 포함한다는 점에서 도 15와 다르다. 즉, 서브 그래프(1505)는 1회 규정될 수 있고, 그 서브 그래프(1505)의 복수의 인스턴스화는 그래프(1600)에 삽입될 수 있다. 예를 들어, 그래프(1600)에 의해 규정된 수신기 체인은, 도 15의 1채널 시스템보다는 2채널 시스템에 대응하기 때문에, 서브 그래프(1505)에 의해 규정된 필터 중 2개를 사용할 수 있다. 이러한 방식으로, 서브 그래프(1505)는 그래프 소스 코드와 별도로(예를 들어, 자체 파일에서) 규정된 후, 임의의 횟수로 인스턴스화될 수 있다.

도 16에서, 커널 b는 데이터 윈도우를 서브 그래프(1505A)로 송신하기 위한 제1 포트(1510B) 및 데이터 윈도우를 서브 그래프(1505B)로 송신하기 위한 제2 포트(1510A)를 포함하도록 수정된다. 이는 소스 코드에서 프로그래머에 의해 규정될 수 있다.

도 17은 일 예에 따른, 제약된 데이터 흐름 그래프(1700)이다. 도 17은 도 16에 예시된 그래프(1600)를 포함하며, 이는 서브 그래프(1505)의 복수의 인스턴스화를 포함한다. 그러나, 그래프(1600)는 제약된 데이터 흐름 그래프(1700) 내에 포함된다. 일 실시예에서, 제약된 그래프(1700)는 로직 설계에 제약 조건을 추가하는 래퍼 그래프이다. 즉, 제약된 그래프(1700)(이는 포트(1705)를 사용하여 액세스 가능함) 내에 그래프(1600)를 캡슐화함으로써, 프로그래머는 그래프(1600)의 실행에 전체 제약 조건을 추가할 수 있다. 또한, 컴파일러는 그래프(1600)를 다른 데이터 흐름 그래프로 인스턴스화될 수 있는 다른 구현으로 변환할 수 있는 제약된 그래프(1700)로부터 제약 조건을 자동으로 전파한다.

도 18은 일 예에 따른, 복수의 소스로부터의 제약 조건을 병합하기 위한 제약 조건 처리 흐름(1800)이다. 흐름(1800)은 위에서 논의된 제약 조건 유형 중 임의의 것을 포함할 수 있는 제약 조건(1810)을 포함하는 그래프 소스 코드(1805)를 포함한다. 또한, 흐름(1800)은 위에서 논의된 임의의 제약 유형을 다시 포함할 수 있는 다른 소스(1815)로부터의 제약을 포함한다. 이러한 후자의 제약 조건은 JSON(JavaScript Object Notation) 파일 포맷, TCL 파일 포맷으로, 또는 GUI(그래픽 사용자 인터페이스)를 사용하여 규정될 수 있다. 이와 같이, 다른 소스(1815)로부터의 제약 조건은, 소스 코드(1805) 내에 포함되지 않지만, 별도의 파일이다.

제약 조건 처리(1820) 동안에, 컴파일러는 소스 코드(1805)의 제약 조건(1810)을 다른 소스(1815)로부터의 제약 조건과 병합한다. 일 실시예에서, 제약 조건(그들이 규정된 위치에 관계없음)은 포맷을 가지므로, 이러한 제약 조건은 컴파일러의 내부 데이터 구조와 병합될 수 있다. 일 실시예에서, 프로그래머는 각 서브 그래프에 대한 제약 조건을 개별적으로 지정할 수 있고, 컴파일러는 이러한 제약 조건을 판독하고 소스 코드(1805)에 의해 규정된 부모 그래프 프로그램과 병합하는 것을 처리할 수 있다.

파티셔너, 맵퍼 및 라우터와 같은 제약 조건 클라이언트(1825)는, 병합된 제약 조건을 수신하고 솔루션(1830)이 제약 조건을 충족한다는 것을 보장한다. 즉, 제약 조건 클라이언트(1825)는 SoC의 데이터 흐름 그래프의 구현이 소스 코드(1805)에 포함된 제약 조건(1810) 뿐만 아니라 다른 소스(1815)로부터의 제약 조건을 충족한다는 것을 보장한다.

제어 API

도 19는 일 예에 따른, SoC 상의 데이터 흐름 그래프를 구현하기 위한 컴퓨팅 시스템(1900)의 블록도이다. 컴퓨팅 시스템(1900)은 본 명세서에서 상세하게 논의되지 않은, 도 4에서 위에서 논의된 많은 동일한 구성요소를 포함한다. 그러나, 도 19는 컴퓨팅 시스템(1900)이 도 4에 예시된 컴퓨팅 시스템에 있거나 없을 수 있는 제어 API(1905)를 포함한다는 점에서 도 4와 상이하다. 도시된 바와 같이, 제어 API(1905)는 제어 소스 코드(430)에 배치된다.

일반적으로, 프로그래머는 제어 API(1905)를 사용하여 SoC(100) 상의 데이터 흐름 그래프(440)의 실행을 제어하는 파라미터를 변경할 수 있다. 즉, 본 명세서의 실시예는 API(1905) 및 대응하는 방법을 사용하여. 제어 소스 코드(430)로부터 컴파일된 로컬 제어 프로그램을 통해 SoC의 이종 프로세싱 시스템에서 실행되거나 PS 자체에서 제어 소스 코드를 실행하는 사용자 애플리케이션(예를 들어, 데이터 흐름 그래프(440))을 제어, 상호작용, 및 적어도 부분적으로 재구성한다. 제어 APl(1905)를 사용하여, 사용자는 로컬 객체와 같은 원격 실행 그래프를 직접 조작하고 이들에 대한 제어 동작(예를 들어, 그래프의 로딩 및 초기화에 대해, 적응 제어를 위한 파라미터를 동적으로 조정; 애플리케이션 파라미터, 시스템 상태 및 이벤트의 모니터링; 플랫폼의 분산 메모리 경계에 걸쳐 데이터를 판독 및 기록하기 위한 동작을 스케쥴링; 서브 시스템의 실행 라이프-사이클을 제어; 및 새로운 서브 시스템에 대한 컴퓨팅 리소스를 부분적으로 재구성)을 수행할 수 있다.

예를 들어, SoC(100)의 커널 또는 다른 그래프 객체는, 이러한 객체의 동작을 제어하는 이득 또는 필터 계수와 같은 파라미터를 가질 수 있다. 이러한 파라미터는 호스트 또는 SoC 자체에서 실행되는 제어 프로그램을 사용하여 동적으로 제어될 수 있다. 컴파일러(435)는 파라미터를 변경하도록 제어 프로그램을 구성할 수 있고, 이는 프로그래머가 하이 레벨(소스 코드를 사용함)에서 API(1905)를 표현할 수 있는 반면에 컴파일러(435)가 레지스터의 구성, 경로 식별, 그래프 객체의 위치 식별 등과 같은 파라미터를 조정하기 위한 하드웨어 세부사항을 처리한다는 것을 의미한다.

유리하게, 컴파일러(435)는 API(1905)가 원하는 기능을 수행할 수 있도록, 드라이버(1910), 레지스터, 및 SoC(100)의 다른 하드웨어를 구성할 수 있다. 예를 들어, 드라이버(1910)는 데이터 흐름 그래프(440)에서 커널을 실행하는 DPE(110) 중 하나에, SoC(100)의 DDR 메모리에 있는 데이터를 판독하기 위해 DMA를 수행하는 데 사용될 수 있다. 드라이버(1910)가 PS(130)의 일부로서 예시되어 있지만, 다른 실시예에서, 드라이버(1910)는 PL(125)의 제어기를 사용하거나, 네트워크를 사용하여 원격 제어기로부터 SoC(100)로 송신되는 제어 신호를 통해 구현될 수 있다.

제어 API(1905)가 없으면, 프로그래머는 드라이버(1910)를 직접 구성해야 하며, 드라이버는 프로그래머가 커널(예를 들어, 호스트 DPE)의 위치뿐만 아니라 커널에 도달하는 경로를 알도록 요청할 수 있다. 대신에, 컴파일러(435)는 제어 소스 코드(430)에서 대응하는 API(1905)를 검출하는 것에 응답하여 드라이버(1910)를 구성할 수 있다. 즉, API(1905)를 규정할 때, 프로그래머는 단순히 그래프 객체(예를 들어, 특정 커널 또는 커널 포트)를 식별하고, 컴파일러(435)는 나머지를 수행 - 예를 들어, DMA를 수행하도록 드라이버(1910) 및 프로그램 레지스터를 구성할 수 있다.

도 20a 및 20b는 예들에 따른, SoC 상의 데이터 흐름 그래프의 실행을 제어하기 위한 제어 API들을 예시한다. 도 20a는 데이터 흐름 그래프의 동작을 제어하는데 사용될 수 있는 제어 API(1905)의 목록을 예시한다. 도 20a는 그 목적을 설명하는 각 API(1905) 옆에 주석을 포함한다. 예를 들어, graph() API는 빈(empty) 데이터 흐름 그래프 클래스 생성자를 규정한다. 모든 사용자 규정된 그래프는 이 클래스의 확장이다.

init() API는 데이터 흐름 그래프를 초기화하고, run() API는 그래프를 실행하고, wait() API는 이전 실행을 완료하거나 복수의 사이클 동안 그래프를 대기하여 그래프를 일시 중지하고, resume( ) API는 일시 중지 후 그래프를 재개하고, end() API는 마지막 실행이 완료될 때까지 대기한 후, DPE를 비활성화시킨다. 따라서, 이러한 API(1905)를 사용하여, 프로그래머는 그래프가 동작을 시작하는 시기, 작동하는 시간 및 그래프를 종료할 수 있는 시간을 제어할 수 있다.

update() API는 프로그래머로 하여금 그래프 개체를 지정함으로써(예를 들어, input_port & p 포인터를 사용함으로써) 데이터 흐름 그래프의 런타임 파라미터를 업데이트하도록 허용한다. 제공된 정보를 사용하여, 컴파일러는 아래에 논의된 트리거를 사용하여 업데이트를 수행하도록 SoC의 하드웨어를 구성할 수 있다.

read() API를 사용하여, 프로그래머는 실행 중인 데이터 흐름 그래프로부터 런타임 파라미터를 판독할 수 있다. 이는 동적 데이터 종속 결정에 기초하여 그래프 실행을 제어하는데 특히 유용하다.

도 20b는 프로그래밍 모델의 일부일 수 있는 다른 제어 API(1905)를 예시한다. 도 20b는 SoC에서 DPE 어레이와 DDR 메모리 사이에서 데이터를 이동하기 위한 특수 API를 가진 글로벌 메모리 입/출력(GMIO) 클래스를 포함한다. 예를 들어, init() API는, DDR 메모리에 존재하는 메모리 어드레스의 집합을 제공함으로써 GMIO 객체를 초기화한다. gm2me_nb() API는 심(shim)의 DMA 레지스터를 사용하여 글로벌 메모리로부터 DPE 어레이로 데이터를 전송할 수 있다. 일 실시예에서, 컴파일러는 GMIO 클래스 내에서 API(1905)를 수행하기 위해 심(shim)의 레지스터를 구성한다. 또한, 이러한 API(1905)는 비차단 커맨드이며, 이는 PS(이는 제어 프로그램을 호스팅할 수 있음)가 GMIO 판독 및 기록과 동시에 다른 기능을 수행할 수 있음을 의미한다. 일 실시예에서, GMIO API는, SoC가 동일한 세트의 DDR 메모리를 사용하여, 데이터를 DPE 어레이로 전송하고 그 어레이로부터 데이터를 판독할 수 있게 한다. 즉, 프로그래머는 GMIO API를 사용하여 DPE 어레이의 DDR 메모리로부터 데이터를 판독하고, 상기 DPE 어레이는 데이터를 처리하고, 처리된 데이터를 동일한 DDR 메모리에 저장할 수 있다.

도 20b는 또한 PL과 DPE 어레이 사이에서 데이터를 이동시키기 위한 API를 갖는 프로그래밍 가능한 로직 입/출력(PLIO) 클래스를 포함한다. PLIO API는 DPE 어레이와 입/출력 파일 간에 데이터가 전송되는 시뮬레이션 환경에서만 사용될 수 있기 때문에, GMIO API보다 더 간단하다.

도 20b는 또한 성능을 모니터링하거나 특정 그래프 객체(예를 들어, GMIO 포트의 특정 커널)에 대한 이벤트 추적을 실행하기 위한 API를 갖는 이벤트 클래스를 갖는다. 이벤트 API는 프로그래머로 하여금 특정 하드웨어 이벤트를 추적하게 하고, 하드웨어 이벤트 발생 횟수를 계산하고, 집계 성능 메트릭을 측정할 수 있다. 일 예에서, 프로그래머는 데이터 흐름 그래프의 입력 및 출력을 추적함으로써 그래프의 대기 시간을 측정할 수 있다. 예를 들어, API에 대한 응답으로, 컴파일러는 제1 데이터가 데이터 흐름 그래프에 입력되는 시점과 제1 데이터가 데이터 흐름 그래프에 의해 출력되는 시점 사이의 처리 사이클의 수를 계산하는 성능 카운터를 설정할 수 있다. 다른 예에서, 프로그래머는 DPE 내에서 실행되는 그래프의 처리량을 측정할 수 있다. 컴파일러는 몇 번의 그래프 실행의 반복 동안 생성된 데이터 항목의 수와 사이클 수를 계산하는 성능 카운터를 설정할 수 있다.

도 21은 일 예에 따라, DPE 어레이(105)를 상이한 영역으로 논리적으로 분할하는 것을 도시한다. 이 실시예에서, TopRegion(2105)은 전체 DPE 어레이(105) 및 그 DPE(110)를 포함한다. RC영역(2110)은 DPE 어레이(105)의 열의 세브세트를 포함한다. 영역(2115A 및 2115B)은 RC영역(2110) 내의 서브 영역을 규정한다. 이러한 방식으로, DPE 어레이(105)는 영역의 계층으로 분할될 수 있다. 이 예에서, RC영역(2110)은 TopRegion(2105)의 서브 영역인 반면에, 영역(2115A 및 2115B)은 RC영역(2110) 내에 포함된 서브 영역이다.

위에서 논의된 API 및 제약 조건을 사용하여, 프로그래머는 어레이(105)의 다른 영역에 다른 데이터 흐름 그래프를 할당할 수 있다. 예를 들어, 복수의 데이터 흐름 그래프는, 하루의 시각에 따라, 다른 수의 안테나를 사용하여 데이터를 수신할 수 있는 무선 송수신기로부터 획득된 디지털 데이터를 처리할 수 있다. 안테나에 대응하는 데이터 흐름 그래프를 비활성화 또는 활성화하기 위해, 프로그래머는 특정 안테나에 대응하는 프로세스 제어가 선택적으로 활성화 및 비활성화될 수 있도록, 개별 RC영역(2110)에 각 데이터 흐름 그래프를 배치하기 위해 배치 제약 조건을 사용할 수 있다. 따라서, 다른 영역에 다른 데이터 흐름 그래프를 배치하는 것은, 프로그래머가 제어할 수 있으므로, 다른 영역에서 동작하는 데이터 흐름 그래프에 영향을 주지 않고 하나의 데이터 흐름 그래프가 활성화되거나 비활성화될 수 있다. 일 실시예에서, 프로그래머는 RCGraph 클래스로부터 유도된 복수의 논리적으로 독립적인 컨테이너 그래프를 제공하고 복수의 데이터 흐름 그래프를 그들에 할당한다. 그 후, 컴파일러는 각 데이터 흐름 그래프를 독립적으로 제어할 수 있도록, 각 컨테이너 그래프에 대한 특정 하드웨어 영역을 결정한다.

다른 실시예에서, 프로그래머는 단일 컨테이너 그래프 내에서 복수의 대안적인 그래프를 설정하기 위해 위에서 논의된 제어 API를 사용할 수 있다. 대안적인 그래프는, 동일한 논리적 컨테이너 그래프를 공유하고, 이에 따라 동일한 하드웨어 영역을 공유하는 데이터 흐름 그래프이다. 컨테이너 그래프의 대안적인 그래프 수가, 1 보다 크면, 이는 다른 데이터 흐름 그래프가 동일한 하드웨어 영역을 공유하지만 다른 시간에 실행된다는 것을 의미한다. 일 실시예에서, 컨테이너 그래프 및 특정 영역에 대한 대안적인 데이터 흐름 그래프의 할당은, 컴파일러에 의해 SoC에 제공되는 패키지 바이너리에서 규정된다.

도 22a는 일 예에 따른 데이터 흐름 그래프의 실행을 동적으로 변경하는 것을 예시한다. 즉, 도 22a는 그래프(2200)가 데이터를 처리하는 방법을 변경하기 위해 데이터 흐름 그래프(2200)를 동적으로 재구성(예를 들어, 런타임 파라미터를 변경)하기 위해 하나 이상의 제어 API를 사용하는 것을 예시한다. 이 재구성은 기본 하드웨어를 변경하지 않고 발생할 수 있다. 즉, SoC가 초기화된 후, 데이터 흐름 그래프(2200)는 하드웨어를 재구성할 필요 없이 즉석에서 다른 상태 사이를 전환할 수 있다.

데이터 흐름 그래프(2200)는 전용 LTE20 채널(2205), 전용 LTE10 채널(2215) 및 런타임 파라미터(2220)를 사용하여 LTE20 채널과 LTE10 채널 사이에서 선택적으로 변경될 수 있는 재구성 가능한 채널(2210)을 포함하는 처리 방식을 예시한다. 예를 들어, 채널(2210)을 LTE20 채널로서 구성하기 위해, 파라미터(2220)는 하프-밴드 필터로부터 수신된 데이터를 출력하도록 mux(2230)를 제어한다. 제어 API는, 채널(2210)이 LTE10 채널(2215)과 유사한 데이터를 처리하도록, mux(2230)가 하프-밴드 필터 및 지연 정렬 블록에 의해 출력된 데이터를 무시하도록 파라미터(2220)를 변경할 수 있다.

일 실시예에서, 데이터 흐름 그래프(2200) 내의 복수의 재구성 가능한 대안이, SoC의 동일한 영역에 할당될 수 있다. 이것은 도 22b에 예시되어 있다. 예를 들어, 그래프(2250)는 SoC의 상부영역(2255)에 할당될 수 있다. 대안적으로, 그래프(2200)의 상이한 채널은 상이한 영역에 할당될 수 있다. 이 예에서, mux(2230)를 포함하는 재구성 가능한 채널(2210)을 갖는 대신, 그래프(2250)는 재구성 가능한 컨테이너 RC영역(2260)에 대한 두 가지 대안으로 구축된다. 하나의 대안 Alt0(2265)은 LTE20 채널이고, 다른 대안 Alt1(2270)은 믹서(2275)와 함께 2 개의 LTE10 채널을 운반한다. Alt0 2265의 고정 LTE20 채널은 2 개의 LTE10 채널이 할당된 영역 또는 영역들과 별도로, SoC의 그 자체 영역에 할당하거나, 상부영역(2255의) 일부로서 만들어질 수 있다. 따라서, RC영역(2260)이 LTE20 채널로서 기능해야 할 때, 제어 API는 그래프 Alt0(2265)을 로드하도록 영역을 재구성할 수 있다(다른 영역에 배치된 전용 LTE20 채널에 영향을 주지 않음). 그러나, RC영역(2260)이 2개의 LTE10 채널로서 기능해야 할 때, 제어 API는 대체 그래프 Alt1(2270)을 로드하도록 영역을 재구성할 수 있다. 그렇게 하면 mux(2230)와 같은 채널(2210)을 동적으로 재구성하는 데 사용되는 도 22a에 예시된 회로를 피하고, 2 가지 대안에 대해 동일한 DPE 리소스를 재사용하지만(이는 그래프(2200)가 SoC에서 사용하는 공간의 양을 줄일 수 있음), 일반적으로 mux(2230)에 대한 파라미터(2220)를 제어하는 것보다 LTE20 실시예와 LTE10 실시예 사이의 영역에서 하드웨어를 재구성하는 데 더 많은 시간이 소요된다.

도 23a 및 23b는 예에 따른 트리거된 파라미터 및 비동기 파라미터를 도시한다. 예를 들어, 스트리밍 데이터에 대응하는 윈도우 및 스트림과 달리, 파라미터는 비스트리밍 데이터를 사용하여 데이터 흐름 그래프의 실행을 제어하도록 사용될 수 있다. 일 실시예에서, 프로그래머는 데이터 흐름 그래프의 파라미터를 변경하기 위해 커널 실행의 시작시에 동기화 트리거를 사용한다. 다른 실시예에서, 파라미터의 변경은 커널의 실행과 비동기적으로 일어날 수 있다. 일 실시예에서, 제어 프로그램(PS에서 실행하든 호스트에서 실행하든)은 파라미터에서 트리거된 또는 비동기식 변경을 개시한다. 다른 실시예에서, 프로그램 가능한 로직은 파라미터의 트리거된 또는 비동기식 변경을 개시한다. 트리거를 사용하여 변경될 수 있는 파라미터의 예는 함수 또는 방법 호출의 파라미터 또는 윈도우의 크기를 변경하는 것을 포함할 수 있다.

도 23a는 커널이 대응하는 기능이 호출될 때마다 새로운 파라미터를 대기하는 트리거된 파라미터를 예시한다. 결과적으로, 커널은 제어 프로그램(2305)이 트리거된 파라미터를 제공할 때까지 실행되지 않는다. 예를 들어, 제어 프로그램(2305)은 커널(2310)을 실행하는 DPE에 의해 수신되는 파라미터의 핑 버퍼에 대한 기록 트랜잭션(2315A)을 생성한다. 이에 응답하여, 커널(2310)은 실행 블록(2325A) 동안 데이터를 처리한다. 동시에, 제어 프로그램(2305)은 시간 블록(2320) 동안 다른 활동을 자유롭게 수행할 수 있다. 즉, 제어 프로그램(2305)은 트리거된 파라미터 값을 핑 버퍼(이는 비차단임)로 송신할 수 있고, 시간 블록(2320) 동안 다른 작업을 수행할 수 있다.

특히, 커널(2310)이 실행 블록(2325A)을 완료할 때, 그 데이터가 그 입력에서 이용가능하더라도 더 많은 데이터를 즉시 처리하기 시작하지 않는다. 대신에, 커널(2310)은 실행 블록(2325B)을 수행하기 위해 트리거된 파라미터(이는 기록 트랜잭션(2315A)에서와 동일한 값 또는 다른 값을 가질 수 있음)를 포함하는 퐁(pong) 버퍼에서 제2 기록 트랜잭션(2315B)을 수신할 때까지 대기한다. 실행 블록(2325B)을 사용하여 완료되면, 커널(2310)은 실행 블록(2325C)을 시작하기 위해 기록 트랜잭션(2315C)에서 트리거된 파라미터를 수신할 때까지 다시 대기한다. 이러한 방식으로, 트리거된 파라미터는 제어 프로그램(2305)이 각 실행 블록 전에 업데이트된 파라미터를 커널(2310)에 송신할 수 있게 한다.

도 23b는 커널(2310)이 이전에 수신된 파라미터를 사용하여 실행되는 비동기 파라미터를 예시한다. 도시된 바와 같이, 제어 프로그램(2305)은 기록 트랜잭션(2315D)을, 커널(2310)이 실행 블록(2325D) 동안 데이터를 처리할 때 사용할 업데이트된 파라미터를 포함하는 핑 버퍼로 송신한다. 동시에, 제어 프로그램(2305)은 도 23a에서와 같이 시간 블록(2320) 동안 다른 활동을 수행할 수 있다. 그러나, 도 23a와 달리, 실행 블록(2325D)이 완료되면, 커널(2310)은 실행 블록(2325E 및 2325F) 동안 데이터 처리를 즉시 시작할 수 있다. 커널(2310)이 제어 프로그램(2305)으로부터 새로운 파라미터를 수신하지 않았기 때문에, 커널(2310)은 실행 블록(2325D) 동안 동일한 파라미터를 사용하여 실행 블록(2325E 및 2325F) 동안 입력 데이터를 처리한다.

실행 블록(2325E) 동안, 제어 프로그램(2305)은 커널(2310)에 대한 업데이트된 파라미터를 포함하는 퐁 버퍼에 새로운 기록 트랜잭션(2315E)을 송신한다. 업데이트된 파라미터 값은 기록 트랜잭션(2315E)이 완료된 후 커널(2310)에서 사용할 수 있다. 따라서, 커널(2310)이 실행 블록(2325G)을 시작할 때, 커널(2310)은 업데이트된 파라미터[이는 블록(2325D-F) 동안에 사용된 파라미터의 값과 다를 수 있음]를 사용한다. 이러한 방식으로, 커널(2310)은 제어 프로그램(2305)이 업데이트된 파라미터를 커널(2310)로 송신할 때까지 동일한 파라미터를 사용하여 계속해서 실행할 수 있다.

일 실시예에서, 커널이 호출될 때, 컴파일러는 커널이 수신된 데이터의 처리를 시작하고 모든 데이터가 데이터 창을 출력하기 전에 전송될 준비가 되기 전에 모든 데이터가 이용 가능함을 보장하는 잠금 기준을 생성한다. 그러나 비동기 통신의 경우, 그래프는 이러한 검사 중 하나를 수행할 필요가 없지만, 사용자는 판독할 입력 윈도우를 획득하거나, 기록할 윈도우를 출력할 때 사용되는 기준을 규정하는 API를 생성할 수 있다. 달리 말하면, 사용자에 의해 제공된 기준은 커널이 동기화될 때의 포인트를 규정한다. 예를 들어 도 6에서, 커널 e에서 커널 b로의 연결은 비동기식이다. 따라서 커널 e는 윈도우를 준비할 수 있고 커널 b는 (API에서 사용자에 의해 제공된 기준을 사용하여) 커널 b와 동기화하기 전에 처음 몇 프레임을 건너뛸지 여부를 결정한다. 즉, 사용자에 의해 제공된 기준을 사용하여 윈도우를 수신하거나 출력할 때를 결정하는 것은 각각 커널 b와 e에 달려 있다.

이전에, 본 개시내용에 제시된 실시예를 참조하였다. 그러나, 본 개시 내용의 범위는 설명된 특정 실시예들에 제한되지 않는다. 그 대신, 상이한 실시예와 관련이 있든 그렇지 않든, 설명된 특징 및 요소의 임의의 조합이 예상된 실시예를 구현하고 실행하도록 고려된다. 또한, 본 명세서에 개시된 실시예가 다른 가능한 솔루션 또는 종래 기술에 비해 이점을 달성할 수 있지만, 특정 이점이 주어진 실시예에 의해 달성되는지 여부는 본 개시 내용의 범위를 제한하지 않는다. 따라서, 앞의 양태, 특징, 실시예 및 이점은 단지 예시일 뿐이며 청구범위(들)에서 명시적으로 인용된 경우를 제외하고는 첨부된 청구범위의 요소 또는 제한으로 간주되지 않는다.

당업자에 의해 인식되는 바와 같이, 본 명세서에 개시된 실시예는 시스템, 방법 또는 컴퓨터 프로그램 제품으로서 구현될 수 있다. 따라서, 양태는 전체 하드웨어 실시예, 전체 소프트웨어 실시예(펌웨어, 상주 소프트웨어, 마이크로코드 등을 포함함) 또는 모두 일반적으로 “회로”, “모듈” 또는 “시스템”으로서 본 명세서에서 지칭될 수 있는 소프트웨어 양태 및 하드웨어 양태를 조합하는 실시예의 형태를 취할 수 있다. 또한, 양태들은, 구현된 컴퓨터 판독 가능한 프로그램 코드를 갖는 하나 이상의 컴퓨터 판독 가능한 매체(들)에 구현된 컴퓨터 프로그램 제품의 형태를 취할 수 있다.

하나 이상의 컴퓨터 판독 가능한 매체(들)의 임의의 조합이 이용될 수 있다. 컴퓨터 판독 가능한 매체는 컴퓨터 판독 가능한 신호 매체 또는 컴퓨터 판독 가능한 저장 매체일 수 있다. 컴퓨터 판독 가능한 저장 매체는, 예를 들어 전자, 자기, 광학, 전자기, 적외선, 또는 반도체 시스템, 장치, 또는 디바이스, 또는 전술한 것의 임의의 적절한 조합일 수 있지만, 이에 제한되지는 않는다. 컴퓨터 판독 가능한 저장 매체의 더 구체적인 예(비제한적 목록)는, 이하의 내용 즉, 하나 이상의 와이어를 갖는 전기 연결, 휴대용 컴퓨터 디스켓, 하드 디스크, RAM(Random Access Memory), 판독-전용 메모리(ROM), 소거 가능한 프로그램 가능한 판독-전용 메모리(EPROM 또는 플래시 메모리), 광섬유, 휴대용 컴팩트 디스크 판독-전용 메모리(CD-ROM), 광학 저장 디바이스, 자기 저장 디바이스, 또는 전술한 것의 임의의 적절한 조합을 포함할 수 있다. 이 문서의 맥락에서, 컴퓨터 판독 가능한 저장 매체는, 명령어 실행 시스템, 장치 또는 디바이스에 의해 또는 이와 관련하여 사용하기 위한 프로그램을 포함하거나 저장할 수 있는 임의의 유형의 매체이다.

컴퓨터 판독 가능한 신호 매체는 예를 들어 기저대역에서 또는 반송파의 일부로서 내부에 구현된 컴퓨터 판독 가능한 프로그램 코드를 갖는 전파된 데이터 신호를 포함할 수 있다. 이러한 전파된 신호는 전자기, 광학 또는 이들의 임의의 적절한 조합을 포함하지만 이에 제한되지 않는 다양한 형태들 중 임의의 것을 취할 수 있다. 컴퓨터 판독 가능한 신호 매체는 컴퓨터 판독 가능한 저장 매체가 아니고 명령어 실행 시스템, 장치, 또는 디바이스에 의해 또는 이와 관련하여 사용하기 위한 프로그램을 통신, 전파, 또는 전송할 수 있는 임의의 컴퓨터 판독 가능한 매체일 수 있다.

컴퓨터 판독 가능한 매체에 구현된 프로그램 코드는, 무선, 유선, 광섬유 케이블, RF 등 또는 전술한 것의 임의의 적절한 조합을 포함하지만 이에 제한되지 않는 임의의 적절한 매체를 사용하여 송신될 수 있다.

본 개시 내용의 양태에 대한 동작을 수행하기 위한 컴퓨터 프로그램 코드는, Java, Smalltalk, C++ 등과 같은 객체 지향 프로그래밍 언어 및 “C” 프로그래밍 언어 또는 유사한 프로그래밍 언어와 같은 종래의 절차적 프로그래밍 언어를 포함한, 하나 이상의 프로그래밍 언어의 임의의 조합으로 기록될 수 있다. 프로그램 코드는, 전체적으로 사용자의 컴퓨터에서, 부분적으로 사용자의 컴퓨터에서, 부분적으로 사용자의 컴퓨터에서 그리고 부분적으로 원격 컴퓨터에서, 또는 전체적으로 원격 컴퓨터 또는 서버에서, 독립 실행형 소프트웨어 패키지로서 실행될 수 있다. 후자의 시나리오에서, 원격 컴퓨터는, LAN(local area network) 또는 WAN(wide area network)을 포함한, 임의의 유형의 네트워크를 통해 사용자의 컴퓨터에 연결되거나, 외부 컴퓨터(예를 들어, 인터넷 서비스 공급자를 사용하여 인터넷을 통해)에 연결이 이루어질 수 있다.

본 개시 내용의 양태는, 본 개시 내용에 제시된 실시예에 따른 방법, 장치(시스템) 및 컴퓨터 프로그램 제품의 흐름도 예시 및/또는 블록도를 참조하여 아래에서 설명된다. 흐름도 예시 및/또는 블록도의 각 블록, 및 흐름도 예시 및/또는 블록도에서의 블록 조합은, 컴퓨터 프로그램 명령어에 의해 구현될 수 있다는 것이 이해될 것이다. 이러한 컴퓨터 프로그램 명령어는, 머신을 생성하기 위해 범용 컴퓨터, 특수 목적 컴퓨터, 또는 다른 프로그램 가능한 데이터 처리 장치의 프로세서에 제공될 수 있으며, 이러한 명령어는 컴퓨터 또는 다른 프로그램 가능한 데이터 처리 장치의 프로세서를 통해 실행되며, 흐름도 및/또는 블록도의 블록 또는 블록들에 지정된 기능/액트(act)를 구현하기 위한 수단을 생성한다.

이러한 컴퓨터 프로그램 명령어는 또한, 컴퓨터, 다른 프로그램 가능한 데이터 처리 장치, 또는 다른 디바이스가 특정 방식으로 기능하도록 지시할 수 있는 컴퓨터 판독 가능한 매체에 저장되어, 컴퓨터 판독 가능한 매체에 저장된 명령어가 제조 물품을 생성할 있고, 이러한 제조 물품은 흐름도 및/또는 블록도의 블록 또는 블록들에 지정된 기능/액트를 구현하는 명령어를 포함한다.

컴퓨터 프로그램 명령어는 또한, 컴퓨터, 다른 프로그램 가능한 데이터 처리 장치, 또는 다른 디바이스에 로드되어, 일련의 동작 단계가 컴퓨터, 다른 프로그램 가능한 장치 또는 다른 디바이스에서 수행되게 하여, 컴퓨터 구현 프로세스를 생성할 수 있으므로, 컴퓨터 또는 다른 프로그램 가능한 장치에서 실행되는 명령어는, 흐름도 및/또는 블록도의 블록 또는 블록들에 지정된 기능/액트를 구현하기 위한 프로세스를 제공한다.

도면의 흐름도 및 블록도는, 본 발명의 다양한 예에 따른 시스템, 방법, 및 컴퓨터 프로그램 제품의 가능한 구현의 아키텍처, 기능, 및 동작을 예시한다. 이와 관련하여, 흐름도 또는 블록도에서의 각 블록은, 모듈, 세그먼트, 명령어의 일부를 나타낼 수 있으며, 이는 특정 논리 기능(들)을 구현하기 위한 하나 이상의 실행 가능한 명령어를 포함한다. 일부 대안적인 구현예에서, 블록에 언급된 기능은, 도면에 언급된 순서와 다르게 발생할 수 있다. 예를 들어, 연속적으로 도시된 2개의 블록은, 관련된 기능에 따라, 실제로 실질적으로 동시에 실행될 수 있거나, 블록이 때때로 역순으로 실행될 수 있다. 또한 블록도 및/또는 흐름도 예시의 각 블록, 및 블록도 및/또는 흐름도 예시에서의 블록들의 조합은, 지정된 기능 또는 액트를 수행하거나, 특수 목적 하드웨어와 컴퓨터 명령어의 조합을 수행하는 특수 목적 하드웨어 기반 시스템에 의해 구현될 수 있다.

전술한 내용은 특정 예에 관한 것이지만, 그 기본 범위를 벗어나지 않고 다른 및 추가 예가 고안될 수 있으며, 그 범위는 다음의 청구범위에 의해 결정된다.

Claims (15)

1. 방법에 있어서,
   데이터 흐름 그래프를 객체 지향 소스 코드로서 규정하기 위한 이종(heterogeneous) 프로그래밍 환경을 제공하는 단계;
   상기 이종 프로그래밍 환경에서 생성된 그래프 소스 코드를 수신하는 단계 - 상기 그래프 소스 코드는 복수의 커널 및 복수의 통신 링크를 규정하고, 복수의 통신 링크의 각각은 복수의 커널의 각각의 쌍을 결합하여 데이터 흐름 그래프를 형성함 -; 및
   이종 처리 시스템에서 상기 데이터 흐름 그래프를 구현하기 위해 상기 그래프 소스 코드를 컴파일하는 단계
   를 포함하고, 상기 그래프 소스 코드를 컴파일하는 단계는,
   상기 그래프 소스 코드에서 상기 복수의 커널의 해상도(definition)에 기초하여 상기 복수의 커널을 상기 이종 처리 시스템에 할당하는 단계,
   상기 그래프 소스 코드에서 규정된 상기 복수의 통신 링크에 통신 유형을 할당하는 단계, 및
   상기 복수의 통신 링크를 사용하여 상기 복수의 커널 사이에서 데이터를 전송하기 위한 동기화 기술을 선택하는 단계
   를 포함하는 것인 방법
2. 제 1 항에 있어서, 상기 복수의 커널을 상기 이종 처리 시스템에 할당하는 단계는,
   제1 커널 및 제2 커널이 상기 그래프 소스 코드에 의해 규정된 바와 같은 상기 복수의 통신 링크 중 제1 링크에 의해 통신 가능하게 결합되었음을 식별하는 단계;
   상기 이종 처리 시스템의 제1 데이터 처리 엔진(DPE)에 상기 제1 커널을 할당하는 단계; 및
   상기 제1 DPE에 직접 이웃하는 상기 이종 처리 시스템의 제2 DPE에 상기 제2 커널을 할당하는 단계
   를 포함하는 방법.
3. 제 2 항에 있어서, 상기 제1 DPE 및 제2 DPE 양쪽은 공유 메모리 모듈에 대한 직접 연결을 가지며, 상기 방법은:
   상기 제1 커널과 상기 제2 커널 사이에서 데이터를 전송하기 위해 상기 공유 메모리 모듈에 이중 버퍼를 할당하는 단계를 포함하는 방법.
4. 제 1 항에 있어서, 상기 복수의 커널을 상기 이종 처리 시스템에 할당하는 단계는,
   제1 커널 및 제2 커널이 상기 그래프 소스 코드에 의해 규정된 바와 같은 상기 복수의 통신 링크 중 제1 링크에 의해 통신 가능하게 결합되었음을 식별하는 단계;
   상기 이종 처리 시스템의 제1 DPE에 상기 제1 커널을 할당하는 단계;
   상기 이종 처리 시스템의 프로그램 가능한 로직에 상기 제2 커널을 할당하는 단계; 및
   데이터를 상기 제1 커널로 전송하기 위해 인터커넥트를 사용하여 DMA(direct memory access)를 수행하도록 상기 제2 커널을 구성하는 단계
   를 포함하고,
   상기 인터커넥트는 제1 DPE를 포함하는 DPE의 어레이를 서로 그리고 프로그램 가능한 로직에 상호 연결하는 것인 방법.
5. 제 1 항에 있어서, 상기 복수의 커널을 상기 이종 처리 시스템에 할당하는 단계는,
   제1 커널 및 제2 커널이 상기 그래프 소스 코드에 의해 규정된 바와 같은 상기 복수의 통신 링크 중 제1 링크에 의해 통신 가능하게 결합되었음을 식별하는 단계;
   상기 제1 및 제2 커널이 제1 코어에 대한 사이클 버짓(budget) 이하인 조합된 사이클 카운트를 갖는다고 결정하는 것에 응답하여, 상기 이종 처리 시스템의 DPE의 어레이의 제1 코어에 상기 제1 및 제2 커널을 클러스터링하는 단계; 및
   상기 제1 커널과 상기 제2 커널 사이에서 데이터를 송신하기 위한 메모리 모듈에 버퍼를 할당하는 단계
   를 포함하고,
   상기 메모리 모듈은 상기 제1 코어에 직접 연결되어 있는 것인 방법.
6. 제 1 항에 있어서, 상기 복수의 통신 링크에 상기 통신 유형을 할당하는 단계는,
   상기 그래프 소스 코드에서 상기 복수의 통신 링크의 해상도에 기초하여 상기 복수의 통신 링크의 각각에 대한 데이터를 송신하기 위해 스트리밍 및 윈도잉 중 하나를 사용할지 여부를 선택하는 단계를 포함하는 것인 방법.
7. 제 6 항에 있어서,
   상기 윈도잉은 수신된 데이터를 미리 규정되거나 파라미터화된 블록 크기를 가진 개별 윈도우로 분할하는 것을 포함하고, 상기 개별 윈도우를 수신하도록 구성된 상기 복수의 커널의 각각은 상기 수신된 윈도우를 처리하기 전에 모든 호출에서 윈도우를 수신할 때까지 대기하고,
   윈도잉을 수행하는 통신 링크 중 적어도 하나의 링크에 대해, 상기 개별 윈도우의 시작 부분에, 개별 윈도우를 수신하는 복수의 커널 중 수신 커널이 그 상태를 유지하도록, 이전에 송신된 윈도우의 끝과 중첩하는 데이터를 갖는 것인 방법.
8. 제 1 항에 있어서, 상기 동기화 기술을 선택하는 단계는,
   상기 복수의 통신 링크 중 제1 링크에 할당된 이중 버퍼를 식별하는 단계; 및
   상기 복수의 통신 링크 중 상기 제1 링크에 대응하는 제1 커널 및 제2 커널이 병렬로 상기 이중 버퍼에 액세스할 수 있도록, 잠금(locking) 프로토콜을 구성하는 단계
   를 포함하는 것인 방법.
9. 제 1 항에 있어서,
   상기 데이터 흐름 그래프를 실행하도록 상기 이종 처리 시스템을 구성하는 그래프 소스 코드를 컴파일하는 것에 기초하여 비트스트림 및 2진 코드를 송신하는 단계; 및
   제어 프로그램을 사용하여 상기 이종 처리 시스템에서 상기 데이터 흐름 그래프의 실행을 제어하는 단계를 더 포함하는 방법.
10. 제 1 항에 있어서, 상기 이종 처리 시스템은 제1 칩 및 제2 칩을 포함하고, 상기 복수의 커널이 상기 제1 칩에 할당되고, 상기 그래프 소스 코드는 제2 복수의 커널을 규정하고, 상기 그래프 소스 코드를 컴파일하는 단계는:
    상기 제2 복수의 커널을 상기 제2 칩에 할당하는 단계
    를 포함하고,
    상기 제2 칩에 할당된 제2 복수의 커널은, 상기 제1 칩에 할당된 상기 복수의 커널과 통신하도록 구성되는 것인 방법.
11. 제 1 항에 있어서, 상기 그래프 소스 코드는, 상기 이종 처리 시스템을 형성하는 SoC의 하드웨어 설계와는 독립적이고, 상기 컴파일러에 의해 각각이 상이한 하드웨어 설계를 갖는 복수의 다른 유형의 SoC에서 구현될 수 있는 것인 방법.
12. 제 1 항에 있어서, 상기 이종 처리 시스템은 프로그램 가능한 로직 그리고 데이터 처리 엔진(DPE)의 어레이를 포함하고, 상기 복수의 커널 중 적어도 하나의 커널은 상기 프로그램 가능한 로직에 할당되고, 상기 복수의 커널 중 적어도 하나의 커널은 DPE들 중 하나에 할당되는 것인 방법.
13. 제 1 항에 있어서,
    서브 그래프를 상기 데이터 흐름 그래프로 캡슐화하는 단계 - 상기 서브 그래프는 상기 그래프 소스 코드와 별개의 그래프 클래스에 의해 규정됨 -; 및
    상기 데이터 흐름 그래프 및 상기 서브 그래프에 제약 조건을 추가하는 제약된 그래프를 생성하는 단계
    를 포함하고,
    상기 제약된 그래프는 상기 데이터 흐름 그래프에 대한 래퍼로서 기능하는 것인 방법.
14. 제 1 항에 있어서, 상기 복수의 커널의 각각은 상기 복수의 커널의 각각이 상기 데이터 흐름 그래프에서 다른 커널과 통신할 수 있게 하는 적어도 하나의 포트를 포함하고, 상기 데이터 흐름 그래프에서, 상기 복수의 통신 링크의 각각의 링크는 제1 커널 상의 제1 포트를 제2 커널 상의 제2 포트에 결합하는 것인 방법.
15. 호스트로서,
    프로세서;
    데이터 흐름 그래프를 객체 지향 소스 코드로서 규정하기 위한 이종 프로그래밍 환경;
    상기 이종 프로그래밍 환경에서 생성된 그래프 소스 코드 - 상기 그래프 소스 코드는 복수의 커널 및 복수의 통신 링크를 규정하고, 상기 복수의 통신 링크의 각각은 상기 복수의 커널의 각각의 쌍을 결합하여 상기 데이터 흐름 그래프를 형성함 -; 및
    이종 처리 시스템에서 상기 데이터 흐름 그래프를 구현하기 위해 상기 그래프 소스 코드를 컴파일하도록 구성된 컴파일러
    를 포함하고, 상기 그래프 소스 코드를 컴파일하는 것은:
    상기 그래프 소스 코드에서 상기 복수의 커널의 해상도에 기초하여 상기 복수의 커널을 상기 이종 처리 시스템에 할당하는 것,
    상기 그래프 소스 코드에서 규정된 상기 복수의 통신 링크에 통신 유형을 할당하는 것, 및
    상기 복수의 통신 링크를 사용하여 상기 복수의 커널 사이에서 데이터를 전송하기 위한 동기화 기술을 선택하는 것을 포함하는 것인, 호스트.

Images