KR102375350B1 - 그래프 기반 프로그램 명세의 컴파일링 - Google Patents

Abstract

그래프 기반 프로그램 명세(628)는 각각이 처리 태스크에 대응하고 하나 이상의 데이터 요소들을 전송하거나 수신하기 위한 하나 이상의 포트들을 포함하는 복수의 구성요소들; 및 각각이 상기 복수의 구성요소들의 업스트림 구성요소의 출력 포트를 상기 복수의 구성요소들의 다운스트림 구성요소의 입력 포트에 연결하는 하나 이상의 링크들을 포함한다. 상기 복수의 구성요소들의 서브세트들(630, 631)을 나타내는 준비된 코드가 생성되고, 연결된 구성요소들의 특성들에 적어도 부분적으로 기반하여 상이한 서브세트들의 구성요소들 사이의 복수의 서브세트 경계들을 식별하는 것; 및 런타임 시스템에 의한 실행을 위해 사용될 때 해당 형성된 서브세트의 구성요소들에 대응하는 처리 태스크들이 해당 형성된 서브세트에 대해 상기 준비된 코드에 임베드된(embedded)된 정보에 따라 수행되게 하는 각각의 형성된 서브세트에 대해 준비된 코드를 생성하는 것을 포함한다.

Description

그래프 기반 프로그램 명세의 컴파일링{COMPILING GRAPH-BASED PROGRAM SPECIFICATIONS}

본 출원은 2014년 9월 2일에 출원된 미국 출원 번호 62/044,645, 및 2015년 5월 20일에 출원된 미국 출원 번호 62/164,175에 대해 우선권을 주장한다.

본 설명은 그래프 기반 프로그램 명세를 컴파일하는 방법에 관한 것이다.

데이터 흐름 계산에 대한 하나의 방법은 그래프의 노드들(정점들)에 대응하는 계산 구성요소들이 상기 그래프(“데이터플로 그래프(dataflow graph)”라고 함)의 링크들(방향성 에지들(directed edges))에 대응하는 데이터 흐름들에 의해 결합되는 그래프 기반 표현을 사용한다. 데이터 흐름 링크에 의해 업스트림(upstream) 구성요소에 연결된 다운스트림(downstream) 구성요소는 입력 데이터 요소들의 정렬된 스트림을 수신하여, 상기 수신된 순서로 상기 입력 데이터 요소들을 처리하고, 선택적으로 출력 데이터 요소들의 하나 이상의 대응하는 흐름들을 생성한다. 이러한 그래프 기반 계산들을 실행하기 위한 시스템은 본원에서 참조로 원용된 “EXECUTING COMPUTATIONS EXPRESSED AS GRAPHS”이라는 타이틀의 선행 미국 특허 5,966,072에서 설명된다. 이전 특허에서 설명된 방법과 관련된 구현에서, 각각의 구성요소는 전형적으로 다수의 컴퓨터 서버들 중 하나 상에 호스팅되는 프로세스로서 구현된다. 각각의 컴퓨터 서버는 한 번에 여러 개의 이러한 구성요소 프로세스들을 활성화할 수 있고, 운영 시스템 (예를 들어, Unix) 스케줄러는 해당 서버 상에 호스팅된 구성요소들간에 자원(예를 들어, 프로세서 시간 및/또는 프로세서 코어)을 공유한다. 이러한 구현에서, 구성요소들간의 데이터 흐름들은 운영 시스템의 데이터 통신 서비스와 서버들을 연결하는 데이터 네트워크(예를 들어, 명명된 파이프들(named pipes), TCP/IP 세션들, 등)를 사용하여 구현될 수 있다. 구성요소들의 서브세트는 일반적으로 데이터 파일, 데이터베이스 테이블, 및 외부 데이터 흐름들로의 및/또는 그것들로부터의 전체 계산으로부터의 데이터의 소스(sources) 및/또는 싱크(sinks) 역할을 한다. 구성요소 프로세스들과 데이터 흐름들이 예를 들어, 조정 프로세스(coordinating process)에 의해 확립된 후, 데이터는 일반적으로 각각의 구성요소에서 입력 데이터의 가용성 및 상기 구성요소들 각각에 대해 자원들을 계산하는 스케줄링에 의해 통제되는 그래프로 표현된 상기 계산을 구현하는 전체 계산 시스템을 통해 흐른다. 따라서 적어도 상이한 구성요소들이 (동일한 또는 상이한 서버 컴퓨터들 또는 프로세서 코어들에 호스팅된) 상이한 프로세스들에 의해 병렬로 실행될 수 있게 하여 병렬처리(parallelism)가 달성될 수 있고, 여기서 데이터플로 그래프를 통해 상이한 경로들에서 병렬로 실행되는 상이한 구성요소들이 본원에서 구성요소 병렬처리로 지칭되고, 데이터플로 그래프를 통해 동일한 경로의 상이한 부분에서 병렬로 실행되는 상이한 구성요소들이 본원에서 파이프라인 병렬처리(pipeline parallelism)으로 지칭된다.

이러한 방법에 의해 병렬처리의 다른 형태들도 지원된다. 예를 들어, 입력 데이터 세트가 예를 들어, 데이터 세트의 레코드들을 처리하는 구성요소의 별개의 복사본으로 보내지는 각각의 부분으로 상기 데이터 세트의 레코드들의 필드의 값들의 파티션(partition)에 따라 분할될 수 있다. 구성요소의 이러한 별도의 복사본들(또는 “인스턴스들”)이 별개 서버 컴퓨터들 또는 서버 컴퓨터의 별개 프로세서 코어들에서 실행될 수 있어서, 그것을 달성하는 것이 본원에서 데이터 병렬처리(data parallelism)으로 지칭된다. 별개 구성요소의 결과들이 단일 데이터 흐름 또는 데이터 세트를 다시 형성하도록 병합될 수 있다. 구성요소의 인스턴스들을 실행하는데 사용되는 컴퓨터들 또는 프로세서 코어들의 개수는 데이터플로 그래프가 개발될 때 개발자에 의해 지정될 수 있다.

다양한 방법들이 이러한 방법의 효율성을 향상시키는데 사용될 수 있다. 예를 들어, 구성요소의 각각의 인스턴스가 예를 들어, 여러 구성요소들(예, 더 큰 그래프의 연결된 서브그래프를 형성하는 구성요소들)을 구현하기 위해 하나의 운영 시스템 프로세스를 사용하여, 반드시 그 자체 운영 시스템 프로세스에서 호스팅되어야 할 필요가 없다.

상술된 방법의 적어도 일부 구현들은 기반 컴퓨터 서버들(underlying computer servers)에서 결과 프로세스들의 실행 효율성과 관련하여 제한을 받는다. 예를 들어, 상기 제한들은 데이터 병렬처리의 정도를 변경하기 위해, 다양한 구성요소들을 호스팅하는 서버들로 변경하기 위해 및/또는 상이한 계산 자원들에 대한 부하 균형을 조정하기 위해 그래프의 실행중인 인스턴스를 재구성하는 것의 어려움과 관련될 수 있다. 기존 그래프 기반 계산 시스템들은 또한 자주 너무 많은 프로세스가 불필요하게 시작되어 많은 양의 메모리를 낭비하기 때문에 시작 시간이 느리다. 일반적으로, 프로세스들은 그래프 실행의 시작시 시작되고, 그래프 실행이 완료되면 종료된다.

전체 계산이 더 작은 부분들로 분할되고 상기 부분들이 하나의 마스터 컴퓨터 서버로부터 다양한 다른(예를 들어, “슬레이브(slave)”) 컴퓨터 서버들-각각이 독립적으로 계산을 수행하고 그 결과를 마스터 서버로 반환함-로 분산되는, 계산을 분산하기 위한 다른 시스템들이 사용되어 왔다. 이러한 방법들 중 일부는 “그리드 컴퓨팅(grid computing)”이라고 한다. 그러나 이러한 방법들은 그 부분들을 호출하는 마스터 컴퓨터 서버를 경유하는 것을 제외하고는, 계산 부분들 사이에 데이터를 전달하거나, 그 부분들의 실행을 스케줄링(scheduling) 및/또는 시퀀싱(sequencing)하기 위한 메커니즘을 제공하지 않고 일반적으로 각각의 계산의 독립성에 의존한다. 따라서 이러한 방법들은 여러 구성요소들 사이의 상호작용들을 포함하는 호스팅 계산(hosting computation)에 직접적이고 효율적인 솔루션을 제공하지 않는다.

큰 데이터세트에 대한 분산 계산을 위한 또 다른 방법은 예를 들어, Apache Hadoop® 시스템으로 구현된 것과 같은 맵리듀스 프레임워크(MapReduce framework)를 사용한다. 일반적으로 Hadoop은 각각의 명명된 파일에 대한 부분들이 분산되는 분산 파일시스템을 가진다. 사용자는 두 개의 함수 - 분산 방식으로 명명된 입력들의 모든 부분들에 실행되는 맵 함수(map function), 및 상기 맵 함수 실행의 출력 부분들에 실행되는 리듀스 함수(reduce function) - 관점에서 계산을 지정한다. 맵 함수 실행의 결과들이 분할되어 분산 파일시스템에 중간 부분들로 다시 저장된다. 그런다음 리듀스 함수가 상기 중간 부분들을 처리하기 위해 분산 방식으로 실행되어 전체 계산 결과를 산출한다. 비록 맵리듀스 프레임워크에서 표현될 수 있고, 그 입력들과 출력들이 상기 맵-리듀스 프레임워크의 파일시스템 내 저장을 위해 수정가능한 계산들이 효율적으로 실행될지라도, 많은 계산들이 이 프레임워크와 일치하지 않고/않거나 상기 분산 파일 시스템 내 모든 입력들과 출력들을 가지도록 쉽게 조정되지 않는다.

일반적으로, 구성요소들(또는 구성요소들의 병렬 실행 복사본들)이 상이한 서버들에 호스팅되는 상술된 방법들과 비교하여 기반 명세(underlying specification)가 그래프에 관한 것인 계산의 계산 효율을 증가(예를 들어, 주어진 컴퓨팅 자원들의 단위당 처리된 레코드들의 개수를 증가)시킬 필요가 있다. 또한, 다양한 계산 자원들 및 요구사항들에 적응할 수 있는 것이 바람직하다. 또한 하나 이상의 그래프 기반 계산들의 실행 동안 가용한 계산 자원들의 변화, 및/또는 예를 들어, 처리되는 데이터의 특성들로 인한 계산 부하의 변화들 또는 이러한 계산들의 상이한 구성요소들의 부하의 시간 변화에 적응할 수 있는 계산 방법을 제공할 필요가 있다. 예를 들어, 서버당 프로세서들의 상이한 개수, 프로세서당 프로세서 코어들의 상이한 개수, 등을 가지는 서버들을 이용하여 상이한 특성들을 가지는 계산 자원들을 효율적으로 이용할 수 있고, 이종 환경뿐만 아니라 동종 환경 모두를 효율적으로 지원할 수 있는 계산 방법 또한 제공할 필요가 있다. 또한 그래프 기반 계산의 시작을 빠르게 하려는 요구가 있다. 이러한 효율성과 적응성을 제공하는 일 측면은 (디자인 타임시) 그래프 생성시에 개발자에 의한 선택들, (컴파일시) 컴파일러에 의해 취해진 동작들, 및 (런타임시) 런타임 시스템에 의해 취해진 동작들 사이의 적절한 분리 및 추상화 장벽들(abstraction barriers)을 제공하는 것이다.

본 발명의 목적은 그래프 기반 프로그램 명세를 처리하기 위한 방법, 그래프 기반 프로그램 명세를 처리하기 위해, 컴퓨터 판독가능 매체상에 비일시적 형태로 저장된 소프트웨어, 및 그래프 기반 프로그램 명세를 처리하기 위한 컴퓨팅 시스템을 제공하는 것이다.

일 측면에서, 일반적으로, 그래프 기반 프로그램 명세를 처리하기 위한 방법은 상기 그래프 기반 프로그램 명세를 수신하는 단계 - 상기 그래프 기반 프로그램 명세는 각각이 처리 태스크에 대응하고 적어도 하나의 데이터 요소를 전송하거나 수신하기 위한 적어도 하나의 포트를 포함하는 복수의 구성요소들; 및 각각의 링크가 상기 복수의 구성요소들의 업스트림 구성요소의 출력 포트를 상기 복수의 구성요소들의 다운스트림 구성요소의 입력 포트에 연결하는 적어도 하나의 링크를 포함함 - ; 및 상기 그래프 기반 프로그램 명세의 상기 복수의 구성요소들의 서브세트들(“실행 세트들”에 대응함)을 나타내는 준비된 코드를 생성하기 위해 상기 그래프 기반 프로그램 명세를 처리하는 단계를 포함한다. 본원에서 사용된 바와 같이, “준비된 코드”는 그래프 기반 프로그램 명세의 파싱된 요소들을 변환할 때, 컴파일러 또는 인터프리터에 의해 사용된 임의의 대상 언어의 코드를 포함하며, 실행 가능한 코드 또는 실행 가능한 코드로 더 컴파일되거나 해석될 수 있는 코드를 포함할 수 있다. 상기 처리하는 단계는 연결된 구성요소들의 특성들에 적어도 부분적으로 기반하여 상이한 서브세트들의 구성요소들 사이의 복수의 서브세트 경계들을 식별하는 단계; 상기 식별된 서브세트 경계들에 기반하여 상기 서브세트들을 형성하는 단계; 및 런타임 시스템에 의한 실행을 위해 사용될 때 해당 형성된 서브 세트의 구성요소들에 대응하는 처리 태스크들이 해당 형성된 서브세트에 대해 준비된 코드에 임베드된(embedded) 정보에 따라 수행되게 하는 각각의 형성된 서브세트에 대해 준비된 코드를 생성하는 단계를 포함한다.

측면들은 다음 특징들 중 하나 이상을 포함할 수 있다.

상기 서브세트들을 형성하는 단계는 횡단된 서브세트 경계들의 레코드를 유지하면서 상기 그래프 기반 프로그램 명세의 구성요소들을 횡단하는 단계, 및 상기 그래프 기반 프로그램 명세의 각각의 구성요소를 상기 횡단된 서브세트 경계들의 레코드로부터 결정된 단일 서브세트 식별자와 연관시키는 단계를 포함한다.

상기 복수의 구성요소들의 식별된 서브세트와 연관된 각각의 서브세트 식별자가 고유하다.

상기 횡단된 서브세트 경계들의 레코드는 식별자 값들의 경로로서 유지된다.

상기 식별자 값들의 경로는 구분 문자에 의해 서로 분리된 식별자 값들의 문자열을 포함한다.

상기 서브세트들을 형성하는 단계는 상기 그래프 기반 프로그램 명세의 제1 구성요소를 서브세트 식별자와 연관시키는 단계; 상기 제1 구성요소로부터 하류의 구성요소들로 상기 서브세트 식별자를 전파하는 단계; 및 상기 식별된 서브세트 경계들에 기반하여 상기 서브세트 식별자의 전파 동안 상기 서브세트 식별자를 수정하는 단계를 포함한다.

상기 서브세트 식별자의 전파 동안 상기 서브세트 식별자를 수정하는 단계는 제1 서브세트 경계를 횡단할 때 상기 서브세트 식별자의 값을 제1 서브세트 식별자 값에서 상기 제1 서브세트 경계와 연관된 제2 서브세트 식별자 값으로 변경하는 단계; 및 상기 제1 서브세트 경계와 연관된 제2 서브세트 경계를 횡단할 때 상기 서브세트 식별자 값을 상기 제1 세브세트 식별자 값으로 변경하는 단계를 포함한다.

연결된 구성요소들의 특성들에 적어도 부분적으로 기반하여 적어도 하나의 서브세트 경계들을 식별하는 단계는 업스트림 구성요소의 제1 유형의 포트와 다운스트림 구성요소의 제2 유형의 포트 사이의 링크에 기반하여 서브세트 경계를 식별하는 단계를 포함한다.

연결된 구성요소들의 특성들에 적어도 부분적으로 기반하여 적어도 하나의 서브세트 경계들을 식별하는 단계는 업스트림 구성요소와 다운스트림 구성요소 사이의 링크의 결정된 유형에 기반하여 서브세트 경계를 식별하는 단계를 포함하고, 상기 링크의 결정된 유형은 구성요소들 사이의 링크들의 복수의 상이한 유형들 중 하나이다.

상기 각각의 형성된 서브세트에 대해 준비된 코드를 생성하는 단계는 해당 형성된 서브세트의 구성요소들에 대응하는 처리 태스크들 간에 허용된 동시성을 나타내는 정보를 적어도 하나의 형성된 서브세트에 대해 준비된 코드에 임베드하는 단계를 포함한다.

상기 각각의 형성된 서브세트에 대해 준비된 코드를 생성하는 단계는 다른 형성된 서브세트들에 대한 우선순위를 나타내는 정보를 적어도 하나의 형성된 서브세트에 대해 상기 준비된 코드에 임베드하는 단계를 포함한다.

상기 각각의 형성된 서브세트에 대해 준비된 코드를 생성하는 단계는 해당 형성된 서브세트의 구성요소들에 대응하는 적어도 하나의 처리 태스크들의 트랜잭션성(transactionality)을 나타내는 정보를 적어도 하나의 형성된 서브세트에 대해 상기 준비된 코드에 임베드하는 단계를 포함한다.

상기 각각의 형성된 서브세트에 대해 준비된 코드를 생성하는 단계는 상기 준비된 코드의 실행 동안 잠길(locked) 적어도 하나의 자원을 나타내는 정보를 적어도 하나의 형성된 서브세트에 대해 상기 준비된 코드에 임베드하는 단계를 포함한다.

상기 각각의 형성된 서브세트에 대해 준비된 코드를 생성하는 단계는 해당 형성된 서브세트의 구성요소들에 대응하는 적어도 하나의 처리 태스크들에 의해 처리된 데이터 요소들 간 순서 특성들(ordering characteristics)을 나타내는 정보를 적어도 하나의 형성된 서브세트에 대해 상기 준비된 코드로 임베드하는 단계를 포함한다.

상기 각각의 형성된 서브세트에 대해 준비된 코드를 생성하는 단계는 상기 준비된 코드를 사용하여 실행되는 상기 형성된 서브세트의 각각의 인스턴스에 의해 동작될 여러 데이터 요소들을 나타내는 정보를 적어도 하나의 형성된 서브세트에 대해 상기 준비된 코드에 임베드하는 단계를 포함한다.

또 다른 측면에서, 일반적으로, 소프트웨어가 그래프 기반 프로그램 명세를 처리하기 위해, 컴퓨터 판독가능 매체상에 비일시적 형태로 저장되고, 상기 소프트웨어는 컴퓨팅 시스템이 상기 그래프 기반 프로그램 명세를 수신하도록 하고 - 상기 그래프 기반 프로그램 명세는 각각이 처리 태스크에 대응하고 적어도 하나의 데이터 요소를 전송하거나 수신하기 위한 적어도 하나의 포트를 포함하는 복수의 구성요소들; 및 각각의 링크가 상기 복수의 구성요소들의 업스트림 구성요소의 출력 포트를 상기 복수의 구성요소들의 다운스트림 구성요소의 입력 포트에 연결하는 적어도 하나의 링크를 포함함 -; 및 상기 그래프 기반 프로그램 명세의 상기 복수의 구성요소들의 서브세트들을 나타내는 준비된 코드를 생성하기 위해 상기 그래프 기반 프로그램 명세를 처리하도록 하는 - 상기 처리하는 것은 연결된 구성요소들의 특성들에 적어도 부분적으로 기반하여 상이한 서브세트들의 구성요소들 사이의 복수의 서브세트 경계들을 식별하는 것; 상기 식별된 서브세트 경계들에 기반하여 상기 서브세트들을 형성하는 것; 및 런타임 시스템에 의한 실행을 위해 사용될 때 해당 형성된 서브 세트의 구성요소들에 대응하는 처리 태스크들이 해당 형성된 서브세트에 대해 준비된 코드에 임베드된(embedded) 정보에 따라 수행되게 하는 각각의 형성된 서브세트에 대해 준비된 코드를 생성하는 것을 포함함 - 명령들을 포함한다.

또 다른 측면에서, 일반적으로, 그래프 기반 프로그램 명세를 처리하기 위한 컴퓨팅 시스템은 상기 그래프 기반 프로그램 명세를 수신하도록 구성된 적어도 하나의 입력 디바이스 또는 포트 - 상기 그래프 기반 프로그램 명세는 각각이 처리 태스크에 대응하고 적어도 하나의 데이터 요소를 전송하거나 수신하기 위한 적어도 하나의 포트를 포함하는 복수의 구성요소들; 및 각각의 링크가 상기 복수의 구성요소들의 업스트림 구성요소의 출력 포트를 상기 복수의 구성요소들의 다운스트림 구성요소의 입력 포트에 연결하는 적어도 하나의 링크를 포함함 -; 및 상기 그래프 기반 프로그램 명세의 상기 복수의 구성요소들의 서브세트들을 나타내는 준비된 코드를 생성하기 위해 상기 그래프 기반 프로그램 명세를 처리하도록 구성된 적어도 하나의 프로세서 - 상기 처리하는 것은 연결된 구성요소들의 특성들에 적어도 부분적으로 기반하여 상이한 서브세트들의 구성요소들 사이의 복수의 서브세트 경계들을 식별하는 것; 상기 식별된 서브세트 경계들에 기반하여 상기 서브세트들을 형성하는 것; 및 런타임 시스템에 의한 실행을 위해 사용될 때 해당 형성된 서브 세트의 구성요소들에 대응하는 처리 태스크들이 해당 형성된 서브세트에 대해 준비된 코드에 임베드된(embedded) 정보에 따라 수행되게 하는 각각의 형성된 서브세트에 대해 준비된 코드를 생성하는 것을 포함함 - 를 포함한다.

측면들은 다음 장점들 중 하나 이상을 가질 수 있다.

본원에서 설명된 기법들은 또한 그 아키텍처의 다양한 계층들에서 비통상적인 기술적 기능들(technical features)을 사용하여 컴퓨팅 시스템에서 대량의 데이터를 효율적으로 처리하는 것을 용이하게 한다. 이러한 기술적 기능들은 디자인 타임(design-time), 컴파일 타임(compile-time) 및 런타임(runtime)을 포함하여 컴퓨팅 시스템의 다양한 동작 단계에서 함께 작동한다. 프로그래밍 플랫폼은 그래프 기반 프로그램 명세가 디자인 타임에 원하는 계산을 지정할 수 있게 한다. 컴파일러는 런타임에 컴퓨팅 시스템의 서버들 간에 세분화된 태스크들(fine-grained tasks)을 효율적으로 분산시키기위해 컴파일 타임에 대상 프로그램 명세(target program specification)를 준비한다. 예를 들어, 태스크들은 상기 그래프 기반 프로그램 명세 내 임의의 제어 흐름 및 데이터 흐름 제약 조건들에 따라 구성된다. 런타임 시스템은 (예를 들어, 주어진 계산 자원들의 단위당 처리되는 레코드들의 수에서) 계산 효율성을 증가시키는 방식으로 동시 실행을 위해 이러한 태스크들의 동적 분배를 지원한다. 다양한 기술적 기능들이 종래 시스템보다 효율 개선을 달성하기 위해 함께 작동한다.

예를 들어, 컴퓨팅 시스템은 프로그래머에게 과도한 부담을 요구하지 않으면서 태스크들의 유연한 런타임 실행을 용이하게 하는 방식으로 데이터 처리 그래프(또는 다른 그래프 기반 프로그램 명세)의 구성요소들에 대응하는 태스크들을 사용하여 데이터 요소들을 처리할 수 있다. 그래픽 사용자 인터페이스는 원하는 데이터 처리 계산들을 수행하는 구성요소들 상의 상이한 유형의 포트들 사이의 연결들을 허용하고, 컴퓨팅 시스템은 하나 이상의 구성요소들 및/또는 프로그램 명세의 처리에 추후에 사용하기 위한 구성요소들의 네스팅된 서브세트들을 포함하는 서브세트들을 자동적으로 식별할 수 있다. 예를 들어, 이러한 실행 세트 발견 전처리 절차는 사람이 인식하기 매우 어려울 수 있는 구성요소들의 잠재적으로 구성요소들의 네스팅된 실행 세트들의 계층구조를 식별할 수 있고, 그런 다음 시스템은 효율적인 병렬 데이터 처리를 위해 이러한 서브세트들을 실행하도록 기본 시스템 아키텍처에서 자원들의 할당을 결정할 수 있다. 구성요소들의 이러한 서브세트들(“실행 세트들”)을 자동적으로 식별하여, 이하에서 더 상세히 설명되는 바와 같이, 컴퓨팅 시스템은 데이터 처리 그래프가 특정 일관성 요구사항들을 만족하는 것을 보장할 수 있고, 실행 세트에 대한 병렬처리 정도가 런타임시 결정될 수 있고 런타임시 가용한 계산 자원들에 의해서만 제한되므로 실행 세트들이 매우 확장가능한 병렬처리 정도로 기본 계산 시스템에 의해 동작되도록 허용하여, 데이터 처리 그래프의 효율적 실행에 기여할 수 있다. 또한, 실행 세트들을 식별하는 준비된 코드로 특정 정보를 임베딩(embedding)하여, 이러한 세트들이 궁극적으로 기본 컴퓨팅 시스템에 의해 특정 태스크들로서 처리될 수 있고, 컴퓨팅 시스템은 처리 태스크들이 예를 들어 태스크를 병렬처리하여 컴퓨팅 시스템의 내부 기능의 효율성을 향상시키는 방식으로 수행되는 것을 보장할 수 있다.

이러한 기법들은 또한 메모리에 대한 요구 및 다른 계산 자원들을 감소시키는 것과 같은 본원에서 설명된 방법들을 실행할 때 컴퓨팅 시스템의 내부 기능에 추가 기술적인 효과를 나타낸다. 특히, 이러한 장점들은 데이터 처리 그래프들의 효율적인 실행에 기여한다. 예를 들어, 종래 그래프 기반 계산 시스템들은 그래프를 실행할 때 다른 프로세스들에 의해 시작되는 프로세스들(예를 들어, Unix 프로세스들)의 수로 인해 (예를 들어, 수십밀리초 단위로) 상대적으로 더 높은 지연(latency), 및 결과로 초래된 그 프로세스들의 누적 시동 시간(start-up time)을 가질 수 있다. 반면, 본원에서 설명된 기법들은 단일 프로세스 내 프로그램 코드가 프로세스 시동 오버헤드(process start-up overhead)없이 직접적으로 다른 프로그램 코드를 시작하게 하도록 허용하여 (예를 들어, 수십 마이크로 초 단위로) 상대적으로 더 낮은 지연, 및 초당 처리되는 데이터의 더 높은 처리량을 가능하게 한다. 데이터 처리 그래프들의 효율적인 실행에 기여하는 다른 측면들은 다음 설명에서 명백해질 것이다.

본 발명의 다른 특징들과 장점들은 다음 설명으로부터, 그리고 청구범위로부터 명백해질 것이다.

도 1은 태스크 기반 계산 시스템의 블록도이다.
도 2a는 제어 및 데이터 포트들을 가지는 데이터 처리 그래프의 일 부분의 일 예이다.
도 2b-2c는 제어 및 데이터 포트들을 가지는 데이터 제어 그래프의 예들이다.
도 3a는 여러 스칼라 출력 포트 대 스칼라 입력 포트 연결들을 포함하는 데이터 처리 그래프이다.
도 3b는 여러 콜렉션 출력 포트 대 콜렉션 입력 포트 연결들을 포함하는 데이터 처리 그래프이다.
도 3c는 콜렉션 출력 포트 대 스칼라 입력 포트 연결 및 스칼라 출력 포트 대 콜렉션 입력 포트 연결을 포함하는 데이터 처리 그래프이다.
도 4a는 두 개의 구성요소들 사이의 스칼라 포트 대 스칼라 포트 연결이다.
도 4b는 두 개의 구성요소들 사이의 콜렉션 포트 대 콜렉션 포트 연결이다.
도 4c는 실행 세트 입구점(execution set entry point)를 포함하는 두 개의 구성요소들 사이의 콜렉션 포트 대 스칼라 포트 연결이다.
도 4d는 실행 세트 출구점(execution set exit point)을 포함하는 두 개의 구성요소들 사이의 스칼라 포트 대 콜렉션 포트 연결이다.
도 5는 스택 기반 할당 알고리즘(stack based assignment algorithm)이 적용된 데이터 처리 그래프이다.
도 6은 글로벌 매핑 기반 할당 알고리즘(global mapping based assignment algorithm)이 적용된 데이터 처리 그래프이다.
도 7은 사용자 정의 실행 세트들을 가지는 데이터 처리 그래프이다.
도 8a 및 도 8b는 데이터 처리 그래프에서 관계가 “동일한 세트”를 도시한다.
도 9는 데이터 요소들을 복제하는 입구점을 가지는 데이터 처리 그래프이다.
도 10a-10c는 사용자 인터페이스 작업 흐름을 도시한다.
도 11a는 불법 실행 세트들(illegal execution set)을 가지는 데이터 처리 그래프이다.
도 11b는 불법 실행 세트 루프(illegal execution set loop)를 가지는 데이터 처리 그래프이다.
도 12a-12b는 데이터 처리그래프 및 대응하는 제어 그래프의 예들의 블록도들이다.
도 13a-13b는 예시 실행 상태 머신(execution state machine)에 대한 상태 천이도들(state transition diagrams)이다.
도 14는 처리 엔진들의 세트의 다이어그램이다.

도 1을 참조하면, 태스크 기반 계산 시스템(task-based computation program)(100)은 프로그램 명세(program specification)(110)에 의해 지정되는 계산을 실행하기 위해 컴퓨팅 플랫폼(150)의 계산 및 저장 자원들을 제어하도록 고레벨 프로그램 명세(110)를 사용한다. 컴파일러/인터프리터(120)는 고레벨 프로그램 명세(110)를 수신하고 태스크 기반 런타임 인터페이스/콘트롤러(140)에 의해 실행될 수 있는 형태인 태스크 기반 명세(130)를 생성한다. 컴파일러/인터프리터(120)는 개별적으로 또는 하나의 단위로 인스턴스화될 수 있는 하나 이상의 “구성요소”의 하나 이상의 “실행 세트”를 여러 데이터 요소들 각각에 적용될 세분화된 작업으로서 식별한다. 컴파일 또는 해석 프로세스 중 일부는 아래에 더 상세히 설명되는 바와 같이 이러한 실행 세트들을 식별하는 것과 상기 세트들을 실행을 위해 준비하는 것을 포함한다. 컴파일러/인터프리터(120)는 고레벨 프로그램 명세(110)를 파싱하고, 구문을 검증하고, 데이터 형식의 유형 체크를 하고, 임의의 에러나 경고를 생성하며, 태스크 기반 명세(130)를 준비하는 것 같은 단계들을 포함하는 다양한 알고리즘들 중 임의의 것을 사용할 수 있고, 컴파일러/인터프리터(120)는 예를 들어, 컴퓨팅 플랫폼(150)에서 수행되는 계산의 효율을 최적화하는 다양한 기법들을 사용할 수 있음을 이해해야 한다. 컴파일러/인터프리터(120)에 의해 생성되는 대상 프로그램 명세는 태스크 기반 명세(130)를 생성하기 위해 그 자체가 시스템(100)의 또 다른 부분에 의해 더 처리되어야(예를 들어, 더 컴파일되어야, 해석되어야, 등)할 중간 형태일 수 있다. 이하의 논의는 이러한 변환의 하나 이상의 예를 개략적으로 설명하나 물론 예를 들어, 컴파일러 디자인에 능숙한 사람에 의해 이해될 수 있는 변환에 대한 다른 방법들도 가능하다.

일반적으로, 계산 플랫폼(150)은 여러 컴퓨팅 노드들(152)(예를 들어, 분산 계산 자원들 및 분산 저장 자원들 모두를 제공하는 개별 서버 컴퓨터들)로 이루어져 고도의 병렬처리를 가능하게 한다. 이하에서 더 상세히 논해지는 바와 같이, 고레벨 프로그램 명세(110)에 표현된 계산은 상대적으로 세분화된 태스크들로 컴퓨팅 플랫폼(150)에서 실행되어, 지정된 계산의 효율적인 병렬 실행을 더 가능하게 한다.

1. 데이터 처리 그래프

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

이러한 포트들은 여러 상이한 특성들을 가질 수 있다. 포트의 한 특성은 입력 포트 또는 출력 포트로서의 방향성(directionality)이다. 방향성 링크들은 업스트림 구성요소의 출력 포트로부터 다운스트림 구성요소의 입력 포트로 전달되는 데이터 및/또는 제어를 나타낸다. 개발자는 상이한 유형들의 포트들을 함께 연결할 수 있다. 상기 데이터 처리 그래프의 데이터 처리 특성들 중 일부는 어떻게 상이한 유형의 포트들이 함께 연결되는지에 의존한다. 예를 들어, 상이한 유형의 포트들 사이의 링크들은 이하에서 더 상세히 설명되는 바와 같이 병렬처리의 계층적 형태를 제공하는 상이한 “실행 세트들”의 구성요소들의 네스팅된 서브세트들(nested subsets)로 이어질 수 있다. 특정 데이터 처리 특성들이 상기 포트의 유형의 의해 암시된다. 구성요소가 가질 수 있는 상이한 유형의 포트들은 다음 포트들을 포함할 수 있다.

· 콜렉션 입력 또는 출력 포트들. 구성요소의 인스턴스가 상기 포트에 결합된 링크를 통해 전달될 콜렉션의 모든 데이터 요소들을 각각 판독하거나 기록할 것을 의미함. 콜렉션 포트들 사이의 단일 링크를 가지는 구성요소들의 쌍에 대해, 다운스트림 구성요소가 업스트림 구성요소에 의해 기록되고 있을 때 일반적으로 데이터 요소들을 판독할 수 있어, 업스트림 및 다운스트림 구성요소들 사이의 파이프라인 병렬처리를 가능하게 한다. 데이터 요소들은 또한 재정렬될 수 있어서, 이하에서 더 상세히 설명된 바와 같이 병렬처리(parallelization)의 효율성을 높일 수 있다. 일부 그래픽 표현에서, 예를 들어, 프로그래밍 그래픽 인터페이스에서, 이러한 콜렉션 포트들은 일반적으로 구성요소에서 사각형 커넥터 기호(connector symbol)로 표시된다.

· 스칼라 입력 또는 출력 포트들. 구성요소의 인스턴스가 상기 포트에 결합된 링크로부터/로 최대 하나의 데이터 요소를 각각 읽거나 기록할 것을 의미함. 스칼라 포트들 사이에 단일 링크를 가지는 구성요소들의 쌍에 대해, 업스트림 구성요소가 실행을 종료한 후에 다운스트림 구성요소의 직렬 실행(serial execution)은 제어의 전송으로서 단일 데이터 요소의 전송을 이용하여 시행된다. 일부 그래픽 표현에서, 예를 들어, 프로그래밍 그래픽 인터페이스에서, 이러한 스칼라 포트들은 일반적으로 구성요소에서 삼각형 커넥터 기호로 표시된다.

· 제어 입력 또는 출력 포트들. 스칼라 입력들 또는 출력들과 유사하나, 어떠한 데이터 요소도 전달될 필요가 없고 구성요소들 사이에 제어의 전송을 통신하는데 사용된다. 그 제어 포트들 사이의 링크를 가지는 구성요소들의 쌍에 대해, (그 구성요소들이 또한 콜렉션 포트들 사이의 링크를 가지는 경우에도) 업스트림 구성요소가 실행을 종료한 후에 다운스트림 구성요소의 직렬 실행이 시행된다. 일부 그래픽 표현에서, 예를 들어 프로그래밍 그래픽 인터페이스에 대해, 이러한 제어 포트들이 일반적으로 구성요소에서 원형 커넥터 기호로 표시된다.

이러한 상이한 유형의 포트들은 데이터 처리 그래프들의 유연한 디자인을 가능하게 하여, 포트 유형들의 중첩되는 속성들로 데이터 및 제어 흐름의 강력한 결합들을 허용한다. 특히, 어떤 형태로 데이터를 전달하는 두 유형의 포트들 - 콜렉션 포트들 및 스칼라 포트들 - (“데이터 포트들”로 지칭됨) 이 있고, 직렬 실행을 시행하는 두 유형의 포트들 - 스칼라 포트들 및 제어 포트들 - (“시리얼 포트들”로 지칭됨) 이 있다.

데이터 처리 그래프는 일반적으로 임의의 연결된 입력 데이터 포트가 없는 “소스 구성요소(source component)”인 하나 이상의 구성요소들 및 임의의 연결된 출력 데이터 포트가 없는 “싱크 구성요소(sink component)”인 하나 이상의 구성요소들을 가질 것이다. 일부 구성요소들은 연결된 입력 및 출력 데이터 포트들을 모두 가질 것이다. 일부 실시 예에서, 상기 그래프는 사이클이 허용되지 않고, 따라서, 방향성 비순환 그래프(directed acyclic graph)(DAG)이어야만 한다. 이러한 특징은 이하에서 더 상세히 설명되는 바와 같이 DAG의 특정 특성들을 활용하는 데 사용될 수 있다.

데이터 처리 그래프의 구성요소들에 전용 제어 포트의 사용은 또한 특정 다른 제어 흐름 기법들을 사용하여 할 수 없는 계산의 상이한 부분들의 유연한 제어를 가능하게 한다. 예를 들어, 데이터플로 그래프들 사이에 종속성 제약 조건들(dependency constraints)을 적용할 수 있는 작업 제어 솔루션들(job control solutions)은 단일 데이터플로 그래프 내의 구성요소들 사이에 종속성 제약 조건들을 정의하는 제어 포트들에 의해 가능하게 되는 세밀한 제어를 제공하지 않는다. 또한, 연속적으로 실행하는 상이한 단계들에 구성요소들을 할당하는 데이터플로 그래프들은 개별적인 구성요소를 시퀀싱하는(sequencing) 유연성을 허용하지 않는다. 예를 들어, 단순한 단계들을 사용하여 할 수 없는 네스팅된 제어 토폴로지들(nested control toplogies)은 본원에서 설명된 제어 포트들 및 실행 세트들을 사용하여 정의될 수 있다. 이러한 더 큰 유연성은 또한 가능할 때 더 많은 구성 요소들을 동시에 실행할 수 있게 하여 잠재적으로 성능을 향상시킬 수 있다.

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

컴파일러/인터프리터(120)는 실행을 위해 데이터 처리 그래프를 준비하는 절차들을 수행한다. 제1 절차는 구성요소들의 잠재적으로 네스팅된 실행 세트들의 계층 구조를 식별하는 실행 세트 발견 전처리 절차(execution set discovery pre-processing procedure)이다. 제2 절차는 각각의 실행 세트에 대해 컴파일러/인터프리터(120)가 각각의 실행 세트 내 구성요소들의 실행을 제어하기 위해 런타임시 상태 머신(state machine)을 효율적으로 구현할 제어 코드를 형성하는 데 사용할 대응하는 제어 그래프를 생성하는 제어 그래프 생성 절차이다. 이러한 절차들 각각이 이하에서 더 상세히 설명될 것이다.

적어도 하나의 입력 데이터 포트를 가지는 구성요소는 각각의 입력 데이터 요소 또는 콜렉션(또는 여러 입력 포트의 콜렉션들 및/또는 데이터요소들의 튜플(tuple))에서 수행될 처리를 명시한다. 이러한 명세의 한 형태는 절차로서 콜렉션들 및/또는 입력 데이터 요소들 중 하나 또는 튜플에서 수행될 것이다. 구성요소가 적어도 하나의 출력 데이터 포트를 가진다면, 대응하는 콜렉션들 및/또는 출력 데이터 요소들 중 하나 또는 튜플을 생성할 수 있다. 이러한 절차는 고레벨 문(high level statement) 기반 언어로(예를 들어, 미국 특허 8,069,129“Editing and Compiling Business Rules”에서 사용된 바와 같은 Data Manipulation Language(DML), 또는 Java 소스 문을 사용하여) 명시될 수 있거나, 어떤 전체적으로 또는 부분적으로 컴파일된 형태로(예를 들어, Java bytecode로) 제공될 수 있다. 예를 들어, 구성요소는 그 인수들(arguments)이 그 입력 데이터 요소들 및/또는 콜렉션들 및 그 출력 데이터 요소들 및/또는 콜렉션들, 또는 더 일반적으로는 입력을 획득하고 출력 데이터 요소들 또는 콜렉션들을 제공하는 데 사용되는 데이터 요소들 또는 콜렉션들에 대한 또는 절차들 또는 데이터 객체들에 대한 참조들(본원에서 “핸들(handles)”로 언급됨)을 포함하는 작업 절차를 가질 수 있다.

작업 절차들은 다양한 유형들일 수 있다. 명시될 수 있는 절차들의 유형을 제한할 의도없이, 한 유형의 작업 절차는 레코드 형식에 따라 데이터 요소들에 대한 이산 계산을 명시한다. 단일 데이터 요소가 테이블(또는 다른 유형의 데이터세트)로부터의 레코드일 수 있고, 레코드들의 콜렉션이 테이블의 레코드들 모두일 수 있다. 예를 들어, 단일 스칼라 입력 포트와 단일 스칼라 출력 포트를 가지는 구성요소에 대한 한 유형의 작업 절차는 하나의 입력 레코드를 수신하는 것, 그 레코드에 대해 계산을 수행하는 것, 및 하나의 출력 레코드를 제공하는 것을 포함한다. 또 다른 유형의 작업 절차는 어떻게 여러 스칼라 입력 포트들로부터 수신된 입력 레코드들의 튜플이 여러 스칼라 출력 포트들에서 전송된 출력 레코드들의 튜플을 형성하기 위해 처리되는가를 명시할 수 있다.

데이터 처리 그래프에 의해 명시된 계산의 의미론적 정의(semantic definition)는 그것이 상기 그래프에 의해 정의되는 계산의 처리의 순서(ordering) 및 동시성(concurrency)에 대한 제약 조건들 및/또는 제약조건들의 결여를 나타낸다는 점에서 본질적으로 아주 유사하다. 따라서, 계산의 정의는 그 결과가 상기 계산 단계들의 어떤 순차적 순서와 동등할 것을 요구하지 않는다. 반면에, 계산의 정의는 계산의 부분들의 시퀀싱, 및 상기 계산의 부분들의 병렬 실행의 제한들(restrictions)을 요구하는 특정 제약조건들(constraints)을 제공한다. 데이터 처리 그래프들에 대한 논의에서, 런타임 시스템에서 별도 “태스크들”로서 구성요소들의 인스턴스들의 구현이 시퀀싱 및 병렬처리 제약조건들을 나타내는 수단으로 간주된다. 의미론적 정의로 일관되게 계산을 구현하는 태스크 기반 명세로의 데이터 처리 그래프의 구현의 더 상세한 논의가 그래프 기반 명세 자체의 특성들의 논의 후에 더 자세히 논해진다.

일반적으로, 데이터 처리 그래프의 각각의 구성요소는 상기 그래프의 실행동안 여러 번 컴퓨팅 플랫폼에서 인스턴스화될 것이다. 각각의 구성요소의 인스턴스들의 개수는 여러 실행 세트들 중 어느 것이 할당된지에 따라 달라질 수 있다. 구성요소의 여러 인스턴스들이 인스턴스화될 때, 하나 이상의 인스턴스가 병렬로 실행될 수 있고, 상이한 인스턴스들이 상기 시스템의 상이한 컴퓨팅 노드들에서 실행될 수 있다. 포트들의 유형을 포함하여 구성요소들의 상호연결은 명시된 데이터 처리 그래프에 의해 허용되는 병렬 처리의 본질을 결정한다.

이하에서 논해지는 바와 같이, 일반적으로 구성요소의 상이한 인스턴스들의 실행 사이에서 상태가 유지되지 않을지라도, 구성요소의 여러 인스턴스들의 실행을 포괄할 수 있는 영구 저장소를 명시적으로 참조하기 위해 특정 공급들이 시스템에서 제공된다.

작업 절차가 단일 출력 레코드를 산출하기 위해 단일 레코드가 어떻게 처리되는지를 명시하고, 포트들이 콜렉션 포트들인 것으로 표시되는 예에서, 구성요소의 단일 인스턴스가 실행될 수 있고, 상기 작업 절차가 연속적인 출력 레코드들을 생성하기 위해 연속적인 레코드들을 처리하도록 반복된다. 이러한 상황에서는, 반복에서 반복까지 상태가 구성요소 내에서 유지될 수 있다.

작업 절차가 단일 출력 레코드를 산출하기 위해 단일 레코드가 어떻게 처리되는지를 명시하고, 포트들이 스칼라 포트들로 표시되는 예에서, 구성요소의 여러 인스턴스들이 실행될 수 있고, 어떠한 상태도 상이한 입력 레코드들에 대한 작업 절차의 실행들 사이에서 유지되지 않는다.

또한, 일부 실시 예에서, 시스템은 상술된 가장 세밀한 명세를 따르지 않는 작업 절차들을 지원한다. 예를 들어, 작업 절차는 예를 들어, 스칼라 포트를 통해 단일 레코드를 받아들이고 콜렉션 포트를 통해 여러 출력 레코드들을 생산하는 반복을 내부적으로 구현할 수 있다.

상술된 바와 같이, 어떤 형태로 데이터를 전달하는 두 가지 유형의 데이터 포트 - 콜렉션 포트 및 스칼라 포트 - 가 있고, 직렬 실행을 시행하는 두 가지 유형의 시리얼 포트 - 스칼라 포트 및 제어 포트 - 가 있다. 일부 경우에, 한 유형의 포트가 또 다른 유형의 포트에 링크로 연결될 수 있다. 이러한 경우들 중 일부가 이하에서 설명될 것이다. 일부 경우에, 한 유형의 포트는 동일한 유형의 포트에 연결될 것이다. 두 개의 제어 포트들 사이의 링크(“제어 링크”라고 함)는 데이터가 링크를 통해 전송될 필요없이, 연결된 구성요소들 사이에 직렬 실행 순서를 부과한다. 두 개의 데이터 포트들 사이의 링크(“데이터 링크”라고 함)는 데이터 흐름을 제공하고 또한 스칼라 포트들의 경우에는 직렬 실행 순서 제약 조건을 시행하고 콜렉션 포트들의 경우에는 직렬 실행 순서를 요구하지 않는다. 전형적 구성요소는 일반적으로 입력 및 출력 데이터 포트들(콜렉션 포트 또는 스칼라 포트 중 하나)과 입력 및 출력 제어 포트들을 포함하는 적어도 두 종류의 포트들을 가진다. 제어 링크들은 업스트림 구성요소의 제어 포트를 다운스트림 구성요소의 제어 포트로 연결한다. 유사하게, 데이터 링크들은 업스트림 구성요소의 데이터 포트를 다운스트림 구성요소의 데이터 포트로 연결한다.

그래픽 사용자 인터페이스가 구성요소들 - 각각은 특정 태스크 (예를 들어, 데이터 처리 태스크)를 수행함 - 의 세트로부터의 특정 데이터 처리 계산을 명시하기 위해 개발자들에 의해 사용될 수 있다. 개발자는 디스플레이 화면에 보여지는 캔버스 영역 상에 데이터 처리 그래프를 조립하여 그렇게 한다. 이는 캔버스 상에 구성요소들을 배치하는 것, 그것의 다양한 포트들을 적절한 링크들로 연결하는 것, 및 그 외에 구성요소들을 적절하게 구성하는 것을 포함한다. 다음의 단순 예는 콜렉션 포트들의 단일 쌍과 제어 포트들의 단일 쌍을 가지는 구성요소들의 상황에서 특정 행동을 설명한다.

도 2a는 조립되는 데이터 처리 그래프의 일부가 입력 및 출력 제어 포트들 (212A, 214A) 과 입력 및 출력 콜렉션 포트들 (216A, 218A) 를 가지는 제1 구성요소(210A)를 포함하는 예를 보여준다. 제어 링크들(220A, 222A)은 입력 및 출력 제어 포트들(212A, 214A)을 데이터 처리 그래프의 다른 구성요소들의 제어 포트들로 연결한다. 유사하게, 데이터 링크들(224A, 226A)은 입력 및 출력 콜렉션 포트들(216A, 218A)을 데이터 처리 그래프의 다른 구성요소들의 포트들로 연결한다. 콜렉션 포트들(216A, 218A)은 도면에서 직사각형 형상으로 표현되지만, 제어 포트들(212A, 214A)은 원형 형상으로 표현된다.

일반적으로, 입력 콜렉션 포트(216A)는 구성요소(210A)에 의해 처리될 데이터를 수신하고, 출력 콜렉션 포트(214)는 구성요소(210A)에 의해 처리된 데이터를 제공한다. 콜렉션 포트의 경우에, 이 데이터는 일반적으로 불특정 개수의 데이터 요소들의 정렬되지 않은 콜렉션이다. 전체 계산의 특정 인스턴스에서, 콜렉션은 여러 데이터 요소들, 또는 단일 데이터 요소를 포함하거나, 어떠한 데이터 요소도 포함하지 않을 수 있다. 일부 구현에서, 콜렉션은 콜렉션의 요소들이 정렬되지 않는지 또는 정렬되는지(그리고 정렬된다면, 무엇이 순서를 결정하는지)를 결정하는 파라미터와 관련된다. 이하에서 더 상세하게 설명될 바와 같이, 정렬되지 않은 콜렉션에 대해, 데이터 요소가 데이터 링크의 수신 측에서 구성요소에 의해 처리되는 순서는 데이터 링크의 송신 측에서 구성요소가 이러한 데이터 요소들을 제공하는 순서와는 다를 수 있다. 따라서, 콜렉션 포트들의 경우에, 그것들 사이의 데이터 링크는 특정 순서로 하나의 구성요소로부터 또 다른 구성요소로 데이터 요소들을 이동시키는 “컨베이어 벨트(conveyor belt)”와는 달리, 데이터 요소가 임의의 순서로 꺼내질 수 있는 “가방(bag)”으로서 동작한다.

제어 링크들은 제어 포트들 사이에 구성요소가 실행을 시작할지와 언제 시작할 것인지를 결정하는 제어 정보를 전달하는 데 사용된다. 예를 들어, 제어 링크(222A)는 구성요소(210B)가 구성요소(210A)가 완료된 후 실행을 시작할 것(즉, 순차적 순서로)을 표시하거나, 구성요소(210B)가 실행을 시작하지 않을 것(즉, “억제될 것”)을 표시한다. 따라서, 제어 링크를 통해 어떠한 데이터도 전송되지 않지만, 수신측 구성요소에 신호를 보내는 것으로 볼 수 있다. 이러한 신호가 전달되는 방법은 구현에 따라 다를 수 있고, 일부 구현에서는 구성요소들 사이에 제어 메시지의 전송을 포함할 수 있다. 다른 구현은 실제 제어 메시지를 전송하는 것을 포함하지 않을 수 있으나, 대신에 수신측에서 구성요소에 의해 나타내어지는 태스크와 관련된 함수를 호출하거나 프로세스를 직접 호출하는 프로세스(또는 억제의 경우에 그러한 호출 또는 함수 호출의 누락)를 포함할 수 있다.

따라서 제어 포트들을 연결하는 기능은 개발자가 데이터 처리 그래프의 상이한 구성요소들에 의해 나타내어지는 데이터 처리 계산의 상이한 부분들 사이의 상대적인 순서를 제어할 수 있게 한다. 또한, 구성요소들의 제어 포트들을 사용하여 이러한 순서화 메커니즘을 제공하는 것은 데이터 흐름 및 제어 흐름과 관련된 로직(logic)의 혼합을 가능하게 한다. 사실상, 이는 데이터가 제어에 관한 결정을 내리는데 사용될 수 있게 한다.

도 2a에서 보여지는 예에서, 제어 포트들은 다른 제어 포트들로 연결되고, 데이터 포트들은 다른 데이터 포트들로 연결된다. 그러나, 데이터 포트의 데이터는 본질적으로 두 개의 상이한 종류의 정보를 실어 나른다. 첫번째 종류는 데이터 그 자체이고, 두번째는 적어도 데이터의 존재이다. 이러한 두번째 종류의 정보는 제어 신호로서 사용될 수 있다. 결과적으로, 스칼라 데이터 포트가 제어 포트에 연결될 수 있게 하여 추가적인 유연성을 제공할 수 있게 된다.

도 2b는 스칼라 포트들을 제어 포트들에 연결하는 기능에 의해 부여된 유연성을 활용하는 예시 데이터 처리 그래프(230)를 보여준다.

데이터 처리 그래프(230)는 “ 날짜 정보 계산”이라는 라벨의 제1 구성요소(231), “월간 보고서 작성?”이라는 라벨의 제2 구성요소(232), “주간 보고서 작성”이라는 라벨의 제3 구성요소(233), “월간 보고서”라는 라벨의 제4 구성요소(234), “주간 보고서 작성?”이라는 라벨의 제5 구성요소(235), 및 “주간 보고서”라는 라벨의 제6 구성요소(236)를 포함할 수 있다. 데이터 처리 그래프(230)는 일일 보고서, 일일 보고서 및 주간 보고서, 또는 세 종류의 보고서들 모두를 항상 생성하는 절차를 수행한다. 이러한 결과들 중 어떤 것이 발생할지에 대한 결정은 제1 구성요소(231)에 의해 제공된 특정 날짜 정보의 평가에 따라 달라진다. 따라서, 도 2b는 효과적으로 실행 제어의 데이터의 일 예를 보여준다.

제1 구성요소(231)가 그 출력 스칼라 포트들로부터 날짜 정보를 제2 구성요소(232)의 입력 스칼라 포트와 제3 구성요소(233)의 입력 스칼라 포트로 제공할 때 실행이 시작된다. 연결된 입력 제어 포트를 가지지 않는 제2 구성요소(232)는 즉시 작동하게 된다. 제3 구성요소(233)를 포함한 모든 다른 구성요소들은 연결된 입력 제어 포트(들)을 가지고 적절한 양의 제어 신호에 의해 활성화되기를 기다려야만 한다.

제2 구성요소(232)는 이 날짜 정보를 검사하고 월간 보고서를 작성하기에 적절한지를 결정한다. 가능한 결과는 두 가지이다: 월간 보고서가 필요하다 또는 그렇지 않다. 제2 구성요소(232)와 제3 구성요소(233) 모두 두 개의 출력 스칼라 포트들을 가지며, 하나의 출력 스칼라 포트(즉, 선택된 포트)에 양의 제어 신호로서 그리고 나머지 출력 스칼라 포트에 음의 제어 신호로서 작용하는 데이터 요소를 제공하는 선택 기능을 수행하도록 구성된다.

날짜 정보에 기초하여 제2 구성요소(232)가 어떠한 월간 보고서도 필요하지 않다고 결정한다면, 제2 구성요소(232)는 데이터 요소를 그 하부 출력 스칼라 포트로부터 제3 구성요소(233)의 입력 제어 포트로 전송한다. 이러한 데이터 요소는 제2 구성요소(232)가 제1 구성요소(231)에 의해 제공된 데이터를 처리하는 것을 완료하고 제3 구성요소(233)가 이제 수신된 날짜 정보 데이터를 처리하기 시작할 수 있음을 제3 구성요소(233)에 대해 나타내는 양의 제어 신호로서 해석된다.

반면에, 제2 구성요소(232)가 제1 구성요소(231)에 의해 제공된 날짜 정보에 기초하여 월간 보고서가 필요로 된다고 결정한다면, 대신에 양의 제어 신호로 해석되는 데이터 요소를 그 출력 스칼라 포트로부터 제4 구성요소(234)의 입력 제어 포트로 전송한다. 상기 데이터 요소는 단순한 제어 신호 이상이지만, 입력 제어 포트에 제공되고 있기 때문에 제4 구성요소(234)는 그것을 양의 제어 신호로 취급한다. 제4 구성요소(234)는 상기 데이터 요소의 실제 데이터는 무시하고 단지 상기 데이터 요소의 존재를 양의 제어 신호로 사용한다.

제4 구성요소(234)는 월간 보고서를 생성하도록 진행한다. 완료시, 제4 구성요소(234)는 제어 신호를 그 출력 제어 포트로부터 제3 구성요소(233)의 입력 제어 포트로 출력한다. 이는 제3 구성요소(233)에게 그것(즉, 제3 구성요소(233))이 제1 구성요소(231)가 제공했던 날짜 정보를 처리하기 이제 시작할 수 있다는 것을 알린다.

따라서, 제3 구성요소(233)는 항상 그 입력 스칼라 포트를 통해 제1 구성요소(231)에 의해 제공되는 데이터를 최종적으로 처리할 것이다. 유일한 차이점은 어떤 구성요소가 그것이 처리를 시작하도록 유발할지에 있다: 제2 구성요소(232) 또는 제4 구성요소(234). 이는 한 쪽 포트(또는 둘 다)에서 수신된 양의 제어 신호가 처리를 유발하도록 제3 구성요소(233)의 두 개의 입력 제어 포트들이 OR 로직을 이용하여 결합될 것이기 때문이다.

그래프(230)의 나머지는 본질적으로 동일한 방식으로 동작하지만 제3 구성요소(233)는 제2 구성요소(232)의 역할을 대신하고 제6 구성요소(236)는 제4 구성요소(234)의 역할을 대신한다.

그 입력 제어 포트들에서 제2 구성요소(232)로부터 또는 제4 구성요소(234)로부터 오는 제어 신호에 의해 활성화될 때, 제3 구성요소(233)는 제1 구성요소(231)를 제3 구성요소(233)에 연결하는 데이터 링크를 통해 제1 구성요소(2231)에 의해 제공된 날짜 정보를 검사한다. 제3 구성요소(233)는 날짜 정보로부터 주간 보고서가 필요하지 않다고 결정하면, 그 출력 스칼라 포트들 중 하나로부터 제5 구성요소(235)의 입력 제어 포트로 양의 제어 신호로서 해석되는 데이터 요소를 전송한다.

반면에, 제3 구성요소(233)는 주간 보고서가 필요하다고 결정하면, 그것의 다른 출력 스칼라 포트로부터 제6 구성요소(236)의 입력 제어 포트로 양의 제어 신호로서 해석된 데이터 요소를 전송한다. 제6 구성요소(236)는 주간 보고서 생성을 진행한다. 완료시, 그것은 그 출력 스칼라 포트로부터 제5 구성요소(235)의 입력 제어 포트로 양의 제어 신호로서 해석되는 데이터 요소를 전송한다.

따라서, 유일한 차이가 제3 구성요소(233) 또는 제6 구성요소(236)가 궁극적으로 실행을 시작하도록 유발하는지 여부인 제5 구성요소(235)가 항상 최종적으로 실행될 것이다. 제3 구성요소(233) 또는 제6 구성요소(236)로부터 제어 신호를 수신할 때, 제5 구성요소(235)는 일일 보고서를 생성한다.

또한 스칼라 및 콜렉션 데이터 포트들의 사용을 보여주는 일 예가 도 2c에서 보여진다.

도 2c는 “파일 입력”이라는 라벨의 제1 구성요소(241), “요청으로부터 파일명 가져오기”이라는 라벨의 제2 구성요소(242), “파일 판독”라는 라벨의 제3 구성요소(243), “잘못된 레코드인가?”라는 라벨의 제4 구성요소(244), “유효하지 않은 레코드”라는 라벨의 제5 구성요소(245), “잘못된 레코드 파일명 생성”이라는 라벨의 제6 구성요소(246), “임의의 검증 에러?”라는 라벨의 제7 구성요소(247), 및 “경고 전송”이라는 라벨의 제8 구성요소(248)를 가지는 데이터 처리 그래프(240)를 도시한다. 이 그래프는 잘못된 레코드들을 파일에 기록하고 이러한 잘못된 레코드들을 발견하면 경고를 보내려 한다.

구성요소들(241 및 243)은 데이터의 소스 역할을 하는 구성요소들의 예이고 구성요소(245)는 데이터의 싱크 역할을 하는 구성요소의 예이다. 구성요소들(241 및 243)은 파일시스템(로컬 파일시스템 또는 분산 파일시스템 등)의 다양한 형식들 중 임의의 것으로 저장될 수 있는 입력 파일을 그 소스로서 사용한다. 파일 입력 구성요소는 파일의 내용을 판독하고 그 파일로부터 레코드들의 콜렉션을 생성한다. (구성요소(243)에서 보여지는 바와 같이) 스칼라 입력 포트는 판독될 파일의 위치(예를 들어, 경로 또는 URL(uniform resource locator))와 사용될 레코드 형식을 명시하는 데이터 요소를 제공한다. 일부 경우에, 위치와 레코드 형식이 파일 입력 구성요소에 파라미터들로서 제공될 수 있고, 그 경우에 입력 스칼라 포트는 임의의 업스트림 구성요소에 연결될 필요가 없고 (구성요소(241)에 대해서 처럼) 도시될 필요가 없다. (구성요소(241 및 243) 모두에서 도시된 바와 같은) 콜렉션 출력 포트는 레코드들의 콜렉션을 제공한다. 유사하게, 파일 출력 구성요소(구성요소(245) 등)는 입력 콜렉션 포트를 통해 수신된 레코드들의 콜렉션을 출력 파일(그 위치 및 레코드 형식은 입력 스칼라 포트에 의해 선택적으로 지정될 수 있음)에 기록할 수 있다. 파일 입력 또는 파일 출력구성요소는 또한 (구성요소(245) 와 같은) 또 다른 구성요소의 제어 포트에 연결된 제어 입력 또는 출력 포트를 포함할 수 있다.

도시된 데이터 처리 그래프(240)에서, 더 큰 점선 사각형 내의 구성요소들은 실행 세트의 일부이다. 이러한 실행 세트는 그 안에 네스팅된 또 다른 실행 세트를 포함한다. 또한 점선 사각형 내에서 도시된 이러한 네스팅된 실행 세트는 제4 구성요소(244)만을 포함한다. 실행 세트들은 아래에서 더 상세히 논해진다.

동작시에, 제1 구성요소(241)는 입력 파일을 판독한다. 실행중일 때, 그것은 출력 콜렉션 데이터 포트로부터 제2 구성요소(242)의 입력 콜렉션 데이터 포트로 데이터 링크를 통해 입력 파일 내의 레코드들의 콜렉션을 제2 구성요소에 제공한다. 이하에서 더 상세히 설명될 바와 같이, 제2 구성요소(242)와 다른 다운스트림 구성요소들(동일한 실행 세트에 있음)의 상이한 인스턴스들이 콜렉션의 각각의 레코드에 대해 실행될 수 있다. 제2 구성요소(242)는 그 제어 입력에 연결된 어떠한 것도 가지지 않기 때문에, 즉시 처리를 시작한다. 완료시, 제2 구성요소(242)는 그 출력 스칼라 포트들에 파일명을 제공한다. 이러한 파일명은 각각의 입력 스칼라 포트에서 제3 구성요소(243) 및 제6 구성요소(246) 모두에 의해 수신된다.

제3 구성요소(243)는 파일명에 의해 식별된 파일을 즉시 판독하고 제4 구성요소(244)의 인스턴스의 입력 스칼라 포트로 전달하기 위해 출력 콜렉션 포트에 파일의 내용을 제공한다. 한편, 제6 구성요소(246)는 동일한 파일명을 수신하고 제5 구성요소(245)와 제7 구성요소(247)의 대응하는 입력 스칼라 포트들에 연결된 출력 스칼라 포트들 모두에 제공하는 또 다른 파일명을 출력한다.

제6 구성요소(246)으로부터 파일명과 제4 구성요소(244)로부터 잘못된 레코드들을 수신할 때, 제5 구성요소(245)는 그 파일명이 제6 구성요소(246)에 의해 식별되는 출력 파일에 잘못된 레코드들을 기록한다.

제7 구성요소(247)는 그 데이터 입력 포트에서 데이터를 수신할 때 실행될 준비가 되어 있지 않은 유일한 것이다. 제5 구성요소(245)가 출력파일에 기록을 완료하면, 그 제어 출력 포트로부터 제7 구성요소(247)의 입력 제어 포트로 제어 신호를 전송한다. 제7 구성요소(247)가 에러가 있었다고 결정하면, 제8 구성요소(248)의 입력 스칼라 포트에 데이터를 제공한다. 이것은 제8 구성요소(248)로 하여금 경보를 발생하게 한다. 이것은 제어 포트들이 데이터 처리 그래프 내의 특정 구성요소들의 실행을 제한하는 데 사용되는 예를 제공한다.

또 다른 구성요소의 상태에 기반하여 하나의 구성요소에서의 처리를 제어하는 기능이 여러 업스트림 구성요소들의 세트가 모두 특정 상태들에 도달했을 때 처리를 제어할 가능성을 가지고 있음이 분명해야 한다. 예를 들어, 데이터 처리 그래프는 동일한 제어 포트로/로부터의 여러 제어 링크들을 지원할 수 있다. 대안적으로, 일부 구현에서, 구성요소는 여러 입력 및 출력 제어 포트들을 포함할 수 있다. 기본 로직(default logic)이 컴파일러/인터프리터(120)에 의해 적용될 수 있다. 개발자는 또한 제어 신호들이 어떻게 결합될지를 결정하는 커스텀 로직(custom logic)을 제공할 수 있다. 이는 업스트림 구성요소들의 다양한 제어 링크에 적용하도록 그리고 특정 로직 상태에 도달될 때(예를 들어, 모든 업스트림 구성요소들이 완료되었을 때, 및 기본 OR 로직의 경우에 적어도 하나가 활성 제어 신호(activation control signal)를 보냈을 때)만 구성요소의 시작을 유발하도록 조합 로직(combinatorial logic)을 적절하게 배열하여 수행될 수 있다.

일반적으로, 제어 신호는 처리의 개시를 유발하거나 처리의 억제를 유발하는 신호일 수 있다. 전자는 “양의 제어 신호”이고 후자는 “음의 제어 신호”이다. 그러나 태스크가 호출되어야만 하는지 (처리의 개시를 유발하는지) 여부를 결정하는 데 조합 로직이 사용된다면, 태스크가 모든 입력들이 음의 제어 신호를 제공할 때만 호출되도록 로직이 일반적인 해석을 “인버트(invert)”시킬 수 있다. 일반적으로, 조합 로직은 아래에서 더 상세히 설명되는 제어 그래프에 대응하는 상태 머신에서 다음 상태를 결정하기 위한 임의의 “진리표(truth table)”를 제공할 수 있다.

연결되지 않은 제어 포트에 기본 상태가 할당될 수 있다. 일 실시 예에서, 상기 기본 상태는 양의 제어 신호에 대응한다. 아래에서 더 상세히 설명되는 바와 같이, 이것은 데이터 처리 그래프를 나타내는 제어 그래프의 암시적인 시작 및 종료 구성요소들을 사용하여 달성될 수 있다.

다양한 구성 요소들의 상이한 유형의 데이터 포트들은 그 구성요소들을 연결하는 입력 및 출력 포트들의 유형에 따라 상이한 방법으로 구성요소들 간 링크를 통해 데이터를 전달할 수 있다. 상술된 바와 같이, 스칼라 포트는 최대 하나의 데이터 요소(즉, 0 또는 1 데이터 요소)의 생성(스칼라 출력 포트의 경우) 또는 소비(스칼라 입력 포트의 경우)를 나타낸다. 반면에, 콜렉션 포트는 잠재적으로 여러 데이터 요소들의 세트의 생산(콜렉션 출력 포트의 경우) 또는 소비(콜렉션 입력 포트의 경우)를 나타낸다. 단일 데이터 처리 그래프에서 두 유형의 데이터 포트들을 지원하여 계산 자원이 더 효율적으로 할당될 수 있고 더 복잡한 제어 흐름과 데이터 흐름이 태스크들 사이에서 생성될 수 있어, 개발자가 원하는 동작을 쉽게 표시할 수 있다.

도 3a를 참조하면, 데이터 처리 그래프(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)의 직렬 실행을 실시한다.

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

일부 예에서, 구성요소들 중 하나 이상은 억제된 상태로 배치될 수 있다. 즉 하나 이상의 구성요소들이 실행되지 않으며 따라서 그 출력 포트들로부터 임의의 데이터 요소들을 전달하지 않는다. 구성요소들이 억제되게 할 수 있는 것은 예를 들어, 유용한 처리를 수행하지 않는 구성요소들이 그것들에 사용될 컴퓨팅 자원들 (예를 들어, 프로세스들 또는 메모리)이 필요없음을 보장하여 낭비되는 자원을 피한다. 억제된 구성요소들의 출력 포트들에 대해서만 연결된 스칼라 입력 포트들을 가지는 임의의 구성요소들은 어떠한 데이터도 수신하지 않기 때문에 실행되지 않는다. 예를 들어, 제1 구성요소(302)가 억제된 상태로 배치된다면 제2 구성요소(304)의 스칼라 입력 포트(312)는 제1 구성요소(302)의 스칼라 출력 포트(310)으로부터 어떠한 데이터도 수신하지 않고 따라서 실행되지 않는다. 제2 구성요소(304)가 실행되지 않기 때문에, 제3 구성요소(306)의 스칼라 입력 포트(316)는 제2 구성요소(304)의 스칼라 출력 포트(314)로부터 어떠한 데이터도 수신하지 않으며 또한 실행되지 않는다. 따라서, 두 개의 스칼라 포트들 사이에 전달된 데이터는 또한 두 개의 연결된 제어 포트들 사이에 전송된 신호와 유사한 양의 제어 신호로서 작동한다.

도 3a의 예시 데이터 처리 그래프에서, 제1 구성요소의 입력 포트(308)와 제3 구성요소(318)의 출력 포트는 콜렉션 포트들이 되고, 그것들에 연결된 스칼라 포트들에 의해 부과된 제1, 제2 및 제3 구성요소(302, 304, 306)의 직렬 실행 동작에 어떠한 영향도 미치지 않는다.

일반적으로, 구성요소들 사이의 데이터 요소들의 콜렉션을 전달하기 위해 콜렉션 포트들이 양쪽에 사용되고 동시에 해당 세트 내의 데이터 요소들을 재정렬하는 라이선스(license)를 런타임 시스템에 부여할 수 있다. 하나의 데이터 요소로부터 또 다른 데이터 요소로의 계산 상태에 의존하지 않거나, 각각의 데이터 요소가 처리될 때 액세스되는 전역 상태(global state)가 있다면 최종 상태가 그 데이터 요소들이 처리되었던 순서와 독립적이기 때문에 정렬되지 않은 콜렉션의 데이터 요소들의 재정렬이 허용된다. 이러한 재정렬 라이선스는 런타임때까지 병렬화(parallelization)에 대한 결정을 지연시키는 유연성을 제공한다.

도 3b를 참조하면, 데이터 처리 그래프(324)는 일련의 세 개의 연결된 구성요소들, 제1 구성요소(A2)(326), 제2 구성요소(B2)(328), 및 제3 구성요소(C2)(330)를 포함한다. 제1 구성요소(326)는 콜렉션 유형 입력 포트(332)와 콜렉션 유형 출력 포트(334)를 포함한다. 제2 구성요소(328)은 콜렉션 유형 입력 포트(336)와 콜렉션 유형 출력 포트(338)를 포함한다. 제3 구성요소(330)는 콜렉션 유형 입력 포트(340)와 콜렉션 유형 출력 포트(342)를 포함한다.

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

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

일부 예에서, 그래프 개발자는 데이터의 콜렉션의 데이터 요소들의 처리가 하나의 구성요소의 콜렉션 유형 출력 포트를 또 다른 구성요소의 스칼라 유형 입력 포트에 연결하여 동적으로 병렬화될 수 있다는 것을 명시적으로 표시할 수 있다. 이러한 표시는 또한 상태가 상기 콜렉션의 상이한 요소들의 처리 사이에서 유지되지 않을 것을 요구한다. 도 3c를 참조하면, 데이터 처리 그래프(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)에 연결된다. 이하에서 더 상세히 설명되는 바와 같이, 콜렉션 유형 출력 포트로부터 스칼라 유형 입력 포트로의 링크는 실행 세트로의 입구점(entry point)을 의미하고 스칼라 유형 출력 포트로부터 콜렉션 유형 입력 포트로의 링크는 실행 세트의 출구점(exit point)을 의미한다. 매우 일반적으로, 이하에서 더 상세히 설명되는 바와 같이, 실행 세트에 포함된 구성요소들은 데이터 요소들의 콜렉션으로부터의 데이터 요소들을 처리하기 위해 런타임 콘트롤러에 의해 동적으로 병렬화될 수 있다.

도 3c에서, 제1 구성요소(350)의 콜렉션 유형 출력 포트(358)와 제2 구성요소(352)의 스칼라 유형 입력 포트(360) 사이의 링크(368)는 실행 세트로의 입구점을 의미한다. 제2 구성요소(253)의 스칼라 유형 출력 포트(362)와 제3 구성요소(354)의 콜렉션 유형 입력 포트(364) 사이의 링크(370)는 실행 세트의 출구점을 의미한다. 즉, 제2 구성요소(352)가 실행 세트의 유일한 구성요소이다.

제2 구성요소(352)가 실행 세트에 포함되기 때문에, 제2 구성요소(352)의 별도의 인스턴스가 제1 구성요소(350)의 콜렉션 유형 출력 포트(358)로부터 수신된 각각의 데이터 요소에 대해 론칭(launch)된다. 별도의 인스턴스들 중 적어도 일부는 런타임시까지 할 수 없는 결정들에 따라 병렬로 실행될 수 있다. 이 예에서 제1(350) 및 제3(354) 구성요소들은 함께 시작하고 동시에 실행되는 반면, 제2 구성요소는 링크(368)를 통해 수신된 콜렉션 내 각각의 데이터 요소들에 대해 한번씩 실행된다. 대안적으로 제2 구성요소(352)는 콜렉션 내 여러 데이터 요소들의 각각의 튜플에 대해 한번씩 실행될 수 있다.

2. 실행 세트

도 1과 관련해서 상술된 바와 같이, 컴파일러/인터프리터(120)는 데이터 처리 그래프를 실행을 위해 준비시키기 위해 데이터 처리 그래프에 실행 세트 발견 전처리 절차를 수행한다. 일반적으로, 본원에서 사용된 바와 같이, “실행 세트” 라는 용어는 유닛으로서 호출되거나 출력 콜렉션 포트의 데이터 요소들의 일부와 같은 데이터의 일부에 적용될 수 있는 하나 이상의 구성요소들의 세트를 지칭한다. 따라서, 실행 세트의 각각의 구성요소의 최대 하나의 인스턴스가 각각의 입력 데이터 요소(또는 실행 세트의 하나 이상의 입력 포트들에 제공되는 여러 입력 데이터 요소들의 튜플)에 대해 실행된다. 실행 세트 내에서, 시퀀싱 제약조건들을 위반하지 않는 한 허용가능한 실행 세트의 구성요소들의 병렬 실행과 함께, 시퀀싱 제약조건들이 스칼라 및 제어 포트들로의 링크들에 의해 부과된다. 컴파일러/인터프리터(120)에 의한 실행 세트에 대해 준비된 코드는 상기 코드가 실행될 때 구성요소들에 대응하는 태스크들이 어떻게 수행되어야 하는지(예를 들어, 병렬처리의 정도)를 표시하는 임베딩된(embedded) 정보(예를 들어, 주석(annotation) 또는 수정자(modifier))를 포함할 수 있다. 실행 세트의 하나의 인스턴스가 수신된 콜렉션의 여러 데이터 요소들의 튜플에 대해 실행되는 예에서, 튜플은 예를 들어, 고정된 수의 데이터 요소들, 또는 일부 특성(예를 들어, 공통 키 값)을 공유하는 여러 데이터 요소들로 구성될 수 있다. 병렬로 실행되는 것이 허용되는 적어도 일부 구성요소들이 존재하는 예에서, 실행 세트는 여러 태스크들, 예를 들어, 전체로서 실행 세트에 대한 태스크 및 구성요소들 중 하나 이상의 인스턴스의 동시 실행에 대한 하나 이상의 서브 태스크들을 사용하여 구현될 수 있다. 따라서, 실행 세트의 상이한 인스턴스들을 나타내는 태스크들은 자체가 더 세분화된 태스크들, 예를 들어, 동시에 실행할 수 있는 서브 태스크들로 나눠질 수 있다. 상이한 실행 세트들에 대한 태스크들은 일반적으로 독립적으로 그리고 병렬로 실행될 수 있다. 그래서 예를 들어, 대규모 데이터세트가 백만 개의 레코드들을 가진다면, 백만개의 독립적 태스크들이 있을 수 있다. 태스크들 중 일부가 컴퓨팅 플랫폼(150)의 상이한 노드들(152)에서 실행될 수 있다. 태스크들은 심지어 단일 노드(152)에서도 동시에 효율적으로 실행될 수 있는 경량 스레드(lightweight threads)를 사용하여 실행될 수 있다.

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

매우 일반적으로, 실행 세트 발견 절차는 데이터 요소들의 정렬되지 않은 콜렉션의 요소들을 입력하기 위해 세트로서 적용될 데이터 처리 그래프 내의 구성요소들의 서브세트들을 결정하는 할당 알고리즘을 사용한다. 할당 알고리즘은 데이터 처리 그래프를 횡단하고 할당 규칙들에 기초하여 각각의 구성요소를 서브세트에 할당한다. 다음의 예에서 명백한 바와 같이, 주어진 데이터 처리 그래프는 실행 세트 계층 구조의 상이한 레벨에서 네스팅된 여러 실행 세트들을 포함할 수 있다.

본원에서 설명된 데이터 처리 그래프들에는, 두 가지 유형의 데이터 포트들이 있다: 스칼라 데이터 포트 및 콜렉션 데이터 포트. 일반적으로 연결된 구성요소들의 쌍(즉, 도 4a 내지 4d의 업스트림 구성요소 A(402) 및 다운스트림 구성요소 B(404))이 (그것들이 또 다른 이유로 상이한 실행 세트들에 있지 않다면) 동일한 유형의 포트들 사이의 링크에 의해 연결되면 기본으로 동일한 실행 세트에 있을 것이다. 도 4a에서, 구성요소 A(402)는 스칼라 유형의 출력 포트(406)을 가지고 구성요소 B(404)는 스칼라 유형의 입력 포트(408)을 가진다. 구성요소 A(402)와 구성요소 B(404) 사이의 링크(410)가 두 개의 스칼라 포트들을 연결하기 때문에, 구성요소 A와 B(402, 404)는 이 예에서 동일한 실행 세트에 있다. 도 4a에서, 구성요소 A(402)와 구성요소 B(404) 사이의 링크가 스칼라 대 스칼라 링크이기 때문에 0데이터 요소들 또는 1 데이터 요소가 링크(410)를 통해 업스트림 구성요소 A(402)와 다운스트림 구성요소 B(404) 사이에 전달된다. 업스트림 구성요소 A(402)의 처리의 완료시, (상술된 바와 같이) 그 경우에 어떠한 데이터 요소도 링크(410)를 통해 전달되지 않는, 업스트림 구성요소 A(402)가 억제된 경우가 아니라면 데이터 요소가 링크(410)를 통해 전달된다.

도 4b를 참조하면, 구성요소 A(402)는 콜렉션 유형의 출력 포트(412)를 가지고 구성요소 B(404)는 콜렉션 유형의 입력 포트(414)를 가진다. 구성요소 A(402)와 구성요소 B(404) 사이의 링크(410)가 두 개의 콜렉션 유형 포트들을 연결하기 때문에, 구성요소 A(402)와 구성요소 B(404)는 이 예에서 또한 동일한 실행 세트에 있다. 도 4b에서, 구성요소 A(402)와 구성요소 B(404) 사이의 링크(410)가 콜렉션 대 콜렉션 링크이기 때문에, 데이터 요소들의 세트가 업스트림과 다운 스트림 구성요소들 사이에 링크(401)를 통해 전달된다.

링크의 양단의 포트 유형들 사이에 불일치가 있을 때, 실행 세트 계층구조의 레벨에 암시적인 변경이 존재한다. 특히, 불일치된 포트들은 실행 세트 계층구조의 특정 레벨에서 실행 세트에 대한 입구점들 또는 출구점들을 나타낸다. 일부 예에서, 실행 세트 입구점이 콜렉션 유형 출력 포트와 스칼라 유형 입력 포트 사이의 링크로서 정의된다. 도 4c에서, 구성요소 A(402)의 출력 포트(416)가 콜렉션 유형 포트이고 구성요소 B(404)의 입력 포트(418)가 스칼라 유형 포트이기 때문에, 실행 세트 입구점(424)의 일 예가 구성요소 A(402)와 구성요소 B(404) 사이의 링크(410)에서 도시된다.

일부 예에서는, 실행 세트 출구점이 스칼라 유형 출력 포트와 콜렉션 유형 입력 포트 사이의 링크로서 정의된다. 도 4d를 참조하면, 구성요소 A(402)의 출력 포트(420)가 스칼라 유형 포트이고 구성요소 B(404)의 입력 포트(422)가 콜렉션 유형 포트이기 때문에, 실행 세트 출구점(426)의 일 예가 구성요소 A(402)와 구성요소 B(404) 사이의 링크(410)에서 도시된다.

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

2.1 스택 기반 할당 알고리즘

설명을 위해, 제1 예에서, 데이터 처리 그래프는 단순한 일차원 그래프 구조를 가지고 보다 단순한 할당 알고리즘이 스택 기반 알고리즘을 이용하여 설명된다. 스택 기반 할당 알고리즘에서, 데이터 처리 그래프의 각각의 구성요소는 분리 문자 ‘/’에 의해 분리되는 정수들로 구성된 하나 이상의 “ID 문자열”로 라벨링된다. 분리 문자 ‘/’가 주어진 구성요소에 대한 ID 문자열에서 나타나는 횟수는 실행 세트 계층 구조에서 구성요소의 레벨을 결정한다. 일부 예에서, 구성요소는 여러 입력 링크들을 가질 수 있고 따라서 여러 ID 문자열들을 가질 수 있다. 이러한 경우에, 알고리즘은 어떤 ID 문자열을 사용할지 결정하기 위해 이하에서 더 상세히 설명되는 규칙들을 가진다.

스택 기반 할당 알고리즘의 일 예에서, 컴파일러/인터프리터(120)는 다음 절차에 따라 업스트림에서 다운스트림 방향으로 데이터 처리 그래프를 워킹(walk)한다. 초기에, 가장 업스트림의 구성요소(들)은 그것이 실행 세트 계층구조의 루트 레벨에 있는 구성요소인 것을 표시하는 ‘0’의 ID 문자열로 라벨링된다.

그런 다음 최상위 구성요소로부터 최하위 구성요소로의 경로 상의 링크들과 구성요소들이 횡단된다. 업스트림 구성요소의 콜렉션 유형 출력 포트와 다운스트림 구성요소의 콜렉션 유형 입력 포트 사이의 링크를 마주치게 되면, 업스트림 구성요소의 ID 문자열이 다운스트림 구성요소로 전파된다. 유사하게, 업스트림 구성요소의 스칼라 유형 출력 포트와 다운스트림 구성요소의 스칼라 유형 입력 포트 사이의 링크를 마주치게 되면, 업스트림 구성요소의 ID 문자열이 다운스트림 구성요소로 전파된다.

업스트림 구성요소의 콜렉션 유형 출력 포트와 다운스트림 구성요소의 스칼라 유형 입력 포트 사이의 링크를 마주치게 되면, 다운스트림 구성요소에 끝에 ‘/n’이 붙은 업스트림 구성요소의 라벨을 포함하는 라벨이 할당되고, 여기서 n은 1+<모든 기존의 ID 문자열 정수 중 최대값>이다. 업스트림 구성요소의 스칼라 유형 출력 포트와 다운스트림 구성요소의 콜렉션 유형 입력 포트 사이의 링크를 마주치게 되면, 다운스트림 구성요소에 가장 오른쪽 ID 문자열 정수(및 그 구분문자 ‘/’)가 제거된 업스트림 구성요소의 라벨을 포함하는 라벨이 할당된다.

일부 예에서, (예를 들어, 구성요소가 실행 세트 계층구조의 동일한 레벨에서 두 개의 상이한 ID 문자열, 또는 실행 세트 내 사이클의 존재를 가진다면) 다양한 조건들이 불법으로 간주될 수 있고 알고리즘에 에러를 야기할 것이다.

도 5를 참조하면, 상술된 스택 기반 할당 알고리즘은 예시 데이터 처리 그래프(550)에 적용되어 그 결과 (루트, “Level 0” 실행 세트(551) 외에) 두 개의 실행 세트들을 발견한다: 제1 “Level 1” 실행 세트(570) 및 제1 “Level 1” 실행세트(670)에 네스팅된 제2 “Level 2” 실행 세트(572). 두 개의 실행 세트들(570, 572)의 발견에 도달하기 위해, 스택 기반 할당 알고리즘은 먼저 가장 상류의 구성요소, 제1 데이터세트(656)을 ‘0’의 ID 문자열로 라벨링한다. 그런 다음 스택 기반 할당 알고리즘은 데이터 처리 그래프(550)를 통해 일차원 경로의 구성요소들을 횡단한다. 경로를 횡단할 때, 스택 기반 할당 알고리즘은 먼저 제1 데이터세트(556)으로부터 제1 구성요소(558)로의 링크를 횡단한다. 제1 데이터세트(556)의 출력 포트가 콜렉션 유형 출력 포트이고 제1 구성요소(558)의 입력 포트가 스칼라 유형 입력 포트이기 때문에, 제1 구성요소(558)는 끝에 ‘/1’이 붙은 제1 데이터세트(556)의 ID 문자열인 ‘0/1’의 ID 문자열이 제1 구성요소(558)에 할당되고, 여기서 1은 모든 기존 ID 문자열 정수+1의 최대값이다. 일반적으로, 제1 구성요소(558)의 ID 문자열에 ‘/1’을 추가한 것은 루트, “Level 0’ 실행 세트(551)로부터 “Level 1” 실행 세트(570)로의 천이(transition)의 표시이다. 일부 예에서, 이러한 천이는 제1 실행 세트 입구점 표시자(557)를 사용하여 나타내어진다.

그런 다음 할당 알고리즘은 제1 구성요소(558)로부터 제2 구성요소(560)로의 링크를 횡단한다. 제1 구성요소(558)의 출력 포트가 콜렉션 유형 출력 포트이고 제2 구성요소(560)의 입력 포트가 스칼라 유형 입력 포트이기 때문에, 제2 구성요소(560)에 끝에 ‘/2’가 붙은 제1 구성요소(558)의 ID 문자열인 ‘0/1/2’의 ID 문자열이 할당되고, 여기서 2는 모든 기존 ID 문자열 정수+1의 최대 값이다. 일반적으로, 제2 구성요소(560)의 ID 문자열에 ‘/2’를 추가한 것은 "Level 1" 실행 세트(570)으로부터 “Level 2” 실행 세트(572)로의 천이의 표시자이다. 일부 예에서, 이러한 천이는 제2 실행 세트 입구점 표시자(559)를 사용하여 나타내어진다.

그런 다음 할당 알고리즘은 제2 구성요소(560)로부터 제3 구성요소(562)로의 링크를 횡단한다. 제2 구성요소(560)의 출력 포트가 스칼라 유형 출력 포트이고 제3 구성요소(562)의 입력 포트가 스칼라 유형 입력 포트이기 때문에, 제2 구성요소(560)의 ID 문자열(즉, ‘0/1/2’)이 제3 구성요소(562)로 전파된다.

그런 다음 할당 알고리즘은 제3 구성요소(562)로부터 제4 구성요소(564)로의 링크를 횡단한다. 제3 구성요소(562)의 출력 포트가 스칼라 유형 출력 포트이고 제4 구성요소(564)의 입력 포트가 콜렉션 유형 입력 포트이기 때문에, 제4 구성요소에 가장 오른쪽 ID 문자열 ‘2’(및 그 구분 문자 ‘/’)를 제거한 제3 구성요소(562)의 ID문자열인 ‘0/1’의 ID 문자열이 할당된다. 일반적으로 제3 구성요소(562)의 ID 문자열로부터 ‘/2’를 제거한 것은 “Level 2” 실행 세트(572)로부터 “Level 1” 실행 세트(570)으로의 천이의 표시자이다. 일부 예에서는, 이러한 천이가 제1 실행 세트 출구점 표시자(563)을 사용하여 나타내어진다.

그런 다음 할당 알고리즘은 제4 구성요소(564)로부터 제5 구성요소(566)으로의 링크를 횡단한다. 제4 구성요소(564)의 출력 포트가 스칼라 유형 출력 포트이고 제5 구성요소(566)의 입력 포트가 콜렉션 유형 입력 포트이기 때문에, 제5 구성요소(566)에 가장 오른쪽 ID문자열 정수(및 그 구분 문자 ‘/’)가 제거된 제4 구성요소(564)의 ID 문자열인 ‘0’의 ID 문자열이 할당된다. 일반적으로, 제4 구성요소(564)의 ID 문자열로부터 ‘/1’을 제거한 것은 “Level 1” 실행 세트로부터 루트, “Level 0” 실행 세트(551)로의 천이의 표시이다. 일부 예에서, 이러한 천이는 제2 실행 세트 출구점 표시자(565)를 사용하여 나타내어진다.

마지막으로, 할당 알고리즘은 제5 구성요소(566)로부터 제2 데이터세트(568)로의 링크를 횡단한다. 제5 구성요소(566)의 출력 포트가 콜렉션 유형 출력 포트이고 제2 데이터세트(568)의 입력 포트가 콜렉션 유형 입력 포트이기 때문에, 제5 구성요소(566)의 ID 문자열(즉, ‘0’)이 제2 데이터세트(568)로 전파된다.

일부 예에서, 입구점 표시자들과 출구점 표시자들 외에, 데이터 요소들의 콜렉션들의 흐름과 개별 스칼라 데이터 요소들 사이의 변화가 사용자 인터페이스 내의 부가적인 시각적 큐(visual cue)를 사용하여 시각적으로 나타내어질 수 있다. 예를 들어, 링크를 나타내는 라인이 콜렉션 포트와 표시자 사이에서 더 두꺼워지고 스칼라 포트와 표시자 사이에서 더 얇아질 수 있다.

스택 기반 할당 알고리즘의 결과는 구성요소들 각각이 ID 문자열로 라벨링되는 데이터 처리 그래프(550) 버전을 포함한다. 도 5의 예에서, 제1 데이터세트(556), 제2 데이터세트(568), 및 제5 구성요소(566)가 모두 ID 문자열 ‘0’으로 라벨링된다. 제1 구성요소(558)와 제4 구성요소(564)는 ID 문자열 ‘0/1’로 라벨링된다. 제2 구성요소(560)와 제3 구성요소(562)는 각각 ID 문자열 ‘0/1/2’로 라벨링된다.

각각의 고유한 ID 문자열은 실행 세트 계층구조에서 고유한 실행 세트를 나타낸다. ID 문자열 ‘0’을 가지는 구성요소들은 실행 계층구조에서 루트, “Level 0” 실행 세트(551)로 그룹화된다. ID 문자열 ‘0/1’을 가지는 구성요소들은 루트 실행 세트(651) 내에 네스팅된 “Level 1” 실행 세트(670)로 그룹화된다(여기서 ‘0/1’은 실행 세트 0 내에 네스팅된 실행 세트 1로 판독될 수 있다). ID 문자열 ‘0/1/2’를 가지는 구성요소들은 루트, “Level 0” 실행 세트(551)와 “Level 1” 실행 세트(570) 둘 모두 내에 네스팅된 “Level 2” 실행 세트(572)로 그룹화된다.

2.2 전역 매핑 기반 할당 알고리즘

일부 예에서, 더 일반적인 데이터 처리 그래프들에 대해, 스택 기반 할당 알고리즘은 실행 세트 계층구조를 정확하게 결정하는 데 충분하지 않을 수 있다. 예를 들어, 일반 데이터 처리 그래프들에서, 임의의 주어진 구성요소가 여러 입력 포트들 및/또는 여러 출력 포트들을 가질 수 있어, 스택 기반 방법과 양립할 수 없는 일반 데이터 처리 그래프들을 렌더링한다. 이러한 예에서, 전역 매핑 기반 할당 알고리즘이 실행 세트 계층구조를 결정하는 데 사용된다.

전역 매핑 기반 할당 알고리즘은 데이터 처리 그래프들이 방향성 비순환 그래프들(directed acyclic graph)이 되도록 제한된다는 사실을 이용한다. 방향성 비순환 그래프들은 토폴로지 정렬 순서(topological sorted order)를 이용하여 처리될 수 있어, 그 구성요소의 바로 상류에 있는(upstream) 구성요소들 모두가 처리된 후에만 그래프의 각각의 구성요소가 처리되는 것을 보장한다. 상기 구성요소의 바로 상류에 있는 구성요소들 모두가 처리된 것으로 알려져 있기 때문에, 해당 구성요소의 대한 ID 문자열이 상기 구성요소로부터 직접적으로 상류에 있는 (실행 세트 계층구조에서) 가장 깊게 네스팅된 ID 문자열을 선택하여 결정될 수 있다.

일부 예에서, 전역 매칭 기반 할당 알고리즘은 주어진 데이터 처리 그래프에 대한 토폴로지 정렬 순서를 획득하기 위해 칸의 알고리즘(Kahn’s algorithm) 같은 표준 토폴로지 정렬 알고리즘을 사용한다. 칸의 알고리즘은 다음의 의사코드(pseudo-code)에 의해 요약된다:

토폴로지 정렬 순서를 결정한 후에, 전역 매핑 기반 할당 알고리즘은 구성요소들 각각에 대해 적절한 ID 문자열(또는 단순히 ID 번호)을 결정하기 위해 토폴로지 정렬 순서로 데이터 처리 그래프의 구성요소들을 횡단한다. 특히, 구성요소들이 횡단될 때, 데이터 처리 그래프의 매 구성요소는 그 출력 포트로 자신의 ID 문자열을 복사한다. 업스트림 구성요소로부터 바로 하류에 있고 실행 세트 입구점 또는 실행 세트 출구점에 의해 업스트림 구성요소로부터 분리되지 않은 구성요소들은 업스트림 구성요소의 출력 포트로부터 ID 문자열을 판독하고 그ID 문자열을 그것들의 ID 문자열로 사용한다.

실행 세트 입구점에 의해 다운스트림 구성요소로부터 분리된 업스트림 구성요소에 대해, 새로운 ID 문자열이 실행 세트 입구점에 할당되고 다운스트림 구성요소에 그것의 ID 문자열로 사용하기 위해 제공된다. 업스트림 구성요소의 ID 문자열의 다운스트림 구성요소의 ID 문자열로의 매핑(즉, 부모/자식 매핑)이 추후 사용을 위해 전역 매핑 데이터 스토어(global mapping data store)에 저장된다.

실행 세트 출구점에 의해 다운스트림 구성요소로부터 분리된 업스트림 구성요소에 대해, 상기 업스트림 구성요소의 출력 포트에서의 ID 문자열이 실행 세트 출구점에 의해 판독된다. 그런 다음 상기 출력 포트에서의 ID 문자열에 대한 부모 ID 문자열을 결정하기 위해 전역 매핑 데이터 스토어가 쿼리(query)된다. 상기 부모 ID 문자열이 다운스트림 구성요소에 그것의 ID 문자열로 사용하기 위해 제공된다.

도 6을 참조하면, 예시 일반 2차원 데이터 처리 그래프(628)의 일 예가 상술한 전역 매핑 기반 할당 알고리즘을 이용하여 분석된다. 데이터 처리 그래프(628)는 제1 데이터세트(D1)(632), 제1 구성요소(C1)(638), 제2 구성요소(C2)(642), 제3 구성요소(C3)(645), 제4 구성요소(C4)(646), 제5 구성요소(C5)(642), 제6 구성요소(C6)(644), 및 제2 데이터세트(D2)(634)를 포함한다. ID 문자열들을 데이터 처리 그래프(628)의 개별 구성요소들에 할당하기 전에, 토폴로지 정렬 알고리즘(예를 들어, 칸의 알고리즘)이 데이터 처리 그래프에 적용되어 D1, C1, C2, C3, C4, C5, C6, D2의 토폴로지 정렬 순서를 초래한다.

토폴로지 정렬 순서가 결정되면, 전역 매핑 기반 할당 알고리즘은 구성요소들 각각에 대해 적절한 ID 문자열을 결정하기 위해 상기 토폴로지 정렬 순서로 데이터 처리 그래프의 구성요소들을 횡단하여, (루트, “Level 0” 실행 세트 외에) “Level 1” 실행 세트(630)와 “Level 2” 실행 세트(631)를 발견한다. 두 개의 실행 세트(630, 631)의 발견에 도달하기 위해, 전역 매핑 기반 할당 알고리즘은 먼저 ‘0’의 ID 문자열로 가장 상류의 구성요소, 제1 데이터세트(D1)(632)를 라벨링한다. 그런 다음 스택 기반 할당 알고리즘이 토폴로지 정렬 순서로 데이터 처리 그래프(628)의 구성요소들과 링크들을 횡단한다.

전역 매핑 기반 할당 알고리즘은 먼저 제1 데이터세트(D1)(632)로부터 제1 구성요소(C1)(638)로의 링크를 횡단한다. 제1 데이터세트(D1)(632)의 출력 포트가 콜렉션 유형 출력 포트이고 제1 구성요소(C1)(638)의 입력 포트가 콜렉션 유형 입력 포트이기 때문에, 어떠한 실행 세트 입구점 또는 출구점도 식별되지 않고 제1 데이터세트(D1)(632)의 ID 문자열(즉, ‘0’)이 제1 데이터세트(D1)(632)의 출력 포트로부터 판독되어 제1 구성요소(C1)(638)에 할당된다.

그런 다음 할당 알고리즘은 제1 구성요소(C1)(638)와 제2 구성요소(C2)(640) 사이의 링크를 횡단한다. 제1 구성요소(C1)(638)의 출력 포트가 콜렉션 유형 출력 포트이고 제2 구성요소(C2)(640)의 입력 포트가 스칼라 유형 입력 포트이기 때문에, 제1 실행 세트 입구점(639)이 두 개의 구성요소(638, 640) 사이에서 식별된다. 제1 실행 세트 입구점(639)에서, 새로운 ID 문자열(즉, ‘1’)이 할당되어 제2 구성요소(C2)(640)의 ID 문자열로 할당된다. 제1 실행 세트 입구점(639)에 대한 부모 ID 문자열(즉, ‘0’)의 제1 실행 세트 입구점(639)에 대한 자식 ID 문자열(즉, ‘1’)로의 매핑(653)이 추후 사용을 위해 전역 매핑 데이터 스토어(649)에 저장된다.

그런 다음 할당 알고리즘은 제2 구성요소(C2)(640)로부터 제3 구성요소(C3)(645)로의 링크를 횡단한다. 제2 구성요소(C2)(640)의 출력 포트가 콜렉션 유형 출력 포트이고 제3 구성요소(645)의 입력 포트가 스칼라 유형 입력 포트이기 때문에, 제2 실행 세트 입구점(641)이 두 개의 구성요소(640, 645) 사이에서 식별된다. 제2 실행 세트 입구점(641)에서, 새로운 ID 문자열(즉, ‘2’)이 할당되어 제3 구성요소(C3)(645)의 ID 문자열로 할당된다. 제2 실행 세트 입구점(641)에 대한 부모 ID 문자열(즉, ‘1’)의 제2 실행 세트(641)에 대한 자식 ID 문자열(즉, ‘2’)로의 매핑(651)이 추후 사용을 위해 전역 매핑 데이터 스토어(649)에 저장된다.

그런 다음 할당 알고리즘은 제3 구성요소(C3)(645)로부터 제4 구성요소(C4)(646)로의 링크를 횡단한다. 제3 구성요소(C3)(645)의 출력 포트가 콜렉션 유형 출력 포트이고 제4 구성요소(C4)(646)의 입력 포트가 콜렉션 유형 입력 포트이기 때문에, 어떠한 실행 세트 입구점 또는 출구점도 식별되지 않고 제3 구성요소(C3)(645)의 ID 문자열(즉, ‘2’)이 제3 구성요소(C3)(645)의 출력포트로부터 판독되어 제4 구성요소(C4)(646)에 할당된다.

그런 다음 할당 알고리즘은 제4 구성요소(C4)(656)로부터 제5 구성요소(C5)(642)로의 링크를 횡단한다. 제4 구성요소(C4)(646)의 출력 포트가 스칼라 유형 출력 포트이고 제5 구성요소(C5)(642)의 입력 포트가 콜렉션 유형 입력 포트이기 때문에, 제1 실행 세트 출구점(647)이 두 개의 구성요소(646, 642) 사이에서 식별된다. 제1 실행 세트 출구점(647)에서, 제4 구성요소(C4)(646)의 ID 문자열이 제4 구성요소(C4)(646)의 출력 포트로부터 판독되어 전역 매핑 데이터 스토어(649)를 쿼리(query)하는데 사용된다. 전역 매핑 데이터 스토어(649)는 제2 실행 세트 입구점(641)과 관련되어 저장된 부모 자식 관계(651)(즉, ‘1/2’)를 반환한다. 상기 부모/자식 관계(651)의 부모 ID 문자열(즉, ‘1’)이 제5 구성요소(C5)(642)에 대한 ID 문자열로 할당된다.

그런 다음 할당 알고리즘은 제5 구성요소(C5)(642)로부터 제6 구성요소(C6)(644)로의 링크를 횡단한다. 제5 구성요소(C5)(642)의 출력 포트가 스칼라 유형 출력 포트이고 제6 구성요소(C6)(644)의 입력 포트가 콜렉션 유형 입력 포트이기 때문에, 제2 실행 세트 출구점(643)이 두 개의 구성요소들(642, 644) 사이에서 식별된다. 제2 실행 세트 출구점(643)에서, 제5 구성요소(C5)(642)의 ID 문자열이 제5 구성요소(C5)(642)의 출력 포트로부터 판독되어 전역 매핑 데이터 스토어(649)를 쿼리하는데 사용된다. 전역 매핑 데이터 스토어(649)는 제1 실행 세트 입구점(639)와 관련되어 저장된 부모/자식 관계(653)(즉, ‘0/1’)을 반환한다. 부모/자식 관계(653)의 부모 ID 문자열(즉, ‘0’)이 제6 구성요소(C6)(644)에 대한 ID 문자열로 할당된다.

마지막으로, 할당 알고리즘은 제6 구성요소(C6)(644)로부터 제2 데이터세트(D2)(634)로의 링크를 횡단한다. 제6 구성요소(C6)(644)의 출력 포트가 콜렉션 유형 출력 포트이고 제2 데이터세트(D2)(634)의 입력 포트가 콜렉션 유형 입력 포트이기 때문에, 어떠한 실행 세트 입구점 또는 출구점도 식별되지 않고 제6 구성요소(C6)(644)의 ID 문자열(즉, ‘0’)이 제6 구성요소(C6)(644)의 출력 포트로부터 판독되어 제2 데이터세트(D2)(634)에 할당된다.

전역 매핑 기반 할당 알고리즘의 결과는 구성요소들 각각이 ID 문자열로 라벨링되는 데이터 처리 그래프(628)의 버전을 포함한다. 도 6의 예에서, 제1 데이터세트(D1)(632), 제1 구성요소(C1)(638), 제6 구성요소(C6)(644), 및 제2 데이터세트(D2)(634)는 ID 문자열 ‘0’으로 모두 라벨링된다. 제2 구성요소(C2)(640)와 제5 구성요소(C5)(642)는 모두 ID 문자열 ‘1’로 라벨링된다. 제3 구성요소(C3)(645)와 제4 구성요소(C4)(646)는 모두 ID 문자열 ‘2’로 라벨링된다.

각각의 고유한 ID 문자열은 실행 세트 계층구조의 고유한 실행 세트를 나타낸다. ID 문자열 ‘0’을 가지는 구성요소들은 실행 계층구조에서 루트, “Level 0” 실행 세트(629)로 그룹화된다. ID 문자열 ‘1’을 가지는 구성요소들은 루트 실행 세트(629) 내에 네스팅된 “Level 1” 실행 세트(630)로 그룹화된다. ID 문자열 ‘2’를 가지는 구성요소들은 루트, “Level 0” 실행 세트(629) 내에 그리고 또 “Level 1” 실행 세트(630) 내에 네스팅된 “Level 2” 실행 세트로 그룹화된다.

2.3 사용자 정의 실행 세트

상술된 예에서는, 할당 알고리즘(들)이 임의의 사용자 개입없이 데이터 처리 그래프에 존재하는 실행 세트들을 자동적으로 발견하도록 사용된다. 그러나, 일부 예에서는, 사용자가 할당 알고리즘(들)에 의해 제공되는 기능 이외의 기능을 요구할 수 있다. 이러한 경우에, 사용자는 실행 세트들이 시작하고/하거나 끝나는 곳을 명시적으로 정의하기 위해 실행 세트 입구점들 및 출구점들을 추가할 수 있다. 도 7을 참조하면, 데이터 처리 그래프(776)는 제1 데이터세트(774), 제1 구성요소(778), 제2 구성요소(780) 및 제2 데이터세트(790)를 포함한다. 상술된 할당 알고리즘(들)을 데이터 처리 그래프(776)에 적용하는 것이 제1 구성요소(778)과 제2 구성요소(780)를 포함하는 단일 실행 세트의 발견을 초래할 것이다. 그러나 이경우에, 사용자는 데이터 처리 그래프(776)에 대해 두 개의 실행 세트(즉, 제1 실행 세트(782)와 제2 실행 세트(786))를 명시적으로 정의했다. 특히, 사용자는 실행 세트 출구점 구성요소(784)를 제1 구성요소(778)의 출력 포트로부터 나오는 링크에 삽입했고 실행 세트 입구점(788)을 제2 구성요소(780)의 입력포트로 들어가는 링크에 삽입했다. 실행 세트 출구점(784)과 실행 세트 입구점(788)을 제1 구성요소(778)와 제2 구성요소(780) 사이의 링크에 추가하여 사용자는 단일 실행 세트였던 것을 두 개의 별개의 실행 세트(782, 786)로 근본적으로 분할했다.

일부 예에서, 사용자는 데이터 처리 그래프에 대해 실행 세트 입구 및 출구점들을 모두 정의한다. 다른 예에서, 사용자는 실행 세트 입구 및 출구점들 중 일부를 정의한 다음 데이터 처리 그래프에 대해 나머지 실행 세트 입구 점들과 출구 점들의 발견하는 것을 할당 알고리즘(들)에 맡긴다.

2.4 관계와 동일한 세트

일부 예에서, 사용자는 주어진 구성요소가 어떤 실행 세트에 속하는지 명시적으로 지정하길 원할 수 있다. 예를 들어, 도 8a를 참조하면, 데이터 처리 그래프(892)는 데이터 생성 구성요소(896)와 테이블 판독 구성요소(898)로부터 데이터 요소들을 수신하는 제1 실행 세트(894)를 포함한다. 이러한 구성요소들은 그것들이 제공하는 데이터 요소들의 콜렉션에 대해 상이한 소스들을 가진다는 것을 제외하고는 파일 입력 구성요소와 유사하다. 데이터 생성 구성요소(896)에 대해, 파일 위치를 명시하는 스칼라 입력 포트 대신에, 생성될 레코드 데이터 요소들 의 수를 명시하는 (선택적) 스칼라 입력 포트가 있고, 또한 각각의 데이터 요소가 어떻게 생성될 것인지를 명시하는 파라미터가 있다. 테이블 판독 구성요소(898)에 대해, 파일 위치를 명시하는 스칼라 입력 포트 대신에, 데이터베이스의 테이블을 명시하는 (선택적) 스칼라 입력 포트가 있다. 제1 실행 세트(894)는 제1 데이터세트(899)에 제공되는 출력을 생성하기 위해 데이터 생성 구성요소(896)와 테이블 판독 구성요소(898)로부터의 데이터 요소들을 함께 처리하는 제1 구성요소(891)와 제2 구성요소(893)을 포함한다.

도 8a에 있어서, 테이블 판독 구성요소(898)는 제1 실행 세트(894) 외부에 있다. 즉, 그것은 한번 실행되고 그 콜렉션 유형 출력 포트로부터 데이터 요소들의 콜렉션을 출력한다. 데이터 요소들의 콜렉션이 제1 실행 세트(894)의 경계를 횡단하여 제1 구성요소(891)의 콜렉션 유형 입력 포트에 제공된다. 실행 세트(894)의 구성요소들의 각각의 병렬 인스턴스에 대해, 제1 구성요소(891)의 콜렉션 유형 입력 포트에서 데이터 요소들의 콜렉션의 복사본이 생성된다. 일반적으로, 링크가 콜렉션 포트, 스칼라 포트, 또는 제어 포트로부터이든 아니든 상이한 실행 세트들에 할당된 구성요소들 사이의 링크가 실행 세트로 유입되는 링크들에 대한 모든 인스턴스들에 대해 복사된 데이터 또는 제어 요소들을 가질 것이고, 실행 세트로부터 유출되는 링크들에 대한 모든 인스턴스들로부터 수집된 데이터 또는 제어 요소들을 가질 것이다. 데이터 요소들은 콜렉션으로 수집되고 제어 요소들은 벡터로 수집되며, 이는 다운스트림 구성요소의 제어 로직에 따라 (에러로 표시될 수 있는 것을 포함하여) 적절하게 처리될 수 있다.

도 8b를 참조하면, 일부 예에서는, 사용자가 테이블 판독 구성요소(898)가 실행 세트(894)의 구성요소들의 각각의 병렬 인스턴스에 대해 실행될 것을 요구할 수 있다. 이 기능을 달성하기 위해, 사용자는 테이블 판독 구성요소(898)와 제1 구성요소(891) 사이의 관계와 “동일한 세트”를 명시할 수 있다. 사용자가 관계와 “동일한 세트”를 명시한 결과로서, 테이블 판독 구성요소(898)가 제1 구성요소(891)와 동일한 실행 세트(즉, 제1 실행 세트(894))로 이동된다. 테이블 판독 구성요소(898)가 제1 실행 세트(894)에 포함되므로, 제1 실행 세트(894)의 구성요소들의 각각의 병렬 인스턴스는 테이블 판독 구성요소(898)의 인스턴스를 실행한다.

일부 예에서, 사용자는 (예를 들어, 아래에서 더 상세히 설명되는 사용자 인터페이스를 통해) 소스 실행 세트(source execution set)와 관련된 메뉴로부터 데스티네이션 실행 세트(destination execution set)를 선택하여, 또는 소스 실행 세트로부터 데스티네이션 실행 세트로 구성요소를 드래그하여 관계와 “동일한 세트”를 명시할 수 있다. 일부 예에서는, 드래그된 구성요소가 목적 실행 세트에 합법적으로 위치될 수 있는지를 검증하기 위해 에러 검사가 수행된다. 예를 들어, 서로에 대해 관계와 “동일한 세트”를 가질 임의의 두 개의 구성요소들에 강요될 수 있는 하나의 가능한 요구사항은 그 구성요소들 모두를 포함하는 데이터 처리 그래프를 통과하는 적어도 하나의 경로가 있어야 한다는 것이다.

2.5 콜렉션 데이터 복제

일부 예에서는, 실행 세트의 여러 구성요소들이 각각 실행 세트 입구점을 통해 업스트림 구성요소의 단일 콜렉션 출력 포트에 연결된 스칼라 입력 포트들을 가질 수 있다. 유사하게, 실행 세트의 여러 구성요소들이 각각 실행 세트로부터 하류의 구성요소의 단일 콜렉션 입력 포트에 연결된 스칼라 출력 포트들을 가질 수 있다.

일부 예에서는, 콜렉션 유형 출력 포트로부터 여러 구성요소들의 스칼라 입력 포트들로 동일한 데이터를 제공하기 위해, 실행 세트 입구점이 스칼라 입력 포트들 각각에 대해 콜렉션으로부터의 각각의 데이터 요소의 복제본(들)을 생성하고 상기 복제본(들)을 해당 스칼라 입력 포트들에 제공한다. 유사하게, (실행 세트의 상이한 각각의 반복으로부터의) 여러 구성요소들의 스칼라 출력 포트들에 의해 출력되는 데이터를 병합하기 위해, 실행 세트 출구점은 스칼라 출력 포트들로부터의 출력 데이터 요소들을 수신하고, 상기 출력 데이터 요소들을 병합한 다음, 다운스트림 구성요소의 콜렉션 입력 포트에 상기 병합된 출력 데이터 요소들을 제공할 수 있다. 일반적으로, 다운스트림 구성요소의 콜렉션 입력 포트는 병합된 데이터 요소들을 처리하도록 구성된다.

도 9를 참조하면, 데이터 처리 그래프(923)는 제1 데이터세트(924), 제2 데이터세트(926), 및 실행 세트(928)를 포함한다. 실행 세트(928)는 두 개의 구성요소 - 제1 구성요소(930)과 제2 구성요소(932) - 를 포함한다. 제1 데이터세트(924)는 실행 세트(928)의 실행 세트 입구점(936)에 연결된 콜렉션 출력 포트(934)를 가지고 실행 세트(928)의 실행 세트 입구점(936)에 데이터 요소들의 콜렉션을 제공한다. 제2 데이터 세트(926)는 실행 세트(928)의 실행 세트 출구점(940)에 연결된 콜렉션 입력 포트(938)를 가지고 실행 세트(928)의 실행 세트 출구점(940)으로부터 데이터 요소들의 콜렉션을 수신한다.

실행 세트(928)내에서, 제1 구성요소(930)는 제1 스칼라 입력 포트(942)를 가지고 제2 구성요소(932)는 제2 스칼라 입력 포트(944)를 가진다. 제1 스칼라 입력 포트(942)와 제2 스칼라 입력 포트(944) 모두 실행 세트 입구점(936)에 연결되고 실행 세트 입구점(936)으로부터 개별 데이터 요소들을 수신한다. 상술된 바와 같이, 실행 세트 입구점(936)은 실행 세트 입구점(936)에 연결된 각각의 스칼라 입력 포트에 데이터 요소들의 콜렉션의 각각의 데이터 요소의 복사본을 제공하기 위해 콜렉션 출력 포트(934)로부터 수신된 데이터 요소들을 복제한다. 도 9에서, 실행 세트 입구점(936)은 각각의 데이터 요소의 두 개의 복제본을 생성하여 제1 스칼라 입력 포트(942)에 복제본들 중 하나를 그리고 나머지 복제본을 제2 스칼라 입력 포트(944)에 제공한다. 도면으로부터 명백한 바와 같이, 일부 예에서는 그래픽 사용자 인터페이스에서 실행 세트 입구점(936)의 시각적 표현이 데이터 요소의 얼마나 많은 복제본들이 실행 세트 입구점(936)에 의해 생성되는지의 표현을 제공한다. 또한 다른 예에서는, 복제본들의 상이한 복사본들을 나타내는 상이한 입구점 표시자들이 분리되어 실행세트에 제공하는 콜렉션 출력 포트로부터 제공되는 각각의 복제된 데이터 요소의 복사본을 필요로하는 실행 세트 내에 있는 것만큼 많은 구성요소들로 실행 세트의 경계 둘레에서 분산될 수 있다.

제1 구성요소(930)와 제2 구성요소(932)는 각각의 데이터 요소들을 처리하여 스칼라 출력 포트들(946, 948)을 통해 실행 세트 출구점(940)에 각각의 처리된 데이터 요소들을 제공한다. 일부 예에서는, 실행 세트 출구점(940)은 처리된 데이터 요소들을 쌍들로 그룹화하여 제2 데이터세트(926)의 콜렉션 입력 포트(938)로 처리된 데이터 요소들의 쌍들을 출력한다. 도면으로부터 명백한 바와 같이, 일부 예에서는 그래픽 사용자 인터페이스에서 실행 세트 출구점(940)의 시각적 표현이 데이터 요소의 얼마나 많은 복제본들이 실행 세트 입구점(936)에 의해 그룹화되는가의 표현을 제공한다.

2.6 자원 래칭(Resource Latching)

일부 예에서는, 주어진 실행 세트의 구성요소들이 병렬 인스턴스들에서 여러 번 실행될 수 있다. 일부 예에서는, 병렬 인스턴스들을 실행하는 구성요소들은 공유 자원에 액세스할 필요가 있을 수 있다. 공유 자원들을 액세스하는 여러 프로세스들과 관련된 경쟁 조건들 및 다른 문제들을 방지하기 위해, 래칭 메커니즘(latching mechanism)이 사용될 수 있다. 일반적으로, 래칭 메커니즘은 실행 세트의 구성요소들의 하나의 인스턴스가 그 인스턴스가 실행을 종료하는 데 걸리는 시간 동안 공유 자원에 대한 런타임 록(runtime lock)을 획득하는 것을 허용한다. 인스턴스가 공유 자원이 래치되게 하는 동안, 상기 인스턴스의 구성요소들이 공유자원에 대한 액세스를 가지고 다른 인스턴스들의 구성요소들은 상기 래치가 해제되기를 기다려야만 한다. 상기 인스턴스가 완료된 후, 런타임 록을 해제하여 다른 인스턴스들이 공유 자원을 액세스하도록 허용한다. 래칭 메커니즘은 (예를 들어, 업스트림 단에서 명시적 래치 구성요소 및 다운스트림 단에서 명시적 언래치 구성요소를 사용하여) 단일 실행 세트 내의 공유 자원의 래치(latch) 및 언래치(unlatch) 둘 모두를 하여야 한다. 일부 실시 예에서, 이러한 “래치된 실행 세트들”은 네스팅될 수 없거나 서로 중첩될 수 없다.

2.7 기타

전역 매핑 기반 할당 알고리즘이 이차원 데이터 처리 그래프와 관련하여 설명되지만, 또한 일 차원 데이터 처리 그래프들에 대한 실행 세트들을 발견하는 데 사용될 수 있음에 유의한다.

일반적으로, 실행 세트들은 임의로 네스팅될 수 있다.

일반적으로, 실행 세트는 연결된 출력 콜렉션 포트로부터 실행 세트의 각각의 인스턴스에 대해 수신된 최대 하나의 구동 데이터 요소를 가진다. 그러나, 여러 스칼라 입력 포트들이 실행 세트의 경계를 가로질러 명시적으로 또는 암시적으로 복제되는 경우 동일한 데이터 요소를 수신할 수 있다.

일반적으로, 실행 세트의 경계를 가로지르는 링크들을 가지는 모든 출력 스칼라 포트들은, 실행 세트의 여러 인스턴스들 각각으로부터, 연결된 입력 콜렉션 포트에 제공되는 동일한 콜렉션으로 수집되는 모든 데이터 요소들을 가진다. 그러나, 실행 세트가 단지 단일 인스턴스만 가진다면, 실행 세트의 경계를 가로지르는 링크들을 가지는 출력 스칼라 포트들은 입력 스칼라 포트에 연결될 수 있다.

일반적으로, 실행 세트의 순회(traversal)가 데이터 처리 그래프에 어떠한 사이클도 발생시키지 않는다고 가정할 때 동일한 유형의 두 개의 포트 사이의 링크는 실행 세트 경계를 횡단할 수 있다.

일부 예에서는, 각각의 실행 세트에 기본으로 고유한 식별자(예를 들어, ‘1’)가 할당된다. 다른 예에서는, 각각의 실행 세트에 실행 세트 ID 경로(예를 들어, ‘1/3/6’)가 할당될 수 있다. 일부 예에서는, 사용자가 실행 세트 ID문자열을 명시적으로 공급한다. 실행 세트 ID 문자열은 반드시 고유하지는 않다. 실행 세트 ID 문자열이 고유하지 않은 경우에, 실행 세트 ID 문자열은 그 부모, 조부모 등의 실행 세트 ID 문자열과 결합될 수 있어서, 고유한 ID 문자열이 될 수 있다.

일부 예에서는, 전역 매핑 기반 할당 알고리즘은 구성요소들에 가장 깊게 네스팅된 실행 세트에 대응하는 ID 문자열이 할당되게 한다. 일부 예에서, 실행 세트들에 실행 세트 ID 경로들이 할당된 때, 실행 세트 ID 경로들이 반드시 고유하지는 않다. 실행 세트 ID 경로들이 고유하지 않은 상황들을 보완하기 위해, 주어진 실행 세트의 상류의 실행 세트 ID 경로들이 “양립가능(compatible)”해야 하는 것을 요구하는 제약조건이 실행 세트 ID 경로상에 배치된다. 여기서, 두 개의 실행 세트 ID 경로들은 그것들이 같거나 하나가 나머지의 적절한 접두어인 경우 및 경우만 양립가능하다. 예를 들어:

·/1/2/3 과 /1/2/3 은 양립가능하다

·/1/2/3 과 /1/2 은 양립가능하다

·/1/2 와 /1/2/3 은 양립가능하다

·/1/2/3 과 /1 은 양립가능하다

·/1/2/3 과 /1/4 는 양립가능하다

·/1/2/3 과 /1/4/5 는 양립가능하다

상술된 실시 예들은 본질적으로 스칼라 블록들의 인스턴스들의 실행에 어떠한 순서(ordering)/병행성(concurrence) 제약조건들을 부과하지 않는다. 그러나, 일부 실시 예에서는, 실행 세트를 제공하는 콜렉션으로부터 수신된 데이터 요소들의 서브세트들의 필수 직렬화(serialization) 및 허용가능한 병행성(concurrency)을 제어하기 위해 다른 입력들이 제공된다. 일부 실시 예에서는, 부분 순서에 따른 순차적 처리가 데이터 요소들의 일부 서브세트들에 부과될 수 있다.

기본으로 실행 세트의 인스턴스들이 완전히 병렬로 실행될 수 있다. 그러나 일부 경우에, 사용자는 다른 동작을 원할 수 있다. 예를 들어, 처리되는 데이터가 계정 레벨 데이터인 경우, 사용자는 각각의 계정 내의 데이터를 처리하는 데 특정 제한 사항을 시행하고자 할 수 있다. 예를 들어, 사용자는 직렬 실행을 시행하고자 할 수 있다. 이러한 경우에, 어느 정도의 병렬처리가 계정들에 걸쳐 허용될 수 있지만, 동일한 계정들에 대한 두 개의 데이터 요소들은 동시에(즉, 함께) 처리되어서는 안 된다. 선택적으로, 동일한 계정의 두 개의 데이터 요소들이 예를 들어, 키(key)에 의해, 또는 수신된 순서에 의해 정의된 순서에 따라 순서에 맞지 않게 처리되어서는 안되게 하기 위해 추가적인 제한이 순서대로 처리하는 것(in-order processing)일 수 있다.

이를 달성하기 위해, 직렬화 키(serialization key)가 실행 세트에 제공될 수 있다. 직렬화 키의 동일한 값을 가지는 모든 데이터 요소들이 순차적으로, 그리고 일부 경우에는 잘 정의된 순서로 처리되어야 한다. 런타임 시스템이 동일한 직렬화 키를 가지는 데이터 요소들에 대해 직렬 실행을 시행하는 한가지 방법은 특정 컴퓨팅 노드(152)에서 실행되도록 구동 데이터 요소가 특정 직렬화 키(또는 직렬화 키의 해시 값)를 가지는 인스턴스들을 할당하여 직렬화 키에 의해 실행 세트 인스턴스들을 분할하는 것이다. 실행시, 시스템은 실행가능한 태스크들의 큐들이 가득 차 있도록 데이터 요소들의 콜렉션을 스캐닝하여 컴퓨팅 노드들(152)에 걸쳐 작업이 균등하게 분산되도록 할 수 있다. (콜렉션에서와 같이) 명시적으로 정의된 순서가 반드시 필요한 것이 아닌 경우, 순서는 출력 포트 (심지어 콜렉션 출력 포트) 로부터 생성되었던 것과 동일한 순서 또는 직렬화 키 그룹 내에서 처리 순서를 제어하는 상이한 조합 키(collation key)와 관련된 순서일 수 있다. 일부 경우에, 실행 세트는 미리 정의된 값을 직렬화 키로 제공하여 완전히 순차적으로 실행하도록 강제될 수 있다.

일부 실시 예에서, 처리가 엄격하게 그 순서에 따라 수행되지 않는 경우에도, 순서가 보존된 외관이 유지될 수 있다. 실행 세트의 입력과 출력 모두에서 데이터가 특정 순서(예를 들어, 벡터 내의 요소들의 순서)와 관련된다면, 사용자는 그 순서를 보존하길 원할 수 있다. 데이터 요소들의 처리에서 직렬화없이도, 출력 데이터 요소들은 예를 들어, 그것들이 처리될 때 데이터 요소들과 함께 전달된 순서 키를 사용하여, 입력 데이터 요소들의 대응하는 세트와 관련된 순서를 복원하도록 정렬될 수 있다. 대안적으로, 병렬로 생성되었던 출력 데이터 요소들이 반드시 명시적 정렬 동작이 수행될 것을 요구하지 않고 그것들이 실행 세트에 들어왔던 것과 동일한 순서로 병합될 수 있다.

실행 세트들에 대해 준비된 실행 코드와 관련된 다양한 계산 특성들이 사용자로부터의 입력과 함께 또는 입력 없이 컴파일러/인터프리터(120)에 의해 구성될 수 있다. 예를 들어, 특정 실행 세트 내의 구성요소들에 대응하는 태스크들이 어떻게 수행되는지를 나타내기 위해 상술된 임베딩된 정보는 다음 중 임의의 것을 포함할 수 있다. 상기 정보는 태스크들이 완전히 순차적으로(즉, 병렬처리가 수행되지 않음) 수행될 것을 나타내는 컴파일러 주석을 포함할 수 있다. 상기 정보는 태스크들이 시퀀싱 제약조건들에 의해 허용되는만큼의 병렬처리로 수행될 것을 나타내는 컴파일러 주석을 포함할 수 있다. 상기 정보는 동일한 키 값에 관련된 태스크들이 순차적으로 수행되고 상이한 키 값들에 관련된 태스크들이 병렬로 수행될 것을 나타내는 컴파일러 주석으로 포함할 수 있다(즉, 상술한 바와 같이 키에 의한 직렬화).

컴파일러 주석들 또는 수정자들은 다양한 계산 특성들 중 임의의 것을 나타내도록 사용될 수 있다:

·동시성 (예를 들어, 상술된 바와 같이 병렬, 직렬, 키에 의한 직렬)

·서로 다른 실행 세트들 간의 우선 순위(예를 들어, 하나의 실행 세트의 모든 태스크들이 또 다른 실행 세트의 모든 태스크들 후에 발생함)

·트랜잭션성(transactionality)(예를 들어, 실행 세트의 태스크들이 데이터베이스 트랜잭션으로 처리됨)

·자원 래칭(예를 들어, 실행 세트의 태스크들이 공유 변수와 같은 로킹된(locked) 특정 자원으로 수행되며 태스크들은 원자 단위로 자원에 액세스할 수 있음)

·순서화(예를 들어, 데이터 요소들 간의 순서가 보존됨)

·튜플 크기(예를 들어, 실행 세트의 각각의 인스턴스에 의해 연산될 데이터 요소들의 수)

컴파일러/인터프리터(120)는 실행세트의 또는 전체로서 데이터 처리 그래프의 속성들을 자동적으로 분석하는 것에 기반하여, 및/또는 사용자로부터 입력을 수신하는 것(예를 들어, 그래프 내의 사용자 주석들)에 기반하여 특성들을 결정할 수 있다. 예를 들어, 키 값들이 실행 세트에서 참조되면 컴파일러 주석은 키에 의한 직렬화를 나타낼 수 있다. 자원이 실행 세트 내에서 사용된다면, 컴파일러 수정자들은 실행 세트 전/후에 해당 자원을 로킹/언로킹(locking/unlocking)을 할 수 있다. 실행 세트 내에서 데이터베이스 연산들이 있다면, 실행 세트의 각각의 인스턴스가 데이터베이스 트랜잭션으로 실행되도록 구성될 수 있다. 가용한 코어들의 수가 컴파일시 결정될 수 있다면, 컴파일러 주석은 각 코어가 코어들의 수로 나눈 콜렉션의 총 크기와 동일한 여러 데이터 항목들로 구성된 데이터 항목들의 튜플에 실행 세트의 인스턴스를 실행할 것을 나타낼 수 있다.

컴파일러 주석들과 수정자들이 적합한 고레벨 언어(예를 들어, DML) 또는 저레벨 실행가능한 코드 등의 대상 언어(target language) 또는 데이터 처리 그래프의 대상 중간 형태(target intermediate form )로 준비된 코드에 추가될 수 있다. 예를 들어, 컴파일러/인터프리터(120)는 실행 세트에 대해 입구점 또는 출구점을 명시적으로 표시하는 데이터 처리 그래프로 구성요소들을 삽입할 수 있거나, 트랜잭션들을 시작/종료하는 구성요소들이 트랜잭션을 처리하기 위한 구성요소들의 세트의 입구/출구 점들에 배치될 수 있거나, 구성요소들이 자원을 로킹/언로킹하는 데 사용될 수 있다.

대안적으로, 컴파일러/인터프리터(120)는 데이터 흐름 링크의 수정된 유형으로서 수정자를 추가할 수 있다.

3. 데이터 처리 그래프에 대한 사용자 인터페이스

일부 예에서, 사용자 인터페이스는 사용자가 구성요소들을 캔버스위로 드래그하고 링크들을 사용하여 구성요소들의 포트들을 함께 연결하여 데이터 처리 그래프를 개발할 수 있게 한다. 일부 예에서, 사용자 인터페이스는 사용자가 데이터 처리 그래프를 개발할 때 상술된 할당 알고리즘(들)을 데이터 처리 그래프에 반복적으로 적용한다. 예를 들어, 사용자가 개발되는 데이터 처리 그래프에 구성요소를 추가할 때, 할당 알고리즘(들)이 추가된 구성요소들을 가지는 그래프에 적용될 수 있다. 그런 다음 할당 알고리즘(들)에 의해 발견된 결과 실행 세트들이 예를 들어, 사용자 인터페이스에서 구성요소들 둘레에 그려진 박스들, 또는 구성요소들을 감싸는 임의의 형상의 영역으로 디스플레이될 수 있고, 그것은 동일한 실행 세트의 구성요소들을 포함하는 영역을 렌더링하는데 사용된 고유한 색, 음영, 텍스처(texture) 또는 라벨(label)에 의해 구별될 수 있다. 그런 다음 일부 예에서, 사용자는 실행 세트들로 또는 실행세트들로부터 구성요소들을 추가하거나 제거하여 할당 알고리즘(들)에 의해 발견된 실행 세트들을 수정할 수 있다. 일부 예에서, 할당 알고리즘(들)은 수정된 실행 세트들이 합법적인지 검증한다. 예를 들어, 다양한 합법적인 방법들 중 임의의 것으로 실행 세트들로 잠재적으로 나뉠 수 있는 다양한 포트들 사이의 링크들 및 구성요소들의 일부 구성들이 있을 수 있다. 이러한 모호한 경우에, 할당 알고리즘이 기본으로 실행 세트들의 하나의 할당을 선택할 수 있지만, 사용자는 실행 세트들의 상이한 할당을 의도했을 수 있으며, 그 경우에 (예를 들어, 구성요소들의 체인에서 더 일찍 실행 세트를 닫기 위해 출구점을 삽입하여) 사용자는 할당을 수정할 수 있다. 대안적으로, 할당 알고리즘이 여러 법적인 할당들이 가능한 모호한 구성들을 인식하도록, 그리고 사용자에게 하나를 선택하도록 입력을 요구하게 구성될 수 있다.

도 10a를 참조하면, 사용자는 세 개의 구성요소들, 제1 데이터세트(1022), 제1 계산 구성요소(1024), 제2 데이터세트(1026)를 데이터 처리 그래프 개발 사용자 인터페이스의 캔버스 위로 드래그하였다. 사용자는 링크들을 사용하여 함께 구성요소들(1022, 1024, 1026)의 포트들을 아직 연결하지 않았고, 할당 알고리즘(들)은 데이터 처리 그래프에서 (루트 실행 세트 외의) 임의의 실행 세트들을 아직 발견하지 못했다.

도 10b를 참조하면, 사용자가 링크들로 구성요소들(1022, 1024, 1026)의 포트들을 함께 연결할 때, 할당 알고리즘(들)이 자동적으로 제1 실행 세트(1030)를 발견하며, 제1 실행 세트(1030)는 제1 계산 구성요소(1024)를 포함한다. 제1 실행 세트(1030)는 사용자 인터페이스를 통해 사용자에게 디스플레이된다. 사용자가 그래프에 구성요소들과 링크들을 계속해서 추가할 때, 할당 알고리즘(들)이 자동적으로 사용자 인터페이스를 통해 실행 세트들을 발견하고 디스플레이한다.

도 10c를 참조하면, 일부 예에서, 사용자는 링크들을 (예를 들어, 링크에 또 다른 구성요소를 삽입하기 위해) 끊을 필요가 있을 수 있다. 이러한 예에서, 할당 알고리즘(들)이 데이터 처리 그래프를 재분석하도록 허용되었다면, 제1 실행 세트(1030)가 제거될 것이고, 아마도 사용자에 대한 작업의 중단 및 손실을 야기할 수 있다.

이러한 중단을 피하기 위해, 사용자가 데이터 처리 그래프로부터 흐름들 또는 구성요소들을 제거할 때, 할당 알고리즘(들)이 실행될 수 없지만 대신에 나머지 구성요소들과 그것들의 실행 세트 연관성들이 훼손되지 않은 채 남겨진다. 예를 들어, 도 10c에서, 그 입력 포트와 출력포트가 단절된 경우, 제1 구성요소(1024)가 여전히 제1 실행 세트(1030)에 포함된다. 일부 예에서, 단절된 구성요소들이 재연결될 때, 할당 알고리즘(들)이 자동적으로 재연결된 구성요소들과 관련된 임의의 실행 세트들을 발견하고 디스플레이하도록 허용된다.

일부 예에서, 데이터 처리 그래프의 구성요소가 명시적인(예를 들어, 사용자 정의) 실행 세트 지정을 가지지 않는다면, 할당 알고리즘(들)이 구성요소가 속하는 실행 세트를 발견하도록 허용된다. 그렇지 않으면, 구성요소가 명시적인, 사용자 정의 실행 세트 지정을 가진다면, 할당 알고리즘(들)이 구성요소들이 포함되는 실행 세트를 선택하도록 허용되지 않는다. 예를 들어, 사용자가 수동적으로 주어진 실행 세트로 구성요소를 이동한다면, 할당 알고리즘(들)이 사용자 지정 실행 세트 외의 임의의 실행 세트에 구성요소를 포함하도록 허용되지 않는다. 즉, 데이터 처리 그래프에 대한 임의의 사용자 수정들이 할당 알고리즘(들)에 의해 무시될 수 없다.

일부 예에서, 사용자 인터페이스는 사용자가 구성요소를 주어진 실행 세트로 승격시키고/시키거나 구성요소를 주어진 실행 세트로부터 강등시키도록 제스처(gesture) 또는 입력 디바이스와의 다른 상호작용을 사용할 수 있게 한다. 일부 예에서, 사용자는 메뉴 옵션 또는 다른 어포던스(affordance)를 사용하여 구성요소들을 승격 또는 강등시킬 수 있다. 다른 예에서, 사용자는 단순히 구성요소를 사용자 인터페이스의 원하는 실행 세트로 드래그할 수 있다.

일부 예에서, 사용자 인터페이스는 사용자들이 데이터 처리 그래프의 실행 세트들에 대해 하나 이상의 제약조건들을 지정할 수 있게 한다. 예를 들어, 사용자는 주어진 시간에 병렬로 N번 이상 실행되지 않도록 실행을 제한할 수 있다.

일부 예에서, 컴파일러/인터프리터(120)는 수동적으로 정의된 실행 세트들과 할당 알고리즘에 의해 발견된 실행 세트들의 혼합을 포함하는 데이터 처리 그래프의 표현을 수신한다.

일부 예에서, 사용자는 인터페이스를 사용하여 가능/억제(enable/suppress) 실행 세트로 언급되는 또 다른 유형의 실행 세트를 정의할 수 있다. 예를 들어, 사용자는 가능/억제 실행 세트에 포함되길 원하는 하나 이상의 구성요소들 둘레에 박스를 그릴 수 있다. 가능/억제 실행 세트는 하나 이상의 구성요소들을 포함하고 스칼라 입력 포트를 가진다. 업스트림 구성요소의 스칼라 출력 포트가 하나의 데이터 요소를 가능/억제 실행 세트의 스칼라 입력 포트에 제공한다면, 가능/억제 실행 세트의 구성요소들이 실행되는 것이 허용된다. 업스트림 구성요소의 스칼라 출력 포트가 가능/억제 실행 세트의 스칼라 입력 포트에 0 데이터 요소들을 제공한다면, 가능/억제 실행 세트에 포함된 구성요소들이 억제된다. (가능/억제 실행 세트들 포함하는) 임의의 실행 세트는 전체 실행 세트가 실행될지 여부를 결정하고, 다른 구성요소들 또는 실행 세트들에 제어 신호들을 전파하는 데 사용될 수 있는 제어 입력 및 출력 포트들을 포함할 수 있다. 실행 세트가 병렬처리된다면(즉, 여러 인스턴스들을 가진다면), 입력 제어 포트가 임의의 인스턴스가 실행되기 전에 활성화되어야하고, 출력 제어 포트가 모든 인스턴스들이 실행을 완료한 후에 활성화되어야한다. 일부 예에서, 이러한 입력 및 출력 제어 포트들이 실행 세트의 경계 상에 포트들의 시각적 표현을 배치하여 제공된다. 다른 예에서, 이러한 입력 및 출력 제어 포트들이 실행 세트의 앞의 추가 구성요소 상에 그것들을 배치하여 제공된다. 예를 들어, 이러한 추가 “포올(forall) 구성요소”가 업스트림 콜렉션 출력 데이터 포트와 입구점 표시자 사이에, 또는 입구점 표시자 위치에 (즉, 업스트림 콜렉션 출력 데이터 포트와 구동 입력 스칼라 데이터 포트 사이에) (예를 들어, 사용자 인터페이스에 의해 자동적으로, 또는 사용자에 의해 수동적으로) 삽입될 수 있다.

도 7과 관련하여 위에서 언급된 바와 같이, 일부 예에서, 사용자는 데이터 처리 그래프의 흐름들을 따라 실행 세트 입구점과 출구점 구성요소들을 배치하여 실행 세트 입구점들과 출구점들을 명시적으로 정의할 수 있다.

일부 예에서, 사용자 인터페이스는 그래프가 불법적인 동작(operation)을 포함할 때 사용자에게 알리기 위해 실시간 피드백을 제공한다. 예를 들어, 사용자 지정 실행 세트인 구성요소에 의해 야기되는 충돌이 있다면, 할당 알고리즘(들)이 사용자 인터페이스를 통해 사용자에게 경고를 발행할 수 있다. 실시간 피드백을 제공하기 위해, 할당 알고리즘(들)이 데이터 처리 그래프에 검증 규칙들(validation rules)을 적용하여 데이터 처리 그래프가 합법적인지를 사용자에게 알린다. 도 11a를 참조하면, 불법적 데이터 처리 그래프 구성(1195)의 일 예는 두 개의 데이터 소스들, 제1 실행 세트(1197)의 제1 구성요소(1102)의 스칼라 포트에 데이터 요소들의 제1 콜렉션을 제공하는 제1 데이터 소스(1191) 및 제2 실행 세트(1199)의 제2 구성요소(1104)의 스칼라 포트에 데이터 요소들의 제2 콜렉션을 제공하는 제2 데이터 소스(1198)를 포함한다. 그런 다음 제2 실행 세트(1199)는 제1 실행 세트(1197)의 제3 구성요소(1106)의 스칼라 데이터 포트에 입력되는 데이터 요소들의 제3 콜렉션을 출력한다. 데이터 요소들의 두 개의 상이한 콜렉션들이 제1 실행 세트(1197)의 상이한 스칼라 포트들에 연결되기 때문에, (구성요소들의 하나의 인스턴스가 제1 실행 세트(1197)의 경계에 존재하는 각각의 데이터 요소에 대해 생성되기 때문에) 제1 실행 세트(1197)의 구성요소들의 얼마나 많은 병렬 인스턴스들이 인스턴스화되어야 하는지 알 수 있는 방법이 없다. 일부 예에서, 사용자는 예를 들어, 제2 구성요소(1104) 상에 에러 표시자(1108)를 디스플레이하여 이러한 충돌을 통지받는다.

도 11b를 참조하면, 불법적인 데이터 처리 구성(1110)의 또 다른 예는 제1 실행 세트(1116)의 제1 구성요소(1114)의 스칼라 입력 포트에 데이터 요소들의 콜렉션을 제공하는 데이터 소스(1112)를 포함한다. 제1 구성요소(1114)의 스칼라 출력은 데이터의 콜렉션으로서 그 출력을 제1 실행 세트(1116) 외부의 제2 구성요소(1118)의 콜렉션 포트에 제공한다. 제2 구성요소(1118)는 콜렉션 유형 출력 포트로부터의 데이터 요소들의 콜렉션을 제1 실행 세트(1116)의 제3 구성요소(1120)의 스칼라 데이터 포트에 제공한다.

제1 실행 세트(1116) 외부로 제1 구성요소(1114)의 콜렉션 유형 출력 포트로부터의 데이터 요소들의 콜렉션을 전달하고, 제2 구성요소(1118)에서 데이터 요소들의 콜렉션을 처리한 다음, 제3 구성요소(1120)의 스칼라 포트로 다시 처리된 데이터 요소들의 컬렉션을 전달하여, “실행 세트 루프(execution set loop)”가 정의된다.

일반적으로, 실행 세트 루프들은 그것들이 실행 순서화에 해가 되므로 불법이다. 예를 들어, 일반적으로 입력들에 대해 입력 데이터가 실행 세트를 실행하기 전에 버퍼링될 수 있고 출력들에 대해 출력 데이터가 실행 세트가 실행을 완료한 후에 수집될 수 있기 때문에 실행 세트로 들어가거나 실행 세트로부터 나오는 추가적인 흐름들을 가지는 것이 허용된다. 그러나 이것은 외부 구성요소가 실행 세트 전과 후 모두에서 실행되도록 요구된다면 불가능하다.

일부 예에서, 사용자는 구성요소들 중 하나 이상에서 에러 표시자(1108)를 디스플레이하여 실행 세트 루프들을 통지받는다.

일부 예에서, 각각의 실행 세트 입구점이 적어도 하나의 대응하는 실행 세트 출구점에 의해 매칭되지 않는다면 데이터 처리 그래프는 불법인 것으로 간주된다. 대안적으로, 입구점을 가지나 대응하는 출구점을 가지지 않는 실행 세트는 할당 알고리즘에 의해 자동적으로 인식되지 않는 경우라도 사용자 정의 실행 세트로 허용될 수 있다. 이러한 경우들에서, 실행 세트는 가장 다운스트림 구성요소(들)이 실행을 종료한 후에 (임의의 출력 데이터 요소들을 제공하지 않고) 종료될 수 있다. 일부 예에서, 각각의 래치 동작이 대응하는 언래치 동작에 의해 매칭되지 않는다면 데이터 처리 그래프가 불법인 것으로 간주된다. 대안적으로, 어떤 것도 명시적으로 지정되지 않은 경우 언래치 동작이 유추될 수 있고, 단지 유추된 언래치 동작이 래치 동작으로부터 상이한 실행 세트에 있을 필요가 있다면 불법으로 표시된다. 일부 예에서, 래치 동작과 그 대응하는 언래치 동작이 동일한 실행 세트에 둘 모두 존재하지 않는다면 데이터 처리 그래프는 불법인 것으로 간주된다.

4. 제어 그래프에 대한 상태 머신

데이터 처리 그래프를 실행을 위해 준비하는 과정에서, 컴파일러/인터프리터(120)는 또한 제어 그래프 생성 절차에서 제어 그래프를 생성한다. 일부 구현에서, 제어 그래프를 생성하는 것은 개별적인 구성요소들에 대응하는 태스크들을 수행하기 위한 실행가능한 코드 및 그 태스크들 사이의 데이터 및 제어의 흐름을 결정하는 구성요소들 사이의 다양한 링크들에 대응하는 코드를 생성하는 것을 포함한다. 이는 컴파일러/인터프리터(120)에 의해 발견된 실행 세트들의 계층 구조 간의 데이터 및 제어의 전달을 포함한다.

이러한 실행 가능한 코드를 생성하는 부분은 일부 데이터 구조 표현에서, 임의의 가능/억제 실행 세트들을 포함하여, 각각의 실행 세트에 대해 대응하는 제어 그래프 생성하는 것을 포함한다. 실행 세트 내의 임의의 네스팅된 실행 세트들은 제어 그래프를 생성하기 위해 네스팅된 실행 세트를 나타내는 단일 구성요소로서 처리된다. 이러한 대표 구성요소들의 포트들은 네스팅된 실행 세트의 경계를 가로지르는 링크들에 연결된 네스팅된 실행 세트 내의 구성요소들의 포트들에 대응한다. 그런 다음 컴파일러/인터프리터(120)는 제어 코드를 성성하기 위해 이러한 제어 그래프를 사용할 것이다. 이러한 생성된 제어 코드는 효율적으로 실행시 실행을 제어하는 상태 머신을 구현한다. 특히, 실행이 시작되면, 이 생성된 제어 코드는 이러한 상태 머신의 한 상태로부터 또 다른 상태로 구성요소 또는 포트가 천이할 때를 제어한다.

도 12a는 컴파일러/인터프리터(120)가 루트 실행 세트의 제1 및 제2 구성요소 쌍들(1202, 1204)을 제어 그래프(1206)로 어떻게 결합하는지의 일 예를 보여준다. 이 예에서, 제1 구성요소 쌍(1202)은 각각의 콜렉션 데이터 포트들(1212, 1214)에 의해 연결된 제1 및 제2 구성요소들(1208, 1210)을 포함한다. 제2 구성요소 쌍(1204)은 각각의 스칼라 데이터 포트들(1220, 1222)에 의해 연결된 제3 및 제4 구성요소들(1216, 1218)을 포함한다.

컴파일러/인터프리터(120)는 시작 구성요소(1224)와 종료 구성요소(1226)를 추가하고 데이터 처리 그래프의 토폴로지에 의해 지시된 바와 같이 구성요소들을 시작 및 종료 구성요소들(1224, 1226)에 연결하여 제어 그래프를 생성한다. 시작 및 종료 구성요소들은 임의의 계산 태스크들을 수행하지 않지만, 특정 구성요소들의 실행을 시작하고 실행 세트의 모든 구성요소들이 실행을 종료했을 때를 결정하기 위해 사용될 제어 신호들을 관리하기 위해 컴파일러/인터프리터(120)에 의해 사용된다.

특정 구성요소가 시작 구성요소(1224)에 연결될 필요가 있는지를 결정하기 위해, 컴파일러/인터프리터(120)는 상술한 바와 같이 제어 포트들과 스칼라 포트들 모두를 포함하는 업스트림 시리얼 포트에 대한 기존 링크에 기반하여 실행을 시작하도록 지정되지 않는지를 결정하기 위해 해당 구성요소에 대한 입력들을 검사한다.

예를 들어, 구성요소가 그 제어 입력 포트에 대한 어떠한 링크도 가지지 않는다면, 시작하도록 알리는 제어 신호가 결코 없을 것이기 때문에 결코 실행을 시작하지 않을 가능성이 있다. 반면에, 제어 입력 포트가 없더라도, 구성요소가 가지는 데이터 입력의 유형에 따라 그 구성요소의 실행을 트리거하는 데이터가 도착할 수 있다. 예를 들어, 구성요소가 스칼라 입력 포트를 가진다면, 그것의 제어 입력 포트에서의 제어 신호가 없는 경우에도 그 구성요소는 그것의 스칼라 입력 포트에서 데이터를 보는 즉시 실행을 시작할 것이다. 반면에, 구성요소가 콜렉션 데이터 입력만을 가진다면, 이것은 발생하지 않을 것이다. 이러한 구성요소가 실행을 유발할 제어 입력 또는 스칼라 데이터 입력을 가지지 않는다면, 시작 구성요소(1224)로의 연결이 필요할 것이다.

도 12a의 맥락에서, 제1 구성요소(1208)는 제어 입력이나 스칼라 데이터 입력을 갖지 않는다. 따라서, 제1 구성요소(1208)가 단독으로 실행을 시작할 방법이 없을 것이다. 그러므로, 제1 구성요소(1208)는 시작 구성요소(1224)에 연결되어야 한다. 마찬가지로 제3 구성요소(1216)는 제어 입력이나 스칼라 데이터 입력을 갖지 않는다. 그러므로, 제3 구성요소(1216) 또한 시작 구성요소(1224)에 연결되어야 한다.

제4 구성요소(1218)는 제어 입력을 갖지 않는다. 그러나 그것은 제3 구성요소(1216)로부터 스칼라 데이터 입력을 수신하도록 연결된다. 그러므로, 그것은 입력 스칼라 포트(1222)를 통해 데이터를 수신시 실행을 시작할 것이다. 따라서, 제4 구성요소(1218)는 시작 구성요소(1224)로의 연결을 필요로하지 않는다.

제2 구성요소(1210)는 제1 구성요소(1208)로부터 데이터를 수신하도록 구성된다. 그러나 이 데이터는 입력 콜렉션 포트(1214)에서 수신되고, 입력 스칼라 포트에서 수신되지 않는다. 그 결과, 제2 구성요소는 제1구성요소와 마찬가지로 또한 시작 구성요소(1224)에 연결되어야 한다.

컴파일러/인터프리터(120)는 또한 구성요소들 중 어떤 것이 종료 구성요소(1226)에 연결될 필요가 있을지를 식별할 필요가 있다.

일반적으로, 구성요소는 제어 출력 링크 또는 (임의의 유형의) 데이터 출력 링크가 없을 때 종료 구성요소(1226)에 연결된다. 도 12a의 좌측 다이어그램에서, 이러한 조건은 제2 구성요소(1210)와 제4 구성요소(1218)에 의해서만 만족된다. 따라서, 도 12a의 우측에 도시된 바와 같이, 이러한 두 개의 구성요소들만이 종료 구성요소(1226)에 연결된다.

도 12b는 제어 링크가 도면의 좌측의 제1 구성요소(1208)와 제3 구성요소(1216) 사이에 존재한다는 점을 제외하고는 도 12a와 유사하다. 규칙들과 일관되게, 결과적인 대안 제어 그래프(1206’)의 시작 구성요소(1224)에 제3 구성요소(1216)를 더 이상 연결할 필요가 없다.

제어 그래프는 업스트림 구성요소들과 시리얼 포트들에 대해 발생하는 천이들에 응하여 구성요소들과 그것들의 시리얼 포트들이 한 상태로부터 또 다른 상태로 천이하는 분산 상태 머신(distributed state machine)을 효과적으로 정의한다. 일반적으로, 업스트림 구성요소는 한 상태로부터 또 다른 상태로 천이할 것이어서, 출력 시리얼 포트들이 천이하게 하고, 다운스트림 구성요소들의 연결된 시리얼 입력 포트들이 천이하게 하고, 그 다운스트림 구성요소들이 천이하게 하는 등을 한다. 이러한 동작을 달성하기 위한 특정 유형의 상태 머신의 일 예가 구성요소들과 그 시리얼 포트들에 대한 상태 천이 다이어그램들을 참조하여 이하에서 더 상세히 설명된다.

상태 머신의 천이들에 대한 제어를 제공하기 위해, 컴파일러/인터프리터(120)는 특성 구성요소에 의해 표현된 태스크를 수행하기 위한 코드에 추가 제어 코드를 접목한다. 본 명세서에서 사용된 바와 같이, “접목(grafting)”은 앞에 추가(pre-pending), 뒤에 추가(appending) 또는 앞에 추가 및 뒤에 추가 제어 코드 모두를 의미한다. 앞에 추가된 제어 코드는 본 명세서에서 “프롤로그(prologue)” 코드로 언급되는 반면, 뒤에 추가된 제어 코드는 “에필로그(epilogue)” 코드로 언급된다. 구성요소에 대한 프롤로그 코드는 구성요소가 태스크를 실행하기 전에 실행된다. 구성요소에 대한 에필로그 코드는 구성요소(610a)가 태스크의 실행을 완료한 후에 실행된다.

접목된 제어 코드는 하나 이상의 다운스트림 구성요소들이 그 각각의 태스크들을 실행하게 할지 여부를 결정하기 위해, 누산기(accumulator)(예를 들어, 입력이 구성요소를 호출할 준비가 되었음을 나타내는 값으로 카운트 다운하는 카운터)의 값 또는 플래그(flag)(예를 들어, 구성요소가 억제되었음을 나타내는 값으로 설정된 플래그)의 상태와 같은 저장된 상태 정보를 검사한다.

일 실시 예에서, 프롤로그 코드는 업스트림 출력 시리얼 포트들의 상태를 모니터하고 구성요소의 입력 시리얼 포트들의 상태를 업데이트하는 반면, 에필로그 코드는 구성요소가 태스크 수행을 완료한 후에 구성요소의 출력 시리얼 포트들을 업데이트한다.

또 다른 실시 예에서, 업스트림 출력 시리얼 포트들을 모니터링하는 다운스트림 구성요소의 프롤로그 코드 대신에, 업스트림 구성요소의 에필로그 코드는 다운스트림 입력 시리얼 포트들의 집단 상태(collective state)를 업데이트하고 입력 시리얼 포트들의 수로 초기화된 카운터가 0에 도달한 때와 같은 적절한 때에 다운스트림 구성요소의 프롤로그 코드의 실행을 유발하기 위해 그 집단 상태를 모니터링한다. 대안적으로, 입력 포트들의 수로부터 카운트다운(또는 입력 포트들의 수로 카운트업)하는 카운터 대신에, 또 다른 형태의 누산기가 상이한 구성요소들의 상이한 포트들의 상태들을 나타내는 비트들을 저장하는 비트맵 같은, 구성요소를 트리거링(triggering)하기 위한 상태 정보를 저장하는 데 사용될 수 있다.

이러한 접목된 제어 코드의 결과로서, 특정 구성요소의 실행이 시작되고 종료될 때, 태스크들의 완료가 제어 그래프에 의해 표현된 데이터 제어 종속성들과 일관된 방식으로 그리고 여러 구성요소들의 동시 동작 및 하나 이상의 업스트림 로직 상태들의 콜렉션의 발생에 기반하여 제어하기 위해 조건부 제어 로직의 사용을 허용하는 방식으로 다른 태스크들의 자동 실행으로 자동적으로 이어진다.

도 13a와 13b는 구성요소들(도 13a의 상태 천이 다이어그램(1300)) 및 그것들의 시리얼 포트들(도 13b의 상태 천이 다이어그램(1310))에 대해 사용될 수 있는 예시 상태 머신에 대한 상태 천이 다이어그램들을 도시한다. 상기 상태 천이 다이어그램들은 활성 상태(active state)(1304)가 진행 중인 실행과 관련되기 때문에 그리고 포트들이 아닌 구성요소들만이 실행을 수행하기 때문에 구성요소만이 활성 상태(1304)일 수 있다는 점을 제외하고는 유사하다.

필요에 따라 도 13a 및 13b를 참조하면 상태 천이 다이어그램 둘 모두의 모든 가능한 상태들뿐만 아니라 상태들 사이의 각각의 천이를 따르는데 필요한 조건들이 설명될 것이다. 제어 그래프의 구성요소들이 시리얼 포트들(콜렉션 포트들이 아님)을 연결만 하면 되기 때문에 상태 천이 다이어그램들의 이 설명에서 언급되는 모든 입력 및 출력 포트들은 시리얼 포트들이다. 제어 그래프의 특정 구성요소는 상태 천이 다이어그램(1300)의 네 개의 로직 상태들(logic states) 중 하나일 수 있다. 제1 상태는 보류 상태(1302)이다. 이는 제어 그래프와 관련된 실행 세트가 실행을 시작할 때 구성요소가 시작하는 상태이다. 구성요소의 임의의 입력 포트가 보류 상태(pending state)(1312)에 있다면 구성요소는 보류 상태(1302)로 유지된다. 구성요소가 입력 포트들을 갖지 않는다면, 보류 상태(1302)로 시작하나 즉시 보류 상태(1302)로부터 천이할 수 있다.

보류 상태(1302)로부터, 구성요소는 활성 상태(1304) 또는 억제 상태(suppressed state)(1306) 중 하나로 천이할 수 있다.

입력 포트들 중 어떤 것도 보류 상태(1312)에 있지 않고 입력 포트들 모두가 억제 상태(1316)에 있지 않다면(즉, 적어도 하나의 입력 포트가 완료 상태(1314)에 있음) 구성요소는 활성 상태(1304)로 천이한다. 포트들은 기본적으로 “필수(required)”이나 “선택사항(optional)”으로 표시될 수 있다. 선택적 포트는 (경고가 있을 수 있을지라도) 에러를 발생시키지 않고 또 다른 포트로 연결되지 않은 상태로 둘 수 있다. 연결되지 않은 임의의 선택적 포트는 자동으로 완료 상태(complete state)(1314)에 있다. 구성요소는 태스크를 여전히 실행하고 있는 한 활성 상태(1304)로 남는다. 구성요소가 활성상태(1304)에 있는 동안, 출력 포트들이 상이한 때에 또는 함께 보류 상태(1312)로부터 완료 상태(1314) 또는 억제 상태(1316)로 천이할 수 있다. 태스크 실행의 완료시, 구성요소는 활성 상태(1304)로부터 완료 상태(1308)로 천이한다.

구성요소의 태스크가 실행을 종료하면 구성요소는 완료 상태(1308)로 천이하고, 그 출력 포트들 모두가 “분해(resolved)”되어, 즉, 더 이상 보류가 아니게 된다.

커스텀 제어 로직(custom control logic)으로 인해, 억제되는 입력 포트들 모두로 인해, 필수 입력 포트들 중 적어도 하나의 억제로 인해, 또는 구성요소의 처리되지 않은 에러로 인해 구성요소의 프롤로그가 억제 상태(1306)로의 천이를 유발했다면 구성요소는 억제 상태(1306)에 있다. 구성요소들의 출력 포트들 모두가 또한 억제 상태(1316)로 되어 억제를 하류로 전파한다.

포트들에 대해, 상태 천이 규칙들은 포트가 입력 포트 또는 출력포트인지에 따라 다르다.

포트에 대한 초기 상태는 보류 상태(1312)이다. 입력 포트는 일반적으로 연결된 업스트림 출력 포트의 상태를 따른다. 따라서, 업스트림 출력 포트가 천이할 때, 제어 그래프의 그 출력 포트에 연결된 입력 포트는 동일한 상태로 천이한다. 출력 포트는 구성요소가 활성 상태인 동안 출력 포트는 어떤 상태로 될지를 결정할 때까지 보류 상태로 남는다.

상술된 바와 같이, 입력 포트들은 연결된 업스트림 출력 포트들을 따른다. 따라서, 단일 업스트림 출력 포트에 연결된 입력 포트에 대해, 연결된 업스트림 출력 포트가 완료 상태(1314)로 천이할 때 그 입력 포트가 완료 상태(1314)로 천이한다. 입력 포트가 여러 링크들을 통해 여러 업스트림 출력 포트들에 연결되면, 업스트림 출력 포트들 중 적어도 하나가 완료 상태(1314)로 천이된 후에 입력 포트가 완료 상태(1314)로 천이한다. 그렇지 않으면, 모든 업스트림 출력 포트들이 억제 상태(1316)로 천이하면, 입력 포트가 억제 상태(1316)로 천이한다. 일부 실시 예는 입력 포트를 완료 상태(1314) 또는 억제 상태(1316)로 천이할 지를 결정하기 위해 이러한 기본 “OR 로직”과는 다른 로직(예를 들어, 모든 업스트림 출력 포트들이 완료 상태(1314)에 있을 경우에만 입력 포트가 완료 상태(1314)로 천이하는 “AND 로직”)을 사용한다. 구성요소의 입력 데이터 포트가 완료 상태(1314)로 된다면, 데이터 요소는 해당 구성요소가 처리하도록 준비된다. 구성요소의 출력 데이터 포트가 완료 상태(1314)로 된다면, 데이터 요소는 그 구성요소로부터 하류로 전송할 준비가 된다.

입력 포트들이 연결된 업스트림 출력 포트들의 상태를 따르는 규칙과 일관되게, 입력 포트는 연결된 업스트림 출력 포트가 억제 상태(1316)로 될 때 억제 상태(1316)로 된다. 활성 구성요소(active component)가 출력 포트를 억제해야 한다고 결정한 결과는 계산했거나, 업스트림 억세 구성요소로부터 억제를 하류로 전파할 수 있거나, 또는 구성요소에서 처리되지 않은 에러가 있었기 때문에 출력 포트는 억제 상태(1316)로 된다. 일부 실시 예에서, 컴파일러가 구성요소 단위로 억제를 하류로 전파할 필요 없이 억제 구성요소에서 루트를 갖는 다운스트림 구성요소들의 트리를 억제하여 실행을 최적화하는 것이 가능하다.

다른 실시 예에서, 콜렉션 포트들 사이의 링크들이 또한 제어 그래프에 포함될 수 있는 다양한 대안적인 상태 머신들 중 임의의 것이 사용될 수 있다. 일부 이러한 실시 예에서, 콜렉션 포트들에 대한 상태 천이 다이어그램은 구성요소들에 대한 상태 천이 다이어그램(1300)에서와 같이 보류, 종료, 및 억제 상태들 외에 활성 상태를 포함할 수 있다. (출력 포트로서) 데이터를 생성하거나 (입력 포트로서) 데이터를 소비할 때 콜렉션 포트가 활성 상태에 있다. 예를 들어, 입력 콜렉션 포트에 대해, 모든 입력 포트들이 억제되지 않을 것이라고 결정되는 즉시, 첫번째 데이터 요소가 상류로 생성될 때 활성 상태가 트리거될 수 있다. 일부 실시 예에서, 콜렉션 포트들에 대한 억제 상태는 존재하지 않는다. 콜렉션 포트들에 대한 상태 천이들을 포함하는 제어 그래프의 구성요소가 따르는 천이 규칙들은 완료 상태가 입력 스칼라 포트 또는 제어 포트에 대해 처리된 것과 동일한 방식으로 입력 콜렉션 포트에 대한 활성 상태를 처리할 수 있다.

5. 컴퓨팅 플랫폼

도 1을 참조하면, 데이터 처리 그래프의 구성요소들의 인스턴스들이 데이터 처리 그래프를 실행하는 상황에서 태스크로서 스포닝되고(spawned) 일반적으로 컴퓨팅 플랫폼(150)의 여러 컴퓨팅 노드들(152)에서 실행된다. 이하에서 더 상세히 논해지는 바와 같이, 콘트롤러(140)는 예를 들어, 계산 부하의 할당, 통신 또는 입력/출력 오버헤드의 감소, 및 메모리 자원의 사용과 관련된 시스템에 대한 성능 목표를 달성하기 위해 이러한 태스크들의 실행의 스케줄링 및 장소(locus)의 감독 제어 양상을 제공한다.

일반적으로, 컴파일러/인터프리터(120)에 의한 변환 후에, 전체 계산은 컴퓨팅 플랫폼(150)에 의해 실행될 수 있는 대상 언어의 절차들의 관점에서 태스크 기반 명세(130)로 표현된다. 이러한 절차들은 “spawn” 및 “wait” 같은 프리미티브(primitive)를 사용하고, 고레벨 (예를 들어, 그래프 기반) 프로그램 명세(110)의 구성요소들에 대해 프로그래머에 의해 지정된 작업 절차들을 그것들 내에 포함할 수 있거나 호출할 수 있다.

많은 경우에, 구성요소의 각각의 인스턴스는 단일 구성요소의 단일 인스턴스를 구현하는 일부 태스크, 실행 세트의 여러 구성요소들의 단일 인스턴스를 구현하는 일부 태스크, 및 구성요소의 연속적인 인스턴스들을 구현하는 일부 태스크로, 태스크로서 구현된다. 구성요소들 및 그 인스턴스들로부터의 특정 매핑은 컴파일러/인터프리터의 특정 디자인에 따라 달라져서, 결과로 초래된 실행이 계산의 의미론적 정의(semantic definition)와 일관성을 유지한다.

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

런타임 환경에서, 스포닝된 각각의 태스크는 가능한 상태들의 세트 중 하나에 있을 수 있다. 처음 스포닝될 때, 태스크는 처음에 실행되기 전에 스폰 상태(Spawned state)에 있다. 실행 시, 그것은 실행 상태(Executing state)에 있다. 때때로, 태스크는 중단 상태(Suspended state)에 있다. 예를 들어, 특정 구현에서, 스케줄러는 프로세서 사용량을 초과하거나 자원을 기다리는 등의 경우에 태스크를 중단 상태에 처하게 할 수 있다. 일부 구현에서는, 태스크들의 실행이 선점되지(preempted) 않으며, 태스크는 제어를 포기해야 한다. 세 개의 중단 서브 상태들이 있다: 실행가능(Runnable), 차단(Blocked), 및 완료(Done). 태스크는 예를 들어, 계산을 완료하기 전에 제어를 포기했다면 실행가능이다. 태스크는 예를 들어, 부모 태스크 가 그 태스크의 반환 값을 검색하기 전에 처리를 완료했을 때 완료이다. 태스크는 예를 들어, (예를 들어, “wait for” 프리미티브로 사용했기 때문에) 또 다른 태스크의 완료 또는 데이터 레코드의 가용성(예를 들어, in.read( ) 또는 out.write( ) 함수 중 하나의 실행을 차단)과 같이 그 태스크 외부의 이벤트를 기다리는 경우 차단된다.

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

처리 엔진의 일 예가 가상 머신 상황에서 호스팅된다. 가상 머신의 한 유형은 자바 가상 머신(JVM)이며, 자바 바이트코드로서 컴파일된 형태로 지정된 태스크들이 실행될 수 있는 환경을 제공한다. 그러나 가상 머신 아키텍처를 사용할 수 있거나 사용하지 않을 수 있는 다른 형태의 처리 엔진들이 사용될 수 있다.

도 14를 참조하면, 컴퓨팅 노드(152)의 처리 엔진들(154) 각각은 하나 이상의 러너(runner)(1450)를 가진다. 각각의 러너(1450)는 실행가능한 태스크들을 실행하기 위해 하나 이상의 프로세스들을 사용하거나 스레드들(threads)을 처리한다. 일부 구현에서, 러너의 스레드와의 이러한 연관성은 필요하지 않지만, 각각의 러너는 연관된 프로세스 스레드를 가진다. 언제든지, 각 러너는 계산의 최대 하나의 실행 가능한 태스크를 실행 중이다. 각각의 러너는 별도의 실행가능 큐(1466)를 가진다. 계산의 각각의 실행가능한 태스크는 시스템의 러너(1450)의 하나의 실행가능 큐(1466)에 있다. 각각의 러너(1450)는 현재 실행중인 태스크를 모니터하는 스케줄러/인터프리터(1460)를 가지고, 태스크가 상태를 완료(Done), 차단(Blocked) 또는 중단(Suspended)으로 변경할 때 실행가능 큐(1466)으로부터 또 다른 태스크를 선택하여 실행한다. 태스크들은 러너들과 연관되고, 실행가능하지 않은 러너들의 태스크들은 실행가능 큐(1466) 외부에 예를 들어, 차단 및 완료 큐(1468)에 도시된 바와 같이 유지된다.

러너들(1450)은 처리 엔진들(154)이 초기화될 때, 예를 들어, 엔진당 사전구성된 수의 러너들을 생성할 때, 생성될 수 있다. 이하에서 논해지는 바와 같이, 일부 구현에서, 데이터 처리 그래프의 실행중에도, 러너들은 처리 엔진들에 추가되거나 그로부터 제거될 수 있고, 처리 엔진들 자체는 컴퓨팅 플랫폼(150)에 추가되거나 그로부터 제거될 수 있다. 그러나, 이하의 초기 설명에 대해, 각각의 처리 엔진 내의 처리 엔진들의 수와 러너들의 수는 일정하게 유지된다고 가정한다.

일 예로서, 데이터 처리 그래프에 대한 처리가 최상위 태스크의 메인 절차(Main procedure)의 실행으로 시작된다. 예를 들어, 태스크 기반 콘트롤러(140)는 처리 엔진들(1450) 중 하나의 모니터(1452)와 통신하는 컴퓨팅 노드들 중 하나가 메인 절차의 실행을 시작하도록 명령한다. 이 예에서, 모니터(1452)는 메인 절차를 실행하기 위한 태스크를 처리 엔진들 중 하나의 실행가능 큐(1466)에 배치한다. 이 예에서, 러너는 유휴 상태(즉, 그 시점에 실행중인 다른 태스크들, 및 실행가능 큐의 다른 실행가능한 태스크들이 존재하지 않음)이어서, 그 러너의 스케줄러/인터프리터(1460)는 실행가능 큐로부터 태스크를 검색하고 상기 태스크의 실행을 시작한다. 절차가 해석될 필요가 있는 언어로 표현될 때, 스케줄러/인터프리터(1460)는 절차의 연속적인 문장들(statements)을 해석한다.

이 예에서, 메인 절차의 첫번째 문장은 정렬되지 않은 콜렉션들의 흐름을 지원하는 링크들에 대한 링크 버퍼들(1470) - 이 예에서는 정렬되지 않은 무제한 버퍼, 버퍼1, 버퍼2, 및 버퍼 3를 포함함 - 을 생성한다(즉, 메모리를 할당한다). 다양한 방법들이 이러한 유형의 구성요소 간 링크를 생성하고, 업스트림 포트가 컬렉션 포트인 임의의 링크를 포함하는 (링크 버퍼들(1470)을 포함하는) 이러한 링크들에 대한 관련 컴퓨팅 자원들을 관리하기 위해 사용된다. 일부 예에서, 링크 버퍼들(1470)은 콜렉션의 소스를 나타내는 출력 콜렉션 포트들에 대한 버퍼들 및 콜렉션의 데스티네이션을 나타내는 입력 콜렉션 포트들에 대한 별도의 버퍼들을 포함한다. 이러한 버퍼들은 콜렉션에 대한 처리가 시작하기 직전에 런타임시 할당되거나 콜렉션에 대한 처리가 종료된 직후에 할당 해제(즉, 버퍼에 사용된 메모리를 해제)될 수 있다. 이 예에서, 이러한 링크 버퍼들(1470)은 태스크의 러너가 실행중인 처리 엔진(154)의 메모리에 할당된다. 일부 구현에서, 디스크들 같은 다른 저장디바이스들이 버퍼 데이터 중 적어도 일부를 저장하는 데 사용될 수 있지만, 일반적으로, 버퍼들이 생성되는 메모리는 반도체 랜덤 액세스 메모리(RAM)에 있다. 다른 접근 방식에서는 버퍼가 러너 자체에 로컬일 수 있다. 실제로, 처리 엔진(154)이 운영 시스템 프로세스로서 구현된다면, 버퍼들이 그 프로세스의 주소 공간의 메모리 영역으로 생성된다. 따라서, 버퍼들에 대한 직접적인 하드웨어 주소 기반 액세스는 그 프로세스 내에서 실행되는 명령들로 제한된다. 이러한 방법에서, 여러 러너들이 버퍼들을 판독하거나 그에 기록할 수 있다면, 예를 들어, 록(lock) 또는 세마포어(semaphor)를 사용하여 버퍼들에 대한 적어도 일부 동기화 및 액세스 제어가 필요할 수 있다. 각각의 러너가 운영 시스템 프로세스 내에서 단일 스레드로 구현되는 방법에서, 버퍼들은 특정 러너와 관련될 수 있고 모든 액세스가 그 러너로 제한될 수 있어서, 그에 따라 여러 스레드들로부터의 잠재적인 경쟁을 회피할 수 있다. 이하의 논의에서는, 버퍼들이 처리 엔진의 임의의 러너로부터 액세스 가능하고, 적절한 액세스 제어가 이러한 공유 액세스를 허용하기 위해 구현된다고 가정한다.

메인 프로세스의 다음 단계는 메인 프로세스에 의해 호출되는 spawn 또는 forall 프리미티브를 포함한다. 일반적으로, 적어도 기본적으로, 자식 태스크 또는 태스크들의 스포닝(spawning)은 그 태스크들이 처음에 부모와 동일한 러너에서 형성되도록 한다. 예를 들어, spawn Work_Read_External_Data 태스크는 동일한 러너에서 스포닝된다. 태스크가 외부 데이터에 액세스중인 범위에서, 태스크는 그 외부 데이터에 대한 I/O 인터페이스(1464)를 사용할 수 있다. 예를 들어, 해당 인터페이스는 외부 데이터베이스에 대한 개방 연결(open connection), 네트워크 데이터 연결의 종점 등으로 구성될 수 있다. 러너들 사이의 태스크들의 잠재적인 마이그레이션(migration)의 상황에서 이하에서 더 논의되는 바와 같이, 이러한 I/O 인터페이스는 특정 러너에 바인딩될 수 있고 따라서 그 인터페이스를 이용하는 태스크가 그 러너로부터만 인터페이스에 액세스하도록 요구될 수 있다. 이 예에서, 태스크가 합리적으로 측정되고 예를 들어, 버퍼 1이 처리 엔진의 용량을 초과하도록 하여 시스템을 압도하지 않는 방식으로, 버퍼 1을 채우는 것으로 추정한다. 예를 들어, 자원의 정체 또는 고갈을 피하기 위한 제어 측면에 대한 방법들도 이하에서 논해진다.

Work_Read_External_Data 태스크의 실행과 동시에, forall Work_A는 태스크들이 버퍼 1로부터 판독된 레코드들 각각에 대해 스포닝되도록 한다. 특히, “forall” 프리미티브는 프리미티브의 인수에 의해 식별된 태스크의 여러 인스턴스들이 실행되도록 하고, 여기서 인스턴스들의 수는 일반적으로 수신된 데이터 요소들의 수에 의해 결정되고, 그것들이 실행되는 위치와 그것들이 호출되는 순서는 추후 런타임시 결정을 위해 컴파일러에 의해 무제한으로 남을 수 있다. 이상에서 논해진 바와 같이, 기본적으로 이러한 태스크들은 또한 동일한 러너(1450)에서 생성되고, 다시 다른 제어들이 없으면 데이터가 버퍼 1로부터 사용할 수 있을 때 최대한 빨리 스포닝된다. Work_B 및 Work_Write_External_Data에 대한 태스크들이 유사하게 동일한 러너에서 생성된다.

태스크 기반 명세는 런타임 콘트롤러가 모든 데이터가 처리되도록 하게 하기 위해 태스크들의 분산을 어떻게 구현할지를 명시적으로 지정하지 않고 “forall” 프리미티브를 사용한다. 이상에서 논해진 바와 같이, 런타임 콘트롤러에 의해 사용될 수 있는 하나의 방법은 동일한 컴퓨팅 노드에서 별개의 태스크들을 스포닝하는 것이고, 그런 다음 태스크들이 별개의 노드들에서 실행하도록 하여 부하를 조절하기 위해 마이그레이션 기능을 필요로 할 수 있다. 다른 방법들이 “forall” 프리미티브가 태스크들이 직접적으로 여러 노드들에서 실행되도록 하는 데 사용될 수 있다. 인 메모리 데이터베이스(in-memony database)의 테이블의 행들의 인덱스 기반 서브세트를 정의하는 커서(cursor)의 경우에, cursor forall 프리미티브의 구현은 커서가 각각이 상이한 노드들에 저장된 레코드들과 관련된 부분들로 분할되도록 할 수 있고, 태스크들이 상이한 노드들에서 커서의 별개 부분들에 대해 스포닝되어서 처리와 데이터 저장의 집약성(locality)을 유발한다. 그러나 컴파일러(120)의 출력인 태스크 기반 명세(130)에서 사용되는 “forall” 프리미티브를 실행하기 위해 런타임 콘트롤러 및 분산 컴퓨팅 플랫폼의 하나 이상의 실시 예에서 광범위한 방법들이 구현될 수 있다는 것을 이해해야 한다. 일부 예에서, 방법의 선택은 예를 들어, 레코드들의 수, 컴퓨팅 노드들을 통한 데이터의 분산, 노드들에서의 부하 등에 기반한 런타임 결정들에 의존할 수 있다. 임의의 경우에, “forall” 프리미티브를 구현하는 데 사용된 방법은 데이터 처리 그래프의 개발자 또는 컴파일러의 설계자에게 반드시 알려지진 않는다.

상기 시스템의 특징은 태스크들이 생성된 후에 러너들 사이에 전송될 수 있다는 것이다. 매우 일반적으로 이러한 태스크들의 전송의 한가지 방법은 유휴상태 또는 적어도 가볍게 부하가 걸린 러너가 또 다른 러너로부터의 태스크들이 그것으로 전송되도록 하는 “스틸링(stealing)” 또는 “풀(pull)” 메커니즘에 의해 구현된다. 다양한 기준들이 사용될 수 있지만, 러너의 실행가능 큐(1466)의 실행가능한 태스크들의 수가 해당 러너가 태스크들의 임계 수보다 더 적은 수가 그 실행가능 큐에 있는지와 같은 지역 기준(local criterion)에 기반하여 다른 러너들로부터 스틸링하기 위해 태스크들을 탐색해야만 하는지를 결정할 수 있다. 일부 구현에서 여러 러너들에서의 태스크 큐들을 다시 조정하는데 더 전역적인 결정 프로세스가 사용될 수 있으나, 전반적인 효과는 비슷하다.

적어도 일부 실시 예에서, 한 러너로부터 또 다른 러너로의 태스크의 스틸링은 그 태스크에 대한 모든 데이터를 전송하는 것을 반드시 포함하지는 않는다. 예를 들어, 현재 실행 “프레임(frame)”(예를 들어, 현재 프로그램 스코프(scope) -예를 들어, 현재 서브루틴 호출 - 로부터 액세스 가능한 지역 및 전역 변수들에 대한 데이터)에서 액세스가능한 데이터만이 다시 태스크 “홈(home)” 러너에 대한 참조와 함께 패키징된다. 이러한 데이터는 마이그레이션의 데스티네이션 러너에서 작업의 실행가능한 복사본을 만들기 충분하고 데스티네이션 실행가능 큐의 엔트리는 해당 러너에서 실행 준비가 된다.

이송된 러너가 실행을 완료하거나 또는 지역 변수가 가용했던 프로그램 스코프로부터 반환에 의해 러너로 전송된 데이터를 소모하면, 태스크는 홈 러너로 다시 전송되고, 여기서 그 태스크에 대한 데이터는 병합되고 태스크는 한번 다시 홈 러너에서 실행가능이 된다.

단일 처리 엔진 내에서 태스크의 전송 동안, 러너들 사이의 통신은 로컬 메모리를 통할 수 있어서 (즉, 디스크 또는 네트워크 통신을 피함) 상대적으로 적은 자원을 소비할 수 있다. 처리 엔진들 간의 스틸링 및 마이그레이션을 허용하는 구현에서, 한 러너로부터 또 다른 러너로 이동하는 동안 태스크는 상대적으로 적은 자원을 소비한다(예를 들어, 주로 계산 자원보다는 처리 엔진들 간 통신 자원을 소비함). 또한, 전송동안 홈 및 데스티네이션 러너들이 계산에 바쁜 것으로 추정되기 때문에 이러한 통신의 지연은 상대적으로 중요하지 않다. 홈 러너는 그 실행가능 큐가 많이 채워졌기 때문에 비울수 없을 것이고 데스티네이션 러너는 데스티네이션에서 실행가능 큐를 예상하여 스틸링이 수행되기 때문에 비워진다.

도 2a-2b에서 도시된 계산들과 관련된 태스크들에 대한 실행의 예에서, 태스크 스틸링 메커니즘은 하나 이상의 처리 엔진들의 러너들에 걸쳐 계산에 대한 부하를 분산시켰다. 그러나 특정 데이터 액세스는 특정 러너(또는 아마도 특정 처리 엔진)로 제한된다. 예를 들어, 이상에서 설명된 바와 같이, 버퍼 2에 대한 데이터는 단일 러너(또는 아마도 러너들의 그룹)에 의해 액세스가능할 수 있지만, 버퍼 2에 기록될 필요가 있을 수 있는 Work_A 태스크는 버퍼 2에 기록할 수 없는 러너에 의해 스틸링되었을 수 있다. 이러한 경우에 태스크가 현재 실행되는 곳보다 상이한 러너에서 태스크가 실행되어야 하는 동작을 취할 필요가 있을 때, 태스크가 “마이그레이션(migration)” 또는 “푸시(push)” 방식으로 적절한 러너로 이송된다.

적어도 일부 예에서, 계산 플랫폼(150)은 전역 변수들의 (키, 값) 쌍들의 세트에 대한 전역 데이터 저장소를 지원한다. 이러한 데이터 저장소는 여러 컴퓨팅 노드들(또는 처리 엔진들)의 메모리(예를 들어, RAM 또는 디스크)에 걸쳐 분산될 수 있다. 키들의 명칭 공간(name space)은 키의 명세가 모든 컴퓨팅 노드들(152)과 그 러너들(1450)에서 동일한 의미를 가진다는 의미에서 전역적이다. 이러한 변수들에 대한 값들은 태스크가 인스턴스화, 실행, 및 종결되는 동안 지속되어, 정보가 공통 부모 태스크를 통해 한 태스크로부터 또 다른 태스크로 전달될 필요없이 태스크들 사이에서 정보를 전달하는 방법을 제공한다. 이하에서 논해지는 바와 같이 키들에 따른 값들에 대한 액세스는 값들의 사용 및 업데이트가 태스크들 간에 충돌을 야기하지 않도록 제어된다. 일부 예에서, 태스크들은 실행의 일부 또는 전부에 대한 특정 (키, 값) 쌍에 대한 독점적 액세스를 얻는다.

일반적으로, (키, 값) 쌍들에 대한 저장소는 분산되고, 임의의 특정 (키, 값) 쌍이 특정 컴퓨팅 노드(152)와 관련된다. 예를 들어, (키, 값) 쌍은 해당 컴퓨팅 노드의 분산 테이블 저장소(1480)에 저장된다. 일부 구현에서, spawn 프리미티브는 관련 변수의 태스크들의 지역 변수로의 매핑 및 키의 지정을 허용한다. 키가 지정되면, 스폰인 태스크는 실행 동안 키에 대한 독점적 액세스를 얻는다. 실행 시작 전에, 값이 저장소로부터 태스크의 로컬 컨텍스트(local context)로 전달되고, 실행이 완료된 후 로컬 컨텍스트의 값이 다시 전역 저장소로 전달된다. spawn 프리미티브가 또 다른 실행 태스크에 의해 사용중인 키를 지정하면, 이러한 새롭게 스포닝된 태스크가 그 키에 대한 독점적 액세스를 얻을 수 있을 때까지 차단된다. 일부 구현에서, 각각의 컴퓨팅 노드가 특정 키에 대한 홈 노드를 결정할 수 있고, 태스크가 스포닝되도록 요청될 때 그 요청이 (키, 값) 쌍이 상주하는 컴퓨팅 노드에 의해 처리되고, 그 태스크의 실행이 처음에 해당 노드에서 시작될 것이다. 대안적 실시 예에서, 이러한 전역 공유 (키, 값) 쌍들에 대한 유사한 독점적 액세스를 얻기 위한 다른 방법은 예를 들어, 독점적 액세스에 대한 요청들을 통신하고 추후에 키에 대해 업데이트된 값과 독점적 액세스의 해제를 통신하여 저장소와 동일한 위치에서 태스크들을 개시하는 것을 반드시 포함하지는 않는다. 태스크들은 새로운 (키, 값) 쌍이 생성될 때 기본적으로 태스크가 실행 중인 노드에 저장되는 새로운 (키, 값) 쌍들을 생성할 수 있다.

전역 상태 변수들의 한 가지 용도는 콜렉션의 연속적인 레코드들의 함수의 실행 동안 집계(aggregation)를 위한 것이다. 예를 들어, 단일 항목인 값 대신, 전역 저장소는 키에 할당되는 값들의 윈도우를 유지한다. 따라서, 프로그래밍 모델에서, 값은 키에 관련하여 유지되는 이력에 추가될 수 있고, 이전에 추가된 값들의 함수가 제공될 수 있다. 값들의 윈도우는 타임 윈도우(즉, 예를 들어, 값들이 추가되었던 횟수 또는 추가된 때 각각의 값들과 함께 제공되는 명시적 타임 스탬프들에 의해 정의되는 지난 10분 동안 추가된 항목들)에 의해, 항목들의 수(즉, 마지막 100개 항목들)에 따라 정의될 수 있다. 프로그래밍 모델은 구현들이 삭제를 자동적으로 수행할 수 있도록 허용하는 윈도우의 정의로, 윈도우 외부에 있는 오래된 값들의 명시적 삭제를 필요로 하지 않는다. 프로그래밍 모델은 (예를 들어, 윈도우의 특성과 범위를 정의하는) 이러한 윈도우 기반 키처리된 전역 변수(keyed global variables)들을 생성하고, 값들을 키에 추가하고, 값들의 윈도우의 함수들(예를 들어, 최대, 평균, 별개 값들의 수, 등)을 계산하기 위한 여러 프리미티브들을 포함한다. 일부 프리미티브들은 키의 새로운 값의 추가와 윈도우 함수의 반환을 결합한다(예를 들어, 키에 새로운 값을 추가하고 추가된 마지막 100 개의 값의 평균을 반환함).

적어도 일부 예에서, 전역 저장소는 또한 핸들(handle)로 지칭되는 식별자를 통해 액세스되는 공유 레코드 지향 데이터(shared record-oriented data)도 포함한다. 예를 들어, 핸들은 데이터 레코드들의 소스 또는 싱크를 식별할 수 있거나, 또 다른 예로서, 핸들은 데이터 세트에서 특정 레코드를 식별할 수 있다. 일반적으로, 핸들은 핸들 포인트가 데이터에 액세스하는 방법을 제공하고 또한 액세스되는 데이터의 구조의 정의를 제공한다는 점에서 유형이 지정된다. 예를 들어, 핸들은 데이터 레코드의 필드(열) 구조와 관련되어 있을 수 있다.

적어도 일부 예에서, (예를 들어, 컴퓨팅 노드들의 메모리의) 전역 저장소는 유형화된 데이터의 행들의 하나 이상의 테이블들에 대한 테이블 저장소를 포함하며, 테이블들 또는 테이블들의 특정 레코드들은 핸들로 지칭되는 식별자들을 통해 다시 액세스된다. 테이블의 행 유형은 벡터들, 레코드들의 벡터들 등을 가지는 계층적 레코드 유형일 수 있다. 일부 예에서, 테이블은 행에 대한 해시- 또는 B-트리 (정렬된) 액세스를 제공하는 하나 이상의 인덱스를 가질 수 있고, 커서는 테이블, 인덱스, 또는 인덱스와 키 값(들)로부터 생성될 수 있다. 행들은 개별적으로 삽입, 업데이트 또는 삭제될 수 있다. 트랜잭션 처리를 지원하기 위해, 태스크는 예를 들어, 데이터 처리 그래프의 구성요소에 대한 처리 동안 판독 또는 업데이트 액세스를 위해 하나 이상의 테이블들의 하나 또는 여러 행들을 잠글 수 있다. 테이블들은 예를 들어, 데이터 처리 그래프의 데이터의 소스 또는 데스티네이션으로서 데이터 병렬 연산을 위한 콜렉션들로 처리될 수 있다. 일반적으로, 테이블들은 인덱싱되고, 테이블의 행들의 서브세트는 커서를 산출하는 인덱스를 기반으로 선택될 수 있고, 그 커서는 선택된 행들을 데이터 소스로 제공하는 데 사용된다. 일부 예에서, 커서를 분할하고 핸들과 관련된 레코드들의 수를 추정하는 등의 동작들에 대한 태스크에 추가 프리미티브들이 사용가능하다. 커서가 실행 세트에 대한 데이터의 소스로서 제공되면, 커서는 각각이 실행 세트의 대응하는 인스턴스에 대한 테이블의 행들 중 일부를 제공하는 부분들로 분할될 수 있어, 병렬처리 및 행들이 저장되는 노드들에서 실행을 가능하게 하는 커서의 적절한 분할을 제공한다. 데이터 테이블은 또한 변경들이 태스크에 의해 명시적으로 행해질 때까지 태스크 외부에서 보이지 않게 데이터 테이블의 변경들이 유지되도록 트랜잭션을 구현하는 태스크에 의해 액세스될 수 있다. 일부 예에서, 이러한 트랜잭션 지원은 테이블의 하나 이상의 행들을 잠금으로써 구현될 수 있는 반면, 다른 예에서는 행들의 여러 버전들을 포함하는 더 복잡한 방법들이 로크(locks)를 단독으로 사용하여 제공될 수 있는 것보다 더 큰 잠재적 동시성을 제공할 수 있도록 구현될 수 있다.

파일들, 데이터 흐름들, 및 인 메모리 테이블들은 모두 콜렉션으로 지칭되는 것의 예이다. 리더 태스크(reader task)는 콜렉션으로부터 레코드들을 판독하고, 라이터 태스크(writer task)는 콜렉션에 레코드들을 기록한다. 일부 태스크들은 리더 및 라이터 둘 다이다.

상술된 바와 같이, 콜렉션을 나타내는 흐름들은 인 메모리 버퍼들 사용하여 런타임 시스템에서 구현될 수 있다. 대안적으로, 임의의 형태의 저장소가 데이터베이스 내의 테이블들 또는 분산 저장 시스템을 포함하는 다양한 구현에서 사용될 수 있다. 일부 구현에서는, 인 메모리 분산 데이터베이스가 사용된다. 일부 구현에서, 컴파일러는 데이터 처리 그래프의 개발자에게 반드시 노출되지 않는 방식으로 인 메모리 테이블들을 사용하여 이러한 흐름들을 구현한다. 예를 들어, 컴파일러는 업스트림 구성요소가 테이블의 행들을 채우게 할 수 있고 다운스트림 구성요소가 이전에 채워진 행들을 판독하게 할 수 있어, 정렬되지 않은 데이터 흐름을 구현할 수 있다. 런타임 콘트롤러는 저장소로 수신되었던 순서와 다른 순서로 그리고 특정 형태의 차단(blocking)을 방지하는 방식으로 저장소로부터 데이터 요소들을 검색하여 업스트림 콜렉션 포트로부터의 구동 데이터 요소들을 처리하기 위해 실행 세트에 대응하는 태스크의 여러 인스턴스들을 호출할 수 있다. 예를 들어, (즉, 임의의 특정 다른 인스턴스가 하나 이상의 데이터 요소들을 처리하는 것을 완료할 때까지) 임의의 특정 다른 인스턴스에 의해 인스턴스들 중 임의의 것의 호출을 차단하지 않고 태스크의 인스턴스들이 호출될 수 있다.

일반적으로, 콜렉션의 레코드는 해당 레코드의 데이터가 처음으로 기록되기 전에 핸들을 가질 수 있다. 예를 들어, 테이블이 레코드들의 인덱싱된 세트의 데스티네이션으로 설정될 수 있고, 개별 레코드가 그 레코드에 대한 데이터가 기록되기 전에라도 핸들을 가질 수 있다.

6. 구현

상술된 방법은 예를 들어, 적절한 소프트웨어 명령들을 실행하는 프로그래머블 컴퓨팅 시스템을 사용하여 구현될 수 있거나 필드 프로그래머블 게이트 어레이(FPGA)와 같은 적절한 하드웨어 또는 어떤 하이브리드 형태로 구현될 수 있다. 예를 들어, 프로그래밍된 방법에서 소프트웨어는 하나 이상의 프로그래밍된 또는 프로그래머블 컴퓨팅 시스템(분산, 클라이언트/서버, 또는 그리드 등의 다양한 아키텍처일 수 있음)에서 실행되는 하나 이상의 컴퓨터 프로그램의 절차들을 포함할 수 있으며, 각각은 적어도 하나의 프로세서, 적어도 하나의 데이터 저장 시스템(휘발성 및/또는 비 휘발성 메모리 및/또는 저장 요소들을 포함함), (적어도 하나의 입력 디바이스 또는 포트를 사용하여 입력을 수신하고 적어도 하나의 출력 디바이스 또는 포트를 사용하여 출력을 사용하기 위한) 적어도 하나의 사용자 인터페이스를 포함한다. 소프트웨어는 예를 들어, 데이터 처리 그래프의 디자인, 구성 및 실행에 관련된 서비스를 제공하는 더 큰 프로그램의 하나 이상의 모듈을 포함할 수 있다. 프로그램의 모듈들(예를 들어, 데이터 처리 그래프의 구성요소들)은 데이터 저장소에 저장된 데이터 모델을 따르는 데이터 구조 또는 다른 조직화된 데이터로 구현될 수 있다.

소프트웨어는 시간 주기(예를 들어, 동적 RAM 같은 동적 메모리 디바이스의 리프레시 주기들 사이의 시간)동안 매체의 물리적 특성(예를 들어, 표면 피치(surface pitch) 및 랜드(land), 자구(magnetic domain) 또는 전하(electrical charg))을 이용하여 휘발성 또는 비휘발성 저장 매체, 또는 임의의 다른 비일시적 매체로 구현되는 등 비 일시적 형태로 저장될 수 있다. 명령을 로딩하기 위한 준비에서, 소프트웨어가 CD-ROM 또는 다른 컴퓨터 판독가능 매체(예를 들어, 범용 또는 특수 목적 컴퓨팅 시스템 또는 디바이스에 의해 판독가능함) 같은 유형적, 비일시적 매체 상에서 제공될 수 있거나, 그것이 실행되는 컴퓨팅 시스템의 유형적, 비일시적 매체로 네트워크의 통신 매체를 통해 (예를 들어, 전파된 신호에 인코딩되어) 전달될 수 있다. 처리의 일부 또는 전부는 특수 목적 컴퓨터상에서 또는 코프로세서 또는 필드 프로그래머블 게이트 어레이(FPGAs) 또는 전용, 응용 주문형 집적 회로(ASICs) 같은 특수 목적 하드웨어를 사용하여 수행될 수 있다. 처리는 소프트웨어에 의해 명시된 계산의 상이한 부분들이 상이한 컴퓨팅 요소들에 의해 수행되는 분산 방식으로 구현될 수 있다. 각각의 이러한 컴퓨터 프로그램은 저장 디바이스 매체가 본 명세서에서 설명된 처리를 수행하기 위해 컴퓨터에 의해 판독될 때 컴퓨터를 구성하고 운영하기 위해, 바람직하게는 범용 또는 특수 목적 프로그래머블 컴퓨터의 액세스가능한 저장 디바이스의 컴퓨터 판독가능 저장 매체(예를 들어, 솔리드 스테이트 메모리 또는 매체, 또는 자기 또는 광 매체)상에 저장되거나 다운로드된다. 본 발명 시스템은 또한 컴퓨터 프로그램으로 구성된 유형적, 비일시적 매체로 구현되는 것으로 간주될 수 있고, 이렇게 구성된 매체는 본 명세서에서 설명된 처리 단계들 중 하나 이상을 수행하기 위해 컴퓨터로 하여금 특정 및 미리 정의된 방식으로 동작하게 한다.

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

Claims (18)

1. 그래프 기반 프로그램 명세를 처리하기 위한 방법에 있어서, 상기 방법은
   적어도 하나의 입력 디바이스 또는 포트에 의해, 상기 그래프 기반 프로그램 명세를 수신하는 단계 - 상기 그래프 기반 프로그램 명세는
   각각이 처리 태스크에 대응하고 적어도 하나의 데이터 요소를 전송하거나 수신하기 위한 적어도 하나의 포트를 포함하는 복수의 구성요소들; 및
   각각의 링크가 상기 복수의 구성요소들의 업스트림 구성요소의 출력 포트를 상기 복수의 구성요소들의 다운스트림 구성요소의 입력 포트에 연결하는 적어도 하나의 링크를 포함함 - ; 및
   적어도 하나의 프로세서에 의해, 상기 그래프 기반 프로그램 명세의 상기 복수의 구성요소들의 서브세트들을 나타내는 준비된 코드를 생성하기 위해 상기 그래프 기반 프로그램 명세를 처리하는 단계 - 상기 처리하는 단계는
   연결된 구성요소들의 특성들에 적어도 부분적으로 기반하여 상이한 서브세트들의 구성요소들 사이의 복수의 서브세트 경계들을 식별하는 단계;
   상기 식별된 서브세트 경계들에 기반하여 상기 서브세트들을 형성하는 단계; 및
   런타임 시스템에 의한 실행을 위해 사용될 때 그 형성된 서브 세트의 구성요소들에 대응하는 처리 태스크들이 그 형성된 서브세트에 대해 준비된 코드에 임베드된(embedded) 정보에 따라 수행되게 하는 각각의 형성된 서브세트에 대해 준비된 코드를 생성하는 단계를 포함하고, 상기 런타임 시스템은 그 형성된 서브세트를 여러 번 인스턴스화하고, 그 횟수는 복수의 데이터 요소들의 세트 처리에서의 상기 런타임 시스템의 성능에 적어도 부분적으로 기반하여 런타임 동안 동적으로 결정됨 - 를 포함하는, 그래프 기반 프로그램 명세를 처리하기 위한 방법.
2. 제1항에 있어서,
   상기 서브세트들을 형성하는 단계는 횡단된 서브세트 경계들의 레코드를 유지하면서 상기 그래프 기반 프로그램 명세의 구성요소들을 횡단하는 단계, 및 상기 그래프 기반 프로그램 명세의 각각의 구성요소를 상기 횡단된 서브세트 경계들의 레코드로부터 결정된 단일 서브세트 식별자와 연관시키는 단계를 포함하는, 그래프 기반 프로그램 명세를 처리하기 위한 방법.
3. 제2항에 있어서,
   상기 복수의 구성요소들의 식별된 서브세트와 연관된 각각의 서브세트 식별자가 고유한, 그래프 기반 프로그램 명세를 처리하기 위한 방법.
4. 제2항에 있어서,
   상기 횡단된 서브세트 경계들의 레코드는 식별자 값들의 경로로서 유지되는, 그래프 기반 프로그램 명세를 처리하기 위한 방법.
5. 제4항에 있어서,
   상기 식별자 값들의 경로는 구분 문자에 의해 서로 분리된 식별자 값들의 문자열을 포함하는, 그래프 기반 프로그램 명세를 처리하기 위한 방법.
6. 제1항에 있어서,
   상기 서브세트들을 형성하는 단계는
   상기 그래프 기반 프로그램 명세의 제1 구성요소를 서브세트 식별자와 연관시키는 단계;
   상기 제1 구성요소로부터 하류의 구성요소들로 상기 서브세트 식별자를 전파하는 단계; 및
   상기 식별된 서브세트 경계들에 기반하여 상기 서브세트 식별자의 전파 동안 상기 서브세트 식별자를 수정하는 단계를 포함하는, 그래프 기반 프로그램 명세를 처리하기 위한 방법.
7. 제6항에 있어서,
   상기 서브세트 식별자의 전파 동안 상기 서브세트 식별자를 수정하는 단계는
   제1 서브세트 경계를 횡단할 때 상기 서브세트 식별자의 값을 제1 서브세트 식별자 값에서 상기 제1 서브세트 경계와 연관된 제2 서브세트 식별자 값으로 변경하는 단계; 및
   상기 제1 서브세트 경계와 연관된 제2 서브세트 경계를 횡단할 때 상기 서브세트 식별자 값을 상기 제1 서브세트 식별자 값으로 변경하는 단계를 포함하는, 그래프 기반 프로그램 명세를 처리하기 위한 방법.
8. 제1항에 있어서,
   연결된 구성요소들의 특성들에 적어도 부분적으로 기반하여 적어도 하나의 서브세트 경계들을 식별하는 단계는 업스트림 구성요소의 제1 유형의 포트와 다운스트림 구성요소의 제2 유형의 포트 사이의 링크에 기반하여 서브세트 경계를 식별하는 단계를 포함하는, 그래프 기반 프로그램 명세를 처리하기 위한 방법.
9. 제1항에 있어서,
   연결된 구성요소들의 특성들에 적어도 부분적으로 기반하여 적어도 하나의 서브세트 경계들을 식별하는 단계는 업스트림 구성요소와 다운스트림 구성요소 사이의 링크의 결정된 유형에 기반하여 서브세트 경계를 식별하는 단계를 포함하고, 상기 링크의 결정된 유형은 구성요소들 사이의 링크들의 복수의 상이한 유형들 중 하나인, 그래프 기반 프로그램 명세를 처리하기 위한 방법.
10. 제1항에 있어서,
    상기 각각의 형성된 서브세트에 대해 준비된 코드를 생성하는 단계는 그 형성된 서브세트의 구성요소들에 대응하는 처리 태스크들 간에 허용된 동시성을 나타내는 정보를 적어도 하나의 형성된 서브세트에 대해 준비된 코드에 임베드하는 단계를 포함하는, 그래프 기반 프로그램 명세를 처리하기 위한 방법.
11. 제1항에 있어서,
    상기 각각의 형성된 서브세트에 대해 준비된 코드를 생성하는 단계는 다른 형성된 서브세트들에 대한 우선순위를 나타내는 정보를 적어도 하나의 형성된 서브세트에 대해 상기 준비된 코드에 임베드하는 단계를 포함하는, 그래프 기반 프로그램 명세를 처리하기 위한 방법.
12. 제1항에 있어서,
    상기 각각의 형성된 서브세트에 대해 준비된 코드를 생성하는 단계는 그 형성된 서브세트의 구성요소들에 대응하는 적어도 하나의 처리 태스크들의 트랜잭션성(transactionality)을 나타내는 정보를 적어도 하나의 형성된 서브세트에 대해 상기 준비된 코드에 임베드하는 단계를 포함하는, 그래프 기반 프로그램 명세를 처리하기 위한 방법.
13. 제1항에 있어서,
    상기 각각의 형성된 서브세트에 대해 준비된 코드를 생성하는 단계는 상기 준비된 코드의 실행 동안 잠길(locked) 적어도 하나의 자원을 나타내는 정보를 적어도 하나의 형성된 서브세트에 대해 상기 준비된 코드에 임베드하는 단계를 포함하는, 그래프 기반 프로그램 명세를 처리하기 위한 방법.
14. 제1항에 있어서,
    상기 각각의 형성된 서브세트에 대해 준비된 코드를 생성하는 단계는 그 형성된 서브세트의 구성요소들에 대응하는 적어도 하나의 처리 태스크들에 의해 처리된 데이터 요소들 간 순서 특성들(ordering characteristics)을 나타내는 정보를 적어도 하나의 형성된 서브세트에 대해 상기 준비된 코드로 임베드하는 단계를 포함하는, 그래프 기반 프로그램 명세를 처리하기 위한 방법.
15. 제1항에 있어서,
    상기 각각의 형성된 서브세트에 대해 준비된 코드를 생성하는 단계는 상기 준비된 코드를 사용하여 실행되는 상기 형성된 서브세트의 각각의 인스턴스에 의해 동작될 여러 데이터 요소들을 나타내는 정보를 적어도 하나의 형성된 서브세트에 대해 상기 준비된 코드에 임베드하는 단계를 포함하는, 그래프 기반 프로그램 명세를 처리하기 위한 방법.
16. 그래프 기반 프로그램 명세를 처리하기 위해, 컴퓨터 판독가능 매체상에 비일시적 형태로 저장된 소프트웨어에 있어서, 상기 소프트웨어는 컴퓨팅 시스템이
    상기 그래프 기반 프로그램 명세를 수신하도록 하고 - 상기 그래프 기반 프로그램 명세는
    각각이 처리 태스크에 대응하고 적어도 하나의 데이터 요소를 전송하거나 수신하기 위한 적어도 하나의 포트를 포함하는 복수의 구성요소들; 및
    각각의 링크가 상기 복수의 구성요소들의 업스트림 구성요소의 출력 포트를 상기 복수의 구성요소들의 다운스트림 구성요소의 입력 포트에 연결하는 적어도 하나의 링크를 포함함 - ; 그리고
    상기 그래프 기반 프로그램 명세의 상기 복수의 구성요소들의 서브세트들을 나타내는 준비된 코드를 생성하기 위해 상기 그래프 기반 프로그램 명세를 처리하도록 하는 - 상기 처리하는 것은
    연결된 구성요소들의 특성들에 적어도 부분적으로 기반하여 상이한 서브세트들의 구성요소들 사이의 복수의 서브세트 경계들을 식별하는 것;
    상기 식별된 서브세트 경계들에 기반하여 상기 서브세트들을 형성하는 것; 및
    런타임 시스템에 의한 실행을 위해 사용될 때 그 형성된 서브 세트의 구성요소들에 대응하는 처리 태스크들이 그 형성된 서브세트에 대해 준비된 코드에 임베드된(embedded) 정보에 따라 수행되게 하는 각각의 형성된 서브세트에 대해 준비된 코드를 생성하는 것을 포함하고, 상기 런타임 시스템은 그 형성된 서브세트를 여러 번 인스턴스화하고, 그 횟수는 복수의 데이터 요소들의 세트 처리에서의 상기 런타임 시스템의 성능에 적어도 부분적으로 기반하여 런타임 동안 동적으로 결정됨 - 명령들을 포함하는, 컴퓨터 판독가능 매체상에 비일시적 형태로 저장된 소프트웨어.
17. 그래프 기반 프로그램 명세를 처리하기 위한 컴퓨팅 시스템에 있어서, 상기 컴퓨팅 시스템은
    상기 그래프 기반 프로그램 명세를 수신하도록 구성된 적어도 하나의 입력 디바이스 또는 포트 - 상기 그래프 기반 프로그램 명세는
    각각이 처리 태스크에 대응하고 적어도 하나의 데이터 요소를 전송하거나 수신하기 위한 적어도 하나의 포트를 포함하는 복수의 구성요소들; 및
    각각의 링크가 상기 복수의 구성요소들의 업스트림 구성요소의 출력 포트를 상기 복수의 구성요소들의 다운스트림 구성요소의 입력 포트에 연결하는 적어도 하나의 링크를 포함함 - ; 및
    상기 그래프 기반 프로그램 명세의 상기 복수의 구성요소들의 서브세트들을 나타내는 준비된 코드를 생성하기 위해 상기 그래프 기반 프로그램 명세를 처리하도록 구성된 적어도 하나의 프로세서 - 상기 처리하는 것은
    연결된 구성요소들의 특성들에 적어도 부분적으로 기반하여 상이한 서브세트들의 구성요소들 사이의 복수의 서브세트 경계들을 식별하는 것;
    상기 식별된 서브세트 경계들에 기반하여 상기 서브세트들을 형성하는 것; 및
    런타임 시스템에 의한 실행을 위해 사용될 때 그 형성된 서브 세트의 구성요소들에 대응하는 처리 태스크들이 그 형성된 서브세트에 대해 준비된 코드에 임베드된(embedded) 정보에 따라 수행되게 하는 각각의 형성된 서브세트에 대해 준비된 코드를 생성하는 것을 포함하고, 상기 런타임 시스템은 그 형성된 서브세트를 여러 번 인스턴스화하고, 그 횟수는 복수의 데이터 요소들의 세트 처리에서의 상기 런타임 시스템의 성능에 적어도 부분적으로 기반하여 런타임 동안 동적으로 결정됨 - 를 포함하는, 그래프 기반 프로그램 명세를 처리하기 위한 컴퓨팅 시스템.
18. 제1항에 있어서,
    복수의 인스턴스들이 있다면, 상기 인스턴스들 각각은 복수의 데이터 요소들의 세트의 데이터 요소들의 상이한 각각의 서브세트들에 적용되는, 그래프 기반 프로그램 명세를 처리하기 위한 방법.
    

Images