KR20180034626A - 데이터 처리 그래프 컴파일 - Google Patents

Abstract

수신된 그래프 기반의 프로그램 사양 (900, 1000)은 : 복수의 구성 요소들 - 각각은 적어도 하나의 연산에 대응함 - ; 및 복수의 방향성 링크들 - 각각은 업스트림 구성 요소를 다운스트림 구성 요소에 연결함 - 을 포함한다. 연산들의 적어도 하나의 그룹들을 표시하는 처리된 코드들을 생성하기 위해 : 제 1 그룹에서 다수의 연산들이 상기 그래프의 상기 토폴로지에 의해 동시에 실행되는 것이 방지되지 않도록 상기 연산들의 제 1 그룹에서 상기 그래프의 토폴로지에 적어도 부분적으로 기초하여 가능한 동시성의 레벨을 식별하는 단계; 상기 분석된 연산들과 관련된 런타임 특성들을 결정하기 위해 상기 제 1 그룹에서 상기 연산들의 적어도 일부를 분석하는 단계; 및 상기 연산들을 실행하기 위한 처리된 코드를 생성하는 단계 - 여기서, 상기 처리된 코드는 상기 결정된 런타임 특성들에 적어도 부분적으로 기초하여, 상기 식별된 가능한 동시성의 레벨보다 낮은, 상기 제 1 그룹 내의 감소된 동시성의 레벨을 강화함 - 를 포함한다.

Description

데이터 처리 그래프 컴파일

본 출원은 2015년 8월 11일에 출원된 미국 출원 일련번호 제 62 / 203,547호의 우선권을 주장한다.

이 설명은 그래프 기반 프로그램 사양들을 컴파일하는 방법과 관련이 있다.

데이터 흐름 계산에 대한 하나의 접근법은 그래프의 노드들(꼭지점들)에 대응하는 계산 구성 요소들이 상기 그래프( "데이터흐름 그래프"라고 함)의 링크들(방형성 에지들)에 대응하는 데이터 흐름들에 의해 결합되는 그래프 기반의 표시를 사용한다. 데이터 흐름 링크에 의해 업스트림(upstream) 구성 요소(component)에 결합된 다운스트림(downstream) 구성 요소는 입력 데이터 요소들(elements)의 순서화된 스트림(stream)을 수신하고, 상기 수신된 순서로 상기 입력 데이터 요소들을 처리하며 선택적으로 출력 데이터 요소들의 적어도 하나의 대응하는 흐름들을 생성한다. 이러한 그래프 기반 계산들을 실행하기 위한 시스템은 본 명세서에 참고 문헌으로 포함된 "그래프들로 표시된 계산들 실행"이라는 제목의 선행 특허 제5,966,072호에 설명되어 있다.

데이터흐름 그래프들은 적어도 두 개의 구성 요소들이 동시에 (즉, 병렬로) 실행될 수 있는 가능성이 있도록 종종 지정된다. 데이터흐름 그래프들을 컴파일하고 실행하기 위한 많은 시스템들은 데이터흐름 그래프들을 컴파일하여 동시성의 상기 가능성을 이용하여, 가능한 곳에서 상기 데이터흐름 그래프들의 상기 구성 요소들이 동시에 실행되도록 한다. 이렇게 함으로써, 이들 시스템들은 최소한의 레이턴시(latency)로 데이터흐름 그래프를 실행하는 데 집중한다.

일 측면에서, 일반적으로, 접근법은 상기 데이터 처리 그래프의 일부분의 특성에 기초한 적어도 두 개의 컴파일 모드들에서 데이터 처리 그래프의 상기 일부분을 컴파일하는 것을 포함한다. 제 1 컴파일 모드들에서는, 구성 요소들의 동시 실행이 허용된다. 제 2 컴파일 모드들에서는, 구성 요소들의 동시 실행이 허용되지 않으며 구성 요소들의 순차적 실행이 강화된다. 일부 측면들에서, 상기 제 1 컴파일 모드들은 상기 데이터 처리 그래프의 상기 일부분의 적어도 하나의 구성 요소들이 "처리 태스크 (processing task)"를 스폰(spawn) 하는데 요구되는 시간 양에 비해 긴 시간 양이 걸릴 수 있는 연산들을 포함할 때 사용된다 (간단히 "태스크"라고도 함) (예를 들어, 적어도 하나의 구성 요소들의 상기 연산들이 실행되는 프로세스 (process) 또는 쓰레드(thread)).

다른 측면에서, 일반적으로, 연산들의 동시 실행을 지원하는 컴퓨팅 시스템 상에서 실행하기 위한 그래프 기반의 프로그램 사양을 컴파일하기 위한 방법으로서, 상기 방법은: 상기 그래프 기반의 사양을 수신하는 단계 - 상기 그래프 기반의 프로그램 사양은 그래프를 포함하고, 상기 그래프는: 복수의 구성 요소들 - 각각은 적어도 하나의 연산에 대응함 - ; 및 복수의 방향성 링크들 - 각각은 상기 복수의 구성 요소들의 업스트림 구성 요소를 상기 복수의 구성 요소들의 다운스트림 구성 요소에 연결함 - 을 포함함 - ; 및 연산들의 적어도 하나의 그룹들을 표시하는 처리된 코드들을 생성하기 위해 상기 그래프 기반의 프로그램 명세를 처리하는 단계 - 상기 처리하는 단계는: 제 1 그룹에서 다수의 연산들이 상기 그래프의 상기 토폴로지에 의해 동시에 실행되는 것이 방지되지 않도록 상기 연산들의 제 1 그룹에서 상기 그래프의 토폴로지에 적어도 부분적으로 기초하여 가능한 동시성의 레벨을 식별하는 단계; 상기 분석된 연산들과 관련된 런타임 특성들을 결정하기 위해 상기 제 1 그룹에서 상기 연산들의 적어도 일부를 분석하는 단계; 및 상기 제 1 그룹에서 상기 연산들을 실행하기 위한 처리된 코드를 생성하는 단계 - 여기서, 상기 처리된 코드는 상기 결정된 런타임 특성들에 적어도 부분적으로 기초하여, 상기 식별된 가능한 동시성의 레벨보다 낮은, 상기 제 1 그룹 내의 감소된 동시성의 레벨을 강화함 - 를 포함함 - 를 포함한다.

측면들은 다음의 기능들 중 적어도 하나를 포함할 수 있다.

상기 분석된 연산들과 관련된 런타임 특성들을 결정하기 위해 상기 제 1 그룹에서 상기 연산들의 적어도 일부를 분석하는 단계는 상기 분석된 연산들 각각에 대해, 상기 분석된 연산들이 제 1 임계값보다 더 큰 시간의 주기에 걸쳐 잠재적으로 계산을 수행하는 잠재적 연산인지 또는 상기 제 1 임계값보다 더 큰 시간의 주기 동안 응답을 잠재적으로 대기하는 잠재적 연산인지를 결정하는 단계를 포함한다.

상기 분석된 연산들과 관련된 런타임 특성들을 결정하기 위해 상기 제 1 그룹에서 상기 연산들의 적어도 일부를 분석하는 단계는 상기 분석된 연산들의 각각에 대해, 상기 분석된 연산들이 상기 제 1 그룹의 단일 실행 개시에 응답하여 다수 회 실행하는 적어도 하나의 연산들의 반복 집합의 멤버인지를 결정하는 단계를 포함한다.

상기 제 1 임계값은 적어도 하나의 연산들을 실행하기 위해 태스크를 스폰(spawn)하기 위해 요구되는 제 2 주기 시간보다 더 큰 제 1 주기 시간으로서 정의된다.

상기 처리된 코드는, 조건들 중 어느 것도 충족되지 않는 경우, 상기 식별된 가능한 동시성의 레벨보다 낮은, 상기 제 1 그룹 내의 감소된 동시성의 레벨을 강화하며, 상기 조건들은: (1) 상기 그래프의 토폴로지에 의해 동시에 실행되는 것이 방지되지 않는 상기 제 1 그룹에서의 적어도 두 개의 연산들이 모두 잠재적 연산들로 결정되거나, 또는 (2) 상기 제 1 그룹에서의 적어도 하나의 연산은 적어도 하나의 연산들의 반복 집합의 멤버로 결정된다.

상기 처리된 코드는, 추가적인 조건이 또한 충족되지 않는 경우, 상기 식별된 가능한 동시성의 레벨보다 낮은, 상기 제 1 그룹 내의 감소된 동시성의 레벨을 강화하며, 상기 추가적인 조건은 (3) 상기 제 1 그룹에서 적어도 두 개의 연산들의 구성은 반복되는 집합의 존재를 의미한다.

상기 식별된 가능한 동시성의 레벨보다 낮은, 상기 제 1 그룹 내의 감소된 동시성의 레벨을 강화하는 단계는 상기 제 1 그룹에서 모든 상기 연산들의 순차적인 실행을 강화하는 단계를 포함한다.

적어도 하나의 상기 방향성 링크들은 업스트림 구성 요소와 다운스트림 구성 요소 사이의 데이터 흐름을 나타낸다.

적어도 하나의 상기 방향성 링크들은 업스트림 구성 요소와 다운스트림 구성 요소 사이의 제어 흐름을 나타낸다.

연산들의 적어도 하나의 그룹들을 표시하는 처리된 코드들을 생성하기 위해 상기 그래프 기반의 프로그램 사양을 처리하는 단계는: 상기 연산들의 상기 제 1 그룹 중에서 적어도 부분적인 순서화를 지정하는 순서화 정보를 생성하는 단계 - 상기 순서화 정보는 상기 그래프의 상기 토폴로지에 적어도 부분적으로 기초함 - 를 더 포함하고; 그리고 상기 제 1 그룹에서 상기 가능한 동시성의 레벨을 식별하는 단계는 상기 제 1 그룹에서 다수의 연산들이 상기 부분적인 순서화에 의해 동시에 실행되는 것이 방지되지 않도록 상기 부분적 순서화에 의해 허용되는 동시성의 레벨을 식별하는 단계를 포함한다.

상기 순서화 정보를 생성하는 단계는 연산들의 상기 제 1 그룹을 토폴로지별로 분류하는 단계를 포함한다.

다른 측면에서, 일반적으로, 연산들의 동시 실행을 지원하는 컴퓨팅 시스템 상에서 실행하기 위해 그래프 기반의 프로그램 사양을 컴파일하기 위한 비 일시적인 형태의 소프트웨어를 저장하는 컴퓨터 판독 가능한 매체로서, 상기 소프트웨어는 상기 컴퓨팅 시스템으로 하여금: 상기 그래프 기반의 사양을 수신하고 - 상기 그래프 기반의 프로그램 사양은 그래프를 포함하고, 상기 그래프는: 복수의 구성 요소들 - 각각은 적어도 하나의 연산에 대응함 - ; 및 복수의 방향성 링크들 - 각각은 상기 복수의 구성 요소들의 업스트림 구성 요소를 상기 복수의 구성 요소들의 다운스트림 구성 요소에 연결함 - 을 포함함 - ; 및 연산들의 적어도 하나의 그룹들을 표시하는 처리된 코드들을 생성하기 위해 상기 그래프 기반의 프로그램 명세를 처리하는 - 상기 처리하는 단계는: 제 1 그룹에서 다수의 연산들이 상기 그래프의 상기 토폴로지에 의해 동시에 실행되는 것이 방지되지 않도록 상기 연산들의 제 1 그룹에서 상기 그래프의 토폴로지에 적어도 부분적으로 기초하여 가능한 동시성의 레벨을 식별하는 단계; 상기 분석된 연산들과 관련된 런타임 특성들을 결정하기 위해 상기 제 1 그룹에서 상기 연산들의 적어도 일부를 분석하는 단계; 및 상기 제 1 그룹에서 상기 연산들을 실행하기 위한 처리된 코드를 생성하는 단계 - 여기서, 상기 처리된 코드는 상기 결정된 런타임 특성들에 적어도 부분적으로 기초하여, 상기 식별된 가능한 동시성의 레벨보다 낮은, 상기 제 1 그룹 내의 감소된 동시성의 레벨을 강화함 - 를 포함함 - 명령들을 포함한다.

그래프 기반의 프로그램 사양을 컴파일하기 위한 컴퓨팅 시스템으로서, 상기 컴퓨팅 시스템은: 상기 그래프 기반의 프로그램 사양을 수신하기 위해 구성되는 입력 장치 또는 포트 - 상기 그래프 기반의 프로그램 사양은 그래프를 포함하고, 상기 그래프는: 복수의 구성 요소들 - 각각은 하나의 연산에 대응함 - ; 및 복수의 방향성 링크들 - 각각은 상기 복수의 구성 요소들의 업스트림 구성 요소를 상기 복수의 구성 요소들의 다운스트림 구성 요소에 연결함 - 을 포함함 - ; 및 연산들의 적어도 하나의 그룹들을 표시하는 처리된 코드를 생성하기 위해 상기 그래프 기반의 프로그램 명세를 처리하는 적어도 하나의 프로세서 - 상기 처리하는 단계는: 제 1 그룹에서 다수의 연산들이 상기 그래프의 상기 토폴로지에 의해 동시에 실행되는 것이 방지되지 않도록 상기 연산들의 제 1 그룹에서 상기 그래프의 토폴로지에 적어도 부분적으로 기초하여 가능한 동시성의 레벨을 식별하는 단계; 상기 분석된 연산들과 관련된 런타임 특성들을 결정하기 위해 상기 제 1 그룹에서 상기 연산들의 적어도 일부를 분석하는 단계; 및 상기 제 1 그룹에서 상기 연산들을 실행하기 위한 처리된 코드를 생성하는 단계 - 여기서, 상기 처리된 코드는 상기 결정된 런타임 특성들에 적어도 부분적으로 기초하여, 상기 식별된 가능한 동시성의 레벨보다 낮은, 상기 제 1 그룹 내의 감소된 동시성의 레벨을 강화함 - 를 포함함 - 를 포함한다.

측면들은 적어도 하나의 다음과 같은 장점들을 가질 수 있다.

다른 장점들 중, 측면들은 계산 레이턴시와 계산 효율성 간의 절충을 달성하기 위해 그래프 기반 프로그램들을 컴파일한다. 특히, 측면들은 동시에 실행될 수 있는 그룹들 및 동시에 실행될 수 없는 그룹들로 구성 요소들을 유리하게 그룹화한다. 구성 요소들의 상기 그룹핑은 상기 그래프 기반 프로그램들의 상기 실행이 최적화되도록 최적화 기준에 따라 수행된다(예를 들어, 높은 레이턴시 연산들이 동시에 실행되도록 허용되고, 반면에 낮은 레이턴시 연산들은 실행되도록 허용되지 않는다). 일부 예들에서, 상기 최적성 기준은 동시성이 향상된 계산 효율성 및/또는 감소된 계산 레이턴시를 초래하는 상황에서만 사용되는 것을 보장한다.

본 발명의 다른 특징들 및 장점은 하기의 설명 및 청구 범위들로부터 명백해질 것이다.

도 1은 태스크 기반의 계산 시스템의 블록도이다.
도 2는 입력 스칼라 포트(input scalar port) 연결들에 대한 다수의 출력 스칼라 포트(output scalar port)를 포함하는 데이터 처리 그래프이다.
도 3은 입력 수집 포트(input collection port) 연결들에 대한 다수의 출력 수집 포트(output collection port)를 포함하는 데이터 처리 그래프이다.
도 4는 입력 스칼라 포트 연결에 대한 출력 수집 포트 및 입력 수집 포트 연결에 대한 출력 스칼라 포트를 포함하는 데이터 처리 그래프이다.
도 5a는 두 구성 요소들 사이의 스칼라 포트 연결에 대한 스칼라 포트이다.
도 5b는 두 구성 요소들 사이의 수집 포트 연결에 대한 수집 포트이다.
도 5c는 실행 집합 진입점(entry point)를 포함하는 두 개의 구성 요소들 사이의 스칼라 포트 연결에 대한 수집 포트이다.
도 5d는 실행 집합 출구점(exit point)을 포함하는 두 개의 구성 요소들 사이의 수집 포트 연결에 대한 스칼라 포트이다.
도 6은 실행 집합을 포함하는 데이터 처리 그래프이다.
도 7은 도 6의 상기 실행 집합의 상기 구성 요소들의 연산들을 다수의 연산들로 그룹핑한 것이다.
도 8은 도 6의 상기 실행 집합의 상기 구성 요소들의 연산들을 하나의 작업으로 그룹핑한 것이다.
도 9a는 잠재적 연산들(latent operations)이 없는 구성 요소들을 포함하는 실행 집합을 포함하는 데이터 처리 그래프이다.
도 9b는 도 9a의 상기 실행 집합의 연산들의 실행의 예시이다.
도 9c는 도 9a의 상기 실행 집합의 연산들의 실행을 이들 연산들의 대안적인 실행과 비교한 예시이다.
도 10a는 잠재적 연산을 가지는 구성 요소를 포함하는 실행 집합을 포함하는 데이터 처리 그래프이다.
도 10b는 도 10a의 상기 실행 집합의 연산들의 실행의 예시이다.
도 10c는 이들 연산들의 대안적인 실행과 비교한 도 10a의 상기 실행 집합의 연산들의 실행의 예시이다.
도 11은 중첩된(nested) 실행 집합을 포함하는 실행 집합을 포함하는 데이터 처리 그래프이다.
도 12는 암시적(implicit) 실행 집합을 포함하는 실행 집합을 포함하는 데이터 처리 그래프이다.

도 1을 참조하면, 태스크 기반 계산 시스템 (100)은 하이 레벨(High Level) 프로그램 사양 (110)을 사용하여 상기 프로그램 사양 (110)에 의해 지정된 상기 계산을 실행하기 위해 컴퓨팅 플랫폼(computing platform) (150)의 계산 및 저장 자원들을 제어한다. 컴파일러(compiler)/인터프리터(interpreter) (120)는 상기 하이 레벨 프로그램 사양 (110)을 수신하고 태스크 기반 런타임(runtime) 인터페이스/제어기 (140)에 의해 실행될 수 있는 형태의 태스크 기반 사양 (130)을 생성한다. 상기 컴파일러/인터프리터 (120)는 독립적으로 또는 하나의 단위로 인스턴스화(instantiated) 될 수 있는 적어도 하나의 "구성 요소들 (components)"의 적어도 하나의 "실행 집합들 (execution sets)"을 다수의 데이터 요소들 각각에 적용될 세밀화된 태스크들로서 식별한다. 상기 컴파일 또는 해석 프로세스 파트(part)는 이들 실행 집합들을 식별하고 상기 실행 집합들을 준비하는 것을 포함하는데, 이에 대해서는 보다 상세히 후술된다. 상기 컴파일러/인터프리터 (120)는 예를 들어 상기 컴퓨팅 플랫폼 (150) 상에서 수행되는 상기 계산의 효율을 최적화하기 위해 다양한 기술들을 이용할 수 있음을 이해해야 한다. 상기 컴파일러/인터프리터 (120)에 의해 생성된 타겟 프로그램 사양은 그 자체가 상기 태스크 기반 사양 (130)을 생성하기 위해 상기 시스템 (100)의 다른 파트에 의해 추가 처리 (예를 들어, 추가적인 컴파일, 해석 등)되는 중간 형태일 수 있다. 아래의 논의는 이러한 변환들의 적어도 하나의 예들을 개략적으로 설명하지만 물론, 예를 들어, 컴파일러 설계에 익숙한 사람이 이해할 수 있는 상기 변환들에 대한 다른 접근법도 가능하다.

일반적으로, 상기 계산 플랫폼 (150)은 다수의 컴퓨팅 노드들 (152) (예를 들어, 분산 계산 자원들 및 분산된 저장 자원들 모두를 제공하는 독립적인 서버 컴퓨터들)로 이루어져 높은 수준들의 병렬 처리(parallelism)를 가능하게 한다. 상기 하이 레벨 프로그램 사양 (110)에 표시된 상기 계산은 상대적으로 세밀한 태스크들로서 상기 계산 플랫폼 (150) 상에서 실행되어, 상기 지정된 계산의 효율적인 병렬 실행을 더 가능하게 한다.

일부 실시 예들에서, 상기 하이 레벨 프로그램 사양 (110)은 데이터 흐름(데이터흐름 그래프에서와 같이) 및 제어 흐름 모두를 지정할 수 있는 "데이터 처리 그래프"라 불리는 일종의 그래프 기반 프로그램 사양이다. 데이터 처리 그래프는 상기 컴파일러/인터프리터 (120)가 상기 데이터 처리 그래프의 상기 구성 요소들에 병렬 처리를 동적으로 도입할 수 있게 하는, 이하에서 보다 상세하게 설명되는, 병렬 처리를 지원하기 위한 메커니즘들을 또한 포함한다. 예를 들어, 데이터 처리 그래프의 구성 요소들의 인스턴스들 (instances)은 상기 데이터 처리 그래프를 실행하는 맥락(context)에서 태스크들 (예를 들어, 적어도 하나의 구성 요소들의 상기 연산들이 실행되는 쓰레드(thread))로서 스폰되고(spawned), 일반적으로 상기 컴퓨팅 플랫폼 (150)의 다수의 상기 컴퓨팅 노드들 (152)에서 실행된다. 매우 일반적으로, 상기 제어기 (140)는, 예를 들어, 연산 부하의 할당, 통신 또는 입/출력 오버 헤드의 감소, 메모리 자원들의 사용과 관련된 상기 시스템을 위한 성능 목표들을 달성하기 위해 이들 태스크들의 스케줄링 및 실행 궤적(locus)의 감독 제어 측면들을 제공한다.

컴파일러/인터프리터 (120)에 의한 번역(translation) 후에, 전체 계산은 상기 컴퓨팅 플랫폼 (150)에 의해 실행될 수 있는 타겟 언어의 절차들의 관점에서 태스크 기반 사양 (130)으로서 표현된다. 이들 절차들은 "스폰(spawn)" 및 "대기(wait)"와 같은 프리미티브들(primitives)을 사용하며 자신들 내부에 포함할 수 있으며 또는 상기 하이 레벨 (예 : 그래프 기반) 프로그램 사양 (110)의 구성 요소들을 위해 프로그래머에 의해 지정된 작업 절차들을 호출할 수 있다.

일부 경우들에서는, 구성 요소의 각각의 인스턴스는 하나의 구성 요소의 단일 인스턴스를 구현하는 일부 태스크들, 실행 집합의 다수의 구성 요소들의 단일 인스턴스를 구현하는 일부 태스크들, 및 구성 요소의 연속적인 인스턴스들을 구현하는 일부 태스크들로 구현된다. 구성 요소들 및 그들의 인스턴스들로부터의 특정한 매핑은 상기 컴파일러/인터프리터의 특정 설계에 따라 다르므로, 결과 실행은 상기 계산의 의미론적 정의와 일치를 유지한다.

일반적으로, 런타임(runtime) 환경에서의 태스크들은, 예를 들어, 다수의 태스크들을 스포닝(spawning) 하는 하나의 최상위 태스크, 예를 들어, 상기 데이터 처리 그래프의 상기 최상위 구성 요소들의 각각에 대한 하나와 함께 계층 구조적으로 배열된다. 유사하게, 실행 집합의 계산은 상기 수집의 요소를 처리하기 위해 각각 사용되는 다수의(즉, 많은) 서브 태스크들과 함께 전체 수집을 처리하는 하나의 태스크를 가질 수 있다.

일부 예들에서, 각각의 컴퓨팅 노드 (152)는 적어도 하나의 처리 엔진들 (154)을 갖는다. 적어도 일부 구현들에서, 각각의 처리 엔진은 상기 컴퓨팅 노드 (150) 상에서 실행하는 단일 연산 시스템 프로세스와 연관된다. 상기 컴퓨팅 노드의 특성들에 따라 단일 컴퓨팅 노드 상에서 다수의 처리 엔진들을 실행하는 것이 효율적일 수 있다. 예를 들어, 상기 컴퓨팅 노드는 다수의 분리된 프로세서들을 갖는 서버 컴퓨터일 수 있거나, 상기 서버 컴퓨터는 다중 프로세서 코어들을 갖는 단일 프로세서를 가질 수 있거나, 또는 다중 코어들을 갖는 다중 프로세서들의 조합일 수 있다. 임의의 경우에, 다수의 처리 엔진들을 실행하는 것은 컴퓨팅 노드 (152) 상의 단일 처리 엔진만을 사용하는 것보다 더 효율적일 수 있다.

1. 데이터 처리 그래프들

일부 실시 예들에서, 상기 하이 레벨 프로그램 사양 (110)은 "구성 요소들"의 집합을 포함하는 "데이터 처리 그래프"라고 불리는 일종의 그래프 기반 프로그램 사양이며, 각각은 데이터에 대해 수행될 전체 데이터 처리 계산의 일부를 지정한다. 상기 구성 요소들은, 예를 들어, 프로그래밍 사용자 인터페이스 및/또는 상기 계산의 데이터 표시에서 그래프의 노드들로 표시된다. 상기 배경에서 설명된 상기 데이터흐름 그래프들과 같은 일부 그래프 기반 프로그램 사양들과 달리 상기 데이터 처리 그래프들에는 임의의 데이터의 전송 또는 제어의 전송 또는 두 가지 모두를 표시하는 상기 노드들 사이의 링크들이 포함될 수 있다. 상기 링크들의 특성들을 나타내는 한 가지 방법은 상기 구성 요소들에 대해 다른 유형들의 포트들을 제공하는 것이다. 상기 링크들은 업스트림 구성 요소의 출력 포트로부터 다운 스트림 구성 요소의 입력 포트로 결합되는 방향성 링크들이다. 상기 포트들은 데이터 요소들이 상기 링크들로부터 어떻게 기록되고 판독되는 지 및/또는 데이터를 처리하기 위해 상기 구성 요소들이 어떻게 제어되는 지의 특성들을 표시하는 표시기(indicator)를 갖는다.

이들 포트들은 여러 가지 특성들을 가질 수 있다. 포트의 한 가지 특성은 입력 포트 또는 출력 포트로서의 그것의 방향성이다. 상기 방향성 링크들은 업스트림 구성 요소의 출력 포트로부터 다운스트림 구성 요소의 입력 포트로 전달되는 데이터 및/또는 제어를 표시한다. 개발자는 다른 유형들 포트들을 함께 링크할 수 있도록 허용된다. 상기 데이터 처리 그래프의 상기 데이터 처리 특성들 중 일부는 서로 다른 유형들의 포트들이 함께 링크되는 방법에 따라 다르다. 예를 들어, 서로 다른 유형들의 포트들 사이의 링크들은 계층 구조 형태의 병렬 처리를 제공하는 서로 다른 "실행 집합들"에 있는 구성 요소들의 중첩된 서브셋들 (nested subsets)로 이어질 수 있다 (자세한 내용은 아래에서 설명함). 특정 데이터 처리 특성들은 상기 포트의 상기 유형에 의해 암시된다. 구성 요소가 가질 수 있는 서로 다른 유형들은 다음을 포함한다:

● 입력 또는 출력 수집 포트들 - 상기 구성 요소의 인스턴스가 상기 포트에 결합된 상기 링크를 거쳐 전달되는 수집의 모든 데이터 요소들을 각각 판독하거나 기록한다. 그들의 수집 포트들 사이에 단일 링크를 가지는 쌍의 구성 요소들의 경우, 상기 다운스트림 구성 요소는 일반적으로 업스트림 구성 요소에 의해 기록될 때 데이터 요소들을 읽을 수 있으므로, 업스트림과 다운스트림 구성 요소들 사이의 파이프라인 병렬 처리(pipleline parallelism)가 가능하다. 상기 데이터 요소들은 또한 재정렬될 수 있으며, 이는 보다 상세히 후술되는 바와 같이 병렬화 (parallelization)에서 효율을 가능하게 한다. 그래픽 인터페이스들을 프로그래밍하는 것과 같은 일부 그래픽 표시들에서, 이러한 수집 포트들은 일반적으로 상기 구성 요소에 사각형 연결 기호로 표시된다.

● 입력 또는 출력 스칼라 포트들 - 상기 구성 요소의 인스턴스가 상기 포트에 결합된 링크에서 또는 링크로부터 최대 하나의 데이터 요소를 각각 판독하거나 기록한다. 그들 스칼라 포트들 사이의 단일 링크를 가진 쌍의 구성 요소들의 경우, 상기 다운스트림 구성 요소의 직렬 실행은 상기 업스트림 구성 요소가 실행을 완료한 후 상기 단일 데이터 요소의 전송을 제어 전송으로 사용하여 시행된다. 그래픽 인터페이스들 프로그래밍과 같은 일부 그래픽 표시들에서 스칼라 포트들은 일반적으로 상기 구성 요소에 삼각형 연결 기호로 표시된다.

● 입력 또는 출력 제어 포트들은 스칼라 입력들 또는 출력들과 비슷하지만 전송될 데이터 요소가 필요하지 않으며, 구성 요소들 사이에 제어 전송들을 통신하는 데 사용된다. 그들의 제어 포트들 사이에 링크가 있는 쌍의 구성 요소들의 경우, 상기 업스트림 구성 요소가 실행을 완료한 후 상기 다운스트림 구성 요소의 직렬 실행이 시행된다 (그들 구성 요소들이 수집 포트들 사이에 링크를 가지고 있는 경우에도). 그래픽 인터페이스 프로그래밍과 같은 일부 그래픽 표시에서 이러한 제어 포트들은 일반적으로 상기 구성 요소에 원형 연결 기호로 표시된다.

이러한 서로 다른 유형들의 포트들은 데이터 처리 그래프들의 유연한 설계를 가능하게 하여, 상기 포트 유형들의 중복되는 속성들과 함께 데이터 및 제어 흐름의 강력한 조합들을 허용한다. 특히, 데이터를 어떤 형태( "데이터 포트들"이라고 함)로 전달하는 수집 포트들과 스칼라 포트들이라는 두 가지 유형들의 포트들이 있으며 ; 그리고 직렬 실행을 시행하는 스칼라 포트들과 제어 포트들 ("직렬 포트"라고 함)이라는 두 가지 유형들의 포트들이 있다. 데이터 처리 그래프에는 일반적으로 연결된 입력 데이터 포트들이 없는 "소스 구성 요소들"인 적어도 하나의 구성 요소들 및 연결된 출력 데이터 포트들이 없는 "싱크 구성 요소들"인 적어도 하나의 구성 요소들을 가지고 있다. 일부 구성 요소들은 연결된 입력 및 출력 데이터 포트들 모두를 가질 것이다. 일부 실시 예들에서, 상기 그래프들은 사이클들을 가지는 것이 허용되지 않으므로, 방향성 비순환 그래프 (DAG) (Directed Acyclic Graph)이어야 한다. 이 기능은 아래에서 자세히 설명하는 DAG들의 특정 특성들을 활용하는 데 사용될 수 있다.

상이한 유형들의 포트들을 상이한 방식들로 연결함으로써 개발자는 데이터 처리 그래프의 구성 요소들의 포트들 사이에 상이한 유형들의 링크 구성들을 지정할 수 있다. 한 유형의 링크 구성은 동일한 유형의 포트 (예 : 스칼라 - 스칼라 링크)에 연결될 특정 유형의 포트에 대응할 수 있으며, 또 다른 유형의 링크 구성은, 예를 들어, 상이한 유형의 포트 (예 : 수집 - 스칼라 링크)에 연결될 특정 유형의 포트에 대응할 수 있다. 이들 상이한 유형들의 링크 구성들은 상기 개발자가 상기 데이터 처리 그래프의 일부와 관련된 예정된 거동을 시각적으로 식별하기 위한 방법 및 상기 컴파일러/인터프리터 (120)에게 그 거동을 가능하게 하는 데 필요한 대응하는 유형의 컴파일 프로세스를 지시하는 방법으로서 사용된다. 본 명세서에 설명된 예들은 상이한 유형들의 링크 구성들을 시각적으로 표시하기 위해 상이한 유형들의 포트들을 위한 고유한 형상들을 사용하지만, 상기 시스템의 다른 구현들은 상이한 유형들의 링크들을 제공함으로써 상이한 유형들의 링크 구성들의 상기 거동들을 구별할 수 있으며 각 유형의 링크를 고유한 시각적 지시자 (예를 들어, 두께, 선 유형, 색상 등)로 할당할 수 있다. 그러나, 포트 유형 대신 링크 유형을 사용하여 위에 나열된 세 가지 유형들의 포트들로 가능한 상기 동일의 다양한 링크 구성들을 표시하기 위해, 여기에는 세가지 이상의 유형들의 링크들이 있을 수 있다 (예 : 스칼라-스칼라, 수집-수집, 제어-제어, 수집-스칼라, 스칼라-수집, 스칼라 - 제어 등).

상기 컴파일러/인터프리터 (120)는 실행을 위해 데이터 처리 그래프를 준비하는 절차들을 수행한다. 첫 번째 절차는 잠재적으로 중첩된 실행 집합들의 구성 요소들의 계층 구조를 식별하기 위한 실행 집합 발견 전 처리 절차 (execution set discovery pre-processing procedure)이다. 두 번째 절차는, 각각의 실행 집합에 대해, 상기 컴파일러/인터프리터 (120)가 각각의 실행 집합 내의 상기 구성 요소들의 실행을 제어하기 위해 런타임에 머신 상태를 효과적으로 구현할 제어 코드를 형성하기 위해 사용할 대응하는 제어 그래프를 생성하기 위한 제어 그래프 생성 절차이다.

적어도 하나의 입력 데이터 포트를 가지는 구성 요소는 각각의 입력 데이터 요소 또는 수집 (또는 다수의 그것의 입력 포트들 상의 데이터 요소들 및/또는 수집들의 튜플(tuple)) 상에서 수행할 상기 처리를 지정한다. 그러한 사양의 한 가지 형태는 입력 데이터 요소들 및/또는 수집들 중의 하나 또는 튜플 상에서 수행되는 절차이다. 상기 구성 요소가 적어도 하나의 출력 데이터 포트를 갖는다면, 출력 데이터 요소들 및/또는 수집들 중 대응하는 하나 또는 튜플을 생성할 수 있다. 그러한 절차는 하이 레벨 문장 기반 언어(예 : Java 소스 문장들 또는 예를 들어 미국 특허 제 8,069,129호 "비즈니스 규칙들 편집 및 컴파일링"에서 사용 된 바와 같은 DML (Data Manipulation Language))로 지정 될 수 있으며, 또는 일부는 완전히 또는 부분적으로 컴파일된 형태 (예 : 자바 바이트 코드와 같은)로 제공될 수 있다. 예를 들어, 구성 요소는 인수들이 그것의 입력 데이터 요소들 및/또는 수집들 및 그것의 출력 데이터 요소들 및/또는 수집들, 또는 보다 일반적으로, 그러한 데이터 요소들 또는 수집들 또는 절차들에 대한 참조들 또는 입력을 획득하고 출력 데이터 요소들 또는 수집들을 제공하는 데 사용되는 데이터 개체들 (여기에서 "핸들들(handles)"이라고 함)을 포함하는 작업 절차를 가질 수 있다.

작업 절차들은 다양한 유형들일 수 있다. 지정될 수 있는 절차들의 상기 유형들을 제한하려는 의도 없이, 한 가지 유형의 작업 절차는 레코드 형식에 따라 데이터 요소들에 대한 이산 계산(discrete computation)을 지정한다. 단일 데이터 요소는 테이블 (또는 다른 유형의 데이터 집합)로부터의 레코드일 수 있으며, 레코드들의 수집은 테이블의 모든 상기 레코드들일 수 있다. 예를 들어, 단일 입력 스칼라 포트와 단일 출력 스칼라 포트가 있는 구성 요소를 위한 한 가지 유형의 작업 절차는 하나의 입력 레코드를 수신하는 것과 그 레코드에 대한 계산을 수행하는 것, 그리고 하나의 출력 레코드를 제공하는 것을 포함한다. 다른 유형의 작업 절차는 다중 입력 스칼라 포트들로부터 수신된 입력 레코들의 튜플이 다중 출력 스칼라 포트들에 대해 송신된 출력 레코드들의 튜플을 형성하기 위해 어떻게 처리되는지를 지정할 수 있다.

상기 데이터 처리 그래프에 의해 지정된 상기 계산의 의미론적 정의는 상기 그래프에 의해 정의된 상기 계산의 순서화 및 처리의 동시성에 대한 제약들 및/또는 제약들의 부족을 표시한다는 점에서 본질적으로 유사하다. 따라서, 상기 계산의 상기 정의는 결과들이 상기 계산 단계들의 일부 순차 순서와 동일할 것을 요구하지 않는다. 반면에, 상기 계산의 상기 정의는 상기 계산의 부분들을 시퀀싱하는 것을 요구하는 특정 제약 조건들과 상기 계산 부분들의 병렬 실행의 제한들을 제공한다.

데이터 처리 그래프들에 대한 논의에서 런타임 시스템에서 구성 요소들의 인스턴스들을 분리된 "태스크들"로 구현하는 것은 시퀀싱 및 병렬화 제약 조건들을 표시하는 수단들로 간주된다. 일반적으로 데이터 처리 그래프의 각각의 구성 요소는 상기 그래프의 실행 동안 여러 번 상기 컴퓨팅 플랫폼에서 인스턴스화될 것이다. 각각의 구성 요소의 인스턴스들의 수는 상기 구성 요소가 할당된 다수의 실행 집합들 중 어떤 것에 의존할 수 있다. 구성 요소의 다수의 인스턴스들이 인스턴스화 될 때, 적어도 하나의 인스턴스가 병렬로 실행될 수 있으며 상기 시스템의 상이한 컴퓨팅 노드들에서 상이한 인스턴스들이 실행될 수 있다. 상기 구성 요소들에 의해 수행되는 상기 연산들과 상기 유형들의 포트들을 포함하여 상기 구성 요소들의 상호 연결들은 지정된 데이터 처리 그래프에 의해 허용되는 병렬 처리의 성격을 결정한다.

다양한 구성 요소들 상의 상기 상이한 유형들의 데이터 포트들은 데이터가 구성 요소들 사이의 링크들을 걸쳐 그들 구성 요소들을 연결하는 입력 및 출력 포트들의 상기 유형들에 따라 상이한 방식으로 전달하는 것을 허용한다. 전술한 바와 같이, 스칼라 포트는 최대 단일 데이터 요소 (즉, 0 또는 1 데이터 요소들)의 생산 (출력 스칼라 포트 용) 또는 소비 (입력 스칼라 포트 용)를 표시한다. 반면에 수집 포트는 잠재적으로 다수의 데이터 요소들의 집합의 생산 (출력 수집 포트 용) 또는 소비 (입력 수집 포트 용)를 표시한다. 단일 데이터 처리 그래프에서 두 유형들의 데이터 포트들을 모두 지원함으로써 개발자는 원하는 상기 거동을 쉽게 나타낼 수 있다.

도 2를 참조하면, 데이터 처리 그래프 (300)는 제 1 구성 요소 A1 (302), 제 2 구성 요소 B1 (304) 및 제 3 구성 요소 C1 (306)의 일련의 세 개의 접속된 구성 요소들을 포함한다. 상기 제 1 구성 요소는 수집 유형 입력 포트 (308) 및 스칼라 유형 출력 포트 (310)를 포함한다. 상기 제 2 구성 요소 (304)는 스칼라 유형 입력 포트 (312) 및 스칼라 유형 출력 포트 (314)를 포함한다. 상기 제 3 구성 요소는 스칼라 유형의 입력 포트 (316) 및 수집 유형 출력 포트 (318)를 포함한다.

상기 제 1 구성 요소 (302)의 상기 출력 스칼라 포트 (310)를 상기 제 2 구성 요소 (304)의 상기 입력 스칼라 포트 (312)에 연결하는 제 1 링크 (320)는 데이터가 상기 제 1 구성 요소 (302)와 상기 제 2 구성 요소 (304) 사이를 통과하고 동시에 상기 제 1 및 제 2 구성 요소들 (302, 304)의 직렬 실행을 시행하는 두가지 모두를 허용한다. 유사하게, 상기 제 2 구성 요소 (304)의 출력 스칼라 포트 (314)를 상기 제 3 구성 요소 (306)의 입력 스칼라 포트 (316)에 연결하는 제 2 링크 (322)는 데이터가 상기 제 2 구성 요소 (304)와 상기 제 3 구성 요소 (306) 사이를 통과하고 상기 제 2 및 제 3 구성 요소 (304, 306)의 직렬 실행을 시행하는 두 가지 모두를 허용한다.

도 2의 상기 스칼라 포트들의 상호 접속들로 인해, 상기 제 2 구성 요소 (304)는 상기 제 1 구성 요소 (302)가 완료된 후에만 실행을 시작하고 (그리고, 상기 제 1 링크 (320)를 걸쳐 단일 데이터 요소를 전달하고), 상기 제 3 구성 요소 (306)는 상기 제 2 구성 요소 (304)가 완료된 후에만 실행을 시작한다 (그리고, 상기 제 2 링크 (322)를 걸쳐 단일 데이터 요소를 전달한다). 즉, 상기 데이터 처리 그래프의 상기 세 가지 구성 요소들 각각은 엄격한 시퀀스 (A1/B1/C1)로 한 번 실행된다.

도 2의 예시적인 데이터 처리 그래프에서, 상기 제 1 구성 요소 (302)의 상기 입력 포트 (308) 및 상기 제 3 구성 요소 (318)의 상기 출력 포트는 이들을 연결하는 상기 스칼라 포트들에 의해 부과되는 상기 제 1, 제 2 및 제 3 구성 요소들 (302, 304, 306)의 상기 직렬 실행 거동에 영향을 미치지 않는 수집 포트들이 될 수 있다.

일반적으로, 수집 포트들은 구성 요소들 사이에 데이터 요소들의 수집을 전달하는 데 사용되며 동시에 상기 런타임 시스템에 그 집합 내의 상기 데이터 요소들을 재정렬할 수 있는 라이센스를 제공할 수 있다. 하나의 데이터 요소에서 다른 데이터 요소로의 상기 계산 상태에 의존하지 않기 때문에, 또는 각각의 데이터 요소가 처리될 때 액세스되는 전역 상태가 있는 경우 최종 상태는 이들 데이터 요소들이 처리된 순서에 독립적이기 때문에 비정렬 수집의 데이터 요소들의 재정렬은 허용된다. 이 재정렬 라이센스는 런타임까지 병렬화에 대한 결정들을 지연시키기 위한 유연성을 제공한다.

도 3을 참조하면, 데이터 처리 그래프 (324)는 제 1 구성 요소 A2 (326), 제 2 구성 요소 B2 (328) 및 제 3 구성 요소 C2 (330)의 세 개의 연결된 구성 요소들의 시리즈를 포함한다. 상기 제 1 구성 요소 (326)는 수집 유형 입력 포트 (332) 및 수집 유형 출력 포트 (334)를 포함한다. 상기 제 2 구성 요소 (328)는 수집 유형 입력 포트 (336) 및 수집 유형 출력 포트 (338)를 포함한다. 상기 제 3 구성 요소 (330)는 수집 유형 입력 포트 (340) 및 수집 유형 출력 포트 (342)를 포함한다.

상기 3 개의 구성 요소들 (326, 328, 330) 각각은 적어도 하나의 출력 요소들의 수집을 생성하기 위해 어떻게 적어도 하나의 입력 요소들의 수집이 처리되는 지를 지정한다. 특정 입력 요소와 특정 출력 요소 사이에 반드시 일대일 대응이 반드시 필요한 것은 아니다. 예를 들어, 상기 제 1 구성 요소 (326)와 상기 제 2 구성 요소 (328) 사이의 데이터 요소들 (344)의 제 1 수집 내의 다수의 데이터 요소들은 상기 제 2 구성 요소 (328)와 상기 제 3 구성 요소 (328) 사이의 데이터 요소들 (346)의 제 2 수집 내의 다수의 요소들보다 다를 수 있다. 수집 포트들 사이의 연결들에 대한 유일한 제한 조건은 상기 수집 내의 각각의 데이터 요소가 하나의 수집 포트에서 다른 수집 포트로 전달되는 한편, 상기 제 1 구성 요소 (326)와 상기 제 2 구성 요소 (328) 사이 및 상기 제 2 구성 요소 (328)와 상기 제 3 구성 요소 (330) 사이에서 그들이 처리되는 상기 순서에 대해 임의적인 재정렬을 허용한다. 또는, 다른 예에서 상기 수집 포트들은 순서를 보존하도록 선택적으로 구성될 수 있다. 이 예에서, 상기 세 개의 구성 요소들 (326, 328, 330)은 함께 시작하여 동시에 실행되어 파이프라인 병렬 처리를 허용한다.

도 1과 관련하여 기술된 상기 컴파일러/인터프리터 (120)는 수집 포트 연결들에 대한 수집 포트를 인식하고 수행되는 상기 계산에 적합한 방식으로 상기 계산을 실행 가능 코드로 번역하도록 구성된다. 상기 수집 데이터 링크의 상기 비정렬 본질은 상기 컴파일러/인터프리터 (120)에게 이것이 달성되는 방법에 유연성을 제공한다. 예를 들어, 상기 제 2 구성 요소 (328)에 대해, 각각의 출력 요소가 단일 입력 요소 (즉, 데이터 요소들에 걸쳐 유지되는 상태가 없음)에 기초하여 계산되는 경우가 발생하는 경우, 상기 컴파일러/인터프리터 (120)는 상기 런타임 시스템이 데이터 요소당 상기 구성 요소의 하나의 인스턴스를 인스턴스화함으로써 상기 데이터 요소의 상기 처리를 동적으로 병렬화하도록 허용할 수 있다(예를 들어, 런타임에 이용 가능한 상기 컴퓨팅 자원들에 의존하여). 선택적으로, 상태는 특별한 경우들에서 입력 수집 포트들이 있는 구성 요소들의 데이터 요소들을 통해 유지될 수 있다. 그러나 일반적인 경우, 상기 런타임 시스템은 상기 구성 요소의 태스크를 병렬 처리하도록 허용될 수 있다. 예를 들어, 상기 런타임 시스템이 전역 상태가 유지되고 있지 않음을 감지한다면, 상기 태스크를 병렬 처리하도록 허용될 수 있다. 상기 수집이 비정렬이라면, 데이터 요소들 사이에서 순서가 유지될 필요가 없다는 사실은 상기 제 2 구성 요소 (328)의 각각의 인스턴스가 그것이 이용 가능한 즉시 상기 제 3 구성 요소 (330)에 그것의 출력 데이터 요소를 제공할 수 있다는 것을 의미하며, 상기 제 3 구성 요소 (330)는 상기 제 2 구성 요소 (328)의 모든 인스턴스들이 완료되기 전에 그들 데이터 요소들의 처리를 시작할 수 있다.

2. 실행 집합들

일부 예들에서, 그래프 개발자는 하나의 구성 요소의 수집 유형 출력 포트를 다른 구성 요소의 스칼라 유형 입력 포트에 연결함으로써 데이터 수집에서 상기 데이터 요소들의 상기 처리가 동적으로 병렬화될 수 있음을 명시적으로 나타낼 수 있다. 그러한 구성 요소임을 표시하는 것 외에도 또한 그러한 표시는 상기 수집의 다른 요소들을 처리하는 사이에 상태가 유지되지 않도록 요구한다. 도 4를 참조하면, 데이터 처리 그래프 (348)는 제 1 구성 요소 A3 (350), 제 2 구성 요소 B3 (352) 및 제 3 구성 요소 C3 (354)의 세 개의 연결된 구성 요소들의 시리즈를 포함한다. 상기 제 1 구성 요소 (350)는 수집 유형 입력 포트 (356) 및 수집 유형 출력 포트 (358)를 포함한다. 상기 제 2 구성 요소 (352)는 스칼라 유형 입력 포트 (360) 및 스칼라 유형 출력 포트 (362)를 포함한다. 상기 제 3 구성 요소 (354)는 수집 유형 입력 포트 (364) 및 수집 유형 출력 포트 (366)를 포함한다.

상기 제 1 구성 요소의 상기 수집 유형 출력 포트 (358)는 제 1 링크 (368)에 의해 상기 제 2 구성 요소 (352)의 상기 스칼라 유형 입력 포트 (360)에 연결되고 상기 제 2 구성 요소 (352)의 상기 스칼라 유형 출력 포트 (362)는 제 2 링크 (370)에 의해 상기 수집 유형 입력 포트 (364)에 연결된다. 아래에서 보다 상세하게 설명되는 바와 같이, 수집 유형 출력 포트로부터 스칼라 유형 입력 포트로의 링크는 "실행 집합"(또는 "반복(iterating) 집합")에 대한 진입점을 의미하고 스칼라 유형 출구점으로부터 수집 유형 입력 포트로의 링크는 실행 집합의 출구점을 의미한다. 매우 일반적으로, 이하에서 더 상세하게 설명되는 바와 같이, 실행 집합에 포함된 구성 요소들은 데이터 요소들의 수집으로부터 데이터 요소들을 처리하기 위해 상기 런타임 제어기에 의해 동적으로 병렬화될 수 있다.

도 4에서, 상기 제 1 구성 요소 (350)의 상기 수집 유형 출력 포트 (358)와 상기 제 2 구성 요소 (352)의 상기 스칼라 유형 입력 포트 (360) 사이의 상기 링크 (368)는 실행 집합으로의 진입점을 의미한다. 상기 제 2 구성 요소 (352)의 상기 스칼라 유형 출구점 (362)과 상기 제 3 구성 요소 (354)의 상기 수집 유형 입력 포트 (364) 사이의 상기 링크 (370)는 상기 실행 집합의 출구점을 의미한다. 즉, 상기 제 2 구성 요소 (352)는 상기 실행 집합의 유일한 구성 요소이다.

상기 제 2 구성 요소 (352)가 상기 실행 집합에 포함되기 때문에, 상기 제 2 구성 요소 (352)의 분리된 인스턴스는 상기 제 1 구성 요소 (350)의 상기 수집 유형 출력 포트 (358)로부터 수신된 각각의 데이터 요소를 위해 론칭된다. 상기 분리된 인스턴스들 중 적어도 일부는 런타임까지 이루어 지지 않는 결정에 따라 병렬로 실행될 수 있다. 이 예에서, 상기 제 1 구성 요소 (350) 및 제 3 구성 요소 (354)는 함께 시작하여 동시에 실행되며, 한편 상기 제 2 구성 요소 (352)는 상기 링크 (368)를 걸쳐 수신된 각각의 데이터 요소를 위해 한번 실행된다. 도 1과 관련하여 상술 한 바와 같이, 상기 컴파일러/인터프리터 (120)는 실행을 위한 상기 데이터 처리 그래프를 준비하기 위해 데이터 처리 그래프 상에 실행 집합 발견 전처리 절차를 수행한다. 실행 집합은 유닛(unit)으로 호출되고 출력 수집 포트의 상기 데이터의 일부와 같이, 데이터의 일부에 적용될 수 있는 적어도 하나의 구성 요소들의 집합이다. 따라서 상기 실행 집합의 각각의 구성 요소의 최대 하나의 인스턴스가 각각의 입력 요소 (또는 상기 집합의 다수의 입력 포트들에 제공된 입력 요소들의 튜플)를 위해 실행된다. 상기 실행 집합 내에서, 상기 링크들에 의해 시퀀싱 제한 조건들이 스칼라 및 제어 포트들에 부과되며, 시퀀싱 제한 조건들이 위반되지 않는 한 실행 집합에 있는 상기 구성 요소들의 병렬 실행이 허용된다. 병렬로 실행되도록 허용된 적어도 일부의 구성 요소들이 있는 예들에서는, 상기 실행 집합은 다수의 태스크들, 예를 들어, 전체로서의 상기 실행 집합을 위한 태스크와 적어도 하나의 구성 요소의 인스턴스의 동시 실행을 위한 적어도 하나의 서브 태스크들을 이용하여 구현될 수 있다. 따라서 상기 실행 집합의 다른 인스턴스를 표시하는 태스크들 자체는 더 세밀화된 태스크들, 예를 들어, 동시에 실행될 수 있는 서브 태스크들로 나눌 수 있다. 다른 실행 집합들에 대한 태스크들은 일반적으로 독립적으로 병렬로 실행될 수 있다. 예를 들어 대형 데이터 집합이 백만 개의 레코드들이 있는 경우 백만 개의 독립적인 태스크들이 있을 수 있다. 상기 태스크들의 일부는 상기 컴퓨팅 플랫폼 (150)의 다른 노드들 (152)에서 실행될 수 있다. 태스크들은 단일 노드 (152) 상에서도 효율적으로 동시에 실행될 수 있는 경량 쓰레드들(threads)를 사용하여 실행될 수 있다.

일반적으로, 할당 알고리즘(들) (즉, 루트 실행 집합 이외의 상기 실행 집합들)에 의해 식별된 상기 실행 집합들은 상기 실행 집합의 경계에서 "구동(driving)" 스칼라 데이터 포트를 통해 데이터 요소들을 수신한다. 상기 실행 집합의 상기 구동 입력 스칼라 데이터 포트에서 수신된 각각의 데이터 요소에 대해, 상기 실행 집합 내의 각각의 상기 구성 요소들은 한 번 실행되거나 (활성화된 경우) 전혀 실행되지 않는다(억제된 경우). 상기 실행 집합의 다수의 인스턴스들은 업스트림 수집 포트로부터 상기 실행 집합으로 사용 가능한 다수의 데이터 요소들을 처리하기 위해 인스턴스화 및 병렬로 실행될 수 있다. 실행 집합을 위한 병렬 처리 수준은 런타임 시에 결정될 수 있으며 (및 상기 실행 집합을 병렬 처리하지 않을 가능성 있는 결정을 포함한다), 런타임시 사용 가능한 상기 계산 자원들에 의해서만 제한된다. 상기 실행 집합의 상기 독립적인 인스턴스들의 독립적인 출력들은 순서에 관계없이 상기 실행 집합의 출력 포트(들)에서 수집되며, 다운스트림 구성 요소들로 사용 가능하다. 대안적으로, 다른 실시 예들에서, 구동 입력 스칼라 데이터 포트를 필요로 하지 않는 상기 루트 실행 집합 이외의 실행 집합들이 인식될 수 있다 (어떤 경우에는, 사용자 입력에 기초하여). 구동 입력 스칼라 데이터 포트가 없는 그러한 실행 집합은 적절한 경우에 (예를 들어, 후술 될 래칭된 실행 집합에 대해) 단일 인스턴스에서 또는 병렬의 다수의 인스턴트에서 여기서 설명된 상기 절차들을 사용하여 실행될 수 있다. 예를 들어, 실행 집합이 실행될 횟수 및/또는 실행될 상기 실행 집합의 병렬 인스턴스들 수를 결정하는 매개 변수(parmeter)가 설정될 수 있다.

매우 일반적으로, 상기 실행 집합 발견 절차는 데이터 요소들의 비정렬 수집의 입력 요소들에 집합으로서 적용되는 상기 데이터 처리 그래프 내의 구성 요소들의 서브 집합들을 결정하는 할당 알고리즘을 사용한다. 상기 할당 알고리즘은 상기 데이터 처리 그래프를 가로 질러 할당 규칙들에 기초하여 각각의 구성 요소를 서브셋에 할당한다. 다음의 예들에서 명백하듯이, 주어진 데이터 처리 그래프는 실행 집합 계층 구조의 상이한 레벨들에 중첩된 다수의 실행 집합들을 포함할 수 있다.

여기에 설명된 상기 데이터 처리 그래프들에는 두 가지 유형들의 데이터 포트들 (스칼라 데이터 포트들 및 수집 데이터 포트들)이 있다. 일반적으로 쌍의 링크된 구성 요소들 (즉, 업스트림 구성 요소와 다운스트림 구성 요소)은 동일한 유형의 포트들 사이에서 링크로 연결된 경우 기본적으로 동일한 실행 집합일 것이다 (그들이 다른 이유로 다른 실행 집합들에 있지 않는 한). 도 5a에서, 구성 요소 A (402)는 스칼라 유형을 갖는 출력 포트 (406)를 가지며 구성 요소 B (404)는 스칼라 유형을 갖는 입력 포트 (408)를 갖는다. 구성 요소 A (402)와 구성 요소 B (404) 사이의 상기 링크 (410)가 두 개의 스칼라 유형 포트들을 연결하기 때문에, 구성 요소 A 및 B (402 및 404)는 이 예에서 동일한 실행 집합에 있다. 도 5a에서, 구성 요소 A (402)와 구성 요소 B (404) 사이의 상기 링크가 스칼라 - 스칼라 링크이기 때문에, 0 데이터 요소들 또는 1 데이터 요소들 중 하나가 상기 링크 (410)를 걸쳐 업스트림 구성 요소 A (402)와 다운스트림 구성 요소 B (404) 사이를 통과하게 된다. 업스트림 성분 A (402)가 억제되지 않는다면 (상술한 바와 같이) 업스트림 구성 요소 A (402)의 처리 완료 시 데이터 요소는 상기 링크 (410)를 걸쳐 통과하게 되고, 업스트림 구성 요소 A (402)가 억제된다면 어떠한 데이터 요소도 상기 링크 (410)를 걸쳐 통과하지 못한다.

도 5b를 참조하면, 구성 요소 A (402)는 수집 유형을 갖는 출력 포트 (412)를 가지며 구성 요소 B (404)는 수집 유형을 갖는 입력 포트 (414)를 가진다. 구성 요소 A (402)와 구성 요소 B (404) 사이의 상기 링크 (410)가 두 개의 수집 유형 포트들을 연결하기 때문에, 구성 요소 A (402) 및 구성 요소 B (404)는 또한 이 예에서 동일한 실행 집합에 있다. 도 5b에서, 구성 요소 A (402)와 구성 요소 B (404) 사이의 상기 링크 (410)가 수집 - 수집 링크이기 때문에, 한 집합의 데이터 요소들이 상기 링크 (410)를 걸쳐 업스트림 및 다운스트림 구성 요소들 사이를 통과하게 된다.

링크의 양쪽 끝에 있는 상기 포트 유형들 사이에 불일치가 있을때, 상기 실행 집합 계층 구조의 레벨에는 암시적인 변화가 있다. 특히, 일치하지 않는 포트들은 실행 집합 계층 구조의 특정 레벨에서 실행 집합에 대한 진입점들 또는 출구점들을 표시한다. 일부 예에서, 실행 집합 진입점은 수집 유형 출력 포트와 스칼라 유형 입력 포트 사이의 링크로 정의된다. 도 5c에서, 구성 요소 A (402)의 상기 출력 포트 (416)가 수집 유형 포트이고 구성 요소 B (404)의 상기 입력 포트 (418)가 스칼라 유형 포트이기 때문에, 실행 집합 진입점 (424)의 일례가 구성 요소 A (402)와 구성 요소 B (404) 사이의 상기 링크 (410)에 도시되어 있다.

일부 예들에서 실행 집합 출구점은 스칼라 유형 출력 포트와 수집 유형 입력 포트 사이의 링크로 정의된다. 도 5d에서, 구성 요소 A (402)의 상기 출력 포트 (420)가 스칼라 유형 포트이고 구성 요소 B (404)의 상기 입력 포트 (422)가 스칼라 유형 포트이기 때문에, 실행 집합 출구점 (426)의 일례가 구성 요소 A (402)와 구성 요소 B (404) 사이의 상기 링크 (410)에 도시되어 있다.

상기 컴파일러/인터프리터 (120)에 의한 컴파일링 및/또는 해석에 앞서 구현된 상기 할당 알고리즘은 실행 집합 진입점들 및 실행 집합 출구점들을 사용하여 상기 데이터 처리 그래프에 존재하는 상기 실행 집합들을 발견한다.

3. 실행 집합 컴파일

도 6을 참조하면, 데이터 처리 그래프 (600)의 일례는 데이터 소스 A (650)로부터 입력 데이터를 수신하고 다수의 구성 요소들을 사용하여 상기 입력 데이터를 처리하고, 및 상기 데이터를 처리한 결과들을 제 1 데이터 싱크 H (652) 및 제 2 데이터 싱크 I (654)에 저장한다. 상기 데이터 처리 그래프 (600)의 상기 구성 요소들은 제 1 구성 요소 B (656), 제 2 구성 요소 C (658), 제 3 구성 요소 D (660), 제 4 구성 요소 E (662), 제 5 구성 요소 F (664) 및 제 6 구성 요소 G (666)를 포함한다.

제 1 흐름 (651)은 상기 데이터 소스 (650)의 출력 수집 포트를 상기 제 1 구성 요소 B (656)의 입력 수집 포트에 연결한다. 제 2 흐름 (653)은 상기 제 1 구성 요소 B (656)의 출력 수집 포트를 제 2 구성 요소 C (658)의 입력 스칼라 포트에 연결한다. 상기 제 2 흐름 (653)은 출력 수집 포트를 입력 스칼라 포트에 연결하기 때문에, 실행 집합 진입점 (655)은 상기 제 1 구성 요소 B (656)와 상기 제 2 구성 요소 C (658) 사이에 존재한다는 점에 유의하라.

제 3 흐름 (657)은 상기 제 2 구성 요소 C (658)의 출력 스칼라 포트를 상기 제 3 구성 요소 D (660) 및 상기 제 4 구성 요소 E (662) 모두의 입력 스칼라 포트들에 연결한다. 제 4 흐름 (659)은 상기 제 3 구성 요소 D (660)의 출력 스칼라 포트를 상기 제 5 구성 요소 F (664)의 입력 수집 포트에 연결한다. 제 5 흐름 (661)은 상기 제 4 구성 요소 (662)의 출력 스칼라 포트를 상기 제 6 구성 요소 G (666)의 입력 수집 포트에 연결한다. 상기 제 4 흐름 (659) 및 상기 제 5 흐름 (661)은 출력 스칼라 포트들을 입력 수집 포트들에 연결하기 때문에, 제 1 실행 집합 출구점 (663)은 상기 제 3 구성 요소 D (660)와 상기 제 5 구성 요소 F (664) 사이에 존재하고, 제 2 실행 집합 출구점 (665)은 상기 제 4 구성 요소 E (662)와 상기 제 6 구성 요소 G (666) 사이에 존재한다는 점에 유의하라.

제 6 흐름 (667)은 상기 제 5 구성 요소의 상기 출력 수집 포트 F (664)를 상기 제 1 데이터 싱크의 입력 수집 포트 H (652)에 연결한다. 제 7 흐름 (669)은 상기 제 6 구성 요소 G (666)의 상기 출력 수집 포트를 상기 제 2 데이터 싱크 I (654)의 상기 입력 수집 포트에 연결한다.

상기 유의된 바와 같이, 상기 컴파일러/인터프리터 (120)가 실행을 위해 상기 데이터 처리 그래프 (600)를 준비할 때, 잠재적으로 중첩된 실행 집합들의 구성 요소들의 계층 구조를 식별하기 위해 실행 집합 발견 전 처리 절차를 먼저 수행한다. 도 6의 상기 예시적인 데이터 처리 그래프 (600)를 위해, 상기 실행 집합 발견 전 처리 절차는 상기 실행 집합 진입점 (655), 상기 제 1 실행 출구점 (663) 및 상기 제 2 실행 집합 출구점 (665)에 의해 한정된 제 1 실행 집합 (668)을 식별한다. 도면으로부터 명백한 바와 같이, 상기 제 1 실행 집합 (668)은 상기 제 2 구성 요소 C (658), 상기 제 3 구성 요소 D (660) 및 상기 제 4 구성 요소 E (662)를 포함한다.

상기 실행 집합 (668)을 식별한 후, 상기 컴파일러/인터프리터 (120)는 상기 컴파일러/인터프리터 (120)가 상기 제 1 실행 집합 내의 상기 구성 요소들의 실행을 제어하기 위해 런타임에 상태 머신을 효과적으로 구현할 제어 코드를 형성하기 위해 사용할 상기 제 1 실행 집합을 위한 제어 그래프를 생성하기 위해 제어 그래프 생성 절차를 수행한다. 상기 제어 그래프를 생성하는 한 단계는 상기 구성 요소들을 태스크 그룹들로 그룹화하는 것을 포함한다.

일부 예들에서, 상기 컴파일러/인터프리터 (120)는 상기 실행 집합 (668)의 상기 구성 요소들을 포함하는 상기 데이터 처리 그래프의 상기 구성 요소들 각각을 적어도 하나의 태스크 그룹들로 그룹화하는 것을 포함한다. 상기 데이터 처리 그래프 (600)가 실행될 때, 태스크는 각각의 태스크 그룹을 위해 스폰되고, 상기 태스크 그룹에 속하는 상기 구성 요소들의 상기 연산들은 상기 태스크 내에서 수행된다. 상기 데이터 처리 그래프의 모든 구성 요소들이 태스크 그룹들로 그룹화되는 동안, 본 명세서에 설명된 측면들은 주로 실행 집합 내의 구성 요소들을 태스크 그룹들로 그룹화하는 것에 관한 것이다. 이러한 이유로, 나머지 논의는 주로 상기 실행 집합 (668)의 상기 구성 요소들을 태스크 그룹들로 상기 그룹화하는 것에 관한 것이다.

상기 실행 집합 (668)의 상기 구성 요소들의 태스크 그룹들로의 다수의 상이한 그룹핑들이 가능하며, 각각의 상이한 그룹핑은 관련된 장점들과 단점들을 가진다. 일반적으로, 상기 실행 집합 (668)의 상기 구성 요소들이 태스크 그룹들로 최적으로 그룹화되는 방식은 최적성 기준(optimlity criterion)에 의존한다.

3.1 레이턴시 최소화를 위한 컴파일링

예를 들어, 최적성 기준이 상기 실행 집합 (668)의 상기 구성 요소들의 최적 그룹핑보다 작다고 지정하면, 최소 계산의 레이턴시를 달성하며, 상기 구성 요소들을 태스크 그룹들로 그룹화할 수 있는 한 가지 가능한 방법은 각각의 구성 요소를 그것 자신의 독립적인 태스크 그룹으로 그룹화하는 것을 포함한다. 이렇게 하는는 것은, 가능한 경우, 구성 요소들의 상기 연산들 (때로는 상기 "작업 절차"라고 함)이 동시에 실행되는 것을 허용한다. 예를 들어, 상기 실행 집합 (668)에서, 제 1 태스크 그룹은 상기 제 2 구성 요소 C (658)에 할당될 수 있고, 제 2 태스크 그룹은 상기 제 3 구성 요소 D (660)에 할당될 수 있고, 및 상기 제 4 구성 요소 E (662)는 제 3 태스크 그룹에 할당될 수 있다.

도 7을 참조하면, 상기 데이터 처리 그래프 (600)의 상기 실행 집합 (668)이 실행될 때, 제 1 태스크 (770)가 상기 제 1 태스크 그룹을 위해 스폰되고, 상기 제 2 구성 요소 C (758)의 상기 연산들은 상기 제 1 태스크 (770)에서 수행된다. 상기 제 2 구성 요소 C (758)의 상기 연산들이 완료되면, 상기 제 1 태스크는 상기 제 2 태스크 그룹을 위한 제 2 태스크 (772) 및 상기 제 3 태스크 그룹을 위한 제 3 태스크 (774)를 스폰한다. 상기 제 3 구성 요소 D (760)의 상기 연산들은 상기 제 3 태스크 (774)에서 수행되는 상기 제 4 구성 요소 E (762)의 상기 연산들과 동시에 상기 제 2 태스크 (772)에서 수행된다.

유리하게, 상기 제 4 구성 요소 E (762)의 상기 연산들과 동시에 상기 제 3 구성 요소 D (760)의 상기 연산들을 수행함으로써, 어느 구성 요소도 그것의 연산들을 수행하기 전에 다른 구성 요소가 완료될 때까지 기다릴 필요가 없으므로 계산적 지연이 최소화된다. 반면에, 다수의 태스크들을 스폰하는 것과 관련된 컴퓨팅 자원들과 시간 모두에서는 비용이 있다. 즉, 상기 실행 집합 (668)의 상기 구성 요소들을 최소 계산적 레이턴시를 위해 태스크 그룹들로 그룹화하는 것은 상기 구성 요소들을 그룹화하는 가장 효율적인 방법이 아니다 (여기서 효율성은 주어진 태스크를 수행하는 데 사용되는 컴퓨팅 자원들의 양을 측정한 것으로 정의된다).

3.2 효율 최대화를 위한 컴파일링

대안적으로, 만일 최적성 기준이 상기 실행 집합 (668)의 상기 구성 요소들의 최적의 그룹핑이 (위에서 정의된 바와 같이) 최대 효율을 달성하도록 지정되면, 상기 실행 집합 (668)의 상기 구성 요소들은 단일 태스크 그룹으로 그룹화된다. 그렇게 하는 것은 동시성이 가능한 경우에도, 상기 실행 집합 (668)의 상기 구성 요소들의 상기 연산들이 단일 태스크 내에서 순차적으로 수행될 것을 요구한다.

예를 들어, 상기 실행 집합 (668)에 대해, 제 1 태스크 그룹은 제 2 구성 요소 C (658), 상기 제 3 구성 요소 D (660), 및 상기 제 4 구성 요소 E (662)를 포함할 수 있다. 도 8을 참조하면, 상기 데이터 처리 그래프 (600)의 상기 실행 집합 (668)이 실행될 때, 단일 태스크 (876)는 상기 제 1 태스크 그룹을 위해 스폰되고 상기 제 2 성분 C (758), 상기 제 3 성분 D (760) 및 상기 제 4 성분 E (762)의 상기 연산들은 상기 단일 태스크 내에서 순차적으로 (즉, 한번에 하나씩) 수행된다. 일부 예들에서, 상기 제 2 구성 요소 C (758), 상기 제 3 구성 요소 D (760) 및 상기 제 4 구성 요소 E (762)의 상기 연산들은 토폴로지별로(topologically) 분류된 순서로 수행되어, 상기 데이터 처리 그래프 (600)에 지정된 상기 연산들의 순서가 보존되는 것을 보장한다.

상기 실행 집합 (668)의 상기 연산들을 단일 태스크에서 순차적으로 수행하는 것의 하나의 이점은 상기 연산들을 실행하는 것의 효율이 최대화된다는 것이다. 특히, 상기 데이터 처리 그래프를 실행되는데 필요한 계산 자원들의 양은 최소화되어, 다수의 태스크들을 스폰하는 것과 관련된 오버헤드를 피한다. 물론 다수의 태스크들의 순차적 실행은 다수의 태스크들의 동시 실행보다 완료하는 데 잠재적으로 시간이 더 오래 걸리는 단점이 있다.

3.3 레이턴시 대(vs.) 효율 절충(tradeoff)을 위한 컴파일링

일부 예들에서, 최적성 기준은 상기 실행 집합 (668)의 상기 구성 요소들을 태스크 그룹들로 최적으로 그룹화하는 것보다 레이턴시 최소화와 효율성 사이의 절충을 달성하도록 지정한다. 그러한 절충을 달성하기 위한 다수의 예시적인 접근법들이 다음 섹션들에서 설명된다.

3.3.1 잠재적 연산 식별

레이턴시 최소화와 효율성 사이의 절충을 달성하는 한 가지 방법은 먼저 상기 데이터 처리 그래프의 상기 구성 요소들에 의해 수행된 특정 연산들이 태스크를 스폰하는데 필요한 상기 시간에 비해 오랜 시간이 걸릴 수 있다는 것을 인식하는 것이다. 이들 연산들을 종종 "잠재적 연산들 (latent operations)"이라고 한다. 특정 다른 연산들은 태스크를 스폰하는 데 필요한 상기 시간에 비해 짧은 양의 시간이 소요될 수 있다.

상기 실행 집합 (668)의 두 개 이상의 상기 구성 요소들이 동시에 실행될 수 있는 상황들에서, 상기 컴파일러/인터프리터 (120)는 상기 실행 집합 (668)의 상기 구성 요소들을 위한 상기 연산이 완료되는 데 걸리는 시간의 추정에 기초하여 상기 실행 집합 (668)의 상기 연산들의 동시 실행을 허용할 지 여부를 결정한다. 임의의 잠재적 연산들이 상기 실행 집합에서 식별되면, 상기 실행 집합 (668)의 상기 구성 요소들은 동시에 실행되도록 허용된다. 만일 상기 실행 집합 (668)에서 잠재적 연산들이 식별되지 않으면, 상기 실행 집합 (668)의 상기 구성 요소들의 동시 실행이 허용되지 않는다.

일부 예들에서, 상기 실행 집합 (668)의 상기 구성 요소들을 위한 상기 연산들이 완료되는 데 걸리는 시간을 결정하기 위해, 상기 컴파일러/인터프리터 (120)는 데이터베이스 액세스들, 룩업 파일 연산들, 원격 절차 호출들, 서비스 호출들 등과 같은 잠재적 연산들을 식별하기 위해 상기 구성 요소들과 관련된 트랜잭션 코드(taransactional code) (예를 들어, 전술 한 바와 같이 DML 코드)를 검사한다. 다른 예들에서, 상기 컴파일러/인터프리터 (120)는 런타임 계측을 사용하여 태스크들이 상기 데이터 처리 그래프 (600)의 다수의 실행들에 걸쳐 완료하는 데 걸리는 시간을 측정한다. 상기 데이터 처리 그래프 (600)는 상기 태스크들이 완료하는 데 걸리는 상기 측정된 시간에 기초하여 온 더 플라이(on-the-fly) 또는 오프라인(offline)으로 재컴파일 될 수 있다.

도 9a를 참조하면, 하나의 매우 단순하고도 예시적인 예에서, 데이터 처리 그래프 (900)는 제 1 구성 요소 B (656)가 상기 데이터 소스 (650)로부터 값 x를 판독하고, x를 제 2 구성 요소 C (658)로 전송하도록 구성된다. 상기 제 2 구성 요소 C (658)는 x에 1을 더함으로써 값 y를 계산하고 상기 값 y를 제 3 구성 요소 D (660) 및 제 4 성분 E (662)로 보낸다. 상기 제 3 구성 요소 D (660)는 y에 2를 곱하여 값 z를 계산하고 z를 제 5 구성 요소 F (664)로 보낸다. 상기 제 4 성분인 E (662)는 y를 2로 나누어 값 q를 계산하고 q를 제 7 성분 G (666)로 보낸다. 상기 제 5 구성 요소 F (665)는 상기 값 z 를 상기 제 1 데이터 싱크 H (652)에 기록한다. 제 6 구성 요소 G (666)는 상기 값 q를 상기 제 2 데이터 싱크 I (654)에 기록한다.

상기 컴파일러/인터프리터 (120)가 도 9a의 상기 데이터 처리 그래프 (900)의 상기 실행 집합 (668)을 분석할 때, 상기 제 2 구성 요소 C (658), 상기 제 3 구성 요소 D (660), 및 상기 제 4 구성 요소 E (662)의 상기 트랜잭션 코드가 검사되어 상기 구성 요소들 중 임의의 구성 요소가 잠재적 연산들을 포함하는지를 결정한다. 도 9a의 상기 예에서, 상기 구성 요소들에 의해 수행되는 모든 상기 연산들이 매우 짧은 시간 내에 완료되는 단순한 산술 연산들이기 때문에 잠재적 연산들이 식별되지 않는다.

상기 실행 집합 (668)에서 잠재적 연산들이 식별되지 않기 때문에, 상기 실행 집합 (668)의 상기 구성 요소들은 동시에 실행되도록 허용되지 않는다. 그것을 위해, 상기 제어 그래프 생성 절차 동안 상기 제 2 구성 요소 C (658), 상기 제 3 구성 요소 D (660) 및 상기 제 4 구성 요소 E (662)가 단일 태스크 그룹으로 그룹화된다. 상기 데이터 처리 그래프가 실행되면, 상기 단일 태스크 그룹을 위한 단일 태스크가 스폰되고 상기 제 2 구성 요소 C (658), 상기 제 3 구성 요소 D (660) 및 상기 제 4 구성 요소 E (662)를 위한 상기 연산들이 상기 단일 태스크에서 실행된다 ( 도 8에서와 같이). 상기 제 1 실행 집합 (668)의 각각의 구성 요소의 단일 태스크에서의 실행과 함께, 상기 제 3 구성 요소 D (660) 및 상기 제 4 구성 요소 E (662)는 상기 제 구성 요소 C (658)의 상기 연산들 이후에 순차적으로 실행되도록 강화된다.

도 9b를 참조하면, 상기 단일 태스크 (즉, 태스크 1)가 스폰될 때 (즉, 태스크 1 개시 시), 제 1 오버헤드 (970)가 발생 되고 상기 제 2 구성 요소 C (658)가 실행을 시작한다. 상기 제 2 구성 요소 C (658)의 실행이 완료되면, 상기 제 3 구성 요소가 실행을 시작한다. 상기 제 3 구성 요소 D (660)의 실행이 완료되면, 상기 제 4 구성 요소 E (662)가 실행되고, 그 후 상기 단일 태스크가 완료된다.

단일 태스크 (즉, 태스크 1)에서 상기 세 개의 구성 요소들이 순차적으로 실행됨으로써, 상기 구성 요소들 중 적어도 일부의 동시 실행이 허용되는 경우보다 상기 세 개의 구성 요소들의 총 실행 시간이 더 길다. 그러나, 상기 단일 태스크를 시작하기 위한 제 1 오버헤드 (970)만이 발생하기 때문에, 단일 태스크 (또는 감소 된 태스크들의 수)에서 실행되는 것은 태스크 개시 관련 오버 헤드의 양이 줄어든다. 위에서 언급된 바와 같이, 오버헤드와 전체 실행 시간 사이의 이러한 절충은 실행 집합에서의 잠재적 연산들이 없는 경우에 종종 바람직하다. 비교로서, 도 9C는 상기 제 2 구성 요소 C (658)를 위한 태스크 (태스크 1) 이후의 분리된 태스크들 (즉, 태스크들 2와 3)에서 동시에 그들을 실행하기 위해 상기 제 3 구성 요소 D (660)와 상기 제 4 구성 요소 E (662) 사이의 상기 허용된 동시성을 사용한 상기 세 개의 구성 요소들의 상기 연산들로부터 야기된, 오버 헤드를 포함하는, 총 실행 시간 (980)을 보여 준다. 이 경우에는 상기 감소된 동시성 실행을 위한 상기 총 실행 시간이 더 짧음이 명백하다.

도 10a를 참조하면, 다른 단순하고 예시적인 예에서, 데이터 처리 그래프 (1000)는 제 1 구성 요소 B (656)가 데이터 소스 (650)로부터 값 x를 판독하고 x를 제 2 구성 요소 C (658)로 전송하도록 구성된다. 상기 제 2 구성 요소 C (658)는 x에 1을 더함으로써 값 y를 계산하고, 값 y를 제 3 구성 요소 D (660) 및 제 4 구성 요소 E (662)로 보낸다. 상기 제 3 구성 요소 D (660)는 y를 2로 곱함으로써 값 z를 계산하고 z를 제 5 구성 요소 F (664)로 보낸다. 상기 제 4 구성 요소 E (662)는 데이터 스토어 (671) (예를 들어, 룩업 파일 또는 데이터베이스)로부터 값 m을 판독하고 m 및 y를 합산함으로써 값 q를 계산한다. 상기 제 4 구성 요소 E (662)는 q를 제 7 구성 요소 G (666)로 보낸다. 상기 제 5 구성 요소 F (665)는 값 z를 제 1 데이터 싱크 H (652)에 기록한다. 상기 제 6 구성 요소 G (666)는 값 q를 제 2 데이터 싱크 I (654)에 기록한다.

상기 컴파일러/인터프리터 (120)가 도 10a의 상기 데이터 처리 그래프 (1000)의 상기 실행 집합 (668)을 분석할 때, 상기 제 2 구성 요소 C (658), 상기 제 3 구성 요소 D (660) 및 상기 제 4 구성 요소 E (662)의 트랜잭션 코드가 검사되어 상기 구성 요소들 중 임의의 구성 요소가 잠재적 연산들을 포함하는지를 판별한다. 도 10a의 예에서, 상기 제 4 구성 요소 E (662)는 상기 데이터 스토어 (671)로부터 값을 판독하기 때문에 잠재적 연산을 포함하는 것으로 식별된다.

잠재적 연산이 상기 실행 집합 (668)에서 식별되기 때문에, 상기 데이터 처리 그래프 (1000)의 상기 구성 요소들이 동시에 실행되도록 허용된다. 이를 위해, 상기 제어 그래프 생성 절차 동안에, 상기 제 2 구성 요소 C (658), 상기 제 3 구성 요소 D (660) 및 상기 제 4 구성 요소 E (662)는 상이한 태스크 그룹 (예들 들어, 제 1 태스크 그룹, 제 2 태스크 그룹 및 제 3 태스크 그룹)으로 각각 그룹화된다. 상기 데이터 처리 그래프 (600)가 실행될 때, 상이한 태스크가 각각의 상기 태스크 그룹들 (예를 들어, 상기 제 2 구성 요소 C (658)의 연산들을 실행하기 위한 상기 제 1 태스크 그룹을 위한 제 1 태스크, 상기 제 3 구성 요소 D (660)의 연산들을 실행하기 위한 상기 제 2 태스크 그룹을 위한 제 2 태스크, 상기 제 4 구성 요소 E (662)의 연산들을 실행하기 위한 상기 제 3 태스크 그룹을 위한 제 3 태스크) (도 7과 같이)을 위해 스폰된다. 상기 제 1 실행 집합 (668)의 각각의 구성 요소의 분리된 태스크에서의 실행과 함께, 상기 제 3 구성 요소 D (660)는 상기 제 4 구성 요소 E (662)와 함께 동시에 실행될 수 있다.

도 10b를 참조하면, 상기 제 1 태스크 (즉, 태스크 1)가 스폰되면 (즉, 태스크 1 시작 시) 제 1 오버헤드 (1070)가 발생하고 및 상기 제 2 구성 요소 C (658)가 실행을 시작한다. 상기 제 2 구성 요소 C (658)의 실행이 완료되면, 상기 제 1 태스크가 완료되고 및 상기 제 2 태스크 및 상기 제 3 태스크가 동시에 스폰되며 (태스크 1 완료 시), 제 2 오버헤드 (1072) 및 제 3 오버헤드 (1074)가 각각 발생한다. 상기 제 3 태스크에서의 상기 제 4 구성 요소 E (662)의 실행과 함께 상기 제 3 구성 요소 D (660)는 상기 제 2 태스크에서 동시에 실행된다. 상기 제 4 구성 요소 E (662)는 잠재적 연산이고 및 상기 제 3 구성 요소 D (660)는 잠재적 연산이 아니기 때문에, 상기 제 3 구성 요소 D (660)는 상기 제 4 구성 요소 E (662) 전에 실행을 완료하여 상기 제 2 태스크의 완료를 유발한다 (즉, 태스크 2 완료 시). 상기 제 4 구성 요소 E (662)가 상기 제 3 태스크에서 완료될 때까지 실행을 계속하여, 상기 제 3 태스크 (즉, 태스크 3 완료 시)의 완료를 유발한다. 도 10b의 타임라인의 타임 스케일이 도 9b의 상기 타임라인의 상기 타임 스케일과 다르며, 상기 태스크 시간들에 비해 상이한 지속 기간들을 가지는 오버헤드 시간의 동일한 절대량을 나타낸다.

비교로서, 도 10c는, 이 경우에, 상기 제 3 구성 요소 D (660) 및 상기 제 4 구성 요소 E (662)를 분리된 태스크들 (즉, 태스크 2 및 3)에서 동시에 실행함으로써, 상기 세 개의 구성 요소들의 총 실행 시간 (1080)은 상기 구성 요소들의 감소된 동시성 (이 경우 직렬) 실행이 사용된 경우에 야기되는 총 실행 시간 (1082)보다 작다. 이는 세 개의 분리된 태스크들을 인스턴스화함으로써 발생하는 오버헤드의 양이 단일 태스크가 감소된 동시성 실행을 위해 사용된 경우보다 큰 경우에도 해당된다. 위에서 언급했듯이, 전체 실행 시간과 오버 헤드 사이의 이러한 절충은 잠재적 연산들이 실행 집합에 존재할 때 종종 바람직하다.

동시 실행을 허용하는 구성 요소들의 태스크 그룹들 (및 최종 독립 태스크들)로의 다른 그룹핑들도 또한 사용될 수 있다. 예를 들어, 분리된 태스크 그룹들로 그룹화되기보다는, 상기 제 2 구성 요소 C (658) 및 상기 제 3 구성 요소 D (660)는 동일한 태스크 그룹으로 그룹화될 수 있고 최종 단일 태스크에서 실행될 수 있다. 물론, 상기 제 4 구성 요소 E (662)의 상기 연산들이 실행되는 단일 태스크는 상기 제 2 구성 요소 C (658)와 상기 제 4 구성 요소 E (662) 사이의 직렬 - 직렬 연결에 의해 부과된 상기 직렬 제한이 충족되는 한, 상기 제 2 구성 요소 C (658)와 제 3 구성 요소 D (660)의 상기 연산들이 실행되는 상기 태스크와 함께 동시에 실행될 수 있다.

3.3.2 중첩된 실행 집합 식별

레이턴시 최소화와 효율성 사이의 절충을 달성하는 또 다른 방법은 실행 집합에 포함된 임의의 "중첩된" 실행 집합들이 태스크를 스폰하기 위해 필요한 시간에 비해 오랜 시간이 걸릴 수 있다는 것을 인식하는 것을 포함한다. 예를 들어, 중첩된 실행 집합은 상기 데이터를 통한 루핑 또는 상기 데이터를 동시에 처리하기 위해 많은 수의 태스크들을 스폰하는 것을 포함하여 업스트림 수집 포트로부터 많은 양의 데이터를 처리할 수 있다.

따라서, 일부 실시 예들에서, 제 1 실행 집합의 적어도 두 개의 상기 구성 요소들이 동시에 실행될 수 있는 경우, 상기 컴파일러/인터프리터 (120)는 상기 제 1 실행 집합에 포함된 다른 중첩된 실행 집합들의 존재에 기초하여 상기 제 1 실행 집합의 상기 연산들의 동시 실행을 허용할지 여부를 결정한다. 임의의 중첩된 실행 집합들이 식별되면 제 1 실행 집합의 상기 구성 요소들이 동시에 실행되도록 허용된다. 상기 제 1 실행 집합에서 중첩된 실행 집합들이 식별되지 않으면, 상기 제 1 실행 집합의 상기 구성 요소들의 동시 실행이 허용되지 않는다.

도 11을 참조하면, 예시적인 데이터 처리 그래프 (1100)는 데이터 소스 A (1150)로부터 입력 데이터를 수신하고, 다수의 구성 요소들을 사용하여 상기 입력 데이터를 처리하고 및 상기 데이터 처리 결과들을 제 1 데이터 싱크 H (1152)와 제 2 데이터 싱크 I (1154)에 저장한다. 상기 데이터 처리 그래프 (1100)의 상기 구성 요소들은 제 1 구성 요소 B (1156), 제 2 구성 요소 C (1158), 제 3 구성 요소 D (1160), 제 4 구성 요소 E (1162), 제 5 구성 요소 J (1172), 제 6 구성 요소 F (1164) 및 제 7 구성 요소 G (1166)를 포함한다.

제 1 흐름 (1151)은 상기 데이터 소스 (1150)의 출력 수집 포트를 상기 제 1 구성 요소 B (1156)의 입력 수집 포트에 연결한다. 제 2 흐름 (1153)은 제 1 구성 요소 B (1156)의 출력 수집 포트를 상기 제 2 구성 요소 C (1158)의 입력 스칼라 포트에 연결한다. 상기 제 2 흐름 (1153)은 출력 수집 포트를 입력 스칼라 포트에 연결하기 때문에, 상기 제 1 구성 요소 B (1156)와 상기 제 2 구성 요소 C (1158) 사이에 제 1 실행 집합 진입점 (1155)이 존재한다는 것에 유의해야 한다.

제 3 흐름 (1157)은 상기 제 2 구성 요소 C (1158)의 출력 수집 포트를 상기 제 3 구성 요소 D (1160)의 입력 수집 포트 및 상기 제 4 구성 요소 E (1162)의 입력 스칼라 포트에 연결한다. 상기 제 3 흐름은 상기 제 2 구성 요소 C (1158)의 출력 수집 포트를 상기 제 4 구성 요소 E (1162)의 입력 스칼라 포트에 연결하기 때문에, 제 2 실행 집합 진입점 (1175)은 상기 제 2 구성 요소 C (1158)와 상기 제 4 구성 요소 E (1162) 사이에 존재한다.

제 4 흐름 (1159)은 상기 제 3 구성 요소 D (1160)의 출력 스칼라 포트를 상기 제 6 구성 요소 F (1164)의 입력 수집 포트에 연결한다. 상기 제 4 흐름은 출력 스칼라 포트를 입력 수집 포트에 연결하기 때문에, 제 1 실행 집합 출구점 (1163)이 상기 제 3 구성 요소 D (1160)와 상기 제 6 구성 요소 F (1164) 사이에 존재한다는 것에 유의해야 한다.

제 5 흐름 (1177)은 제 4 성분 E (1162)의 출력 스칼라 포트를 제 5 성분 J (1172)의 입력 수집 포트에 연결한다. 제 5 흐름 (1177)은 상기 제 4 구성 요소 E (1162)의 출력 스칼라 포트를 상기 제 5 구성 요소 J (1172)의 입력 수집 포트에 연결한다. 상기 제 5 흐름 (1177)은 출력 스칼라 포트를 입력 수집 포트에 연결하기 때문에, 제 2 실행 집합 출구점 (1179)이 상기 제 4 구성 요소 E (1162)와 상기 제 5 구성 요소 J (1172) 사이에 존재한다는 것에 유의해야 한다.

제 6 흐름 (1161)은 상기 제 5 구성 요소 J (1172)의 출력 스칼라 포트를 상기 제 7 구성 요소 G (1166)의 입력 수집 포트에 연결한다. 상기 제 6 흐름 (1161)이 출력 스칼라 포트를 입력 수집 포트에 연결하기 때문에, 상기 제 5 구성 요소 J (1172)와 상기 제 7 구성 요소 G (1166) 사이에 제 3 실행 집합 출구점 (1165)이 존재한다는 것에 유의해야 한다.

제 7 흐름 (1167)은 상기 제 6 구성 요소 F (1164)의 상기 출력 수집 포트를 상기 제 1 데이터 싱크 H (1152)의 상기 입력 수집 포트에 연결한다. 제 8 흐름 (1169)은 상기 제 7 구성 요소 G (1166)의 상기 출력 수집 포트를 상기 제 2 데이터 싱크 I (1154)의 상기 입력 수집 포트에 연결한다.

상기 컴파일러/인터프리터 (120)가 실행을 위해 상기 데이터 처리 그래프 (1100)를 준비할 때, 구성 요소들 중 잠재적으로 중첩된 실행 집합들의 계층 구조를 식별하기 위해 실행 집합 발견 전처리 절차를 먼저 수행한다. 도 11의 상기 예시적인 데이터 처리 그래프 (1100)에 대해, 상기 실행 집합 발견 전처리 절차는 상기 제 1 실행 집합 (1168) 내의 중첩된 제 1 실행 집합 (1168) 및 제 2 실행 집합 (1181)을 식별한다. 상기 제 1 실행 집합 (1168)은 상기 제 1 실행 집합 진입점 (1155), 상기 제 1 실행 출구점 (1163) 및 상기 제 3 실행 집합 출구점 (1165)에 의해 한정된다. 상기 2 실행 집합 (1181)은 상기 제 2 실행 집합 진입점 (1175) 및 상기 제 2 실행 집합 출구점 (1179)에 의해 한정된다. 상기 도면으로부터 명백한 바와 같이, 상기 제 1 실행 집합 (1168)은 상기 제 2 구성 요소 C (1158), 상기 제 3 구성 요소 D (1160), 상기 제 5 구성 요소 J (1172) 및 상기 제 4 구성 요소 E (1162)를 포함하는 상기 제 2 실행 집합 (1181)을 포함한다.

도 11에서, 상기 컴파일러/인터프리터 (120)는 상기 제 2 실행 집합 (1181)이 상기 제 1 실행 집합 (1186) 내에 중첩되어 있다고 결정한다. 중첩된 실행 집합이 상기 제 1 실행 집합 (1168)에서 식별되기 때문에, 동시 실행은 상기 제 1 실행 집합 (1168)의 상기 구성 요소들에 대해 허용된다. 이를 위해, 상기 제어 그래프 생성 절차 동안, 상기 제 2 구성 요소 C (1158), 상기 제 3 구성 요소 D (1160), 상기 제 4 구성 요소 E (1162) 및 상기 제 5 구성 요소 J (1172)는 상이한 태스크 그룹 (예를 들어, 제 1 태스크 그룹, 제 2 태스크 그룹, 제 3 태스크 그룹 및 제 4 태스크 그룹)으로 각각 그룹화된다. 상기 데이타 처리 그래프 (1100)가 실행될 때, 상이한 태스크는 상기 태스크 그룹들 (예를 들어, 상기 제 2 구성 요소 C (1158)의 연산들을 실행하기 위한 상기 제 1 태스크 그룹을 위한 제 1 태스크, 상기 제 3 구성 요소 D (1160)의 연산들을 실행하기 위한 상기 제 2 태스크 그룹을 위한 제 2 태스크, 상기 제 4 구성 요소의 연산들을 실행하기 위한 상기 제 3 태스크 그룹을 위한 제 3 태스크 및 상기 제 5 구성 요소 J (1172)의 연산들을 실행하기 위한 상기 제 4 태스크 그룹을 위한 제 4 태스크)의 각각을 위해 스폰된다. 상기 제 1 실행 집합 (668)의 각각의 구성 요소의 분리된 태스크에서의 실행과 함께, 상기 제 3 구성 요소 D (1160)는 상기 제 4 구성 요소 E (1162) 및 상기 제 5 구성 요소 J (1172) 중 하나 또는 모두와 동시에 실행될 수 있다.

동시 실행을 허용하는 구성 요소들의 태스크 그룹들 (및 최종 독립 태스크들)로의 다른 그룹핑들도 또한 사용될 수 있음에 유의하라. 예를 들어, 분리된 태스크 그룹들로 그룹화되기보다는, 상기 제 2 구성 요소 C (1158) 및 상기 제 3 구성 요소 D (1160)는 동일한 태스크 그룹으로 그룹화될 수 있고 최종 단일 태스크에서 실행될 수 있다. 물론, 상기 제 4 구성 요소 E (1162)와 제 5 구성 요소 J (1172)의 상기 연산들이 실행되는 상기 단일 태스크는 상기 제 2 구성 요소 C (1158) 및 제 3 구성 요소 D (1160)의 상기 연산들이 실행되는 상기 태스크와 함께 동시에 실행될 수 있다.

3.3.3 내부 실행 집합 동시성 식별

레이턴시 최소화와 효율성 사이의 절충을 달성하는 또 다른 방법은 실행 집합 내에 가능한 동시성이 존재하는지 여부를 결정하는 것이다. 예를 들어, 두 구성 요소들이 상기 두 구성 요소들의 제 1 구성 요소가 흐름에 의해 상기 두 구성 요소들의 제 2 구성 요소의 입력 수집 포트에 연결 (즉, 수집 - 수집 포트 연결)된 출력 수집 포트를 갖는 실행 집합 (1268)에 존재할 수 있다. 이 경우에, 상기 두 구성 요소들은 동일한 실행 집합에 있더라도 동시에 실행되도록 허용될 수 있는 가능성을 가진다.

제 1 실행 집합의 적어도 두 개의 상기 구성 요소들이 동시에 실행될 수 있는 일부 예들에서, 상기 컴파일러/인터프리터 (120)는 상기 데이터 처리 그래프의 토폴로지 및 특정 런타임 특성에 기초하여 상기 제 1 실행 집합의 상기 연산들의 동시 실행을 허용할지 여부를 결정한다. 만일 상기 제 1 실행 집합에서 가능한 동시성이 식별되면, 상기 제 1 실행 집합의 상기 구성 요소들이 동시에 실행되도록 허용될 수 있다. 상기 제 1 실행 집합에서 가능한 동시성이 식별되지 않으면, 상기 제 1 실행 집합의 상기 구성 요소들의 동시 실행은 허용되지 않는다. 만일 가능한 동시성이 있으면, 런타임에 실제로 사용되는 상이한 동시성의 레벨이 있을 수 있다. 예를 들어, 가능한 동시성의 최고 레벨로 상기 구성 요소들의 90 %가 동시에 실행될 수 있다 ; 그리고 동시에 실행되는 상기 구성 요소들의 10%의 감소된 동시성의 레벨은 런타임에 실제로 사용되어 (생성된 코드에 의해 강화되어) 특정 요인들에 기초하여 절충들을 만들 수 있다.

도 12를 참조하면, 예시적인 데이터 처리 그래프 (1200)는 데이터 소스 A (1250)로부터 입력 데이터를 수신하고, 다수의 구성 요소들을 사용하여 상기 입력 데이터를 처리하고, 상기 데이터를 처리한 결과들을 제 1 데이터 싱크 H (1252) 및 제 2 데이터 싱크 I (1254)에 저장한다. 상기 데이터 처리 그래프 (1200)의 상기 구성 요소들은 제 1 성분 B (1256), 제 2 성분 C (1288), 제 3 성분 D (1260), 제 4 성분 E (1262), 제 5 성분 J(1272), 제 6 성분 F (1264) 및 제 7 성분 G (1266)을 포함한다.

제 1 흐름 (1251)은 상기 데이터 소스 (1250)의 출력 수집 포트를 상기 제 1 구성 요소 B (1256)의 입력 수집 포트에 연결한다. 제 2 흐름 (1253)은 상기 제 1 구성 요소 B (1256)의 출력 수집 포트를 상기 제 2 구성 요소 C (1258)의 입력 스칼라 포트에 연결한다. 상기 제 2 흐름 (1253)은 출력 수집 포트를 입력 스칼라 포트에 연결하기 때문에, 제 1 실행 집합 진입점 (1255)은 상기 제 1 구성 요소 B (1256)와 상기 제 2 구성 요소 C (1258) 사이에 존재한다는 것에 유의해야 한다.

제 3 흐름 (1257)은 상기 제 2 구성 요소 C (1258)의 출력 스칼라 포트를 상기 제 3 구성 요소 D (1260)의 입력 스칼라 포트 및 상기 제 4 구성 요소 E (1262)의 입력 스칼라 포트에 연결한다.

제 4 흐름 (1259)은 상기 제 3 구성 요소 D (1260)의 출력 스칼라 포트를 상기 제 6 구성 요소 F (1264)의 입력 수집 포트에 연결한다. 상기 제 4 흐름은 출력 스칼라 포트를 입력 수집 포트에 연결하기 때문에, 제 1 실행 집합 출구점 (1263)은 상기 제 3 구성 요소 D (1260)와 상기 제 6 구성 요소 F (1264) 사이에 존재한다는 것에 유의해야 한다.

제 5 흐름 (1277)은 상기 제 4 구성 요소 E (1262)의 출력 수집 포트를 상기 제 5 구성 요소 J (1272)의 입력 수집 포트에 연결한다.

제 6 흐름 (1261)은 상기 제 5 구성 요소 J (1272)의 출력 스칼라 포트를 상기 제 7 구성 요소 G (1266)의 입력 수집 포트에 연결한다. 상기 제 6 흐름 (1261)은 출력 스칼라 포트를 입력 수집 포트에 연결하기 때문에, 제 3 실행 집합 출구점 (1265)은 상기 제 5 구성 요소 J (1272)와 상기 제 7 구성 요소 G (1266) 사이에 존재한다는 것에 유의해야 한다.

제 7 흐름 (1267)은 상기 제 6 구성 요소 F (1264)의 출력 수집 포트를 상기 제 1 데이터 싱크 H (1252)의 입력 수집 포트에 연결한다. 제 8 흐름 (1269)은 상기 제 7 구성 요소 G (1266)의 출력 수집 포트를 상기 제 2 데이터 싱크 I (1254)의 입력 수집 포트에 연결한다.

상기 컴파일러/인터프리터 (120)가 실행을 위해 상기 데이터 처리 그래프 (1200)를 준비할 때, 먼저 잠재적으로 중첩된 실행 집합들의 구성 요소들의 계층 구조를 식별하기 위해 실행 집합 발견 전처리 절차를 수행한다. 도 12의 상기 예시적인 데이터 처리 그래프 (1200)를 위해, 상기 실행 집합 발견 전처리 절차는 단일 실행 집합 (1268)을 식별한다. 상기 실행 집합 (1268)은 상기 제 1 실행 집합 진입점 (1255), 상기 제 1 실행 출구점 (1263) 및 상기 제 3 실행 집합 출구점 (1265)에 의해 한정된다. 상기 도면으로부터 명백한 바와 같이, 상기 실행 집합 (1268)은 상기 제 2 구성 요소 C (1258), 상기 제 3 구성 요소 D (1260), 상기 제 5 구성 요소 J (1272) 및 상기 제 4 구성 요소 E (1262)를 포함한다.

도 12에서, 상기 컴파일러/인터프리터 (120)는 또한 상기 실행 집합 (1268) 내의 가능한 동시성의 레벨 (상기 제 4 구성 요소 (E1262)와 상기 제 5 구성 요소 (J1272) 사이의 상기 수집 포트 - 수집 포트 연결을 인식함으로써)과 상기 실행 집합 (1268) 내의 상기 구성 요소들의 전체 토포롤지를 식별한다. 가능한 동시성이 상기 실행 집합 (1268)에서 식별되기 때문에, 동시 실행은 상기 실행 집합 (1268)의 상기 구성 요소들 중 적어도 일부에 대해 허용된다. 이를 위해, 상기 제어 그래프 생성 절차 동안, 상기 제 2 구성 요소 C (1258), 상기 제 3 구성 요소 D (1260), 상기 제 4 구성 요소 E (1262) 및 제 5 구성 요소 J (1272)는 상이한 태스크 그룹 (예를 들어, 제 1 태스크 그룹, 제 2 태스크 그룹, 제 3 태스크 그룹 및 제 4 태스크 그룹)으로 각각 그룹화된다. 전체 태스크 그룹이 런타임에 스폰될 단일 태스크 (예 : 프로세스 또는 쓰레드)에 의해 실행됨과 함께, 각각의 태스크 그룹은 적어도 하나의 구성 요소들의 연산들 포함한다. 각각의 구성 요소들을 자기 자신의 태스크 그룹에 할당하는 것은 런타임에 동시성의 하이 레벨을 가능하게 한다. 런타임에 감소된 동시성의 레벨을 강화하기 위해 대응하는 태스크가 상기 구성 요소들의 상기 연산들을 순차적으로 (즉, 동시성 없이) 실행함과 함께, 다수의 구성 요소들을 동일한 태스크 그룹에 할당할 수 있다.

상기 데이터 처리 그래프 (1200)가 실행될 때, 상이한 태스크가 상기 태스크 그룹들 (예를 들어, 상기 제 2 구성 요소 C (1258)의 연산들을 실행하기 위한 상기 제 1 태스크 그룹을 위한 제 1 태스크, 상기 제 3 구성 요소 D (1260)의 연산들을 실행하기 위한 상기 제 2 태스크 그룹을 위한 제 2 태스크, 상기 제 4 구성 요소 E (1262)의 연산들을 실행하기 위한 상기 제 3 태스크 그룹을 위한 제 3 태스크 및 상기 제 5 구성 요소 J (1272)의 연산들을 실행하기 위한 상기 제 4 태스크 그룹을 위한 제 4 태스크)의 각각을 위해 스폰된다. 상기 실행 집합 (1268)의 각각의 구성 요소가 분리된 태스크에서 실행됨과 함께, 상기 제 3 구성 요소 D (1260)는 상기 제 4 구성 요소 E (1262) 및 상기 제 5 구성 요소 J (1272) 중 하나 또는 모두와 동시에 실행될 수 있다. 그러나 상기 제 2 구성 요소 C (1288)와 상기 제 3 구성 요소 D (1260) 사이 및 상기 제 2 구성 요소 C (1288)와 상기 제 4 구성 요소 E (1262) 사이에 상기 연결된 직렬 포트들과 같은 상기 구성 요소들의 상기 포트들에 따라 상이한 태스크 사이에 강화되는 몇 가지 제한 조건들이 여전히 있을 수 있다.

상이한 레벨들의 동시 실행을 허용하는 구성 요소들의 태스크 그룹들 (및 최종 독립 태스크들)로의 다른 그룹핑들도 또한 사용될 수 있음에 유의하라. 예를 들어, 분리된 태스크 그룹들로 그룹화되기보다는, 상기 제 2 구성 요소 C (1258) 및 상기 제 3 구성 요소 D (1260)는 동일한 태스크 그룹으로 그룹화될 수 있고 최종 단일 태스크에서 실행될 수 있다. 상기 제 4 구성 요소 E (1262) 및 상기 제 5 구성 요소 J (1272)의 상기 연산들이 실행되는 단일 태스크 그룹 및 최종 태스크가 또한 할당될 수 있다. 그 단일 태스크는 상기 제 4 구성 요소 E (1262)가 실행을 시작하기 전에 상기 제 2 구성 요소 C (1258)가 실행을 완료하는 한, 제 2 구성 요소 C (1258) 및 상기 제 3 구성 요소 D (1260)의 상기 연산들이 실행되는 상기 태스크와 동시에 실행될 수 있다. 따라서, 상기 컴파일러/인터프리터 (120)에 의해 생성된 상기 코드에서 표시된 상기 태스크 그룹의 수 및 구성은 실행 집합의 상기 구성 요소들에 대응하는 연산들의 전체 그룹에서 상이한 동시성의 레벨을 강화할 수 있다.

4. 대안들

일부 예들에서, 실행 집합의 상기 구성 요소들이 출력 스칼라 포트로부터 입력 스칼라 포트 (즉, 스칼라 포트 - 스칼라 포트 연결)로의 연결들에 의해서만 서로 연결된다면, 상기 컴파일러/인터프리터 (120)는 상기 실행 집합의 상기 구성 요소들의 연산들을 단일 태스크 그룹에 자동으로 할당하고, 그런 다음 단일 태스크에 의해 연속적으로 실행되도록 제한된다.

일반적으로, 동시성의 상기 레벨을 변경하는, 실행 집합 내의 특정 구성 요소들 사이의 동시성을 허용하거나 허용하지 않기로 한 결정은, 상기 실행 집합에만 적용되며 구성 요소들 또는 상기 실행 집합 내의 중첩된 실행 집합들 (즉, 상기 실행 집합 계층 구조의 하위 레벨)에 반드시 적용되는 것은 아니다.

일부 예들에서, 주어진 실행 집합에서 동시성이 허용되지 않는 경우 상기 실행의 상기 구성 요소들을 위해 토폴로지별로 분류된 순서가 결정되고 상기 주어진 실행 집합의 상기 구성 요소들을 위해 상기 연산들이 토폴로지별로 분류된 순서로 단일 작업에서 실행된다.

일부 예들에서, 잠재적 연산은 태스크를 생성하는 데 필요한 상기 시간에 비하여 완료하는 데 오랜 시간이 걸리는 연산으로 정의된다. 일부 예들에서 잠재적 연산은 태스크를 생성하는 데 필요한 상기 시간보다 적어도 세 배 더 오래 걸리는 작업으로 정의된다. 일부 예들에서 잠재적 작업은 태스크를 생성하는 데 필요한 시간보다 적어도 10 배 더 오래 걸리는 작업으로 정의된다.

일부 예들에서, 사용자는 잠재적 연산을 정의하는 특성들을 지정한다. 일부 예들에서 사용자는 잠재적 연산들을 포함하는 구성 요소들을 명시적으로 지정한다. 일부 예들에서, 사용자는 실행 집합을 위한 컴파일 모드 (즉, 동시 또는 비 동시)를 명시적으로 지정할 수 있다.

일부 예들에서, 상기 상술된 접근법들은 동시 실행의 상기 가능성이 실행 집합에 존재하는 경우에만 수행된다. 예를 들어, 상기 컴파일러/인터프리터 (120)는 상기 상술된 접근법들을 수행하기 전에 동시 실행이 가능한지 여부를 결정하기 위해 상기 실행 집합에 포함된 상기 데이터 처리 그래프의 일부분을 걸을수 있다. 일부 예들에서, 상기 컴파일러/인터프리터 (120)는 상기 실행 집합에 포함된 상기 데이터 흐름 그래프의 일부분을 위한 최대 동시성을 결정한다.

위에서 설명된 각각의 상기 예들은 실행 집합의 상기 구성 요소들이 동시에 또는 순차적으로 실행되도록 컴파일하게 할 수 있는 적어도 하나의 구성 요소들의 하나의 런타임 특성을 강조 표시한다. 그러나, 실행 집합은 임의의 개수의 이들 특성들 (예를 들어, 잠재적 연산들, 중첩된 실행 집합들, 암시적 실행 집합들 등)의 조합을 갖는 구성 요소들을 포함할 수 있다. 일부 예들에서, 상기 구성 요소들의 상기 연산들이 태스크를 스폰하는데 필요한 상기 시간에 비해 완료하는데 더 오랜 시간이 걸릴 것이라는 것을 표시하는 특성을 포함한다면, 상기 실행 집합은 동시 실행이 허용되도록 컴파일된다.

전술한 상기 데이터 처리 그래프 컴파일 접근법들은, 예를 들어, 적절한 소프트웨어 명령들을 실행하는 프로그램 가능한 컴퓨팅 시스템을 사용하여 구현될 수 있거나, 또는 FPGA (field-programmable gate array)와 같은 적절한 하드웨어 또는 일부 하이브리드 형태로 구현될 수 있다. 예를 들어, 프로그램된 접근법에서, 상기 소프트웨어는 적어도 하나의 프로그램된 또는 프로그램 가능한 컴퓨팅 시스템(이는 분산, 클라이언드/서버 또는 그리드와 같은 다양한 아키텍처 일 수 있다) 상에서 실행하는 적어도 하나의 컴퓨터 프로그램들의 절차들을 포함할 수 있으며, 각각은 적어도 하나의 프로세서, 적어도 하나의 데이터 저장소 (휘발성 및/또는 비 휘발성 메모리 및/또는 저장 요소들을 포함하는)를 포함하며, 적어도 하나의 사용자 인터페이스 (적어도 하나의 입력 장치 또는 포트를 사용하여 입력을 수신하고, 적어도 하나의 출력 장치 또는 포트를 사용하여 출력을 제공하기 위한)를 포함할 수 있다. 상기 소프트웨어는 예를 들어 설계, 구성, 데이터 처리 그래프들의 실행과 관련된 서비스들을 제공하는 보다 큰 프로그램의 적어도 하나의 모듈들을 포함할 수 있다. 상기 프로그램의 상기 모듈들 (예를 들어, 데이터 처리 그래프의 요소들)은 데이터 저장소에 저장된 데이터 모델을 따르는 데이터 구조들 또는 다른 조직화된 데이터로서 구현될 수 있다.

상기 소프트웨어는 휘발성 또는 비 휘발성 저장 매체에 구현되는 것과 같이 일시적이지 않은 형태 또는 일정 기간 (예를 들어, 동적 RAM (dynamic RAM)과 같은 동적 메모리 디바이스의 리프레시 주기들 사이의 시간) 동안 상기 매체의 물리적 특성(예를 들어, 표면 피트들 및 랜드들, 자력 영역들 또는 전기 전하)을 사용하는 기타 비 일시적 매체로 저장될 수 있다. 상기 명령들 로드에 대비하여, 상기 소프트웨어는 CD-ROM 또는 다른 컴퓨터 판독 가능 매체 (예를 들어, 범용 또는 특수 목적 컴퓨팅 시스템 또는 장치에 의해 판독 가능한)와 같은 유형의, 비 일시적인 매체 상에 제공될 수 있거나, 네트워크의 통신 매체를 통해 그것이 실행되는 컴퓨팅 시스템의 유형의, 비 일시적인 매체에 전달 (예를 들어, 전파된 신호에 인코드되어) 될 수 있다. 상기 처리의 일부 또는 전부는 특수 목적 컴퓨터 상에서 수행될 수 있으며, 또는 코프로세서 (coprocessor) 또는 FPGA (Field-Programmable Gate Array) 또는 전용의 주문형 집적 회로 (ASIC)와 같은 특수 목적 하드웨어를 사용한다. 상기 처리는 소프트웨어에 의해 지정된 상기 계산의 상이한 부분들이 상이한 컴퓨팅 요소들에 의해 수행되는 분산 방식으로 구현될 수 있다. 이러한 각각의 컴퓨터 프로그램은 바람직하게는 범용 또는 특수 목적 프로그램 가능한 컴퓨터에 의해 액세스 가능한 저장 장치의 컴퓨터 판독 가능 저장 매체 (예를 들어, 고체 상태 메모리 또는 매체, 또는 자기 또는 광학 매체)에 저장되거나 다운로드되어, 상기 저장 장치 매체가 본 명세서에서 설명된 상기 처리를 수행하기 위해 상기 컴퓨터에 의해 판독될 때 상기 컴퓨터를 구성하고 운영한다. 본 발명의 시스템은 또한 컴퓨터 프로그램으로 구성되는 유형의, 비 일시적인 매체로서 구현되는 것으로 고려될 수 있으며, 그렇게 구성된 상기 매체는 컴퓨터로 하여금 여기서 설명된 적어도 하나의 처리 단계들을 수행하도록 특정의 소정의 방식으로 동작하게 한다.

본 발명의 많은 실시 예들이 설명되었다. 그럼에도 불구하고, 상기 전술한 설명은 예시하기 위한 것이지, 다음의 청구 범위들의 범주에 의해 규정되는 본 발명의 범위를 제한하는 것은 아니다. 따라서, 다른 실시 예들은 또한 다음의 청구항들의 범위 내에 있다. 예를 들어, 본 발명의 범위를 벗어나지 않고 다양한 변형이 이루어질 수 있다. 또한, 전술한 상기 단계들의 일부는 순서 독립적일 수 있으며, 따라서 상기 설명된 것과 다른 순서로 수행될 수 있다.

Claims (14)

1. 연산들의 동시 실행을 지원하는 컴퓨팅 시스템 상에서 실행하기 위한 그래프 기반의 프로그램 사양을 컴파일하기 위한 방법으로서, 상기 방법은:
   상기 그래프 기반의 사양을 수신하는 단계 - 상기 그래프 기반의 프로그램 사양은 그래프를 포함하고, 상기 그래프는:
   복수의 구성 요소들 - 각각은 적어도 하나의 연산에 대응함 - ; 및
   복수의 방향성 링크들 - 각각은 상기 복수의 구성 요소들의 업스트림 구성 요소를 상기 복수의 구성 요소들의 다운스트림 구성 요소에 연결함 - 을 포함함 - ; 및
   연산들의 적어도 하나의 그룹들을 표시하는 처리된 코드들을 생성하기 위해 상기 그래프 기반의 프로그램 명세를 처리하는 단계 - 상기 처리하는 단계는:
   제 1 그룹에서 다수의 연산들이 상기 그래프의 상기 토폴로지에 의해 동시에 실행되는 것이 방지되지 않도록 상기 연산들의 제 1 그룹에서 상기 그래프의 토폴로지에 적어도 부분적으로 기초하여 가능한 동시성의 레벨을 식별하는 단계;
   상기 분석된 연산들과 관련된 런타임 특성들을 결정하기 위해 상기 제 1 그룹에서 상기 연산들의 적어도 일부를 분석하는 단계; 및
   상기 제 1 그룹에서 상기 연산들을 실행하기 위한 처리된 코드를 생성하는 단계 - 여기서, 상기 처리된 코드는 상기 결정된 런타임 특성들에 적어도 부분적으로 기초하여, 상기 식별된 가능한 동시성의 레벨보다 낮은, 상기 제 1 그룹 내의 감소된 동시성의 레벨을 강화함 - 를 포함함 - 를 포함하는 그래프 기반의 프로그램 사양을 컴파일하기 위한 방법.
2. 제 1 항에 있어서, 상기 분석된 연산들과 관련된 런타임 특성들을 결정하기 위해 상기 제 1 그룹에서 상기 연산들의 적어도 일부를 분석하는 단계는 상기 분석된 연산들 각각에 대해, 상기 분석된 연산들이 제 1 임계값보다 더 큰 시간의 주기에 걸쳐 잠재적으로 계산을 수행하는 잠재적 연산인지 또는 상기 제 1 임계값보다 더 큰 시간의 주기 동안 응답을 잠재적으로 대기하는 잠재적 연산인지를 결정하는 단계를 포함하는 그래프 기반의 프로그램 사양을 컴파일하기 위한 방법.
   
3. 선행하는 어느 한 항에 있어서, 상기 분석된 연산들과 관련된 런타임 특성들을 결정하기 위해 상기 제 1 그룹에서 상기 연산들의 적어도 일부를 분석하는 단계는 상기 분석된 연산들의 각각에 대해, 상기 분석된 연산들이 상기 제 1 그룹의 단일 실행 개시에 응답하여 다수 회 실행하는 적어도 하나의 연산들의 반복 집합의 멤버인지를 결정하는 단계를 포함하는 그래프 기반의 프로그램 사양을 컴파일하기 위한 방법.
   
4. 선행하는 어느 한 항에 있어서, 상기 제 1 임계값은 적어도 하나의 연산들을 실행하기 위해 태스크를 스폰(spawn)하기 위해 요구되는 제 2 주기 시간보다 더 큰 제 1 주기 시간으로서 정의되는 그래프 기반의 프로그램 사양을 컴파일하기 위한 방법.
   
5. 선행하는 어느 한 항에 있어서, 상기 처리된 코드는, 조건들 중 어느 것도 충족되지 않는 경우, 상기 식별된 가능한 동시성의 레벨보다 낮은, 상기 제 1 그룹 내의 감소된 동시성의 레벨을 강화하며, 상기 조건들은:
   (1) 상기 그래프의 토폴로지에 의해 동시에 실행되는 것이 방지되지 않는 상기 제 1 그룹에서의 적어도 두 개의 연산들이 모두 잠재적 연산들로 결정되거나, 또는
   (2) 상기 제 1 그룹에서의 적어도 하나의 연산은 적어도 하나의 연산들의 반복 집합의 멤버로 결정되는, 그래프 기반의 프로그램 사양을 컴파일하기 위한 방법.
   
6. 제 5 항에 있어서, 상기 처리된 코드는, 추가적인 조건이 또한 충족되지 않는 경우, 상기 식별된 가능한 동시성의 레벨보다 낮은, 상기 제 1 그룹 내의 감소된 동시성의 레벨을 강화하며, 상기 추가적인 조건은
   (3) 상기 제 1 그룹에서 적어도 두 개의 연산들의 구성은 반복되는 집합의 존재를 의미하는 그래프 기반의 프로그램 사양을 컴파일하기 위한 방법.
   
7. 선행하는 어느 한 항에 있어서, 상기 식별된 가능한 동시성의 레벨보다 낮은, 상기 제 1 그룹 내의 감소된 동시성의 레벨을 강화하는 단계는 상기 제 1 그룹에서 모든 상기 연산들의 순차적인 실행을 강화하는 단계를 포함하는 그래프 기반의 프로그램 사양을 컴파일하기 위한 방법.
   
8. 선행하는 어느 한 항에 있어서, 적어도 하나의 상기 방향성 링크들은 업스트림 구성 요소와 다운스트림 구성 요소 사이의 데이터 흐름을 나타내는 그래프 기반의 프로그램 사양을 컴파일하기 위한 방법.
   
9. 제 8 항에 있어서, 적어도 하나의 상기 방향성 링크들은 업스트림 구성 요소와 다운스트림 구성 요소 사이의 제어 흐름을 나타내는 그래프 기반의 프로그램 사양을 컴파일하기 위한 방법.
   
10. 선행하는 어느 한 항에 있어서, 적어도 하나의 상기 방향성 링크들은 업스트림 구성 요소와 다운스트림 구성 요소 사이의 제어 흐름을 나타내는 그래프 기반의 프로그램 사양을 컴파일하기 위한 방법.
    
11. 선행하는 어느 한 항에 있어서, 연산들의 적어도 하나의 그룹들을 표시하는 처리된 코드들을 생성하기 위해 상기 그래프 기반의 프로그램 사양을 처리하는 단계는:
    상기 연산들의 상기 제 1 그룹 중에서 적어도 부분적인 순서화를 지정하는 순서화 정보를 생성하는 단계 - 상기 순서화 정보는 상기 그래프의 상기 토폴로지에 적어도 부분적으로 기초함 - 를 더 포함하고; 그리고
    상기 제 1 그룹에서 상기 가능한 동시성 레벨을 식별하는 단계는 상기 제 1 그룹에서 다수의 연산들이 상기 부분적인 순서화에 의해 동시에 실행되는 것이 방지되지 않도록 상기 부분적 순서화에 의해 허용되는 동시성 레벨을 식별하는 단계를 포함하는 그래프 기반의 프로그램 사양을 컴파일하기 위한 방법.
12. 제 11 항에 있어서, 상기 순서화 정보를 생성하는 단계는 연산들의 상기 제 1 그룹을 토폴로지별로 분류하는 단계를 포함하는 그래프 기반의 프로그램 사양을 컴파일하기 위한 방법.
    
13. 연산들의 동시 실행을 지원하는 컴퓨팅 시스템 상에서 실행하기 위해 그래프 기반의 프로그램 사양을 컴파일하기 위한 비 일시적인 형태의 소프트웨어를 저장하는 컴퓨터 판독 가능한 매체로서, 상기 소프트웨어는 상기 컴퓨팅 시스템으로 하여금:
    상기 그래프 기반의 사양을 수신하고 - 상기 그래프 기반의 프로그램 사양은 그래프를 포함하고, 상기 그래프는:
    복수의 구성 요소들 - 각각은 적어도 하나의 연산에 대응함 - ; 및
    복수의 방향성 링크들 - 각각은 상기 복수의 구성 요소들의 업스트림 구성 요소를 상기 복수의 구성 요소들의 다운스트림 구성 요소에 연결함 - 을 포함함 - ; 및
    연산들의 적어도 하나의 그룹들을 표시하는 처리된 코드들을 생성하기 위해 상기 그래프 기반의 프로그램 명세를 처리하는 - 상기 처리하는 단계는:
    제 1 그룹에서 다수의 연산들이 상기 그래프의 상기 토폴로지에 의해 동시에 실행되는 것이 방지되지 않도록 상기 연산들의 제 1 그룹에서 상기 그래프의 토폴로지에 적어도 부분적으로 기초하여 가능한 동시성의 레벨을 식별하는 단계;
    상기 분석된 연산들과 관련된 런타임 특성들을 결정하기 위해 상기 제 1 그룹에서 상기 연산들의 적어도 일부를 분석하는 단계; 및
    상기 제 1 그룹에서 상기 연산들을 실행하기 위한 처리된 코드를 생성하는 단계 - 여기서, 상기 처리된 코드는 상기 결정된 런타임 특성들에 적어도 부분적으로 기초하여, 상기 식별된 가능한 동시성의 레벨보다 낮은, 상기 제 1 그룹 내의 감소된 동시성의 레벨을 강화함 - 를 포함함 - 명령들을 포함하는 비 일시적인 형태의 소프트웨어를 저장하는 컴퓨터 판독 가능한 매체.
14. 그래프 기반의 프로그램 사양을 컴파일하기 위한 컴퓨팅 시스템으로서, 상기 컴퓨팅 시스템은:
    상기 그래프 기반의 프로그램 사양을 수신하기 위해 구성되는 입력 장치 또는 포트 - 상기 그래프 기반의 프로그램 사양은 그래프를 포함하고, 상기 그래프는:
    복수의 구성 요소들 - 각각은 하나의 연산에 대응함 - ; 및
    복수의 방향성 링크들 - 각각은 상기 복수의 구성 요소들의 업스트림 구성 요소를 상기 복수의 구성 요소들의 다운스트림 구성 요소에 연결함 - 을 포함함 - ; 및
    연산들의 적어도 하나의 그룹들을 표시하는 처리된 코드를 생성하기 위해 상기 그래프 기반의 프로그램 명세를 처리하는 적어도 하나의 프로세서 - 상기 처리하는 단계는:
    제 1 그룹에서 다수의 연산들이 상기 그래프의 상기 토폴로지에 의해 동시에 실행되는 것이 방지되지 않도록 상기 연산들의 제 1 그룹에서 상기 그래프의 토폴로지에 적어도 부분적으로 기초하여 가능한 동시성의 레벨을 식별하는 단계;
    상기 분석된 연산들과 관련된 런타임 특성들을 결정하기 위해 상기 제 1 그룹에서 상기 연산들의 적어도 일부를 분석하는 단계; 및
    상기 제 1 그룹에서 상기 연산들을 실행하기 위한 처리된 코드를 생성하는 단계 - 여기서, 상기 처리된 코드는 상기 결정된 런타임 특성들에 적어도 부분적으로 기초하여, 상기 식별된 가능한 동시성의 레벨보다 낮은, 상기 제 1 그룹 내의 감소된 동시성의 레벨을 강화함 - 를 포함함 - 를 포함하는 그래프 기반의 프로그램 사양을 컴파일하기 위한 컴퓨팅 시스템.
    

Images