KR20130114577A - 데이터 병렬 프로세싱 - Google Patents

Abstract

비신뢰 어플리케이션이 하나 이상의 프로세싱 모듈을 포함하고 네이티브 프로세싱 환경을 제공하는 데이터 센터에 수신된다. 비신뢰 어플리케이션은 데이터 병렬 파이프라인을 포함한다. 보안 프로세싱 환경이 비신뢰 어플리케이션을 실행하도록 사용된다. 데이터 병렬 파이프라인은 다수의 병렬 데이터 객체들 및 병렬 연산들을 특정할 수 있다. 데이터 병렬 파이프라인을 기초로, 지연 병렬 데이터 객체들 및 지연 병렬 연산들의 데이터플로우 그래프가 일반화될 수 있고 하나 이상의 그래프 변환이 하나 이상의 지연 병렬 데이터 객체 및 지연 컴바이닝 병렬 데이터 연산을 포함하는 수정 데이터플로우 그래프를 생성하도록 데이터플로우 그래프에 적용될 수 있다. 지연 컴바이닝 병렬 연산들이 지연 병렬 데이터 객체들에 대응하는 실체화된 병렬 데이터 객체들을 생성하도록 실행될 수 있다.

Description

데이터 병렬 프로세싱{PARALLEL PROCESSING OF DATA}

본 출원은 2010년 5월 4일 출원된 미국출원번호 제61/331,148호, 2010년 6월 4일 출원된 미국출원번호 제12/794,348호, 및 2010년 12월 2일 출원된 미국출원번호 제12/959,022호에 대한 우선권을 주장하며, 그 내용들은 모두 본 명세서에 참조로 포함되어 있다.

본 명세서는 데이터의 병렬 프로세싱에 관한 것이다.

대규모 데이터 프로세싱은 병렬 프로세싱(parallel processing)을 포함할 수 있는데, 이는 일반적으로 다량의 데이터 셋(data set)의 각각의 엘리먼트에 대해 몇몇의 연산을 수행하는 것을 포함한다. 데이터 셋을 프로세싱하기 위한 효율적인 메커니즘을 생성하도록 다양한 연산이 데이터-병렬 파이프라인(data-parallel pipeline)내에서 함께 연결(chain)될 수 있다.

한 측면에서, 하나 이상의 프로세싱 모듈들을 포함하며 네이티브 프로세싱 환경 (native processing enviroment)을 제공하는 데이터 센터에서 비신뢰 어플리케이션 (untrusted application)이 수신된다. 이 비신뢰 어플리케이션은 데이터 병렬 파이프라인을 포함한다. 데이터 병렬 파이프라인은 다수의 엘리먼트들, 및 엘리먼트들을 연산하는 비신뢰 함수(untrusted function)들과 연관된 다수의 병렬 연산을 포함하는 다수의 병렬 데이터 객체들을 특정(specifiy)한다. 네이티브 프로세싱 환경과 하나 이상의 프로세싱 모듈 상에서 제1 보안 프로세싱 환경(secured processing environment)이 예시(instantiate)된다. 비신뢰 어플리케이션은 제1 보안 프로세싱 환경에서 실행된다. 이 어플리케이션의 실행은 지연 병렬 데이터 객체들과 데이터 병렬 파이프라인에 대응하는 지연 병렬 연산의 데이터플로우 그래프(dataflow graph)를 생성한다. 데이터 흐름도를 나타내는 정보는 제1 보안 프로세싱 환경 외부에 전달된다. 제1 보안 처리 환경의 외부 및 네이티브 처리 환경 내에서, 하나 이상의 지연 병렬 데이터 객체와 하나 이상의 비신뢰 함수와 연관된 지연 컴바이닝 병렬 데이터 연산(deferred, combined parallel data operations)을 포함하는 수정 데이터플로우 그래프를 생성하도록 하나 이상의 그래프 변환이 데이터플로우 그래프를 나타내는 정보에 적용된다. 지연 병렬 데이터 객체에 대응하는 실체화된 병렬 데이터 객체(materialized parallel data objects)를 생성하도록 지연 컴바이닝 병렬 연산이 실행된다. 지연 컴바이닝 병렬 연산의 실행은 네이티브 프로세싱 환경에서 하나 이상의 제2 보안 프로세싱 환경 및 하나 이상의 프로세싱 모듈을 인스턴스화(instantiating)하고 하나 이상의 제2 보안 프로세싱 환경에서 지연 컴바이닝 병렬 연산들과 연관된 비신뢰 함수들을 실행하는 것을 포함한다.

구현은 하나 이상의 다음과 같은 특징을 포함할 수 있다. 예를 들어, 제1 보안 프로세싱 환경은 제1 가상 머신을 포함할 수 있고 하나 이상의 제2 보안 프로세싱 환경은 제2 가상 머신을 포함할 수 있다. 제1 가상 머신 및 하나 이상의 제2 가상 머신은 하드웨어 가상 머신들일 수 있다. 하나 이상의 제2 보안 프로세싱 환경에서 지연 컴바이닝 병렬 연산들과 연관한 비신뢰 함수들을 실행하는 것은 레코드들의 입력 배치(input batch of records)를 제2 보안프로세싱 환경의 외부로부터 상기 제2 보안프로세싱 환경의 내부로 전달하는 것과 (여기서 레코드들의 입력 배치는 다수의 개별 입력 레코드를 포함함); 출력 레코드를 생성하도록 입력 매치 내의 개별 레코드들 각각에 대해 지연 컴바이닝 병렬 연산들과 연관된 적어도 하나의 비신뢰 함수를 실행하는 것과; 출력 레코드들을 출력 배치로 수집하는 것과; 제2 보안프로세싱 환경 외부로 출력 배치를 전달하는 것을 포함할 수 있다.

비신뢰 어플리케이션의 출력은 비신뢰 어플리케이션을 데이터 센터로 전송한 클라이언트 시스템으로 전송될 수 있다. 제1 보안 프로세싱 환경 외부로 데이터플로우 그래프를 나타내는 정보를 전달하는 것은 제1 보안 프로세싱 환경의 외부에서 그래프 서비스를 실행하도록 데이터플루우 그래프를 나타내는 정보를 전달하는 것을 포함할 수 있다.

지연 컴바이닝 병렬 연산들은 적어도 하나의 일반화된 맵리듀스 연산을 포함할 수 있다. 일반화된 맵리듀스 연산은 다수의 병렬 맵 연산과 다수의 병렬 리듀스 연산을 포함할 수 있으며 다수의 병렬 맵 연산을 구현하는 단일 맵 함수와 다수의 병렬 리듀스 연산을 구현하는 단일 리듀스 함수를 포함하는 단일 맵리듀스 연산으로 번역가능하다. 단일 맵 함수와 단일 리듀스 함수는 하나 이상의 비신뢰 함수를 포함할 수 있다.

지연 컴바이닝 병렬 연산들을 실행하는 것은 컴바이닝 맵리듀스 연산을 단일 맵리듀스 연산으로 번역하는 것을 포함할 수 있다. 하나 이상의 제2 보안프로세싱 환경에서 지연 컴바이닝 병렬 연산들과 연관된 비신뢰 함수들을 실행하는 것은 하나 이상의 제2 보안프로세싱 환경에서 단일 맵 함수와 단일 리듀스 함수를 실행하는 것을 포함할 수 있다.

보안프로세싱 환경에서 비신뢰 어플리케이션을 실행하는 것은 제1 보안 프로세싱 환경의 가상 머신 내에서 비신뢰 어플리케이션을 실행하는 것을 포함할 수 있다. 하나 이상의 보안프로세싱 환경에서 지연 컴바이닝 병렬 연산들과 연관된 비신뢰 함수들을 실행하는 것은, 하나 이상의 제2 보안프로세싱 환경의 가상 머신 내에서 지연 컴바이닝 병렬 연산들과 연관된 비신뢰 함수들을 실행하는 것을 포함할 수 있다.

제1 보안 프로세싱 환경 외부로 데이터플로우 그래프를 나타내는 정보를 전달하는 것은 원격 프로시져 호출(remote procedure call)을 사용하여 제1 보안 프로세싱 환경의 외부로 데이터플로우 그래프를 나타내는 정보를 전달하는 것을 포함할 수 있다. 원격 프로시져 호출은 오디트(audit)될 수 있다.

또 다른 측면에서, 시스템은 네이티브 프로세싱 환경을 제공하고 이 네이티브 프로세싱 환경 내에 제1 보안 프로세싱 환경을 구현하도록 구성된 하나 이상의 프로세싱 모듈들, 제1 보안 프로세싱 환경 외부 및 네이티브 프로세싱 환경 내부에 배치된 서비스, 및 네이티브 프로세싱 환경 내의 하나 이상의 제2 보안프로세싱 환경을 포함한다.

제1 보안 프로세싱 환경은 데이터 병렬 파이프라인을 포함하는 비신뢰 어플리케이션을 실행하도록 구성된다. 데이터 병렬 파이프라인은 엘리먼트들에 대해 연산하는 비신뢰 함수들과 연관된 다수의 병렬 연산 및 다수의 엘리먼트를 포함하는 다수의 병렬 데이터 객체들을 특정한다. 어플리케이션을 실행하는 것은 데이터 병렬 파이프라인에 대응하는 지연 병렬 데이터 객체들 및 지연 컴바이닝 병렬 연산들의 데이터플로우 그래프를 생성한다. 제1 보안 프로세싱 환경은 또한 데이터 병렬 파이프라인의 외부에 데이터플로우 그래프를 나타내는 정보를 전달하도록 구성된다.

서비스는 제1 보안 프로세싱 환경으로부터 데이터플로우 그래프를 나타내는 정보를 수신하여, 하나 이상의 그래프 변환을 하나 이상의 비신뢰 함수와 연관된 지연 컴바이닝 병렬 연산들 및 하나 이상의 지연 병렬 데이터 객체들을 포함하는 수정 데이터플로우 그래프를 생성하도록 데이터플로우 그래프를 나타내는 정보에 적용하고, 지연 컴바이닝 병렬 연산들을 실행하여 지연 병렬 데이터 객체들에 대응하는 실체화된 병렬 데이터 객체들을 생성하도록 한다.

하나 이상의 제2 보안프로세싱 환경은 지연 컴바이닝 병렬 연산들과 연관된 비신뢰 함수들을 실행하여 지연 컴바이닝 병렬 연산들이 실행되도록 구성된다.

구현은 하나 이상의 다음 특징을 포함할 수 있다. 예를 들어, 제1 보안 프로세싱 환경은 제1 가상 머신을 포함할 수 있고 하나 이상의 제2 보안프로세싱 환경은 제2 가상 머신을 포함할 수 있다. 제1 가상 머신 및 하나 이상의 제2 가상 머신은 하드웨어 가상 머신일 수 있다.

하나 이상의 프로세싱 장치들이 제2 보안프로세싱 환경의 외부로부터 제2 보안프로세싱 환경의 내부로 레코드들의 입력 배치를 전달하도록 구성된 워커(worker)를 구현하도록 구성될 수 있다. 레코드들의 입력 배치는 다수의 개별 입력 레코드들을 포함할 수 있다. 지연 컴바이닝 병렬 연산들과 연관된 비신뢰 함수들을 실행하기 위해, 하나 이상의 제2 보안프로세싱 환경은 출력 레코드들을 생성하도록 입력 배치 내의 개별 레코드들 각각에 대해 지연 컴바이닝 병렬 연산들과 연관된 적어도 하나의 비신뢰 함수를 실행하고; 출력 레코드들을 출력 배치로 수집하고; 이 출력 배치들을 워커로 전달하도록 구성될 수 있다.

시스템은 비신뢰 어플리케이션의 출력을 수신하도록 구성된 클라이언트 시스템을 포함할 수 있다. 지연 컴바이닝 병렬 연산들은 적어도 하나의 일반화된 맵리듀스 연산을 포함할 수 있다. 일반화된 맵리듀스 연산은 다수의 병렬 맵 연산 및 다수의 병렬 리듀스 연산을 포함할 수 있고 다수의 병렬 맵 연산을 구현하는 단일 맵 함수와 다수의 병렬 리듀스 연산을 구현하는 단일 리듀스 함수를 포함하는 단일 맵리듀스 연산으로 번역가능할 수 있다. 단일 맵 함수 및 단일 리듀스 함수는 하나 이상의 비신뢰 함수를 포함할 수 있다.

서비스는 컴바이닝 맵리듀스 연산을 단일 맵리듀스 연산으로 번역하도록 구성될 수 있다. 하나 이상의 제2 보안프로세싱 환경은 하나 이상의 제2 보안프로세싱 환경 내에서 단일 맵 함수와 단일 리듀스 함수를 실행하도록 구성될 수 있다.

제1 보안 프로세싱 환경은 제1 보안 프로세싱 환경의 가상 머신 내에서 비신뢰 어플리케이션을 실행하도록 구성될 수 있다. 하나 이상의 제2 보안프로세싱 환경은 하나 이상의 제2 보안프로세싱 환경의 가상 머신 내에서 지연 컴바이닝 병렬 연산들과 연관된 비신뢰 함수들을 실행하도록 구성될 수 있다.

또 다른 측면에서, 지연 병렬 데이터 객체들 및 지연 병렬 연산들의 데이터플로우 그래프를 나타내는 정보가 액세스된다. 지연 병렬 데이터 객체들 및 지연 병렬 연산들은 비신뢰 어플리케이션 내에 포함된 데이터 병렬 파이프라인에 의해 특정되는 병렬 데이터 객체들과 병렬 연산들에 대응한다. 병렬 데이터 객체들은 다수의 엘리먼트를 포함하고 병렬 연산들은 엘리먼트에 대해 연산하는 비신뢰 함수들과 연관된다. 하나 이상의 그래프 변환이 하나 이상의 비신뢰 함수와 연관된 지연 컴바이닝 병렬 연산들 및 하나 이상의 지연 병렬 데이터 객체들을 포함하는 수정 데이터플로우 그래프를 생성하도록 데이터플로우 그래프를 나타내는 정보에 적용된다. 지연 컴바이닝 병렬 연산들은 지연 병렬 데이터 객체들에 대응하는 실체화된 병렬 데이터 객체들을 생성하도록 실행된다. 지연 컴바이닝 병렬 연산들을 실행하는 것은 하나 이상의 보안 프로세싱 환경을 인스턴스화하고 하나 이상의 보안 프로세싱 환경에서 지연 컴바이닝 병렬 연산들과 연관된 비신뢰 함수들을 실행하는 것을 포함한다.

데이터 병렬 파이프라인을 포함하는 비신뢰 어플리케이션이 수신될 수 있으며 초기 보안 프로세싱 환경이 인스턴스화될 수 있다. 비신뢰 어플리케이션은 초기 보안 프로세싱 환경에서 실행될 수 있다. 이 어플리케이션을 실행하는 것은 지연 병렬 데이터 객체들 및 지연 병렬 연산들의 데이터플로우 그래프를 생성할 수 있다. 데이터플로우 그래프를 나타내는 정보는 초기 보안 프로세싱 환경의 외부로 전달되어 그래프 변환이 초기 보안 프로세싱 환경의 외부에서 데이터플로우 그래프를 나타내는 정보에 적용되도록 한다. 하나 이상의 보안 프로세싱 환경은 가상 머신을 포함할 수 있다.

또 다른 측면에서, 시스템은 하나 이상의 프로세싱 장치와 하나 이상의 스토리지 장치를 포함한다. 스토리지 장치는 하나 이상의 프로세싱 장치에 의해 실행될 때 어플리케이션, 이벨류에이터, 옵티마이저, 및 익스큐터를 구현하는 명령들을 저장한다. 어플리케이션은 데이터 병렬 파이프라인을 포함한다. 데이터 병렬 파이프라인은 병렬 데이터 객체들에 대해 연산하는 다수의 병렬 연산들과 다수의 엘리먼트를 포함하는 다수의 병렬 데이터 객체를 특정한다. 이벨류에이터는 데이터 병렬 파이프라인을 기초로, 데이터 병렬 파이프라인에 대응하는 지연 병렬 데이터 객체들 및 지연 병렬 연산들의 데이터플로우 그래프를 생성하도록 구성된다.

예를 들어, 지연 병렬 데이터 객체들은 병렬 데이터 객체에 저장된 엘리먼트가 아니라 병렬 데이터 객체들에 대해 연산하는 병렬 데이터 연산에 대한 포인터를 포함하는 데이터 구조일 수 있다. 예를 들어, 지연 병렬 연산들은 지연 병렬 연산들로의 입력인 병렬 데이터 객체에 대한 포인터, 지연 병렬 연산의 출력인 지연 병렬 객체에 대한 포인터, 및 입력 객체에 대해 수행되는 (그러나 아직 미존재) 함수를 포함하는 데이터 구조일 수 있다.

옵티마이저는 하나 이상의 지연 병렬 데이터 객체 및 지연 컴바이닝 병렬 연산을 포함하는 수정 데이터플로우 그래프를 생성하도록 데이터플로우 그래프에 하나 이상의 그래프 변환을 적용하도록 구성된다. 익스큐터는 지연 병렬 데이터 객체들에 대응하는 실체화된 병렬 데이터 객체들을 생성하기 위해 지연 컴바이닝 병렬 연산들을 실행하도록 구성된다. 예를 들어, 실체화된 병렬 데이터 객체들은 데이터 또는 병렬 데이터 객체들의 엘리먼트를 포함하는 데이터 구조일 수 있다.

이러한 측면의 구현은 하나 이상의 다음의 특징을 포함할 수 있다. 예를 들어, 지연 컴바이닝 병렬 연산들은 적어도 하나의 일반화된 맵리듀스 연산을 포함할 수 있으며 다수의 병렬 맵 연산을 구현하는 단일 맵 함수 및 다수의 병렬 리듀스 연산을 구현하는 단일 리듀스 함수를 포함하는 단일 맵리듀스 연산으로 번역가능할 수 있다. 일반화된 맵 리듀스 연산을 실행하기 위해, 익스큐터는 컴바이닝 맵리듀스 연산을 단일 맵리듀스 연산으로 번역하여 이 단일 맵리듀스 연산을 실행하도록 구성될 수 있다. 단일 맵 리듀스 연산을 실행하기 위해, 익스큐터는 단일 맵리듀스 연산을 로컬 순차 연산으로 실행해야 하는지 또는 원격 병렬 연산으로 실행해야 하는지를 결정하도록 구성될 수 있다. 일반화된 맵리듀스 연산을 단일 맵리듀스 연산으로 번역하기 위해, 익스큐터는 다수의 맵 연산을 포함하는 맵 함수와 다수의 리듀서 연산을 포함하는 리듀서 함수를 생성하도록 구성될 수 있다.

다수의 병렬 데이터 객체들은 호스트 프로그래밍 언어의 제1 클래스 객체들일 수 있다.

파이프라인은 또한 단일 엘리먼트를 포함하는 단일 데이터 객체를 포함할 수 있으며 데이터플로우 그래프는 대응하는 지연 단일 데이터 객체를 포함한다. 파이프라인 내의 다수의 병렬 연산 중 적어도 하나는 단일 데이터 객체 및 다수의 병렬 데이터 객체들 중 하나에 대해 연산할 수 있으며 데이터플로우 그래프는 지연 단일 데이터 객체 및 지연 병렬 데이터 객체에 대해 연산하는 대응하는 지연 병렬 연산을 포함할 수 있다.

익스큐터는 데이터 병렬 파이프라인의 미래 실행에 사용하기 위해 지연 컴바이닝 병렬 연산들의 하나 이상의 실행 결과를 캐싱(caching)하도록 구성될 수 있다.

다른 측면에서, 방법은 데이터 병렬 파이프라인을 포함하는 어플리케이션을 포함한다. 데이터 병렬 파이프라인은 다수의 엘리먼트를 포함하는 다수의 병렬 데이터 객체들 및 병렬 데이터 객체들에 대해 연산하는 다수의 병렬 연산을 특정한다. 또한, 방법은 데이터 병렬 파이프라인을 기초로 데이터 병렬 파이프라인에 대응하는 지연 병렬 데이터 객체들 및 지연 병렬 연산들의 데이터플로우 그래프를 포함한다. 예를 들어, 지연 병렬 데이터 객체들은 병렬 데이터 객체들에 저장된 엘리먼트들이 아니라 병렬 데이터 객체들에 대해 연산하는 병렬 데이터 연산에 대한 포인터를 포함하는 데이터 구조일 수 있다. 예를 들어, 지연 병렬 연산들은 지연 병렬 연산으로의 입력인 병렬 데이터 객체에 대한 포인터, 지연 병렬 연산의 출력인 지연 병렬 객체에 대한 포인터, 및 입력 객체에 대해 수행되는 (그러나 아직 미존재) 함수를 포함하는 데이터 구조일 수 있다.

또한, 방법은 하나 이상의 지연 병렬 데이터 객체 및 지연 컴바이닝 병렬 연산을 포함하는 수정 데이터플로우 그래프를 생성하도록 데이터플로우 그래프에 하나 이상의 그래프 변환을 적용하는 것을 포함한다. 또한, 방법은 지연 병렬 데이터 객체들에 대응하는 실체화된 병렬 데이터 객체들을 생성하도록 지연 컴바이닝 병렬 연산들을 실행하는 것을 포함한다. 예를 들어, 실체화된 병렬 데이터 객체들은 데이터 또는 병렬 데이터 객체의 엘리먼트들을 포함하는 데이터 구조일 수 있다.

이러한 측면의 구현은 하나 이상의 다음과 같은 특징들을 포함할 수 있다. 예를 들어, 지연 컴바이닝 병렬 데이터 연산들은 적어도 하나의 일반화된 맵리듀스 연산을 포함할 수 있다. 일반화된 맵리듀스 연산은 다수의 병렬 맵 연산 및 다수의 병렬 리듀스 연산을 포함할 수 있으며 다수의 병렬 맵 연산을 구현하는 단일 맵 함수와 다수의 병렬 리듀스 연산을 구현하는 단일 리듀스 함수를 포함하는 단일 맵리듀스 연산으로 번역가능할 수 있다. 일반화된 맵리듀스 연산을 실행하는 것은 컴바이닝 맵 리듀스 연산을 단일 맵리듀스 연산으로 번역하는 것과 이 단일 맵리듀스 연산을 실행하는 것을 포함할 수 있다. 단일 맵리듀스 연산을 실행하는 것은 단일 맵리듀스 연산이 로컬 순차 연산으로 실행되어야 하는지 원격 병렬 연산으로 실행되어야 하는지를 결정하는 것을 포함할 수 있다. 일반화된 맵리듀스 연산을 단일 맵리듀스 연산으로 번역하는 것은 다수의 맵 연산을 포함하는 맵 함수와 다수의 리듀서 연산을 포함하는 리듀서 함수를 생성하는 것을 포함할 수 있다.

다수의 병렬 데이터 객체들은 호스트 프로그래밍 언어의 제1 클래스 객체들일 수 있다.

또한, 파이프라인은 단일 엘리먼트를 포함하는 단일 데이터 객체를 포함할 수 있으며 데이터플로우 그래프는 대응하는 지연 단일 데이터 객체를 포함한다. 파이프라인 내의 다수의 병렬 연산들 중 적어도 하나는 단일 데이터 객체 및 다수의 병렬 데이터 객체 중 하나에 대해 연산할 수 있고 데이터플로우 그래프는 지연 단일 데이터 객체 및 지연 병렬 데이터 객체에 대해 연산하는 대응하는 지연 병렬 연산을 포함할 수 있다.

방법은 미래의 데이터 병렬 파이프라인 실행에 사용하기 위해 지연 컴바이닝 병렬 연산들의 하나 이상의 실행 결과를 캐싱하는 것을 포함할 수 있다.

다른 측면에서, 방법은 하나 이상의 프로세싱 장치와 하나 이상의 스토리지 장치를 포함한다. 스토리지 장치는 하나 이상의 프로세싱 장치에 의해 실행될 때 익스큐터를 구현하는 명령들을 저장한다. 익스큐터는 지연 병렬 데이터 객체들 및 지연 컴바이닝 병렬 데이터 연산들을 포함하는 데이터플로우 그래프를 액세스하도록 구성된다. 예를 들어, 지연 병렬 데이터 객체들은 병렬 데이터 객체에 저장된 엘리먼트들이 아니라 병렬 데이터 객체들에 대해 연산하는 병렬 데이터 연산에 대한 포인터를 포함하는 데이터 구조일 수 있다. 예를 들어, 지연 병렬 연산들은 지연 병렬 연산으로의 입력인 병렬 데이터 객체에 대한 포인터, 지연 병렬 연산의 출력인 지연 병렬 객체에 대한 포인터, 및 입력 객체에 대해 수행되는 (그러나 아직 미존재) 함수를 포함하는 데이터 구조일 수 있다.

익스큐터는 지연 병렬 데이터 객체들에 대응하는 실체화된 병렬 데이터 객체들을 생성하기 위해 지연 컴바이닝 병렬 연산들을 실행하도록 구성된다. 예를 들어, 실체화된 병렬 데이터 객체들은 데이터 또는 병렬 데이터 객체의 엘리먼트들을 포함하는 데이터 구조일 수 있다. 지연 컴바이닝 병렬 연산들 중 적어도 하나에 대해, 익스큐터는 적어도 하나의 지연 컴바이닝 병렬 연산과 연관된 데이터의 추정 크기를 결정하고, 추정 크기가 임계 크기를 초과하는지를 판정하고, 만약 추정 크기가 임계 크기 아래라면 적어도 하나의 지연 컴바이닝 병렬 연산을 로컬 순차 연산으로서 실행하고, 만약 추정 크기가 임계 크기를 초과한다면 적어도 하나의 지연 컴바이닝 병렬 연산을 원격 병렬 연산으로서 실행함으로써 적어도 하나의 지연 컴바이닝 병렬 연산들을 실행하도록 구성된다.

이러한 측면의 구현은 하나 이상의 다음과 같은 특징을 포함할 수 있다. 예를 들어, 적어도 하나의 지연 컴바이닝 병렬 연산들과 연관된 데이터는 적어도 하나의 지연 컴바이닝 병렬 연산에 대한 하나 이상의 입력 데이터, 적어도 하나의 지연 컴바이닝 병렬 연산에 의해 생성되는 중간 데이터(intermediary data), 또는 적어도 하나의 지연 컴바이닝 병렬 연산에 의해 생성되는 출력 데이터를 포함할 수 있다. 적어도 하나의 지연 컴바이닝 병렬 데이터 연산은 일반화된 맵리듀스 연산일 수 있다. 일반화된 맵리듀스 연산은 다수의 병렬 맵 연산과 다수의 병렬 리듀스 연산을 포함할 수 있으며 다수의 병렬 맵 연산을 구현하는 단일 맵 함수와 다수이 병렬 리듀스 연산을 구현하는 단일 리듀스 함수를 포함하는 단일 맵리듀스 연산으로 번역될 수 있다. 일반화된 맵리듀스 연산을 실행하기 위해, 익스큐터는 컴바이닝 맵리듀스 연산을 단일 맵리듀스 연산으로 번역하여 이 단일 맵리듀스 연산을 실행하도록 구성될 수 있다. 단일 맵리듀스 연산을 원격 병렬 연산으로서 실행하기 위해, 익스큐터는 단일 맵리듀스 연산이 카피되어 데이터 센터 내의 다수의 상이한 프로세싱 모듈 상에서 실행되도록 구성될 수 있다. 일반화된 맵리듀스 연산을 단일 맵리듀스 연산으로 번역하기 위해, 익스큐터는 다수의 맵 연산을 포함하는 맵 함수화 다수의 리듀서 연산을 포함하는 리듀서 함수를 생성하도록 구성될 수 있다. 추정 크기를 결정하기 위해, 익스큐터는 적어도 하나의 지연 컴바이닝 병렬 연산과 연관된 데이터의 크기 추정치를 반영하는 데이터플로우 그래프 내의 주석 달기(annotations)를 액세스하도록 구성될 수 있다.

또 다른 측면에서, 방법은 지연 병렬 데이터 객체들 및 지연 컴바이닝 병렬 연산들을 포함하는 데이터플로우 그래프를 액세스하는 것을 포함한다. 예를 들어, 지연 병렬 데이터 객체들은 병렬 데이터 객체 내에 저장된 엘리먼트들이 아니라 병렬 데이터 객체들에 대해 연산하는 병렬 데이터 연산에 대한 포인터를 포함하는 데이터 구조일 수 있다. 예를 들어, 지연 병렬 연산들은 지연 병렬 연산으로의 입력인 병렬 데이터 객체에 대한 포인터, 지연 병렬 연산의 출력인 지연 병렬 객체에 대한 포인터, 및 입력 객체에 대해 수행되는 (그러나 아직 미존재) 함수를 포함하는 데이터 구조일 수 있다.

또한, 방법은 지연 병렬 데이터 객체 대응하는 실체화된 병렬 데이터 객체들을 생성하도록 지연 컴바이닝 병렬 연산들을 실행하는 것을 포함한다. 예를 들어, 실체화된 병렬 데이터 객체들은 데이터 또는 병렬 데이터 객체의 엘리먼트들을 포함하는 데이터 구조일 수 있다. 적어도 하나의 지연 컴바이닝 병렬 연산에 대해, 적어도 하나의 지연 컴바이닝 병렬 연산을 실행하는 것은 적어도 하나의 지연 컴바이닝 병렬 연산들과 연관된 데이터의 추정 크기를 결정하고; 이 추정 크기가 임계 크기를 초과하는지를 판정하고; 추정 크기가 임계 크기 아래라면 적어도 하나의 지연 컴바이닝 병렬 연산을 로컬 순차 연산으로서 실행하고; 추정 크기가 임계 크기를 초과한다면 적어도 하나의 지연 컴바이닝 병렬 연산을 원격 병렬 연산으로서 실행하는 것을 포함한다.

이러한 측면의 구현은 하나 이상의 다음과 같은 특징을 포함할 수 있다. 예를 들어, 적어도 하나의 지연 컴바이닝 병렬 연산과 연관된 데이터는 적어도 하나의 지연 컴바이닝 병렬 연산에 대한 하나 이상의 입력 데이터, 적어도 하나의 지연 컴바이닝 병렬 연산에 의해 생성되는 중간 데이터, 또는 적어도 하나의 지연 컴바이닝 병렬 연산에 의해 생성되는 출력 데이터를 포함할 수 있다. 적어도 하나의 지연 컴바이닝 병렬 연산은 일반화된 맵리듀스 연산일 수 있다. 이 일반화된 맵 리듀스 연산은 다수의 병렬 맵 연산과 다수의 병렬 리듀스 연산을 포함할 수 있으며 다수의 병렬 맵 연산을 구현하는 단일 맵 함수와 다수의 병렬 리듀스 연산을 구현하는 단일 리듀스 함수를 포함하는 단일 맵리듀스 연산으로 번역가능할 수 있다. 일반화된 맵리듀스 연산을 실행하는 것은 컴바이닝 맵리듀스 연산을 단일 맵리듀스 연산으로 번역하여 이 단일 맵리듀스 연산을 실행하는 것을 포함할 수 있다. 단일 맵리듀스 연산을 원격 병렬 연산으로서 실행하는 것은 단일 맵리듀스 연산이 카피되어 데이터 센터 내의 다수의 상이한 프로세싱 모듈 상에서 실행되도록 하는 것을 포함할 수 있다. 일반화된 맵리듀스 연산을 단일 맵리듀스 연산으로 번역하는 것은 다수의 맵 연산을 포함하는 맵 함수와 다수의 리듀서 연산을 포함하는 리듀서 함수를 생성하는 것을 포함할 수 있다. 추정 크기를 결정하는 것은 적어도 하나의 지연 컴바이닝 병렬 연산과 연관된 데이터의 크기 추정치를 반영하는 데이터플로우 그래프 내의 주석 달기를 액세스하는 것을 포함할 수 있다.

한 측면에서, 시스템은 하나 이상의 프로세싱 장치와 하나 이상의 스토리지 장치를 포함한다. 스토리지 장치는 하나 이상의 프로세싱 장치에 의해 실행될 때 익스큐터를 구현하는 명령들을 저장한다. 익스큐터는 지연 병렬 데이터 객체 및 지연 컴바이닝 병렬 연산들을 포함하는 데이터플로우 그래프를 액세스하도록 구성된다. 예를 들어, 지연 병렬 데이터 객체들은 병렬 데이터 객체 내에 저장되는 엘리먼트들이 아니라 병렬 데이터 객체에 대해 연산하는 병렬 데이터 연산에 대한 포인터를 포함하는 데이터 구조일 수 있다. 예를 들어, 지연 병렬 연산들은 지연 병렬 연산으로의 입력인 병렬 데이터 객체에 대한 포인터, 지연 병렬 연산의 출력인 지연 병렬 객체에 대한 포인터, 및 입력 객체에 대해 수행되는 (그러나 아직 미존재) 함수를 포함하는 데이터 구조일 수 있다.

적어도 하나의 지연 컴바이닝 병렬 연산은 일반화된 맵리듀스 연산이다. 일반화된 맵리듀스 연산은 다수의 병렬 맵 연산과 다수의 병렬 리듀스 연산을 포함하며 다수의 병렬 맵 연산을 구현하는 단일 맵 함수와 다수의 병렬 리듀스 연산을 구현하는 단일 리듀스 함수를 포함하는 단일 맵리듀스 연산으로 번역가능하다.

또한, 익스큐터는 지연 병렬 데이터 객체에 대응하는 실체화된 병렬 데이터 객체를 생성하기 위해 지연 컴바이닝 병렬 연산들을 실행하도록 구성된다. 예를 들어, 실체화된 병렬 데이터 객체들은 데이터 또는 병렬 데이터 객체의 엘리먼트들을 포함하는 데이터 구조일 수 있다. 일반화된 맵리듀스 연산을 실행하기 위해, 익스큐터는 컴바이닝 맵리듀스 연산을 단일 맵리듀스 연산으로 번역하여 이 맵리듀스 연산을 실행하도록 구성된다.

이러한 측면의 구현은 하나 이상의 다음과 같은 특징을 포함할 수 있다. 예를 들어, 일반화된 맵리듀스 연산을 단일 맵리듀스 연산으로 번역하기 위해, 익스큐터는 다수의 맵 연산을 포함하는 맵 함수와 다수의 리듀스 연산을 포함하는 리듀스 함수를 생성하도록 구성될 수 있다.

익스큐터는 단일 맵리듀스 연산을 원격 병렬 연산으로서 실행하도록 구성될 수 있다. 단일 맵리듀스 연산을 원격 병렬 연산으로서 실행하기 위해, 익스큐터는 단일 맵리듀스 연산이 다수의 상이한 프로세싱 모듈 상의 다수의 워커 프로세스에 의해 실행되도록 구성될 수 있다. 다수의 워커 프로세스에 의해 단일 맵리듀스 연산이 실행되도록 하기 위해, 익스큐터는 맵 연산 각각에 대해 다수의 맵 워커 프로세스 각각이 호출되도록 구성될 수 있는데, 여기서 다수의 맵 워커 프로세스 각각에 인덱스 넘버가 할당된다. 맵 워커 프로세스들 각각은 다수의 맵 연산을 구현하는 맵 함수, 맵 연산들 중 하나와 연관된 하나 이상의 입력, 및 맵 워커 프로세스의 연관된 인덱스를 수신하고, 맵 워커 프로세스의 연관된 인덱스를 기초로 입력들과 연관된 맵 연산을 선택하여, 하나 이상의 입력에 대해 선택된 맵 연산을 호출하도록 구성될 수 있다.

다수의 워커 프로세스에 의해 단일 맵리듀스 연산이 실행되도록 하기 위해, 익스큐터는 다수의 리듀스 쿼어 프로세스가 리듀스 연산들 각각에 대해 호출되도록 구성될 수 있는데, 여기서 다수의 리듀스 워커 프로세스 각각에 인덱스 넘버가 할당된다. 다수의 리듀스 워커 프로세스들 각각은 다수의 리듀스 연산을 구현하는 리듀스 함수, 리듀스 연산들 중 하나와 연관된 하나 이상의 입력, 및 리듀스 워커 프로세스의 연관된 인덱스를 수신하고, 워커 프로세스의 연관 인덱스를 기초로 입력과 연관된 리듀스 연산을 선택하여, 하나 이상의 입력에 대해 선택된 리듀스 연산을 호출하도록 구성될 수 있다.

또 다른 측면에서, 방법은 지연 병렬 데이터 객체들 및 지연 컴바이닝 병렬 연산들을 포함하는 데이터플로우 그래프를 액세스하는 것을 포함한다. 예를 들어, 지연 병렬 데이터 객체들은 병렬 데이터 객체 내에 저장된 엘리먼트들이 아니라 병렬 데이터 객체들에 대해 연산하는 병렬 데이터 연산에 대한 포인터를 포함하는 데이터 구조일 수 있다. 예를 들어, 지연 병렬 연산들은 지연 병렬 연산으로의 입력인 병렬 데이터 객체에 대한 포인터, 지연 병렬 연산의 출력인 지연 병렬 객체에 대한 포인터, 및 입력 객체에 대해 수행되는 (그러나 아직 미존재) 함수를 포함하는 데이터 구조일 수 있다.

적어도 하나의 지연 컴바이닝 병렬 연산은 일반화된 맵리듀스 연산이다. 일반화된 맵리듀스 연산은 다수의 병렬 맵 연산과 다수의 병렬 리듀스 연산을 포함하며 다수의 병렬 맵 연산을 구현하는 단일 맵 함수와 다수의 병렬 리듀스 연산을 구현하는 단일 리듀스 함수를 포함하는 단일 맵리듀스 연산으로 번역가능하다.

또한, 방법은 지연 병렬 데이터 객체들에 대응하는 실체화된 병렬 데이터 객체들을 생성하도록 지연 컴바이닝 병렬 연산들을 실행하는 것을 포함한다. 예를 들어, 실체화된 병렬 데이터 객체들은 데이터 또는 병렬 데이터 객체의 엘리먼트들을 포함하는 데이터 구조일 수 있다. 일반화된 맵리듀스 연산을 실행하는 것은 컴바이닝 맵리듀스 연산을 단일 맵리듀스 연산으로 번역하여 이 단일 맵리듀스 연산을 실행하는 것을 포함한다.

이러한 측면의 구현은 하나 이상의 다음과 같은 특징을 포함할 수 있다. 예를 들어, 일반화된 맵리듀스 연산을 단일 맵리듀스 연산으로 번역하는 것은 다수의 맵 연산을 포함하는 맵 함수와 다수의 리듀스 연산을 포함하는 리듀스 함수를 생성하는 것을 포함할 수 있다. 단일 맵리듀스 연산을 실행하는 것은 단일 맵리듀스 연산을 원격 병렬 연산으로서 실행하는 것을 포함할 수 있다. 단일 맵리듀스 연산을 원격 병렬 연산으로서 실행하는 것은 다수의 상이한 프로세싱 모듈 상에서 다수의 워커 프로세스에 의해 단일 맵리듀스 연산이 실행되도록 하는 것을 포함할 수 있다.

다수의 워커 프로세스에 의해 단일 맵리듀스 연산이 실행되도록 하는 것은 맵 연산들 각각에 대해 다수의 맵 워커 프로세스가 호출되도록 하는 것을 포함할 수 있는데, 여기서 다수의 맵 워커 프로세스 각각에 인덱스 넘버가 할당된다. 맵 워커 프로세스들 각각은 다수의 맵 연산을 구현하는 맵 함수, 맵 연산들 중 하나와 연관된 하나 이상의 입력, 및 맵 워커 프로세스의 연관된 인덱스를 수신하고, 맵 워커 프로세스의 연관된 인덱스를 기초로 입력들과 연관된 맵 연산을 선택하여, 하나 이상의 입력에 대해 선택된 맵 연산을 호출하도록 구성될 수 있다.

단일 맵리듀스 연산이 다수의 워커 프로세스에 의해 실행되도록 하는 것은 리듀스 연산들 각각에 대해 다수의 리듀스 워커 프로세스가 호출되도록 하는 것을 포함할 수 있는데, 여기서 다수의 리듀스 워커 프로세스들 각각에 인덱스 넘버가 할당된다. 다수의 리듀스 워커 프로세스들 각각은 다수의 리듀스 연산을 구현하는 리듀스 함수, 리듀스 연산들 중 하나와 연관된 하나 이상의 입력, 및 리듀스 워커 프로세스의 연관된 인덱스를 수신하고, 워커 프로세스의 연관된 인덱스를 기초로 입력들과 연관된 리듀스 연산을 선택하여, 하나 이상의 입력에 대해 선택된 리듀스 연산을 호출하도록 구성될 수 있다.

상술한 기술의 구현은 하드웨어, 시스템, 방법 또는 프로세스, 또는 컴퓨터 액세스 가능 매체 상의 컴퓨터 소프트웨어를 포함할 수 있다.

하나 이상의 구현에 대한 세부사항들은 첨부된 도면과 후술되는 설명에 제시되어 있다. 다른 특징들은 상세한 설명 및 도면과 특허청구의 범위로부터 명백할 것이다.

도 1은 데이터 센터의 예를 도시한 블럭도.
도 2는 프로세싱 모듈의 예의 블럭도.
도 3은 파이프라인 라이브러리(pipeline library)의 예를 도시한 블럭도.
도 4a는 익스큐터(executor), 옵티마이저(optimizer), 및 파이프라인 라이브러리 익스큐터에 의해 실행될 수 있는 프로세스의 예를 도시한 흐름도.
도 4b는 파이프라인 라이브러리의 익스큐터에 의해 실행될 수 있는 프로세스의 예를 도시한 흐름도.
도 5a 및 도 5b는 ParallelDo 프로듀서-컨슈머 퓨전(producer-consumer fusion) 및 사이블링 퓨전(sibling fusion)을 도시한 예시적인 데이터플로우 그래프 변환을 도시한 도면.
도 6a 및 도 6b는 MSCR 퓨전을 도시한 예시적인 데이터플로우 그래프 변환을 도시한 도면.
도 7a 내지 도 7e는 최종 데이터 흐름도를 생성하도록 수행된 데이터플로우 그래프 변환의 예를 도시한 도면.
도 8은 3개의 입력 채널을 갖는 MSCR 연산의 예를 도시한 도면.
도 9는 파이프라인 라이브러리를 서비스로서 구현하는데 사용될 수 있는 시스템의 예를 도시한 도면.
도 10은 데이터 병렬 파이프라인을 포함하는 비신뢰 어플리케이션을 실행하기 위한 프로세스의 예를 도시한 흐름도.

기본적으로, 본 명세서에 기재된 기술은 대규모 데이터 처리, 특히 대규모 데이터-병렬 파이프라인에 적용될 수 있다. 이러한 대규모 처리는 데이터 센터 또는 데이터 센터 네트웍과 같은 분산 데이터 처리 시스템에서 수행될 수 있다. 예를 들어, 대규모 인터넷 서비스 및 이러한 서비스를 지원하는 초병렬 컴퓨팅 시설(massively parallel computing infrastructure)은 수천 또는 수만의 컴퓨팅 노드로 구성된 창고 크기의 컴퓨팅 시스템을 채용할 수 있다.

도 1은 데이터 센터(100)의 예를 도시한 블럭도이다. 이 데이터 센터(100)는 데이터를 저장하고, 연산 업무(computational tasks)를 수행하고, 예를 들어, 데이터 센터에 연결된 네트웍을 사용하여 데이터 센터 외부의 다른 시스템으로 데이터를 전송하는데 이용된다.

데이터 센터(100)는 다수의 랙(rack, 102)을 포함한다. 단지 두개의 랙이 도시되어 있지만, 데이터 센터(100)는 다수의 랙을 포함할 수 있다. 각각의 랙(102)은 프로세싱 모듈(104)과 같은 구성 부품이 설치되는 프레임 또는 캐비넷을 포함할 수 있다. 일반적으로, 각각의 프로세싱 모듈(104)은 데이터 처리를 수행하도록 다양한 컴퓨터 관련 구성 부품들이 설치되는 마더보드와 같은 회로 보드를 포함할 수 있다. 각각의 랙(102) 내의 프로세싱 모듈(104)은 예를 들어, 랙 스위치를 통해 서로 상호접속되어 있으며, 또한 각각의 데이터 센터(100) 내의 랙(102)은 예를 들어, 데이터 센터 스위치를 통해 상호접속되어 있다.

몇몇의 구현에서, 프로세싱 모듈(104)은 각각 마스터 또는 슬레이브의 역할을 취할 수 있다. 마스터 모듈은 스케줄링(scheduling)과 그들 사이의 데이터 분배 업무(data distribution tasks) 및 슬레이브를 제어한다. 랙이 하나 이상의 프로세싱 모듈(104)에 의해 공유되는 스토리지(storage, 예를 들어, 하나 이상의 네트웍 연결 디스크-network attached disks)를 포함 및/또는 각각의 프로세싱 모듈(104)은 그 자신의 스토리지를 포함할 수 있다. 추가적으로, 또는 대안으로, 네트웍을 통해 랙들에 연결되는 원격 스토리지가 존재할 수 있다.

데이터 센터(100)는 모뎀, 브릿지, 라우터, 스위치, 무선 안테나 및 타워 등과 같은 지원 하드웨어 뿐만 아니라, 전용 광 링크 또는 다른 전용 통신 채널을 포함할 수 있다. 데이터 센터(100)은 다수의 근거리 통신망(LAN) 분만 아니라 하나 이상의 원거리 통신망(WAN)을 포함할 수 있다.

도 2는 하나 이상의 프로세싱 모듈(104)을 위해 이용될 수 있는 프로세싱 모듈(200)의 예를 도시한 블럭도이다. 프로세싱 모듈(200)은 메모리(202), 하나 이상의 프로세싱 유닛(CPU, 204), 및 하나 이상의 네트웍 또는 다른 통신 인터페이즈(206)를 포함한다. 이러한 구성 부품은 하나 이상의 통신 버스에 의해 상호접속되어 있다. 몇몇의 구현에서, 프로세싱 모듈(200)은 디스플레이 및 키보드와 같은 입력 및 출력 장치들에 프로세싱 모듈을 연결시키는 입력/출력(I/O) 인터페이즈를 포함할 수 있다. 메모리(202)는 고속 랜덤 엑세스 메모리를 포함할 수 있으며, 또한 하나 이상의 자기 디스크 스토리지 장치와 같은 불휘발성 메모리를 포함할 수 있다. 메모리(202)는 CPU(204)로부터 원격 배치된 대용량 스토리지(mass storage)를 포함할 수 있다.

메모리(202)는 응용 소프트웨어(202a), 맵리듀스 라이브러리(mapreduce library, 202b), 파이프라인 라이브러리(202c), 및 운영 체제(202d, 예를 들어, 리눅스)를 저장하고 있다. 운영 체제(202d)는 일반적으로 다양한 기본 시스템 서비스를 핸들링하고 하드웨어 종속 업무(hardware dependent tasks)를 수행하기 위한 프로시저들(procedures)을 포함한다. 응용 소프트웨어(202a)는 대규모 데이터 처리를 수행한다.

라이브러리(202b 및 202c)는 대규모 데이터 처리를 수행하고 이러한 대규모 데이터 처리 시에 데이터-병렬 파이프라인을 구현하도록 응용 소프트웨어(202a)에 의해 사용될 수 있는 함수 및 클래스를 제공한다. 맵리듀스 라이브러리(202b)는 대량의 데이터를 병렬로 처리하기 위한 맵리듀스 프로그래밍 모델(MapReduce programming model)을 지원할 수 있다. 맵리듀스 모델은 예를 들어, "MapReduce: Simplified Data Processing on Large Clusters, OSDI'04: Sixth Symposium on Operating System Design and Inmplementation, Sasn Francisco, CA, December, 2004" 및 미국 특허 제7,650,331호에 기술되어 있으며, 이들은 본 명세서에 참조로 포함되어 있다.

일반적으로, 맵리듀스 모델은 애플리케이션 개발자에게 그들의 계산(computation)에 대해 생각하는 방법에 대한 추상화(abstraction)를 제공한다. 어플리케이션 개발자는 대규모 병렬-데이터 처리를 수행하기 위한 프로그램의 개발을 간소화할 수 있는 추상화에 따라 그들의 계산을 공식화(formulate)할 수 있다. 어플리케이션 개발자는 맵리듀스 라이브러리(202b)를 사용하거나 사용하지 않고 맵리듀스 모델을 채용할 수 있다. 그러나, 맵리듀스 라이브러리(202b)는 다수의 어려운 로우 레벨 업무(low-level tasks)를 관리할 수 있다. 이러한 로우 레벨 업무는 예를 들어, 적절한 병렬 워커 머신(parallel worker machines)을 선택하고, 그들에게 실행하도록 프로그램을 분배하고, 일시적인 저장 및 3 페이즈(phases) 사이의 중간 데이터의 흐름을 관리하고, 페이즈의 전체 시퀀싱(sequencing)을 동기화하고, 머신, 네트웍, 및 소프트웨어의 일시적인 오류(transient failures)에 대처하는 것을 포함할 수 있다.

맵리듀스 모델은 일반적으로 연산을 단일 맵 연산과 단일 리듀스 연산을 포함하는 맵리듀스 연산으로 분할(break down)하는 것을 포함한다. 맵 연산은 한 셋의 중간 키/값 쌍(intermediate key/value pairs)을 계산하도록 엽력 내의 논리적인 레코드(records) 각각에 대한 연산을 수행한다. 리듀스 연산은 몇가지 방식으로 값들을 결합하도록 동일 키를 공유하는 값들에 대한 연산을 수행한다.

이러한 모델의 암시(Implicit)는 모든 값들을 동일 키로 그룹화하는 것을 포함하는 셔플 연산(shuffle operation)이다.

맵리듀스 라이브러리(202b)는 맵리듀스 모델에 따라 공식화된 계산을 지원하도록 맵 페이즈(map phase), 셔플 페이즈(shuffle phase), 및 리듀스 페이즈 (reduce phase)를 구현할 수 있다. 몇가지 구현에서, 맵리듀스 라이브러리(202b)를 사용하기 위해, 사용자 프로그램(또는 파이프라인 라이브러리 202c와 같은 다른 라이브러리)은 입력 파일(들)을 식별하는 정보를 지시하는 맵 리듀스 라이브러리 (202b), 출력 데이터를 수신하도록 출력 파일들을 식별하거나 지시하는 정보, 및 두개의 어플리케이션 특정 데이터 프로세싱 연산자인 맵 연산자(map operator)와 리듀스 연산자(reduce operator)를 호출한다. 일반적으로, 맵 연산자는 중간 데이터를 생성하도록 입력 데이터를 처리하는 맵 함수를 지시하며 리듀스 연산자는 중간 데이터 값들을 병합(merge)하거나 그렇지 않으면 결합(combine)하는 리듀스 함수를 지시한다. 다음에, 맵리듀스 라이브러리(202b)는 이러한 정보를 맵 페이즈, 셔플 페이즈, 및 리듀스 페이즈를 구현하는데 사용한다.

맵 페이즈(map phase)는 텍스트 파일, 바이너리 레코드 오리엔티드 파일(binary record-oriented file), 또는 MySql 데이터베이스와 같은 입력 소스로부터의 키/값 쌍들 또는 값들의 수집(collection)을 판독함으로써 시작한다. 다량의 데이터 셋들은 다수의, 심지어 수천의 파일들(이하 "샤드(shards)"라 칭함)에 의해 표현될 수 있으며, 다수의 파일 샤드는 단일 논리 입력 소스로서 판독될 수 있다. 다음에, 이 맵 페이즈는 독립적으로 및 병렬로 각각의 엘리먼트 상에서 사용자 정의 함수, 맵 함수, 또는 맵퍼(Mapper)를 호출(invoke)한다. 각각의 입력 엘리먼트에 대해, 사용자 정의 함수는 맵 페이즈의 출력인 0 또는 그 이상의 키/값 쌍들을 출력(emit)한다.

셔플 페이즈(shuffle phase)는 맵퍼에 의해 출력된 키/값 쌍들을 취하여 동일 키로 모든 키/값 쌍들을 함께 그룹화한다. 다음에 셔플 페이즈는 각각의 디스팅트 키(distinct key) 및 그 키를 사용한 값들의 스트림을 다음 페이즈인 리듀스 페이즈로 출력한다.

리듀스 페이즈(reduce phase)는 독립적으로 및 병렬로 각각의 디스팅트 키 및 값들 그룹(distinct key-and-values group)에 대해 셔플 페이즈에 의해 출력된 키-그룹화 데이터를 취하고 사용자 정의 함수, 리듀스 함수, 또는 리듀서(Reducer)를 호출한다. 각각의 리듀서 호출(Reducer invocation)에서 키 및 그 키와 연관된 모든 값들에 대해 이터레이터(iterator)가 통과되고, 입력 키와 연관시킨 0 또는 그 이상의 대체 값들을 출력한다. 전형적으로 리듀서는 주어진 키를 사용하여 모든 값들에 대해 몇 종류의 취합(aggregation)을 수행한다. 몇몇의 연산에서, 리듀서는 단지 아이덴티티 함수(identity function)이다. 모든 리듀서 호출로부터 출력된 키/값 쌍들은 다음에 출력 싱크(output sink), 예를 들어, 샤드 파일(sharded file) 또는 데이터베이스에 기록된다.

이러한 페이즈들을 구현하기 위해, 맵리듀스 라이브러리(202b)는 입력 조각(pieces)을 M개의 조각(예를 들어, 64 메가바이트 크기의 파일)으로 분할하고 다수의 프로세싱 모듈(104)과 같은 머신들의 클러스터에서 라이브러리(202b)를 사용하는 여러 카피의 프로그램을 실행시킬 수 있다. 카피들 중 하나는 마스터 카피일 수 있으며 나머지는 마스터에 의해 작업이 할당되는 워커 카피(worker copies)일 수 있다. 마스터는 아이들 워커(idle workers)를 선택하고 각 하나의 맵 업무 또는 리듀스 업무를 할당한다. M개의 맵 업무(각각의 입력 조각에 대해 하나)가 존재한다. 맵 업무에 할당된 워커들은 예를 들어, R개의 셋으로 분할되는 중간 결과를 생성하도록 맵퍼를 사용하여 입력에 대해 맵핑 연산을 수행한다. 중간 결과가 R개의 셋으로 분할될 때, 할당된 R개의 리듀스 업무가 존재한다. 리듀스 업무에 할당된 워커는 출력을 생성하기 위해 리듀서를 사용하여 중간 값들에 대해 리듀스 연산을 수행한다. 모든 맵 업무 및 모든 리듀스 업무가 완료되면, 마스터는 사용자 프로그램 또는 맵리듀스 라이브러리(202b)를 사용한 라이브러리를 리턴(return)한다. 그 결과, 맵 리듀스 연산은 프로세싱 장치의 클러스터에 걸쳐 한 세트의 병렬 연산으로서 구현된다.

결합, 교환 연산(associative, commutative operation)을 사용하여 주어진 키로 모든 값들에 대해 제1 컴바이닝을 수행하는 리듀서들에 대해, 개별적인 사용자 정의 컴바이너 함수(separate user-defined Combiner function)가 맵 페이즈 동안에 주어진 키와 연관된 값들의 부분 컴바이닝을 수행하도록 지시될 수 있다. 각각의 맵 워커는 맵퍼로부터 출력되었던 키/값 쌍들의 캐시(cache)를 유지할 수 있으며, 컴바이너 함수를 사용하여 셔플 페이즈로 컴바이닝된 키/값 쌍들을 전달하기 전에 가능한 한 많이 국부적으로 컴바이닝을 수행한다. 리듀서는 상이한 맵 워커들로부터의 값들을 컴바이닝함으로써 컴바이닝 스텝을 완료할 수 있다.

자동적으로, 셔플 페이즈는 각각의 키 및 값들 그룹을 임의로 그러나 결정적으로 선택된 리듀스 워커 머신으로 전달하는데, 이러한 선택은 어느 출력 파일 샤드가 그 키의 결과를 유지할 것인지를 결정한다. 다르게는, 사용자 정의 샤더 함수(user defined Sharder function)에서 어느 리듀스 워커 머신이 주어진 키에 대한 그룹을 수신해야 하는지를 선택하는 것이 지시될 수 있다. 사용자 정의 샤더는 로드 벨런싱(load balancing)을 위해 사용될 수 있다. 사용자 정의 샤더는 또한 출력 키들을 리듀스 "버킷(buckets)"으로 정렬하는데 사용될 수 있는데, i번째 리듀스 워커의 모든 키들은 i+1번째 리듀스 워커의 모든 키들 전에 오더(order)된다. 사전식 순서(lexicographic order)로 각각의 리듀스 워커는 키들을 처리한다는 사실과 함께, 이러한 종류의 샤더는 정렬된 출력을 생성하는데 사용될 수 있다.

파이프라인 라이브러리(202c)는 데이터-병렬 파일프라인을 지원하는 클래스 및 함수, 특히 맵리듀스 연산의 체인 또는 방향성 비사이클 그래프(chains or directed acyclic graphs)를 포함하는 파이프라인을 제공한다. 파이프라인 라이브러리(202c)는 맵리듀스 연산의 체인을 구현하는 몇몇 부담을 완화시키는 것을 도울 수 있다. 일반적으로, 다수의 실세계 계산(real-world computations)은 맵리듀스 스테이지들의 체인을 필요로 한다. 몇몇의 논리 계산이 맵리듀스 연산으로서 표현될 수 있지만, 다른 것들은 맵리듀스 연산의 시퀀스 또는 그래프를 필요로 한다. 논리 계산의 복잡성이 증가함에 따라, 계산을 맵리듀스 연산의 물리적인 시퀀스들로 맵핑하려는 시도가 증가하고 있다. "발생 횟수 카운트(count the number of occurrences)" 또는 키에 의한 테이블 조인(join tables by key)"과 같은 하이 레벨 컨셉(Higher-level concepts)은 일반적으로 로우 레벨 맵 리듀스 연산(lower-level mapreduce operations)으로 핸드 컴파일(hand-compile)된다. 또한, 사용자는 맵리듀스 연산을 적절한 시퀀스에서 호출하도록 드라이버 프로그램을 기록하는 추가 부담을 취할 수 있으며, 데이터를 유지하는 중간 파일들의 생성 및 삭제를 관리한다.

파이프라인 라이브러리(202c)는 데이터 병렬 파이프라인의 개별적인 맵리듀스 스테이지들과 함께 이어지는 추가적인 코디네이션 코드(coordination code)를 생성하도록 하는 개발자에 대한 요구 뿐만 아니라 다수의 맵리듀스 연산을 포함하는 데이터 병렬 파이프라인 생성 시 몇몇의 난점을 제거 또는 감소시킬 수 있다. 파이프라인 라이브러리(202c)는 또한 파이프라인 스테이지들 사이에서 중간 결과의 생성 및 후 삭제를 관리하는 추가적인 작업을 제거 또는 감소시킬 수 있다. 그 결과, 파이프라인 라이브러리(202c)는 논리적인 계산 그 자체가 모든 로우 레벨 코디네이션 세부사항들 (low-level coordination details) 중에 숨겨지게 되는 것을 방지하여 새로운 개발자가 그 계산을 보다 쉽게 이해하게 하는데 도움이 될 수 있다. 더욱이, 파이프라인 라이브러리(202c)의 사용은 파이프라인의 특정한 스테이지들로의 분할이 코드로 "베이크드 인(baked in)"되어 후에 논리 계산이 발전될 필요가 있을 경우 변경시키기 어렵게 되는 것을 방지하는데 도움이 될 수 있다.

일반적으로, 어플리케이션 소프트웨어(202a)는 라이브러리들(202b 또는 202c) 중 하나 또는 둘 모두를 사용할 수 있다. 어플리케이션 개발자는 맵리듀스 연산으로서 공식화된 계산을 수행하도록 맵리듀스 라이브러리(202b)를 사용하는 어플리케이션 소프트웨어를 개발할 수 있다.

대안적으로 또는 추가적으로, 어플리케이션 개발자는 다수의 맵리듀스 연산을 포함하는 데이터 병렬 파이프라인을 개발할 때 파이프라인 라이브러리(202c)를 사용할 수 있다. 하기에서 추가 논의되는 바와 같이, 파이프라인 라이브러리(202c)는 맵리듀스 연산에 관하 논리 계산 선정이나 정렬된 연산 그래프의 구축에 대한 생각 없이, 파이프라인 라이브러리(202c)가 구현되는 네이티브 프로그래밍 언어를 사용하여 보다 자연스러운 방식으로 개발자가 계산을 코딩하도록 할 수 있다. 파이프라인 라이브러리(202c)는 실행 전에 다수의 맵리듀스 연산에 관한 논리적인 계산을 공식화할 수 있으며, 다음에 그 자신이 맵리듀스 연산을 구현하거나 맵리듀스 연산을 구현하도록 맵리듀스 라이브러리(202b)와 인터페이싱함으로써 계산을 실행할 수 있다.

도 3은 파이프라인 라이브러리(202c)를 구현하는데 사용될 수 있는 파이프라인 라이브러리(300)의 예를 도시한 블럭도이다. 파이프라인 라이브러리(300)는 하나 이상의 병렬 데이터 콜렉션 클래스(302), 하나 이상의 병렬 연산(304), 이벨류에이터(evaluator, 306), 옵티마이저(optimizer, 308), 및 익스큐터(executor, 310)를 포함한다. 일반적으로, 병렬 데이터 콜렉션 클래스(302)는 데이터의 콜렉션을 유지하는 병렬 데이터 객체들을 인스턴스화(instantiate)하는데 사용되고, 병렬 연산(304)은 병렬 데이터 객체에 의해 유지되는 데이터에 대한 병렬 연산을 수행하는데 사용된다. 병렬 연산(304)은 데이터 병렬 계산 및 전체 파이프라인을 구현하도록 구성되거나, 심지어 다수의 파이프라인이 병렬 콜렉션 클래스(302) 및 병렬 연산(304)을 사용하여 구현될 수 있다.

병렬 데이터 콜렉션 클래스(302) 및 연산(304)은 다수의 상이한 데이터 표현(representations) 및 상이한 실행 전략에 대해 간단한, 하이 레벨 균일 추상화 (simple, high-level, uniform abstraction)를 제공한다. 병렬 데이터 콜렉션 클래스(302)는 메모리 내 데이터 구조, 하나 이상의 파일, 또는 외부 스토리지 서비스로서 데이터가 표현되는지를 포함하여 어떻게 데이터가 표현되는지에 대한 세부사항을 추상화(abstract away)한다. 유사하게 병렬 연산(304)은 로컬 시퀀셜 루프(sequential loop), 맵리듀스 라이브러리(202b)의 원격 병렬 호출, 데이터베이스 상의 질의, 도는 스트리밍 계산(streaming computation)으로서 연산이 구현되는지와 같은 그 구현 전략을 추상화한다.

이벨류에이터(306)는 병렬 연산을 데이터 병렬 파이프라인이 실행될 때 그들이 지나가는대로 평가하기보다 병렬 연산의 평가를 연기한다. 대신에, 이벨류에이터(306)는 연산 및 그 아규먼트(arguments)를 포함하는 내부 실행 계획 데이터플로우 그래프를 구성한다. 전체 논리 계산에 대한 실행 계획 데이터플로우 그래프가 구성되면, 옵티마이저(308)는 예를 들어, 병렬 연산의 체인들을 보다 작은 수의 컴바이닝된 연산으로 퓨징(fusing) 또는 컴바이닝하는 그래프 변환을 적용함으로써 실행 계획을 수정한다. 수정된 실행 계획은 다수의 병렬 맵 연산 및 다수의 병렬 리듀스 연산(예를 들어, 이하 보다 상세히 기술디는 맵셔플컴바인리듀스 연산)을 포함하지만, 다수의 맵 연산을 구현하는 단일 맵 함수와 다수의 리듀스 연산을 구현하는 단일 리듀스 함수를 사용하는 단일 맵리듀스 연산으로 번역될 수 있는 일반화된 맵리듀스 연산을 포함할 수 있다. 익스큐터(310)는 언더라이닝 프리미티브(underlying primitives)(예를 들어, 맵리듀스 연산)를 사용하여 수정된 연산을 실행한다. 실행 계획이 동작할 때, 익스큐터(310)는 처리되는 데이터의 크기 중 일부에 기초하여 각각의 연산(예를 들어, 로컬 시퀀셜 루프 대 원격 병렬 맵리듀스)을 구현하는데 어느 전략을 사용하는지를 선택할 수 있다. 익스큐터(310)는 또한 그들이 연산하는 데이터 근방에 원격 계산을 배치할 수 있고, 병렬로 독립적인 연산을 수행할 수 있다. 익스큐터(310)는 또한 계산 내에서 요구되는 임의의 중간 파일들의 생성 및 소거를 관리할 수 있다.

파이프라인 라이브러리(300)는 임의의 수의 프로그래밍 언어로 구현될 수 있다. 다음은 Java(R) 프로그래밍 언어로 구현한 예를 기술한다.

파이프라인 라이브러리(300)는 PCollection<T>로 참조되는 병렬 데이터 콜렉션 클래스를 제공하는데, 이는 타입 T 엘리먼트의 불변 백(immutable bag)이다. PColletion은 잘 정의된 순서(well-defined order, "시퀀스"로 칭함)를 가지거나 엘리먼트들이 순서가 정해지지 않을 수 있다.("콜렉션"으로 칭함) 이들은 덜 제한적이기 때문에, 콜렉션은 시퀀스보다 생성 및 처리가 보다 효율적일 수 있다. PCollection<T>는 여러 가능한 포맷 중 하나로 파일을 읽음으로서 생성될 수 있다. 예를 들어, 텍스트 파일은 PCollection<String>으로 읽혀질 수 있으며, 바이너리 레코드 오리엔티드 파일은 각각의 바이너리 레코드를 타입 T의 객체로 어떻게 디코딩하는지에 대한 세부사항을 제공하는 PCollection<T>로서 읽혀질 수 있다. 파이프라인 라이브러리(300)가 Java(R)를 사용하여 구현될 때, PCollection<T>는 또한 매모리 내 Java(R) Collection<T>로부터 생성될 수 있다.

다수의 파일 샤드에 의해 표현되는 데이터 셋은 단일 논리 PCollection으로서 읽혀질 수 있다. 예를 들어:

PCollection<String> lines =

readTextFileCollection("gfs/data/shakes/hamlet.txt");

PPCollection<DocInfo> docInfos =

readRecordFileCollection("/gfs/webdocinfo/part-*",recordsOf(DocInfo.class));

이러한 예에서, recordsOf(...)는 DoCInfo 인스턴스(instance)가 바이너리 레코드로서 인코딩(encoding)특정 방식을 특정한다. 다른 소정의 인코딩 지정자들(predefined encoding specifiers)은 UTF-8-인코딩된 텍스트에 대한 string(), 32비트 정수의 가변 길이 인코딩에 대한 ints(), 및 컴포넌트 (components)의 인코딩으로부터 유도된 쌍들의 인코딩에 대한 pairsOf(e1,e2)를 포함할 수 있다. 몇몇의 구현은 사용자가 그 자신의 커스텀(custom) 인코딩을 특정가능하도록 할 수 있다.

제2 병렬 데이터 콜렉션 클래스(302)는 타입 K의 키 및 타입 V의 값으로 (불변의) 멀티-맵을 표현하는 PTable<K,V>이다. PTable<K,V>는 단지 비정렬 백 쌍들(unordered bag of pairs)일 수 있다. 몇몇의 병렬 연산(304)은 PCollection 쌍들에만 적용할 수 있으며, Java(R)에서 PTable<K,V>는 PCollection<Pair<K,V>>의 서브클래스로서 구현되어 추상화를 캡쳐(capture)할 수 있다. 다른 언어에서, PTable<K,V>는 PCollection<Pair<K,V>>의 타입 동의어(type synonym)로서 정의될 수 있다.

PCollections과 같은 병렬 데이터 객체들은 라이브러리(300)가 구현되는 네이티브 언어의 제1 클래스 객체들로서 구현될 수 있다. 이러한 경우일 때, 객체는 네이티브 언어로 다른 객체들과 같이 조작가능(manipulable)할 수 있다. 예를 들어, PCollections은 언어 내에서 정규 메서드(regular method)으로 통과되고 복귀될 수 있으며, (몇몇의 구현이 PCollections이 다른 PCollections 내에 저장되는 것을 방지할 수 있다해도) 그 언어의 다른 데이터 구조 내에 저장될 수 있다. 또한, 네이티브 언어의 정규 제어 흐름 구성(regular controld flow constructs)은 객체를 포함하는 계산을 정의하는데 사용될 수 있는데, 이는 함수, 조건(conditionals), 및 루프를 포함한다. Java(R)가 네이티브 언어라면 :

Collection<PCollection<T2>> pcs =

new ArrayList<...>();

for (Task task : task) {

PCollection<T1>p1 = ...;

PCollection<T2>p2;

if(isFirstKind(task)) {

p2 = doSomeWork(p1);

} else {

p2 = doSomeOtherWork(p1);

}

pcs.add(p2);

}

개발자는 그 또는 그녀가 다른 객체들을 사용하는 방식으로 병렬 데이터 객체들을 사용할 수 있으므로, 라이브러리(300)의 네이티브 언어로 병렬 데이터 객체를 제1 클래스 객체로서 구현하는 것은 라이브러리를 사용하여 프로그램의 개발을 간소화할 수 있다.

병렬 데이터 콜렉션 클래스들에 추가하여, 파이프라인 라이브러리(300)는 또한 파이프라인의 실행 동안에 PCollections의 컨텐츠(contents)를 검사(inspect)하는 능력을 지원하도록 단일 데이터 콜렉션 클래스 PObject<T>를 포함할 수 있다. 다수의 엘리먼트를 유지하는 PCollection과 반대로, POject<T>는 타입 T의 단일 객체 (예를 들어, 타입 T의 단일 네이티브 객체(예를 들어, Java(R) 객체))에 대한 컨테이너(container)이며, POjectsdml 임의의 연관된 방법이 단일 엘리먼트에 대해 연산하도록 설계된다. PCollections 처럼, POjects는 (후술하는 바와 같이) 지연되거나(defered) 또는 실체화(materialized)되어, 이들이 파이프라인 내에서 지연 연산의 결과로서 계산되도록 할 수 있다. 파이프라인이 실행되면, 현재 실체화 (now-materialized) POject의 컨텐츠는 getValue()를 사용하여 추출될 수 있다.

예를 들어, Java(R)을 사용한 구현에서, asSequentialCollection() 연산은 PCollection<T>에 적용되어 PObject<Collection<T>>를 얻을 수 있는데, 이는 파이프라인이 실행되어 계산된 PCollection의 모든 엘리먼트를 정규 Java(R) 메모리 내 콜렉션으로서 읽을 수 있다면 검사될 수 있다.

PTable<String,Integer> wordCounts = ...;

PObject<Collection<Pair<String,Integer>>> result =

wordCounts.asSequentialCollection();

...

FlumeJava.run();

for(Pair<String,Integer>count : result.getValue()) {

System.out.print(count.first+":"+count.second);

}

다른 예로서, PCollection<T> 및 Ts에 대한 컴바이닝 함수에 적용되는 combine() 연산 (후술함)은 완전히 컴바이닝된 결과를 나타내는 PObject<T>를 얻는다. 총 합계 및 최대치가 이러한 방식으로 계산될 수 있다.

PObjects의 컨텐츠는 또한 파이프라인의 실행에서, 예를 들어, 파이프라인 라이브러리(300)에 의해 제공된 operate() 프리미티브(primitive)를 사용하여 조사될 수 있다. 이 operate() 프리미티브는 PObjects의 리스트 및 아규먼트 OperateFn (각각의 PObject에 대해 수행되는 연산을 정의함)를 취하고, PObjects의 리스트를 리턴(return)한다. 평가될 때, operate()는 현재-실체화된 아규먼트 PObjects의 컨텐츠를 추출하고, 이들을 아규먼트 OperateFn으로 통과시킨다. 이 OperateFn은 Java(R)과 같은 네이티브 객체들의 리스트를 리턴하고, operate()은 결과로서 리턴되는 PObject 내의 네이티브 객체들을 래핑(wrap)한다. 이러한 프리미티브를 사용하여, 임의의 계산이 파이프라인 내에서 구현되고 지연 형태로 실행될 수 있다. 즉, 다수의 엘리먼트를 포함하는 PCollections에 대해 연산하는, ParallelDo 연산(후술함)이 아닌 연산들이 파이프라인 내에 포함될 수 있다. 예를 들어, 다음과 같은 파일들을 읽고 쓰는 외부 서비스에 대한 호출을 사용하는 것을 고려한다 :

// Compute the URLs to crawl:

PCollection<URL> urlsToCrawl = ...;

// Crawl them, via an external service:

PObject<String> fileOfUrlsToCrawl =

urlsToCrawl.viewAsFile(TEXT);

PObject<String> fileOfCrawledDocs =

operate(fileOfUrlsToCrawl, new OperateFn() {

String operate(String fileOfUrlstoCrawl) {

return crawlUrls(fileOfUrlsToCrawl);

}

});

PCollection<DocInfo> docInfos =

readRecordFileCollection(fileOfCrawledDocs, recordsOf(DocInfo.class));

// Use the crawled documents.

이러한 예는 파일명을 포함하는 PObjects과 PCollections 사이의 변환을 위한 연산을 사용한다. PCollection 및 파일 포맷 선택에 적용되는 viewAsFile() 연산은 PCollection의 컨텐츠가 파이프라인 실행 동안에 발견될 수 있는 선택된 포맷의 임시 샤드 파일(temporary sharded file) 이름을 포함하는 PObject<String>을 얻는다. readRecordFileCollection()과 같은 파일 읽기 연산은 오버로드(overload)되어 PObjects에 포함된 이름들의 파일들을 읽도록 한다.

많은 동일 방법에서, PObjects의 컨텐츠는 또한 그들을 parallelDo()로의 사이드 입력(side input)으로서 통과시킴으로써 DoFn (후술함) 내에서 조사될 수 있다. 통상, DoFn은 PCollection의 각각의 엘리먼트에 대한 연산을 수행하고, PCollection을 입력으로서 수신한다. 몇몇의 경우에, 각각의 PCollection에 대한 연산은 PObject 내에 저장되는 값 또는 다른 데이터를 포함할 수 있다. 이러한 경우에, DoFn은 통상 PCollection을 입력으로서, 그리고 PObject를 사이드 입력(side input)으로서 수신한다. 파이프라인이 실행되어 parallelDo() 연산이 결과적으로 평가될 때, 임의의 현재-실체화 PObject 사이드 입력의 컨텐츠가 추출되어 사용자의 DoFn에 제공되고, 다음에 DoFn이 입력 PCollection의 각각의 엘리먼트에 대해 호출되어 PObject(s)로부터의 데이터를 사용하여 엘리먼트에 대해 정의된 연산을 수행한다. 예를 들어:

PCollection<Integer>values = ...;

PObject<Integer>pMaxValue = values.combine(MAX_INTS);

PCollection<DocInfo> docInfos = ...;

PCollection<Strings> results = docInfos.parallelDo(

pMaxValue,

new DoFn<DocInfo,String>() {

private int maxValue;

void setSideInputs(Integer max Value) {

this.maxValue = maxValue;

}

void process(DocInfo docInfo, EmitFn<String> emitFn) {

.... use docInfo and maxValue ...

}

}, collectionOf(string()));

상술한 바와 같이, 데이터-병렬 연산(304)은 PCollection과 같은 병렬 데이터 객체에 대해 호출된다. 파이프라인 라이브러리(300)는 몇몇의 프리미티브 데이터-병렬 연산을 정의하는데, 다른 연산들이 이러한 프리미티브들에 관하여 구현된다. 데이터-병렬 프리미티브들 중 하나는 parallelDo()인데, 이는 새로운 출력 PCollection<S>를 생성하도록 엘리먼트 와이즈(elementwise) 계산을 지원한다. 이러한 연산은 그 메인 아규먼트(main argument)로서 DoFn<T,S>를 취하는데, 이는 입력 PCollection<T> 내의 각각의 값을 0 또는 그 이상의 값들로 맵핑하여 출력 PCollection<S>가 나타나도록 하는 방법을 정의하는 객체 함수(function-like object)이다. 이러한 연산은 또한 그 결과의 생성을 위해 PCollection 또는 PTable 종류의 인디케이션(indication)을 취한다. 예를 들어:

PCollection<String> words =

lines.parallelDo(new DoFn<String,String>() {

void process(String line, EmitFn<String> emitFn) {

for(String word : splitIntoWords(line)) {

emitFn.emit(word);

}

}

}, collectionOf(strings()));

이러한 코드에서, collectionOf(strings())은 parallelDo() 연산이 스트링 엘리먼트가 UTF-8을 사용하여 인코딩되어야 하는 비정렬 PCollection을 생성하여야 하는 것을 지시(specify)한다. 다른 옵션은 정렬된 PCollections에 대한 sequenceOf(elemEncoding) 및 PTables에 대한 tableOf(key Encoding, valueEncoding)을 포함할 수 있다. emitFn은 출력 PCollection에 추가되어야 하는 각각의 outElem에 대한 emitFn.emit(outElem)을 호출하여야 하는 사용자의 프로세스(...) 메서드(process method)로 통과되는 콜백 함수(call-back function)이다. 몇몇의 경우에, 보다 간단한 인터페이즈를 제공하도록 MapFn(맵을 구현) 및 FilterFn(필터를 구현)과 같은 DoFn의 서브클래스들이 포함될 수 있다.

연산 parallelDo()는 맵리듀스 연산의 맵 부분과 리듀스 부분 모두를 표현하는데 사용될 수 있다. 라이브러리(300)는 또한 입력 PCollection의 단일 순환(traversal)로부터 동시에 다수의 출력 PCollection이 생성되도록 하는 parallelDo()의 버전(version)을 포함할 수 있다.

DoFn 함수가 원격으로 분배되고 병렬로 실행될 수 있다면, DoFn 함수는

인클로징 프로그램(enclosing program)의 임의의 전체 변화가능 상태(global mutable state)를 액세스(access)하는 것이 방지될 수 있다. DoFn 객체는 로컬 인스턴스 가변 상태를 유지할 수 있으나, 샤드 상태(shared state)가 아니면서 동시에 동작하는 다수의 DoFn 레플리카(replicas)일 수 있다.

제2 프리미티브인 groupByKey()는 타입 PTable<K,V>의 멀티맵(동일 키로 다수의 키/값 쌍들을 가질 수 있음)을 각각의 키가 그 키를 사용하여 모든 값들의 비정렬 콜랙션으로 맵핑하는 타입 PTable<K,Colleciton<V>>의 유니맵(uni-map)으로 변환한다. 예를 들어, 다음과 같이 URL들을 그들로 링크하는 도큐먼트(documents)의 콜렉션으로 맵핑하는 테이블을 계산한다:

PTable<URL,DocInfo> backlinks =

docInfos.parallelDo(new DoFn<DocInfo,Pair<URL,DocInfo>>() {

void process(DocInfo docInfo, EmitFn<Pair<URL,docInfo>>

emitFn){ for(URL targetUrl : docInfo.getLinks()) {

emitFn.emit(Pair.of(targetUrl, docInfo));

}

}

},tableOf(recordsOf(URL.class),recordsOf(DocInfo.class)));

PTable<URL,Collection<DocInfo>> referringDocInfos =

backlinks.groupByKey();

연산 groupByKey()는 맵리듀스의 셔플 스텝에 대응한다. 또한 각각의 키에 대한 값들의 콜렉션에 대한 정렬 순서를 지시하도록 하는 변형이 있을 수 있다.

제3 프리미티브인 combineValues()는 입력 PTable<K,Collection<V>> 및 Vs에 대한 연관 컴바이닝 함수(associative combining function)를 취하고, 값들의 각각의 입력 컬렉션이 단일 출력 값으로 컴바이닝된 PTable<K,V>를 리턴한다. 예를 들어:

PTable<String,Integer> wordsWithOnes =

words.parallelDo(

new DoFn<String,Pair<String,Integer>>() {

void process(String word,EmitFn<Pair<String,Integer>>emitFn)

{ emitFn.emit(Pair.of(word,1));

}

}, tableOf(strings(),ints()));

PTable<String,Collection<Integer>> groupedWordsWithOnes =

wordsWithOnes.groupByKey();

Ptable<String,Integer> wordCounts =

groupedWordsWithOnes.combineValues(SUM_INTS);

연산 combineValues()는 개략적으로 parallelDo()의 특수한 경우이지만, 컴바이닝 함수의 연관성은 리듀서 내에서 모든 컴바이닝을 수행하는 것보다 효율적일 수 있는 맵리듀스 컴바이너(각각의 맵퍼의 일부로서 실행) 및 맵리듀스 리듀서(컴바이닝을 완료)의 조합을 통해 이 연산이 구현되도록 하는 것을 가능하게 한다.

제4 프리미티브인 flatten()은 PCollection<T>들의 리스트를 취하고 입력 PCollection의 모든 엘리먼트를 포함하는 단일 PCollection<T>를 리턴한다. 연산 flatten()은 실제로 입력을 복사하기 보다, 입력들이 하나의 논리 PCollection이라면 단지 입력들을 열람(view)한다.

전형적으로 파이프라인은 외부 스토리지에 최종 결과 PCollection을 기록하는 연산으로 마무리된다. 예를 들어:

wordCounts.writeToRecordFileTable("/gfs/data/shakes/hamlet-counts.records");

파이프라인 라이브러리(300)는 상술한 프리미티브들에 관하여 유도된 PCollection에 대해 다수의 다른 연산을 포함할 수 있다. 이와 같이 유도된 연산은 사용자가 기록할 수 있는 핼퍼 함수(helper function)와 동일할 수 있다. 예를 들어, count() 연산은 PCollection 취하여 입력 PCollection의 각각의 디스팅트 엘리먼트를 엘리먼트가 발생한 횟수로 맵핑한 PTable<T,Integer>를 리턴한다. 이러한 함수는 위에서 wordCounts를 계산하는데 사용된 것과 동일 패턴을 사용하여 parallelDo(), groupByKey(), 및 combineValues()에 관하여 구현될 수 있다. 상기 코드는 다음과 같이 간소화될 수 있다:

PTable<String,Integer> wordCounts = words.count();

다른 연산 join()은 공통 키 타입을 공유하는 두개 이상의 PTable에 대한 조인(join)을 구현한다. 멀티맵 PTable<K,V1> 및 멀티맵 PTable<K,V2>에 적용될 때, join()은 유니맵 PTable<K,Pair<Collection<V1>,Collecton<V2>>>를 리턴하는데, 이는 입력 테이블 내의 각각의 키를 각각의 키를 제1 테이블 내의 키로 모든 값들의 콜렉션으로 맵핑하거나, 제2 테이블 내의 키로 모든 값들의 콜렉션으로 맵핑한다. 이러한 결과 테이블은 전통적인 내부 또는 외부 조인(inner or outer-join)을 계산하도록 더 처리될 수 있지만, 그 외적(cross-product)의 계산 없이 바로 값 콜렉션들을 조작할 수 있는 것이 보다 효율적일 수 있다.

연산 join()은 다음과 같이 구현될 수 있다:

1. parallelDo()를 각각의 입력 PTable<K,Vi>에 적용하여 그것을 타입 PTable<K, TaggedUnion<V1,V2>>의 공통 포맷으로 변환한다.

2. flatten()을 사용하여 테이블들을 컴바이닝한다.

3. groupByKey()를 플래튼 테이블(flattened table)에 적용하여 PTable<K,Collection<TaggedUnion<V1,V2>>>를 생성한다.

4. parallelDo()를 키-그룹화된 테이블에 적용하여, 각각의 Colleciton<TaggedUnion<V1,V2>>를 Collection<V1> 및 Collection<V2>의 쌍으로 변환한다.

다른 유도되는 연산은 top()인데, 이는 비교 함수와 카운트 N을 취하여 비교 함수에 따라 그 수신자 PCollection의 가장 큰 N개의 엘리먼트를 리턴한다. 이러한 연산은 parallelDo(), groupByKey(), 및 combineValues()의 탑(top)에 대해 구현될 수 있다.

단일 PCollection으로서 다수의 파일 샤드를 읽는 상술한 연산들은 또한 flatten() 및 단일-파일 리드 프리미티브(single-file read primitives)를 사용하여 구현되는 유도된 연산들이다.

상술한 바와 같이, 파이프라인 라이브러리(300)는 지연 평가를 사용하여 병렬 연산을 느리게 실행한다. 그 마지막에, 이벨류에이터(306)는 병렬 연산의 평가를 지연하고, 대신에 연산 및 그 연산의 아큐먼트를 포함하는 내부 실행 계획 데이터플로우 그래프를 구성한다. PCollection과 같은 각각의 병렬 데이터 객체는 내부적으로 지연되거나 (아직 계산되지 않음) 또는 실체화(계산됨) 상태가 표현된다. 예를 들어, 지연 병렬 데이터 객체는 병렬 데이터 객체를 계산하는 지연 연산에 대한 포인터를 유지한다. 차례로, 지연 연산은 지연 연산의 아규먼트 (그 자신들이 지연되거나 실체화될 수 있음)인 병렬 데이터 객체들 및 연산의 결과인 지연 병렬 데이터 객체들에 대한 레퍼런스(references)를 유지할 수 있다. parallelDo()와 같은 라이브러리 연산이 호출될 때, 라이브러리(300)는 ParallelDo 지연 연산 객체를 생성하고 그 연산에 대해 지시(point)하는 새로운 지연 PCollection을 리턴한다. 즉, 데이터 병렬 파이프라인이 실행됨에 따라, 이벨류에이터(306)는 병렬 데이터 객체들 및 병렬 연산들을 지연 (미평가) 객체들 및 연산들의 방향성 비사이클 그래프로 변환한다. 이러한 그래프는 실행 계획 또는 실행 계획 데이터 흐름도로 불릴 수 있다.

옵티마이저(308)는 데이터 흐름도 내의 병렬 연산들의 체인 또는 서브그래프를 모다 작은 수의 연산들(그 몇몇은 컴바이닝된 연산일 수 있음)로 퓨징(fusing)하는데, 여기서 익스큐터(310)는 다음에 언더라이닝 프리미티브나 다른 로직을 사용하여 실행할 수 있다. 옵티마이저(308)는 예를 들어, 일련의 독립적인 그래프 변환으로서 기록될 수 있다. 한 구현에서, 옵티마이저(308)는 가장 적은 MapShuffleCombineReduce(MSCR) 연산을 생성하는 전체 목적으로 전체 연산 및 그룹 연산의 수를 감소시키는 초기 실행 계획에 대한 일련의 패스를 수행한다.

MSCR 연산은 ParallelDo, GroupByKey, CombineValues, 및 Flatten 연산의 조합을 포함한다. MSCR 연산은 단일 맵리듀스 연산으로 맵핑되어 실행될 수 있다. MSCR 연산은 M개의 입력 채널(각각 맵 연산을 수행) 및 R개의 출력 채널(각각 셔플, 컴바이닝, 및 리듀스를 수행)을 갖는다. 각각의 입력 채널 m은 PCollection<T_m>을 입력으로서 취하여 타입 PTable<K_r,V_r>의 R개의 출력을 생성하도록 그 입력에 대해 R-출력 ParallelDo"map" 연산을 수행한다. 각각의 출력 채널 R은 그 M개의 입력을 플래트닝(flattening)하고 다음에 (a) GroupByKey"shuffle", 선택적인 CombineValues"combine", 및 O _r -출력 ParallelDo"reduce" (아이덴티티 연산에 대해 디폴트)를 수행하고 다음에 O _r 개의 출력 PCollection으로 결과를 기록하거나 (b) 입력을 바로 출력으로 기록한다. 전자와 같은 종류의 출력 채널은 "그룹화(grouping)" 채널로서 칭할 수 있으며, 후자와 같은 종류의 출력 채널은 "패스-쓰루(pass-through)" 채널로서 칭할 수 있다. 패스-쓰루 채널은 맵퍼의 출력이 MSCR 연산의 결과가 되도록 할 수 있다.

도 8은 3개의 입력 채널(802a, 802b, 및 802c)로 MSCR 연산(800)의 예를 도시하고 있다. 제1 입력 채널(802a)은 ParallelDo M1(804a)을 수행한다. 제2 입력 채널(802b)은 ParallelDo M2(804b)를 수행한다. 제3 입력 채널(802c)은 ParallelDo M3(804c)를 수행한다. MSCR 연산은 두개의 그룹화 출력 채널(806a 및 806b)을 포함한다. 제1 그룹화 출력 채널(806a)은 GroupByKey GBK1(808a), CombineValues CV1(801a), 및 리듀싱 ParallelDo R1(812a)를 포함한다. 유사하게, 제2 그룹화 출력 채널은 GroupByKey GBK2(808b), CombineValues CV2(810b), 및 리듀싱 ParallelDo R2(812b)를 포함한다. MSCR 연산(808)은 또한 하나의 패스-쓰루 출력 채널(814)을 포함한다.

MSCR은 다수의 맵퍼 및 다수의 리듀서 및 컴바이너를 가능하게 하고, 각각의 리듀서가 다수의 출력을 생성하도록 하며, 리듀서 입력과 동일한 키로 리듀서가 출력을 생성해야 하는 요구사항을 제거하고, 패스-쓰루 출력을 가능하게 함으로써 맵리듀스 모델을 일반화한다. 따라서, 임의의 주어진 MSCR은 각각 상이한 입력에 대해 연산하는 다수의 병렬 맵 연산과 다수의 상이한 출력을 생성하도록 맵 연산의 출력에 대해 연산하는 다수의 리듀스 연산을 포함할 수 있다. 그 표현성 (expressiveness)이 보다 명백해짐에도 불구하고, 각각의 MSCR 연산은 상이한 입력에 대해 맵 연산을 구현하는 단일 맵 함수와 다수의 출력을 생성하도록 리듀스 연산을 구현하는 단일 리두스 함수를 포함하는 단일 맵리듀스 연산을 사용하여 구현될 수 있다.

실행 계획이 옵티마이저(308)에 의해 변경되면, 익스큐터(310)는 수정 실행 계획 데이터플로우 그래프를 실행한다. 한 구현에서, 파이프라인 라이브러리(300)는 배치 실행(batch execution)을 수행한다. 즉, 익스큐터(310)는 순방향 위상적 순서(forward topological order)로 수정 실행 계획의 연산을 순회(traverse)하고, 각각을 차례로 실행한다. 독립적인 연산들이 동시에 실행될 수 있다. 대안적으로, 증가 입력이 신속하고 증가적인 출력의 갱신(update)을 유도하는 입력 파이프라인의 증가 또는 연속 실행이 구현될 수 있다. 또한, 최적화(optimization)는 공통 데이터 소스들에 대해 다수의 사용자에 의해서 실행되는 파이프라인들에 걸쳐 수행될 수 있다.

익스큐터(310)는 연산을 수행하는 적절한 계산을 수행함으로써 MSCR이 아닌 연산들을 수행한다. MSCR들은 다음에 실행되는 단일 맵리듀스 연산으로 맵핑된다.

몇몇의 구현에서, 익스큐터(310)는 먼저 맵리듀스 연산이 국부적 및 순차적으로 실행되어야 하는지, 또는 (예를 들어, 맵리듀스 라이브러리 202b를 사용하여) 원격, 병렬 맵리듀스 연산이 실행되어야 하는지를 결정한다. 원격, 병렬 작업(job)을 개시(launching)하는 오버헤드가 존재하므로, 로컬 평가(local evaluation)가 병렬 처리로부터의 이득이 스타트-업 오버헤드(start-up overheads) 의해 더 커지는 보통 크기의 입력(modest-size inputs)에 사용될 수 있다. 보통 크기 데이터 셋은 개발 및 테스트 동안에 공통적일 수 있다. 그러므로, 이러한 데이터 셋에 대해 로컬 평가를 사용하는 것은 정규 IDE들, 디버거들(debuggers), 프로파일러들(profilers), 및 관련 툴들의 사용을 쉽게 하여, 데이터 병렬 계산을 포함하는 프로그램 개발 업무를 용이하게 한다.

입력 데이터 셋이 커지면 (예를 들어, 64 메가바이트 이상), 익스큐터(310)는 맵리듀스 라이브러리(202b)를 사용하여 원격, 병렬 맵리듀스 연산을 시작하는 것을 선택할 수 있다. 익스큐터(310)는 입력 데이터 크기의 관찰 및 출력 데이터 크기의 추정을 사용하여 자동적으로 타당한 수의 병렬 워커 머신을 선택할 수 있다. 사용자는 예를 들어, 그 DoFn에 의해 표현되는 계산을 기초로, 입력 데이터 크기에 대한 출력 데이터 크기의 예상 비율을 리턴하는 메서드(method)로 DoFn을 확장함으로써, 출력 데이터 크기의 추정을 도울 수 있다. 추정은 관찰된 출력 데이터 크기의 동적인 감시 및 피드백을 통해 개선(refine)될 수 있다. 상대적으로 더 많은 병렬 워커(worker)들이 CPU 대 I/O의 비가 높은 일(jobs)에 할당될 수 있다.

익스큐터(310)는 각각의 실행되는 연산의 출력을 유지하도록 자동적으로 임시 파일을 생성할 수 있다. 파이프라인이 완료되면, 이러한 모든 임시 파일이 자동적으로 삭제될 수 있다. 대안적으로 또는 추가적으로, 이러한 임시 파일들 중 몇몇 또는 전부가 그들이 후에 파이프라인 내에서 더이상 필요하지 않게 되는 즉시 삭제될 수 있다.

일반적으로, 파이프라인 라이브러리(300)은 파이프라인 라이브러리가 설계되었던 네이티브 언어의 정규 프로그램을 실행하는 것과 가능한 한 유사하게 파이프라인 필(pipelines feel)을 구축하고 실행하도록 설계될 수 있다. 네이티브 언어가 Java(R)일 때, 중간 크기 입력에 대해 로컬, 순차 평가를 사용하는 것이 그렇게 하는 한가지 방법이다. 다른 방법은 대응하는 원격 맵리듀스 워커로부터 메인 프로그램의 출력 스트림으로의 디버깅 프린트(debugging prints)와 같은 사용자의 DoFn 내로부터의 System.out 또는 System.err로 임의의 출력을 자동적으로 라우팅(routing)하는 것이다. 마찬가지로, 원격 맵리듀스 워커 상에서 실행되는 DoFn 내에 던져진 임의의 예외가 캡쳐되어, 메인 프로그램으로 전달되고, 다시 던져진다.(rethrown)

라이브러리(300)는 캐싱된 실행 모드를 지원할 수 있다. 이러한 모드에서는, 연산을 재계산하기 보다, 익스큐터(310)는 먼저 그것이 (내부 또는 사용자-가시) 파일 내에 저장되어 있고 익스큐터(310)가 그 연산 결과가 변화되지 않았다고 판정한다면 이전 실행으로부터의 그 연산 결과를 재사용하려는 시도를 한다. (a) 연산의 입력이 변화되지 않고 (b) 연산의 코드 및 캡쳐된 상태가 변화되지 않았다면 연산의 결과가 변화되지 않은 것으로 고려될 수 있다. 익스큐터(310)는 이전 결과의 재사용이 안전한 것으로 보장될 경우를 식별하도록 자동, 보존 분석(automatic, conservative analysis)을 수행할 수 있다. 캐싱은 통상 시간이 걸리는 파이프라인들에 대해서도 신속한 편집-컴파일-실행-디버깅 사이클을 유도할 수 있다. 이는 늦은 파이프라인 스테이지에서 버그를 찾고, 프로그램을 수정(fix)하고, 다음에 스크래치로부터 수정된 파이프라인을 재실행하는데 필요한 시간량을 감소시킬 수 있다.

도 4a는 이벨류에이터(306), 옵티마이저(308), 및 익스큐터(310)에 의해 수행될 수 있는 프로세스(400)의 예를 도시한 흐름도이다. 다수의 병렬 데이터 객체와 그 객체에 대해 연산하는 다수의 병렬 데이터 연산을 포함하는 데이터 병렬 파이프라인을 기초로, 이벨류에이터(306)는 데이터 병렬 파이프라인에 대응하는 지연 병렬 데이터 객체 및 지연 병렬 연산의 데이터 흐름도를 생성한다(402). 상술한 바와 같이, 지연 병렬 데이터 객체는 아직 계산되지 않은 것이고 지연 병렬 연산은 실행되지 않은 것이다. 예를 들어, 병렬 데이터 객체를 데이터 병렬 파이프라인에서 접하게 됨에 따라, 이벨류에이터(306)는 병렬 데이터 객체에 대해 연산하는 병렬 데이터 연산에 대한 포인터를 유지하는 데이터 구조를 생성할 수 있다. 유사하게, 병렬 데이터 연산을 접하게 됨에 따라, 이벨류에이터(306)는 지연 병렬 연산으로의 입력인 병렬 데이터 객체에 대한 포인터와 지연 병렬 연산의 출력인 지연 병렬 객체에 대한 포인터를 유지하는 데이터 구조를 생성할 수 있다.

이벨류에이터(306)가 데이터플로우 그래프를 생성하면, 옵티마이저(308)는 하나 이상의 그래프 변환을 데이터플로우 그래프에 적용하여 지연 병렬 데이터 객체(또는 서브셋) 및 지연, 컴바이닝된 병렬 데이터 연산을 포함하는 수정 데이터플로우 그래프를 생성한다(404). 지연, 컴바이닝된 병렬 데이터 연산은 다수의 맵 연산 및 다수의 리듀스 연산을 포함하지만, 맵 연산을 구현하는 단일 맵 함수와 리듀스 연산을 구현하는 단일 리듀스 함수를 포함하는 단일 맵리듀스 연산으로 번역가능한 하나 이상의 일반화 맵리듀스 연산(예를 들어, MSCR)을 포함할 수 있다.

한 구현에서, 옵티마이저(308)는 데이터플로우 그래프에 대해 일련의 패스를 수행하는데, 다음의 순서: (1) 플래튼(flattens)을 싱크(sink); (2) CombineValues 연산을 리프트(lift); (3) 퓨전 블럭(fusion blocks)을 삽입; (4) ParallelDo들을 퓨징(fusing); 및 (5) MSCR들을 퓨징,로 후속하는 그래프 변환 또는 주석 달기(annotations)을 적용한다.

싱크 플래튼 변환(sink flattens transformation)은 각각의 입력 이전에 ParallelDo를 플래튼(flatten)으로 복제함으로써 ParallelDo 연산을 소모하는 것을 통해 Flatten 연산을 푸시다운(push down)하는 것을 포함한다. 즉, h(f(a)+g(b))는 h(f(a))+h(g(b))와 등가이다. 이러한 변환은 ParallelDo 퓨전(후술함)에 대한 기회를 생성한다.

리프트 CombineValues 연산 주석 달기는 트리트먼트(treatment)에 대한 임의의 CombineValues 연산을 ParallelDo 퓨전에 대한 ParallelDo들로서 마킹(marking)하는 것을 포함한다. CombineValues 연산이 GroupByKey 연산에 바로 후속한다면, GroupByKey는 그 사실을 기록한다. 오리지널 CombineVlaues가 제자리에 남겨지고, 이후에 통상의 ParallelDo 연산으로서 취급되어 ParallelDo 퓨전의 적용을 받는다.

삽입 퓨전 블럭 주석 달기는 두개의 GroupByKey 연산을 연결하는 ParallelDo들에 주석 달기하는 것을 포함한다. 두개의 GroupByKey 연산이 하나 이상의 ParallelDo 연산의 체인에 의해 연결되면, 옵티마이저(38)는 어느 ParallelDo들이 보다 앞선 GroupbyKey의 출력 채널로 퓨즈 업(fuse up)하여야 하는지와 후속 GroupByKey의 입력 채널로 퓨즈 다운(fuse down)하여야 하는지를 선택한다. 옵티마이저는 ParallelDo들의 체인을 따라 중간 PCollection들의 크기를 추정하고, 그것을 최소 예상 크기로 식별하고, 중간 PCollection들을 바운더리 블로킹 ParallelDo 퓨전(boundary blocking ParallelDo fusion)을 마킹한다. (즉, 서로 퓨전의 적용을 받는 그 PCollection의 어느 한 측에 대해 ParallelDo들 마킹한다)

퓨즈 ParallelDos 변환은 함께 ParallelDo들을 퓨징하는 것을 포함한다. 옵티마이저(306)가 수행하는 한 타입의 ParallelDo 퓨전은 프로듀서-컨슈머 퓨전으로서 불린다. 하나의 ParallelDO 연산이 함수 f를 수행하고, 그 결과가 함수 g를 수행하는 다른 Paralleldo 연산에 의해 소비된다면, 두개의 ParallelDo 연산이 f 및 g˚f 양자 모두를 계산하는 단일 ParallelDo에 의해 대체될 수 있다. f ParallelDo의 결과가 그래프 내에 다른 연산에 의해 요구되지 않는다면, 표준은 그것을 불필요한 것으로 하여, 그것을 생성하는 코드가 데드(dead)로서 제거될 수 있다.

Paralleldo 퓨전의 다른 타입은 사이블링 퓨전(sibling fusion)으로 불린다. ParallelDo 사이블링 퓨전은 두개 이상의 ParallelDo 연산이 동일 입력 PCollection을 읽을 때 적용될 수 있다. ParallelDo 연산은 입력에 대해 단일 패스 내의 모든 퓨징된 연산의 결과를 계산하는 단일 다중 출력 ParallelDo 연산으로 퓨징될 수 있다. 프로듀서-컨슈머 및 사이블링 퓨전 모두는 다중 출력 ParallelDo 연산의 임의의 트리들에 적용할 수 있다.

이미 언급한 바와 같이, CombineValues 연산은 부분 계산된 결과에 반복적으로 적용될 수 있는 ParallelDo 연산의 특수한 경우이다. 이로써, ParallelDo 퓨전도 CombineValues 연산들에 적용될 수 있다.

퓨즈 MSCRs 변환은 MSCR 연산을 생성하는 것을 포함한다. MSCR 연산은 관련된 GroupByKey 연산의 한 세트로부터 시작한다. 연산이 동일 ParallelDo 연산에 의해 생성된 동일 입력 또는 출력을 소비(가능하게 Flatten 연산을 통해)하는지와 관련되어 GroupByKey 연산이 고려될 수 있다. MSCR의 입력 및 출력 채널은 실행 계획에서 인접한 연산 및 관련된 GroupByKey 연산으로부터 유도된다. GroupByKey 연산 중 하나 (가능하게 Flatten 연산을 통해)에 의해 소비되는 적어도 하나의 출력으로 각각의 ParallelDo 연산이 MSCR에 퓨징되어, 새로운 입력 채널을 형성한다. 또한, GroupByKey들에 대한 임의의 다른 입력들은 아이덴티티 맵퍼를 사용하여 새로운 입력 채널을 형성한다. 관련된 GroupByKey 연산 각각은 출력 채널을 시작한다. GroupByKey의 결과가 CombineValues 연산에 의해 단독으로 소비된다면, 그 연산은 대응 출력 채널로 퓨징된다. 유사하게, GroupByKey의 또는 퓨징된 CombineValues의 결과가 또한 출력 채널로 퓨징되는 ParallelDo 연산에 의해 단독으로 소비된다면, 상이한 MSCR의 입력 채널로 퓨징될 수 없다. 퓨징된 ParallelDo, GroupByKey, 및 CombineValues 연산들에 대한 내부의 모든 ParallelDo은 현재 불필요하여 삭제될 수 있다. 최종적으로, 관련된 GroupByKey들 중 하나가 아닌 연산 또는 출력으로 흐르는 맵퍼 ParallelDo의 각각의 출력은 그 자신의 패스-쓰루출력 채널을 생성한다.

모든 GroupByKey 연산이 MSCR 연산으로 변환된 후에, 임의의 나머지 ParallelDo 연산 또한 ParallelDo를 포함하는 단일 입력 채널과 아이덴티티 출력 채널을 사용하여 사소한 MSCR 연산들로 변환된다. 최종 최적화 실행 계획은 단지 MSCR, Flatten, 및 Operate 연산들만을 포함한다.

수정 데이터플로우 그래프가 생성되면, 익스큐터(310)는 지연, 컴바이닝 병렬 연산을 실행하여 지연 병렬 데이터 객체에 대응하는 실체화 병렬 데이터 객체를 생성한다(406). 일반화 맵리듀스 연산(예를 들어, MSCR)을 실행하는 것은 일반화 맵리듀스 연산을 단일 맵리듀스 연산으로 번역하고 단일 맵리듀스 연산을 실행하는 것을 포함할 수 있다. 단일 맵리듀스 연산의 실행 이전에, 익스큐터(310)는 단일 맵리듀스 연산을 로컬, 순차 연산 또는 원격, 병렬 연산을 실행할 것인지를 결정할 수 있고, 다음에 따라서 맵리듀스를 실행할 수 있다. 예를 들어, 익스큐터(310)는 상술한 바와 같이 입력 데이터 셋의 크기를 기초로 결정할 수 있다.

도 4b는 수정 데이터플로우 그래프를 실행하도록 파이프라인 라이브러리(202c)의 익스큐터(310)에 의해 수행될 수 있는 프로세스(450)의 예를 도시한 흐름도이다. 익스큐터(310)는 수정 데이터플로우 그래프를 액세스하고(452) 예를 들어, 순방향 위상적 방식(forward topological manner)으로 순환(traversing)을 시작한다(454). 상술한 바와 같이, 다른 구현에서, 익스큐터(310)는 파이프라인의 증가적인 또는 연속적인 실행을 지원할 수 있다.

익스큐터(310)가 non-MSCR 연산을 접할 때(456), 익스큐터(310)는 파이프라인 라이브러리(202c) 내에 포함된 로직을 사용하여 국부적으로 그 연산들을 실행한다(458). 한편, 익스큐터(310)가 MSCR 연산을 접할 때(456), 익스큐터(310)는 맵리듀스 라이브러리(202b)를 사용하여 MSCR을 로컬, 순차 연산으로서 실행할지(460) 또는 대신에 원격, 병렬 연산으로서 실행할지를 결정한다. 예를 들어, 익스큐터(310)는 MSCR과 연관된 데이터의 추정 크기를 결정하고 그 추정 크기가 임계 크기를 초과하는지를 결정한다. 추정 크기가 임계치 미만이라면, 익스큐터(310)는 MSCR을 로컬, 순차 연산으로서 실행할 수 있다(462). 반대로, 추정크기가 임계 크기 이상이라면, 익스큐터(310)는 MSCR을 단일 맵리듀스 연산으로 번역하고 그 맵리듀스 연산을 맵리듀스 라이브러리(202c)를 사용하여 원격, 병렬 연산으로서 실행함으로써 MSCR 연산을 원격, 병렬 연산으로서 실행할 수 있다(464).

예를 들어, 한 구현에서, 익스큐터는 MSCR의 각각의 입력 채널에 대한 입력 데이터의 크기를 추정하고, 각각의 입력 채널에 의해 생성된 중간 데이터의 크기를 추정하며, 각각의 출력 채널로부터 출력 데이터의 크기를 추정한다. 이러한 임의의 추정 크기가 64 메가바이트(MB) 이상이라면, MSCR은 맵리듀스 라이브러리(202b) 를 사용하여 원격, 병렬 연산으로서 실행된다(464).

MSCR을 로컬, 순차 연산으로서 실행할 때, 익스큐터(310)는 순차적으로 데이터에 대해 적절한 연산을 수행할 수 있다. 예를 들어, 익스큐터는 데이터를 액세스하고 데이터에 대해 적절한 연산을 수행하도록 인 메모리 포 루프(in-memory for-loops)를 구현할 수 있다.

MSCR을 맵리듀스 라이브러리(202b)를 사용하여 원격, 병렬 연산으로서 실행할 때, 익스큐터(310)는 MSCR의 입력 및 출력 채널의 구성을 기초로 연관된 프로세싱을 수행하는데 요구되는 리듀스 워커 프로세스들 및 맵 워커 프로세스들의 수를 추정할 수 있다. 예를 들어, 익스큐터는 예를 들어, 각각의 채널에 대한 입력 데이터의 추정 또는 알려진 크기를 기초로 각각의 입력 채널에 대한 맵 워커 프로세스들의 수를 추정할 수 있으며, 유사하게, 예를 들어, 각각의 출력 채널에 의해 프로세싱될 데이터의 추정 또는 알려진 량을 기초로 리듀스 워커 프로세스들의 수를 추정할 수 있다. 익스큐터(310)는 다음에 맵 워커 프로세스들과 리듀스 워커 프로세스들의 수를 가산하고 맵리듀스 라이브러리(202b)를 사용하여 이러한 워커 프로세스들이 호출되도록 한다.

각각의 맵 워커 및 각각의 리듀스 워커는 인덱스 넘버(index number)가 주어진다. 예를 들어, MSCR이 두개의 입력 채널을 포함하면, 4개의 맵 워커 프로세스를 갖는 하나와 5개의 맵 워커 프로세스를 갖는 나머지(총 9개의 워커)는 인덱스 넘버가 1부터 9까지 제공될 수 있다. 이러한 인덱스 넘버는 각각 특정한 입력 또는 출력 채널로 주어진 맵 워커 프로세스 또는 리듀스 워커 프로세스를 연관시키는데 사용된다. 전술한 예를 계속하여, 인덱스 넘버 1-4는 제1 입력 채널과 연관될 수 있으며, 인덱스 넘버 5-9는 제2 입력 채널과 연관될 수 있다.

또한, 익스큐터(310)는 MSCR의 입력 채널들 내에 다수의 맵 연산을 구현하는 단일 맵 함수와 MSCR의 출력 채널들 내에 다수의 리듀스 연산을 구현하는 단일 리듀스 함수를 생성함으로써 MSCR을 단일 맵리듀스 연산으로서 번역한다. 맵 함수는 어느 맵 연산이 입력에 적용되는지를 선택하기 위한 근거(basis)로서 맵 워커 프로세스들의 인덱스를 사용한다. 예를 들어, if-then 구문이 맵 함수의 일부로서 포함되어, 맵 워커의 인덱스 넘버가 if-then 구문에 대한 판정 포인트가 된다.

따라서, 맵리듀스 라이브러리(202b)가 맵 업무를 맵 워커 프로세스에 할당할 때, 워커의 연관 인덱스가 작업되는 파일의 아이덴티티(indentity)와 함께 맵 함수로 패스된다. 다음에, 인덱스 넘버는 파일 내의 엘리먼트들 상에서 맵 함수가 호출하는 맵 연산(parallelDo)이 어느 것인지와, 그로써 워커를 구현하는 입력 채널이 어느 것인지를 구술(dictating)한다.

유사하게, 리듀스 함수는 리듀스 워커 프로세스의 입력에 어느 리듀스 연산이 적용되는지를 선택하기 위한 근거로서 리듀스 워커 프로세스들의 인덱스를 사용한다. 리듀스 워커 함수가 리듀스 업무에 할당될 때, 워커의 연관 인덱스가 (키 그룹화 입력의 단일 플래튼 스트림(flatten stream)을 포함하는) 작업되는 파일의 아이덴티티와 함께 리듀스 함수가 패스된다. 다음에, 인덱스 넘버는 파일 내의 엘리먼트 상에서 리듀스 함수가 호출하는 리듀스 연산이 어느 것인지와, 그로써 워커를 구현하는 출력 채널이 어느 것인지를 구술한다. 리듀스 워커 프로세스가 그룹화 출력 채널을 구현하면, 리듀스 워커 프로세스는 CombineValues"combine" 연산(만약에 있다면)을 수행하고, 다음에 ParallelDo"reduce" 연산을 수행한다. 리듀스 워커 프로세스가 패스-쓰루 출력 채널을 구현하면, 리듀스 워커 프로세스는 맵리듀스 라이브러리의 암시 셔플(implicit shuffle)의 효과를 무효화(undoing)하는, 키/값 쌍들을 출력하는 비그룹화 연산(ungrouping operation)을 수행한다.

MSCR 연산의 입력 채널 각각은 그 R개의 출력 채널 중 임의의 채널에 키/값 쌍들을 출력할 수 있다. 예를 들어, 입력 채널 2는 하나의 출력을 출력 채널 1에 전달하고 다른 출력을 출력 채널 3에 전달하며, 출력 채널 2에는 아무것도 전달하지 않는다.

맵리듀스 라이브러리(202b)는 맵 워커 프로세스들에 의해 출력된 데이터에 대해 셔플을 핸들링(handling)하고 다음에 그 출력을 올바른 리듀서 워커로 라우팅한다. MSCR 연산의 입력 채널들 각각은 R개의 출력 채널들 중 임의의 채널에 키/값 쌍들을 출력할 수 있다. 예를 들어, 입력 채널 2는 한 출력을 출력 채널 1로 전달하고 다른 출력을 출력 채널 3으로 전달하며, 출력 채널 2로는 아무것도 전달하지 않는다. 이는 예를 들어, 어느 리듀스 워커가 주어진 맵 워커 프로세스의 출력을 프로세싱하는지를 파이프라인 라이브러리(202c)가 지정(designate)하도록 하는, 맵 리듀스 라이브러리(202b) 내의 emitToShard(key, value, shardNum) 프리미티브를 사용함으로써 파이프라인 라이브러리(202c)에 의해 핸들링된다. 주어진 맵 워커 프로세스로부터 특정한 출력 채널로 출력을 전달할 때, 파이프라인 라이브러리(202c)는 그 출력 채널에 대응하는 맵 워커 인덱스들의 범위를 계산할 수 있으며, deterministic 함수를 사용하여 이들 중 하나를 선택하고, 출력을 선택된 리듀서 워커로 전달하는 emitToShard 함수를 사용한다. deterministic 함수는 출력 값들과 연관된 키에 대한 해시(hash)를 포함할 수 있는데, 해시의 결과는 출력에 대한 인덱스들의 범위 내에서 어느 리듀스 워커 프로세스들이 선택되는지를 판정한다. 이는 특정한 키와 연관된 모든 데이터가 동일한 리듀스 워커 프로세스로 전달되는 것을 보장할 수 있다.

한 구현에서, 맵리듀스 라이브러리(202c)는 단지 단일 출력으로의 기록을 직접 지원한다. 더욱이, 맵리듀스 라이브러리(202b)의 한 구현에서, 리듀스 함수의 출력이 키/값 쌍들을 예측한다면, 이러한 출력에 기록되는 키들은 리듀스 함수로 패스되는 키들과 동일하여야 한다. 반대로, 한 구현에서, 각각의 MSCR 출력 채널은 0, 1, 또는 여러 출력들이 기록될 수 있는데, 키에는 제한이 없다. 이러한 보다 유연한 출력(more-flexible outputs)을 구현하기 위해, 리듀스 함수는 맵리듀스 라이브러리의 통상 출력 메카니즘을 바이패싱(bypassing)함으로써 출력에 바로 기록할 수 있다. 임의의 MSCR의 출력이 맵리듀스 라이브러리의 출력 제한(restrictions)을 만족시키면, 대신에 출력은 맵리듀스 라이브러리의 통상 메카니즘을 사용하여 구현될 수 있다.

병렬 연산들 각각이 평가될 때, 익스큐터(310)가 어플리케이션(202a)에 대해 컨트롤 백(control back)을 리턴하는 어느 시점에서(468), 모든 연산이 완료될 때까지 익스큐터(310)는 객체들을 실체화하는(466) 적절한 데이터로 지연 객체들을 채운다(populating).

도 5는 ParallelDo 프로듀서-컨슈머 퓨전 및 사이블링 퓨전을 도시한 예시적인 실행 계획 변환을 도시하고 있다. 그래프(502)는 PCollection 연산들 A(504), B(506), C(508), 및 D(510)을 포함하는 원본 그래프를 도시하고 있다. 도시된 바와 같이, ParallelDo 연산들 A(504), B(506), C(508), 및 D(510)은 그래프(550)를 형성하도록 단일 ParallelDo A+B+C+D(512)로 퓨징된다. 그래프(550) 내의 새로운 ParallelDo는 원본 그래프(502)로부터의 모든 리프 출력(leaf outputs) + 출력 A.1 (514)를 생성하는데, 이는 출력 A.1(514)이 몇몇의 다른 연산 Op(518)에 의해 요구되기 때문이다. 중간 출력 A.0(516)는 더이상 요구되지 않으며 그래프(550) 내에서 퓨징된다.

도 6a 및 도 6b는 MSCR 퓨전을 도시한 예시적인 실행 계획 변환(600)을 도시하고 있다. 그래프(601)는 3개의 GroupByKey 연산들 GBK1(602), GBK2(604), GBK3(606)을 포함하는 원본 그래프를 도시하고 있다. 이러한 예에서, 모든 3개의 GroupByKey 연산들(602, 604, 606)이 관련되며, 이런 이유로 수정 그래프(650) 내에 도시된 바와 같이 단일 MSCR 연산(652)을 시딩(seeding)한다. 그래프(601)를 참조하면, GBK1(602)는 GBK2(604)에 관련되는데, 이는 이들 양자 모두가 ParallelDo M2(608)의 출력들을 소비하기 때문이다. PCollection M2.0은 별표로 지시된 바와 같이 GBK1(602)가 아닌 후속 연산들에 의해 요구된다. 유사하게, PCollection M4.1은 MSCR 연산을 형성하는 연산들이 아닌 후속 연산들에 의해 요구된다.

그래프(650)를 참조하면, ParallelDo들(M2 608, M3 614, 및 M4 612)이 MSCR 입력 채널들(616)로서 포함된다. GroupByKey(602, 604, 606) 연산 각각은 그룹화 추력 채널(620)이 된다. GBK2의 출력 채널은 CV2 CombineValue 연산(622) 및 R2 ParallelDo 연산(624)을 포함한다. R3 ParallelDo(626) 연산은 또한 출력 채널로 퓨징된다. 추가적인 아이덴티티 입력 채널이 non-ParallelDo Op1으로부터 GBK1로의 입력을 위해 생성된다. 두개의 추가 패스-쓰루 출력 채널들(맵퍼로부터 출력의로의 에지들로서 도시)이 MSCR 연산 후에 사용되는 M2.0 및 M4.1 PCollection을 위해 생성된다. 결과 MSCR 연산(650a)은 4개의 입력 채널들(616) 및 5개의 출력 채널들(620)을 갖는다.

도 7a 내지 도 7e는 예를 들어, 옵티마이저(306)에 의해 수행되는 데이터플로우 그래프 변환의 예를 도시하고 있다.

도 7a는 초기 병렬 데이터 파이프라인(700)을 도시하고 있다. 간소화를 위해, 병렬 데이터 객체가 도시되어 있지 않다. 이 파이프라인은 4개의 상이한 입력 소스를 취하여 두개의 출력을 기록한다. 입력 1은 parallelDo()A(702)에 의해 프로세싱된다. 입력 2는 parallelDo()B(704)에 의해 프로세싱되고, 입력 3은 parallelDo()C(706)에 의해 프로세싱된다. 이러한 두개의 연산의 결과는 함께 flatten()(708)이 적용되어 parallelDo()D(710)로 공급된다. 입력 4는 count() 유도 연산(712)을 사용하여 카운팅되고, 그 결과는 parallelDo()E(714)에 의해 더 프로세싱된다. parallelDo()들 A, D, 및 E(702, 710, 714)는 join()(716) 유도 연산을 사용하여 함께 조인된다. join()(716)의 결과는 parallelDo()F(718)에 의해 더 프로세싱된다. 최종적으로 parallelDo()들 A 및 F(702 및 718)의 결과가 외부 파일로 기록된다.

도 7b는 parallelDo() 및 flatten()과 같은 프리미티브들과, 그들 자신이 로우 레벨 연산에 대한 호출에 의해 구현되는 count() 및 join()과 같은 유도 연산들로의 호출로부터 구성되는 초기 데이터플로우 그래프(720)를 도시하고 있다. 이러한 예에서, count() 호출은 ParallelDo C:MAP(722), GroupByKey C:GBK(724), 및 CombineValues C:CV(726)으로 확장하고, join() 호출은 ParallelDo 연산 J:Tag1(726), J:Tag2(728), 및 J:Tag3(730)으로 확장하여 결과를 프로세싱 하도록 각각의 N 입력 콜렉션, Flatten J:Fltn(732), GroupByKey J:GBK(734) 및 ParallelDo J:Untag(736)을 태그(tag)한다.

도 7c는 그래프(720)에 적용되는 싱크 플래튼 변환(sink flattens transformation)으로부터의 결과인 수정 데이터플로우 그래프(738)을 도시하고 있다. Flatten 연산 Fltn(708)은 ParallelDo 연산들 D(710) 및 JTag:2(728)을 소비하느 것을 통해 푸시 다운(push down)된다.

도 7d는 그래프(738)에 적용되는 ParallelDo 퓨전 변환으로부터의 결과인 수정 데이터플로우 그래프(740)를 도시하고 있다. 프로듀서-컨슈머 및 사이블링 퓨전 양자 모두는 인접한 ParallelDo 연산에 적용되어 ParallelDo 연산들(760, 762, 764, 766, 및 768)을 생성한다.

도 7e는 그래프(740)에 적용되는 MSCR 퓨전 변환으로부터의 결과인 최종적인 수정 데이터플로우 그래프(748)를 도시하고 있다. GroupByKey 연산 C:GBK(724) 및 surrounding ParallelDo 연산들 C:Map(722) 및 C:CV(726)이 제1 MSCR 연산(750)으로 퓨징된다. GroupbyKey 연산들 J:GBK(734)는 제2 MSCR 연산(752)의 코어 연산이 되어 그룹화 출력 채널 내에 포함된다. 제2 MSCR 연산(752)은 또한 각각의 입력 채널 내에 나머지 ParallelDo 연산들(770, 762, 764, 및 766) 및 패스 쓰루 출력 채널(744)을 포함한다. 원본 실행 계획은 16개의 데이터-병렬 연산(ParallelDos, GroupByKeys, 및 CombineValues)을 갖는다.

라이브러리로서 구현되는 것이 설명되었지만, 파이프라인 라이브러리(202c)의 기능(funcitonality)는 추가적으로 또는 대안적으로 클라이언트 시스템이 인터넷과 같은 네트웍을 통해 그 기능을 액세스하도록 하는 서비스로서 구현될 수 있다. 예를 들어, 파이프라인 라이브러리(202c)의 기능은 웹 서비스 어플리케이션 프로그래밍 인터페이즈(APIs)의 대응 셋을 사용하여 웹 서비스로서 서버 시스템 상에 구현될 수 있다. 웹서비스 API는 예를 들어, Representational State Transfer(REST)-기반 HTTP 인터페이즈 또는 Simple Object Access Protocol(SOAP)-기반 인터페이즈로서 구현될 수 있다. 대안적으로, 또는 추가적으로, 웹 페이지와 같은 인터페이즈가 네트웍을 통해 서비스를 액세스하도록 제공될 수 있다.

API 또는 인터페이즈 사용 시, 사용자는 사용자에 의해 개발된 프로그램을 클라이언트 시스템으로부터 서비스로 전송할 수 있다. 이 프로그램은 예를 들어, 병렬 콜렉션 클레스(302) 및 병렬 연산(304)를 사용하여 구현된 데이터 병렬 파이프라인을 포함할 수 있다. API 또는 인터페이즈 사용 시, 사용자는 파이프라인을 위한 데이터를 지정하여 프로그램을 실행하도록 서비스에 메시지를 전송할 수 있다. 이 메시지는 선택적으로 프로그램을 위해 요구되는 임의의 아규먼트(argments)를 포함할 수 있다. 메시지가 수신되면, 서비스는 프로그램을 실행하고 이벨류에이터(306), 옵티마이저(308), 및 익스큐터(310)의 기능을 구현하여 데이터 병렬 파이프라인을 구현한다. 다음에, 서비스는 클라이언트 시스템으로 임의의 프로그램 출력을 리턴할 수 있다. 대안적으로, 또는 추가적으로, 사용자 프로그램은 클라이언트 시스템 상에서 실행할 수 있는데, 이 프로그램은 서비스에 의해 구현된 이벨류에이터(306), 옵티마이저(308), 및 익스큐터(310)의 기능을 사용하여 데이터 병렬 파이프라인을 구현하도록 API를 사용한다.

도 9는 파이프라인 라이브러리(202c)를 서비스(다르게는 파이프라인 프로세싱 서비스로 칭함)로서 구현하는데 사용될 수 있는 시스템(900)의 예를 도시하고 있다. 일반적으로, 시스템(900) 내에 파이프라인 프로세싱 서비스를 구현하는데 사용되는 아키텍쳐는 외부 개발자의 프로그램의 비신뢰 코드가 파이프라인 프로세싱 서비스를 구현하는데 사용되는 데이터 센터 내에서 안전하게 실행하도록 하는 보안 환경(secure environment)을 제공한다. 이는 예를 들어, 데이터 센터를 운영하는 엔티티(entity)가 고용되지 않거나 그렇지 않으면 게열사 또는 그 엔티티에 의해 제어되는 써드파티 개발자에게 이용가능한 파이프라인 프로세싱 서비스를 만들 때 사용될 수 있다.

보다 상세히 후술하는 바와 같이, 도 9에 도시된 구현에서, 비신뢰 데이터-병렬 프로세싱 코드는 두개의 논리 조각으로 분할되고 각각의 조각은 보안 프로세싱 환경("sandbox" 또는 "jail")의 내부에서 실행하도록 격리된다. 한 조각은 상요자의 데이터 병렬 계산(그로부터 데이터플로우 그래프가 구축됨)을 정의하는 실행가능 코드이고, 다른 조각은 데이터에 대해 연산하는 함수들을 포함하는 실행가능 코드이다.

예를 들어, 비신뢰 코드의 각각의 조각은 게스트 운영 체제를 실행하고 네트웍 및 디스크 연결을 에뮬레이션하는 하드웨어 가상 머신(VM)에서 실행할 수 있다. 이 하드웨어 VM은 비신뢰 코드가 호스트 또는 네이티브 환경을 직접 액세스하는 것을 방지할 수 있으며, 특수한 검사 메카니즘(audited mechanisms)을 통해서만 가상 머신 외부로의 통신을 제공할 수 있다. 하드웨어 VM은 사용자의 코드가 데이터 센터 내에서 어떻게 저장되고 전송되는지에 대한 세부사항에 대해 액세스하는 것을 방지할 수 있다.

이러한 아키텍쳐는 비신뢰 코드가 네이티브 프로세싱 환경을 제공하는 데이터 센터 인프라스트럭쳐의 정상에서 실행하는 것을 가능하게 할 수 있다. 데이터 센터 내에서 데이터의 저장 및 이동에 사용되는 파일 시스템 및 상호접속 네트웍은 비신뢰 코드의 속도를 낮출 수 있는 보안 샌드박스(security sandbox) 내부에서 실행하는 데이터를 소비하기 위한 비신뢰 코드를 통해 최대 속도로 실행할 수 있다. 몇몇의 경우에, 데이터 병렬 계산을 수행하는데 걸리는 시간 중 큰 부분이 데이터 이동에 점유된다. 이러한 경우에, 코드의 실행은 데이터 센터 인프라스트럭쳐에 의해 제공되는 네이티브 프로세싱 환경에서 직접 실행하는데 비해 전체 실행 시간의 보통 정도 저하만을 겪을 수 있다. 단지 비신뢰 코드를 보안 샌드박스 내에 위치시키는 것은 몇몇의 예에서 코드 및 그 파일 시스템과 네트웍의 구현을 샌드박스 내부에 위치시키는 것보다 보다 효율적일 수 있다. 단지 비신뢰 코드를 샌드박스 내부에 위치시키는 것은 또한 전체 시스템의 보안을 보다 용이하게 하는데, 이는 샌드박스 내부에서 전체 파일 시스템과 네트웍을 지원하는데 사용될 수 있는 훨씬 넓은 통신 채널과 반대로 신뢰 호스트와 통신하는 비신뢰 코드에 대한 제한된 채널이 존재하기 때문이다.

시스템(900)은 클라이언트 시스템(902), 및 데이터 센터(100)와 유사할 수 있는 데이터 센터(904)를 포함한다. 클라이언트 시스템(902) 및 데이터 센터(904) 인터넷과 같은 네트웍(906)을 통해 서로 통신할 수 있다. 클라이언트 시스템(902)은 예를 들어, 데이터 센터(904)에 의해 제공되는 파이프라인 프로세싱 서비스에 의해 지원되는 상술한 병렬 데이터 콜렉션 클래스들(302)과 하나 이상의 병렬 연산들(304)을 사용하여 구현된 데이터 병렬 파이프라인을 포함하는 사용자 프로그램 또는 어플리케이션(908)을 저장한다.

데이터 센터(904)는 프로세싱 모듈(104)과 유사하며 데이터 프로세싱을 수행하기 위해 메모리(202), CPU(들)(204), 및 네트웍 인터페이즈(206)와 같은 다양한 컴퓨터 관련 구성요소들을 포함하는 프로세싱 모듈들(910, 912, 및 914)을 포함한다. 데이터 센터(904)는 또한 외부적으로 액세스 가능한 스토리지(916)를 포함한다.

프로세싱 모듈(들)(910)은 파이프라인 프로세싱 서비스와 대화하는 클라이언트 시스템(902)을 위한 메카니즘을 포함하는 서비스 인터페이즈(918)를 구현한다. 예를 들어, 서비스 인터페이즈(918)는 서비스와의 인터페이싱을 위한 API를 제공할 수 있다. 상술한 바와 같이, 이러한 API는 예를 들어, Representational State Transfer(REST)-기반 HTTP 인터페이즈 또는 Simple Object Access Protocol(SOAP)-기반 인터페이즈로서 구현될 수 있다. 대안적으로, 또는 추가적으로, 서비스 인터페이즈(918)는 클라이언트 시스템(902) 상에 표시되어 서비스를 액세스하는데 사용될 수 있는 웹 페이지와 같은 사용자 인터페이즈를 제공할 수 있다. API 또는 사용자 인터페이즈는 예를 들어, 사용자 어플리케이션(908)을 데이터 센터(904)에 업로드하고, 사용자 프로그램(908)을 위해 데이터(예를 들어, 스토리지(916)에 의해 저장된)를 지정하고, 프로그램(908)에 필요한 임의의 아규먼트를 선택적으로 포함하는 메시지를 서비스에 전송하여 프로그램(908)을 실행하기 위해 클라이언트 시스템(908)의 사용자에 의해 이용될 수 있다.

프로세싱 모듈(들)(912)은 실행 계획 서비스(920) 및 가상 머신(922)을 구현한다. 가상 머신(922)은 게스트 운영 체제를 실행하고 네트웍 및 디스크 연결을 에뮬레이션g는 하드웨어 가상 머신일 수 있다. 예를 들어, 가상 머신(922)은 "Kernel Virtual Machine"(KVM) 기술에 의해 구현될 수 있는데, 이는 x86 아키텍쳐 상에서 리눅스를 가상화하며, 신뢰 호스트 데이터 센터 상에서 사용자 프로세스로서 실행될 수 있다. KVM은 예를 들어, http://www.redhat.com/f/pdf/rhev/DOC-KVM.pdf에서 이용가능한 KVM 백서에 설명되어 있다. 다른 구현에서, 가상 머신(922)은 프로세스 가상 머신으로 구현될 수 있다. 일반적으로, 프로세스 가상 머신은 운영 체세 상에서 어플리케이션으로서 실행하며, 단일 프로세스를 지원하고, 플랫폼 독립 프로세싱 환경을 제공한다.

가상 머신(922)은 업로드된 사용자 프로그램(908)과 실행 계획 라이브러리(924)를 호스팅(hosting)(및 실행)한다. 사용자 프로그램(908)이 실행될 때, 실행 계획 라이브러리(924)는 사용자 프로그램(906) 내에 파이프라인을 형성하는 병렬 데이터 객체들 및 병렬 연산들을 기초로 데이터플로우를 구축한다. 그 마지막에, 실행 계획 라이브러리(924)는 이벨류에이터(306)와 유사한 이벨류에이터(926)를 구현하고, 지연 객체 및 데이터 병렬 파이프라인에 대응하는 지연 연산의 내부 실행 계획 데이터플로우 그래프를 구성한다. 이벨류에이터(926) 구현에 추가하여, 실행 계획 라이브러리(924)는 실행 계획 서비스(920)에 대한 데이터플로우 그래프의 표시를 전달하는 다른 함수들을 구현할 수 있다. 예를 들어, 한 구현에서, 실행 계획 라이브러리(924)는 원격 프로시져 호출(RPC)을 사용하여 실행 계획 서비스(920) 경계의 가상 머신과 통신하는 다른 함수들을 구현할 수 있다. 이러한 호출은 적절한 호출이 이루어지는지를 보장하도록 모니터링될 수 있다. 예를 들어, 실행 계획 서비스(920)는 유효성(validity)을 위해 주어진 함수에 대한 아규먼트를 체크할 수 있으며, 허용되는 함수 호출의 화이트 리스트(white list)로 함수 호출을 체크할 수 있다. 예를 들어, 비신뢰 코드에 의해 액세스 허용되지 않는 서비스나 다른 데이터 센터 자원들 (예를 들어, 파일 및 다른 RPC 기반 서비스들)에 대한 요청(프로브)을 검출하도록 오디팅(auditing)이 수행될 수 있다.

몇몇의 구현에서, 가상 머신(922)은 이러한 RPC 호출이 가상 머신(922) 외부의 환경과 대화하는 가상 머신 내부의 코드에 대해서만 존재하도록 구성될 수 있다. 데이터플로우 그래프가 최적화되고 실행되었으면, 실행 계획 라이브러리(926)는 또한 실행 계획 서비스(920)로부터 객체의 실체화 (예를 들어, 실체화된 객체 그 자신의 버전 또는 실체화된 객체의 표현)를 인에이블링 (enabling)하는 정보를 수신하는 함수를 구현한다. 실행 계획 라이브러리(922)는 다음에 이 정보를 내부 데이터플로우 그래프에에서 데이터 객체를 실체화하는데 사용하여 이 실체화된 객체들이 사용자 프로그램(906)에 의해 사용될 수 있도록 한다.

실행 계획 서비스(920)는 실행 계획 라이브러리(924)로부터 전달된 데이터플로우 그래프의 최적화 및 실행을 핸들링한다. 한 구현에서, 실행 계획 서비스(920)는 비신뢰 사용자 코드를 실행하지 않고 데이터 센터 인프라스트럭쳐에 대한 전체 액세스 권한을 갖는 신뢰 프로세스이다. 실행 계획 서비스(920)는 비신뢰 실행 계획을 나타내는 정보를 수용하고 그래프 구조를 유효화한다. 실행 계획 서비스(920)는 다음에 그래프의 최적화를 핸들링하고(즉, 상술한 바와 같은 그래프 변환을 적용), 최적화된 그래프를 실행한다.

최적화를 핸들링하기 위해, 실행 계획 서비스(920)는 옵티마이저(928)를 구현한다.옵티마이저(308)와 같은 옵티마이저(928)는 상술한 바와 같은 그래프 변환을 적용하여 MSCR들을 포함할 수 있는 지연 병렬 데이터 객체들(또는 서브셋) 및 지연, 컴바이닝 병렬 데이터 연산들을 포함하는 수정 데이터플로우 그래프를 생성한다. 한 구현에서, 옵티마이저(308)와 같은 옵티마이저(928)는 매우 적은 MSCR 연산을 생성하기 위해, 전체 연산 및 그룹화 연산 수를 감소시키는 초기 실행 계획을 통해 일련의 패스를 수행한다.

수정 데이터플로우 그래프를 실행하는 것을 핸들링하기 위해, 실행 계획 서비스(920)는 익스큐터(930)를 구현한다. 수정 데이터플로우 그래프가 MSCR이 존재하지 않는 (예를 들어, PObject operate 함수) 데이터플로우 그래프에 연산들을 포함한다면, 익스큐터(930)는 가상 머신(922)과 같은 가상 머신과 통신하여 가상 머신 내에 JVM으로 비신뢰 연산을 구현할 수 있다.

MSCR에 대해, 익스큐터(310)와 같은 익스큐터(930)는 그래프 내의 주어진 MSCR을 단일 맵리듀스 연산으로 번역한다. 주어진 MSCR에 대해 그와 같이 수행하기 위해, 예를 들어, 익스큐터(930)는 MSCR의 입력 채널들에 다수의 맵 연산을 구현하는 단일 맵 함수와 MSCR의 출력 채널에 다수의 리듀스 연산을 구현하는 단일 리듀스 함수를 생성한다. 다음에, 익스큐터(930)는 단일 맵리듀스 연산을 원격 병렬 연산으로서 실행한다. 예를 들어, 도 4b를 참조로 설명된 예와 유사하게, 익스큐터(930)는 각각의 수신 데이터를 제어하고 어느 맵 또는 리듀스 연산이 데이터에 대해 각각 수행하는지를 나타내는 연관 인덱스 넘버(associated index number)를 사용하여 다수의 맵 워커 및 리듀스 워커가 호출되도록 할 수 있다.

프로세싱 모듈(들)(914)은 맵 또는 리듀스 워커 중 주어진 하나(한 카피가 다양한 워커 카피들을 코디네이션하는 마스터로서 지정될 수 있다) 및 연관된 가상 머신(934)을 구현한다. 일반적으로, 한 구현에서, 비신뢰 사용자 함수(예를 들어, 단일 맵 또는 리듀스 함수 내의 맵 또는 리듀스 연산)는 가상 머신(934) 내에서만 실행되고, 반면에 워커(932)는 임의의 비신뢰 사용자 코드를 실행하지 않고 데이터 센터 인프라스트럭쳐에 대해 전체 액세스 권한을 갖는 신뢰 프로세스이다. 즉, 단일 맵 함수 또는 단일 리듀스 함수 내에서 코드를 바로 실행하는 각각의 워커(932)보다는, (비신뢰 사용자 코드(936)를 포함하는) 이러한 함수들이 가상 머신(934) 내에서 실행된다. 일반적으로, 신뢰 워커(932)는 데이터 액세스(외부 데이터 스토리지 액세스 포함)와 통신 및 마스터와 다른 워커들의 코디네이션을 포함하는 인프라스트럭쳐의 나머지와의 대화(interaction)를 핸들링한다.

가상 머신(922)과 같이, 가상 머신(934)은 하드웨어 갓아 머신일 수 있으며 KVM 기술을 사용하여 구현될 수 있다. 다른 구현에서, 가상 머신(934)은 프로세스 가상 머신으로 구현될 수 있다. 다른 프로세싱 모듈은 다른 병렬 워커 및 연관된 가상 머신을 구현할 수 있다.

사용자 함수(936)을 호스팅(및 실행)하는 것에 추가하여, 가상 머신(934)은 또한 사용자 함수(936)에 대한 입력 및 출력 데이터를 핸들링하는데 사용되는 언배쳐/배쳐 프로세스(unbatcher/batcher process)(938)를 호스팅하고 실행한다. 일반적으로, 입력 및 출력 데이터가 워커(932)와 가상 머신(934) 사이에서 레코드(record)의 배치(batches)로서 패스된다. 예를 들어, 사용자 함수에 대한 전달을 위해 가상 머신(934)로 각각의 레코드를 패싱하기 보다, 워커(932)는 입력 데이터(예를 들어, 스토리지(916)에 저장된)를 액세스하여, 입력으로부터 레코드의 배치(batches)를 추출하고, 예를 들어, RPC를 사용하여 가상 머신(934) 내의 언배쳐/배쳐(938)로 레코드의 입력 배치를 보낸다. 한 예에서, 워커(932)는 64 MB의 레코드를 추출하고, 이 레코드를 언배쳐/배쳐(938)로 전달하도록 구성된다.

언배쳐/배쳐(938)는 개별 레코드로 배치를 분할하고, 사용자 함수(936)를 호출하고, 개별 레코드를 프로세싱을 위해 사용자 함수(936)로 패스한다. 언배쳐/배쳐(938)는 또한 사용자 함수(936)의 출력을 레코드의 출력 배치로 수집하고, 이 출력 배치를 워커(932)로 전달하는데, 이는 다음에 예를 들어, 실행 계획 서비스(920) 또는 시스템(900)의 다른 컴포넌트에 의해 액세스될 수 있는 출력 파일 또는 파일들로 기록된 결과를 갖도록 배열될 수 있다. 실행 계획 서비스(920)는 실행 계획 라이브러리(922)를 통해 사용자 프로그램(908)으로 다시 결과를 전달할 책임이 있을 수 있다. 배치(batches)에서 워커와 가상 머신(934) 사이에서 입력 및 출력을 패싱(passing)하는 것은 가상 머신 바운더리에 요구되는 프로세싱 오버헤드(예를 들어, RPC를 구현하는데 필요한 오버헤드)를 프로세싱하는 충격을 감소시킬 수 있다.

실행 계획 서비스(920)와 실행 계획 라이브러리(926) 사이의 RPC와 관련하여, 워커(932)와 언배쳐/배쳐(938) 사이의 RPC 호출은 적절한 호출이 이루어지는지를 보장하도록 모니터링될 수 있다. 몇몇의 구현에서, 가상 머신(934)은 이러한 RPC 호출이 가상 머신(934) 외부의 환경과 대화하는 가상 머신 내부의 코드에 대해서만 존재하도록 구성될 수 있다.

도시된 구현은 언배쳐/배쳐(938)와 레코드의 전송, 및 배치의 가상 머신 바운더리에 다른 결과만을 포함하지만, 다른 구현은 가상 머신 바운더리와 통신하는 배칭(batching)을 수행하지 않을 수 있다.

외부 액세스 가능 스토리지(916)는 클라이언트 시스템(902)에 액세스 가능한 호스팅된 스토리지 서비스로서 구성되어 클라이언트 시스템이 스토리지(916) 내에 사용자 프로그램(908)에 대한 입력 데이터와 같은 데이터를 저장 및/또는 사용자 프로그램(908)으로부터의 출력 데이터를 검색할 수 있도록 할 수 있다. 예를 들어, 스토리지(916)는 웹 서비스 API의 대응 셋을 통해 웹 서비스로서 구현될 수 있다. 웹 서비스 API는 예를 들어, Representational State Transfer(REST)-기반 HTTP 인터페이즈 또는 Simple Object Access Protocol(SOAP)-기반 인터페이즈로서 구현될 수 있다. REST-기반 인터페이즈에서, 데이터 객체는 URI를 사용하여 유일하게 명명된 자원으로서 액세스되며, 클라이언트 시스템(908)과 스토리지(916)는 연산의 정의된 셋을 사용하여 자원 상태의 표현을 교환한다. 예를 들어, 요청된 액션은 HTTP GET, PUT, POST, HEAD, 및 DELETE 동사(verb)와 같은 동사로서 표현될 수 있다. 데이터 센터(904)의 일부로서 도시되어 있지만, 스토리지(916)는 개별적인 데이터 센터 또는 다른 시설로 구현될 수 있다.

한 구현에서, 사용자 프로그램(908)의 결과가 스토리지(916) 내에 파일로 저장된다. 파일의 파일명은 실행 계획 서비스(920)에 의해 지정되거나 사용자 프로그램(908)에서 특정될 수 있다. 사용자 프로그램(908)이 실행을 완료하고 그 결과를 스토리지(916)에 저장하면, 성공적인 실행에 대한 통지(indication)가 클라이언트 시스템(902)으로 재전송될 수 있으며 (예를 들어, 파일명이 실행 계획 서비스(920)에 의해 생성되거나 그렇지 않으면 클라이언트 시스템(902)에 의해 알려지지 않았다면) 선택적으로 파일명을 포함할 수 있다. 다음에, 클라이언트 시스템(902)은 파일명과 API를 사용하여 그 결과를 검색할 수 있다.

도 10은 데이터 병렬 파이프라인을 포함하는 비신뢰 어플리케이션을 실행하기 위한 프로세스(1000)의 예를 도시한 흐름도이다. 다른 시스템 또는 시스템 구성이 프로세스(900)를 구현할 수 있지만, 프로세스(1000)가 시스템(900)의 컨텍스트(context)로 다음에서 설명된다. 또한, 다음에서 사용자 프로그램(908)(사용자 함수(936) 포함), 실행 계획 라이브러리(924), 및 언배쳐/배쳐(938)을 구현하기 위해 Java(R) 프로그래밍 언어를 사용한 예를 설명한다. 일반적으로, Java(R) 프로그램은 다양한 프로세싱 하드웨어와 호환되도록 가상 머신에서 실행된다. Java(R) 바이트코드(bytecode)를 실행하는 가상 머신의 사용은 비신뢰 코드가 가상 머신의 다중 계층 내에서 실행되도록 함으로써 비신뢰 사용자 코드에 대한 보안 추가 계층을 제공할 수 있다. 가장 사적인 가상 머신(innermost virtual machine)은 Java(R) 바이트코드를 실행하는데 사용되는 Java(R) VM이다. 다음 가상 머신은 게스트 운영 체제를 실행하고 네트웍 및 디스크 연결을 에뮬레이션하는 하드웨어 가상 머신이다.

시작 시에, 비신뢰 어플리케이션이 데이터 센터(904)에서 수신된다(1002). 예를 들어, 비신뢰 사용자가 (Java(R).jar 파일로서 표현된) 사용자 프로그램(908)을 예를 들어, 제공된 API 또는 인터페이즈를 사용하여 서비스 인터페이즈(918)로 업로드한다. 또한, 다음에, API 또는 인터페이즈를 사용하여, 사용자는 서비스 인터페이즈(910)가 몇몇의 아규먼트를 실행하는 것을 제어하면서 사용자 프로그램(908) 실행을 개시도록 지시한다. 예를 들어, 서비스 인터페이즈(910)는 예를 들어, KVM 기술을 사용하여 슬레이브 하드웨어 가상 머신(922)을 인스턴스화한다. 서비스 인터페이즈(910)는 사용자 프로그램(908) 및 실행 계획 라이브러리(926)를 구현하는데 사용되는 Java(R) runtime (Java(R) VM 포함), 사용자의 .jar 파일(사용자 프로그램)(908), 실행 계획 라이브러리 .jar 파일, 및 임의의 다른 표준 .jar 파일, 및 다른 파일들로 가상 머신의 (가상) 로컬 디스크를 채운다.

다음에, 비신뢰 어플리케이션이 제1 가상 머신에서 실행된다(1006). 예를 들어, 서비스 인터페이즈(918)가 Java(R) VM을 시작시켜 (가상 머신(922) 내에서) Java(R) VM 에서 사용자의 비신뢰 프로그램(906)을 실행할 수 있다. 이 사용자의 비신뢰 프로그램은 실행 계획 라이브러리(924)를 호출하여 이벨류에이터(926)가 사용자 프로그램(908) 내에 파이프라인을 형성하는 병렬 데이터 객체와 병렬 연산을 기초로 가상 머신(922)의 메모리 내에 데이터플로우 그래프를 구축한다.

제1 가상 머신의 외부에 데이터플로우 그래프를 나타내는 정보가 전달된다(1008). 예를 들어, 실행 계획 라이브러리(924)는 데이터플로우 그래프의 표현을 구축하고, 이를 RPC 호출을 사용하여 실행 계획 서비스(920)에 전달한다.

제1 가상 머신 외부에서, 하나 이상의 그래프 변환이 하나 이상의 지연 병렬 데이터 객체와 지연 컴바이닝 병렬 데이터 연산을 포함하는 수정 데이터플로우 그래프를 생성하도록 데이터플로우 그래프를 나타내는 정보에 적용된다(1010). 예를 들어, 실행 계획 서비스(920)는 데이터플로우 그래프의 표현을 수용하고 그래프 구조를 유효화한다. 옵티마이저(928)는 MSCR을 포함할 수 있는 지연 병렬 데이터 객체(또는 서브셋) 및 지연, 컴바이닝 병렬 데이터 연산을 포함하는 수정 데이터플로우 그래프를 생성하도록 그래프의 최적화를 수행한다.

지연 컴바이닝 병렬 연산이 다음에 실행되어 지연 병렬 데이터 객체에 대응하는 실체화된 병렬 데이터 객체를 생성한다(1012). 그 마지막에, 예를 들어, 익스큐터(930)가 다수의 맵 연산을 구현하는 단일 맵 함수와 다수의 리듀스 연산을 구현하는 단일 리듀스 함수를 포함하는 단일 맵리듀스 연산으로 그래프의 MSCR을 번역한다. 다음에, 익스큐터(930)는 단일 맵리듀스 연산을 원격, 병렬 연산으로서 실행하고, 그 결과 적절한 입력 파일(들)의 인디케이션 뿐만 아니라 다수의 병렬 맵 워커와 리듀스 워커(932)가 호출되고 단일 맵 또는 리듀스 함수가 패스된다. 워커들 중 하나는 다른 워커들의 활동을 코디네이션하는 마스터로 지정된다.

하나 이상의 제2 가상 머신이 다음에 비신뢰 사용자 함수에 대해 인스턴스화된다. 예를 들어, 주어진 호출 워커(932)는 사용자 함수(936) 및 언배쳐/배쳐(938)를 구현하는데 필요한 Java(R) runtime (Java(R) VM 포함), 단일 맵 또는 리듀스 함수의 카피, 언배쳐/배쳐 코드, 및 임의의 다른 표준 .jar 파일 및 다른 데이터 파일들로 가상 머신의 로컬 디스크를 채운다. 워커(932)는 가상 머신(934)에서 Java(R) VM을 시작시키고, Java(R) VM에서 언배쳐/배쳐(938)를 실행한다. 언배쳐/배쳐(938)는 Java(R) VM 내의 사용자 함수(936)의 호출을 제어한다.

가상 머신(934)이 인스턴스화되고, 언배쳐/배쳐(938)가 실행되면, 워커(932)는 스토리지(916)로부터 입력 파일을 액세스한다. 워커는 입력 파일로부터 레코드의 배치를 추출하여, RPC를 사용하여 이 레코드의 입력 배치를 VM(934) 내부의 언배쳐/배쳐(938)로 전달한다. 언배쳐/배쳐(938)는 입력 배치를 개별 레코드로 분할하고, 상요자의 함수를 호출하여 각각의 레코드를 차례로 프로세싱하고, 출력 레코드를 출력 배치로 수집하여, 최종적으로 RPC에 대한 응답 시에 워커(932)로 다시 출력 배치를 전달한다.

워커(932)가 출력 배치를 수신하면, 워커(932)는 예를 들어, 실행 계획 라이브러리(922) 또는 시스템(900)의 다른 컴포넌트에 의해 액세스될 수 있는 출력 파일 또는 파일들로 기록되는 결과를 갖도록 배열한다. 출력 파일을 기초로, 실행 계획 서비스(920)는 객체의 실체화 버전 또는 실체화 객체의 표현과 같은 객체의 실체화를 인에이블링하는 정보를 생성한다. 다음에, 실행 계획 서비스(920)는 이러한 정보를 사용하여 내부 데이터플로우 그래프에 데이터 객체를 실체화하여 이 실체화된 객체들이 사용자 프로그램(906)에 의해 사용될 수 있도록 한다.

한 구현에서, 사용자 프로그램(906)이 실행을 종료하면, 사용자 프로그램(906)의 출력 또는 결과가 서비스 인터페이즈(918)에 전달된다. 이 서비스 인터페이즈(918)는 다음에 이 출력을 클라이언트 시스템으로 바로 전달한다.

대안적으로 또는 추가적으로, 출력 또는 결과가 클라이언트 시스템(902)에 대해 액세스 가능해지도록 스토리지(916)에 파일로 저장될 수 있다. 이러한 경우에, 예를 들어, 파일의 파일명이 실행 계획 서비스(920)에 의해 지정될 수 있고 사용자 프로그램(908)이 성공적으로 실행된 것에 대한 인디케이션이 클라이언트 시스템(902)에 제공될 수 있다. 다음에, 클라이언트 시스템(902)은 파일명을 사용하여 결과를 검색할 수 있다. 다른 예에서, 사용자 프로그램(908)은 파일명을 지정할 수 있고 사용자 프로그램(908)의 성공적인 실행의 인디케이션이 파일명 없이클라이언트 시스템(902)으로 전송될 수 있다. 그러나, 사용자 프로그램(908)에 의해 파일명이 지정되었기 때문에, 클라이언트 시스템(902)은 파일명에 대한 액세스를 가질 수 있고 그 결과를 검색할 수 있다.

비신뢰 사용자 코드를 구현하는 가상 머신을 사용하는 것은 혼성 "종심 방어" 전략(heterogeneous "defense in depth" strategy)을 제공할 수 있다. 언더라잉 데이터 센터(underlying data center)를 위태롭게 위해서는, 불법적인 비신뢰 코드는 여러 검사 장벽(audited varriers)을 돌파해야 한다. 예를 들어, 하드웨어 가상 머신이 사용될 때, 비신뢰 코드는 하드웨어 가상 머신 상의 게스트 운영 체제에 의해 구현된 표준 프로세스 모델을 위태롭게 하여야 하고, 게스 액세스에서 "루트(root)"를 획득해야 한다. 다음에, 이 비신뢰 코드는 가상 머신의 에뮬레이터에 의해 제공되는 샌드박스를 위태롭게 하여야 한다. 또한, 런타임을 위해 가상 머신을 채용한 프로그래밍 언어가 사용될 때, 비신뢰 코드는 먼저 가장 사적인 가상 머신을 위태롭게 하여야 한다.

도시된 구조는 사용자 프로그램을 데이터 센터 내의 샌드박싱된 영역으로 격리하였지만, 데이터 센터 인프라스트럭쳐에 대해 제어되는 액세스를 갖는 다른 프로세싱 환경이 사용될 수 있다. 예를 들어, 다른 구현에서, 사용자 프로그램은 클라이언트 시스템(908) 상에서 실행할 수 있다. 실행 계획 라이브러리(924)와 유시한 클라이언트 시스템(908) 상의 라이브러리가 데이터플로우 그래프를 생성하여 그 데이터플로우 그래프의 표현을 실행 계획 서비스(920)에 직접 또는 서비스 인터페이즈(918)를 통해 전달할 수 있다. 다음에, 실행 계획 서비스(920)는 데이터플로우 그래프를 유효화하고, 수정 그래프를 생성하여 상술한 바와 같이 실행할 수 있는데, 언더라잉 데이터 센터 인프라스트럭쳐에 대한 사용자 함수에 의한 직접 액세스를 방지하도록 사용자 함수는 여전히 가상 머신(934) 또는 다른 샌드박스 내에서 실행된다.

상술한 기술은 임의의 특정한 하드웨어 또는 소프트웨어 구성으로 제한되지 않는다. 오히려, 이들은 하드웨어, 소프트웨어, 또는 이들의 조합을 사용하여 구현될 수 있다. 설명된 방법 및 프로세스는 적어도 하나의 프로세서 및 적어도 하나의 데이터 스토리지 시스템을 포함하는 프로그래밍 가능한 컴퓨터 상에서 실행되는 컴퓨터 프로그램으로서 구현될 수 있다. 이 프로그램은 하이 레벨 프로그래밍 언어로 구현될 수 있으며, 또한, 원한다면, 어셈블리 또는 다른 로우 레벨 언어로 구현될 수도 있다.

이러한 임의의 프로그램은 전형적으로 컴퓨터 판독가능한 스토리지 매체 또는 장치 (예를 들어, CD-ROM, RAM, 또는 자기 디스크)에 저장될 것이다. 컴퓨터의 프로세서로 판독되어 실행될 때, 프로그램의 명령은 프로그래밍 가능한 컴퓨터가 상술한 다양한 연산을 수행하도록 한다.

여러 구현 예가 설명되었다. 그럼에도 불구하고, 다양한 변형 예가 가능하다는 것이 이해될 것이다. 따라서, 다른 구현들도 다음의 특허 청구의 범위 내에 있다.

100: 데이터 센터
102: 렉
104: 프로세싱 모듈
202: 메모리
204: CPU
206: 네트웍 인터페이스
202a: 어플리케이션
202b: 맵 리듀스 라이브러리
202c: 파이프라인 라이브러리
202d: 운영 체제

Claims (51)

1. 하나 이상의 프로세싱 모듈(processing modules)을 포함하고 네이티브 프로세싱 환경(native processing environment)을 제공하는 데이터 센터에서, 데이터 병렬 파이프라인을 포함하는 비신뢰 어플리케이션을 수신하는 단계 - 상기 데이터 병렬 파이프라인은 다수의 엘리먼트(elements)를 포함하는 다수의 병렬 데이터 객체 및 상기 엘리먼트에 대해 연산하는 비신뢰 함수들과 연관된 다수의 병렬 연산을 특정(specify)함 - ;
   제1 보안 프로세싱 환경에서 상기 비신뢰 어플리케이션을 실행하는 단계- 상기 어플리케이션의 실행은 데이터 병렬 파이프라인에 대응하는 지연 병렬 연산들및 지연 병렬 데이터 객체들의 데이터플로우 그래프를 생성함 - ;
   상기 제1 보안 프로세싱 환경의 외부로 데이터플로우 그래프를 표현하는 정보를 전달하는 단계;
   상기 제1 보안 프로세싱 환경의 외부 및 상기 네이티브 프로세싱 환경의 내부에서, 하나 이상의 상기 지연 병렬 데이터 객체 및 하나 이상의 상기 비신뢰 함수와 연관된 지연 컴바이닝 병렬 데이터 연산들(deferred, combined parallel data operations)을 포함하는 수정 데이터플로우 그래프를 생성하도록 데이터플로우 그래프를 표현하는 정보에 하나 이상의 그래프 변환을 적용하는 단계; 및
   상기 지연 병렬 데이터 객체들에 대응하는 실체화된(materialized) 병렬 데이터 객체들을 생성하도록 상기 지연 컴바이닝 병렬 연산들을 실행하는 단계를 포함하되,
   상기 지연 컴바이닝 병렬 연산을 실행하는 단계는 상기 네이티브 프로세싱 환경에서 그리고 하나 이상의 프로세싱 모듈 상에서 하나 이상의 제2 보안 프로세싱 환경을 인스턴스화하는 단계와, 상기 하나 이상의 제2 보안 프로세싱 환경에서 상기 지연 컴바이닝 병렬 연산들과 연관된 상기 비신뢰 함수들을 실행하는 단계를 포함하는 방법.
2. 청구항 1에 있어서, 상기 제1 보안 프로세싱 환경은 제1 가상 머신을 포함하고 상기 하나 이상의 제2 보안 프로세싱 환경은 제2 가상 머신을 포함하는 방법.
3. 청구항 2에 있어서, 상기 제1 가상 머신 및 상기 하나 이상의 제2 가상 머신은 하드웨어 가상 머신인 방법.
4. 청구항 1에 있어서, 상기 하나 이상의 제2 보안 프로세싱 환경에서 상기 지연 컴바이닝 병렬 연산들과 연관된 상기 비신뢰 함수들을 실행하는 단계는,
   상기 제2 보안 프로세싱 환경의 외부로부터 상기 제2 보안 프로세싱 환경의 내부로 레코드의 입력 배치(input batch of records)를 전달하는 단계- 상기 레코드의 입력 배치는 다수의 개별 입력 레코드를 포함함 - ;
   출력 레코드를 생성하도록 상기 개별 레코드들 각각에 대해 상기 지연 컴바이닝 병렬 연산과 연관된 비신뢰 함수들 중 적어도 하나를 실행하는 단계;
   상기 출력 레코드들을 출력 배치(output batch) 수집(collecting)하는 단계; 및
   상기 제2 보안 프로세싱 환경의 외부로 상기 출력 배치를 전달하는 단계를 포함하는 방법.
5. 청구항 1에 있어서, 상기 비신뢰 어플리케이션을 상기 데이터 센터로 전송했던 클라이언트 시스템으로 상기 비신뢰 어플리케이션의 출력을 전송하는 단계를 더 포함하는 방법.
6. 청구항 1에 있어서, 상기 제1 보안 프로세싱 환경의 외부로 데이터플로우 그래프를 나타내는 정보를 전달하는 단계는 상기 제1 보안 프로세싱 환경의 외부에서 그래프 서비스를 실행하도록 상기 데이터플로우 그래프를 나타내는 정보를 전달하는 단계를 포함하는 방법.
7. 청구항 1에 있어서, 상기 지연 컴바이닝 병렬 데이터 연산들은 적어도 하나의 일반화된 맵리듀스 연산을 포함하고, 상기 일반화된 맵 리듀스 연산은 다수의 병렬 맵 연산과 다수의 병렬 리듀스 연산을 포함하며 상기 다수의 병렬 맵 연산을 구현하는 단일 맵 함수와 상기 다수의 병렬 리듀스 연산을 구현하는 단일 리듀스 함수를 포함하는 단일 맵 리듀스 연산으로 번역가능하고, 상기 단일 맵 함수와 상기 단일 리듀스 함수는 하나 이상의 상기 비신뢰 함수를 포함하는 방법.
8. 청구항 7에 있어서,
   상기 지연 컴바이닝 병렬 연산들을 실행하는 단계는 상기 컴바이닝 맵 리듀스 연산을 상기 단일 맵리듀스 연산으로 번역하는 단계를 포함하고,
   상기 하나 이상의 제2 보안 프로세싱 환경에서 상기 지연 컴바이닝 병렬 연산들과 연관된 상기 비신뢰 함수들을 실행하는 단계는 상기 하나 이상의 제2 보안 프로세싱 환경에서 상기 단일 맵 함수와 상기 단일 리듀스 함수를 실행하는 단계를 포함하는 방법.
9. 청구항 1에 있어서,
   상기 보안 프로세싱 환경에서 상기 비신뢰 어플리케이션을 실행하는 단계는 상기 제1 보안 프로세싱 환경에서 가상 머신 내에서 상기 비신뢰 어플리케이션을 실행하는 단계를 포함하고,
   상기 하나 이상의 보안 프로세싱 환경에서 상기 지연 컴바이닝 병렬 연산들과 연관된 상기 비신뢰 함수들을 실행하는 단계는 상기 하나 이상의 제2 보안 프로세싱 환경에서 가상 머신 내에서 상기 지연 컴바이닝 병렬 연산들과 연관된 상기 비신뢰 함수들을 실행하는 단계를 포함하는 방법.
10. 청구항 1에 있어서, 상기 제1 보안 프로세싱 환경의 외부로 상기 데이터플로우 그래프를 나타내는 정보를 전달하는 단계는 원격 프로시져 호출(remote procedure call)을 사용하여 상기 제1 보안 프로세싱 환경의 외부로 상기 데이터플로우 그래프를 나타내는 정보를 전달하는 단계를 포함하는 방법.
11. 청구항 10에 있어서, 상기 원격 프로시져 호출을 오디팅(auditing)하는 단계를 더 포함하는 방법.
12. 네이티브 프로세싱 환경을 제공하고 다음을 구현하도록 구성된 하나 이상의 프로세싱 모듈;
    네이티브 프로세싱 환경 내의 제1 보안 프로세싱 환경― 상기 제1 보안 프로세싱 환경은 데이터 병렬 파이프라인을 포함하는 비신뢰 어플리케이션을 실행하고, 상기 데이터 병렬 파이프라인은 다수의 엘리먼트를 포함하는 다수의 병렬 데이터 객체 및 상기 엘리먼트에 대해 연산하는 비신뢰 함수들과 연관된 다수의 병렬 연산을 특정하고, 상기 어플리케이션을 실행하는 것은 상기 데이터 병렬 파이프라인에 대응하는 지연 병렬 연산들과 지연 병렬 데이터 객체들의 데이터플로우 그래프를 생성하며, 상기 제1 보안 프로세싱 환경의 외부로 상기 데이터플로우 그래프를 나타내는 정보를 전달하도록 구성됨―;
    상기 서비스는 상기 제1 보안 프로세싱 환경 외부 및 상기 네이티브 프로세싱 환경 내부에 위치한 서비스―상기 서비스는 상기 제1 보안 프로세싱 환경으로부터 상기 데이터플로우 그래프를 나타내는 정보를 수신하고, 하나 이상의 상기 지연 병렬 데이터 객체 및 하나 이상의 비신뢰 함수와 연관된 지연 컴바이닝 병렬 데이터 연산들을 포함하는 수정 데이터플로우 그래프를 생성하도록 상기 데이터플로우 그래프를 나타내는 정보에 하나 이상의 그래프 변환을 적용하며, 상기 지연 병렬 데이터 객체들에 대응하는 실체화된 병렬 데이터 객체들을 생성하도록 상기 지연 컴바이닝 병렬 연산들을 실행하도록 구성됨―; 및
    상기 지연 컴바이닝 병렬 연산들을 실행하는 결과를 위해 상기 지연 컴바이닝 병렬 연산들과 연관된 상기 비신뢰 함수들 실행하도록 구성된, 상기 네이티브 프로세싱 환경 내의 하나 이상의 제2 보안 프로세싱 환경을 포함하는 시스템.
13. 청구항 12에 있어서, 상기 제1 보안 프로세싱 환경은 제1 가상 머신을 포함하고, 상기 하나 이상의 제2 보안 프로세싱 환경은 제2 가상 머신을 포함하는 시스템.
14. 청구항 13에 있어서, 상기 제1 가상 머신 및 상기 하나 이상의 제2 가상 머신은 하드웨어 가상 머신들인 시스템.
15. 청구항 12에 있어서,
    상기 하나 이상의 프로세싱 장치는 다수의 개별 입력 레코드를 포함하는 레코드들의 입력 배치(input batch)를 상기 제2 보안 프로세싱 환경의 외부로부터 상기 제2 보안 프로세싱 환경의 내부로 전달하도록 구성된 워커(worker)를 구현하도록 구성되고,
    상기 지연 컴바이닝 병렬 연산과 연관된 상기 비신뢰 함수를 실행하기 위해, 상기 하나 이상의 제2 보안 프로세싱 환경은 출력 레코드를 생성하도록 상기 입력 배치 내의 개별 레코드들 각각에 대해 상기 지연 컴바이닝 병렬 연산들과 연관된 상기 비신뢰 함수들 중 적어도 하나를 실행하고, 상기 출력 레코드들을 출력 배치(output batch)로 수집하며, 상기 출력 배치를 상기 워커로 전달하도록 구성되는 시스템.
16. 청구항 12에 있어서, 상기 비신뢰 어플리케이션의 출력을 수신하도록 구성된 클라이언트 시스템을 더 포함하는 시스템.
17. 청구항 12에 있어서,
    상기 지연 컴바이닝 병렬 데이터 연산들은 적어도 하나의 일반화된 맵리듀스 연산을 포함하고, 상기 일반화된 맵리듀스 연산은 다수의 병렬 맵 연산과 다수의 병렬 리듀스 연산을 포함하며 상기 다수의 병렬 맵 연산을 구현하는 단일 맵 함수와 상기 다수의 병렬 리듀스 연산을 구현하는 단일 리듀스 함수를 포함하는 단일 맵 리듀스 연산으로 번역가능하고, 상기 단일 맵 함수와 상기 단일 리듀스 함수는 하나 이상의 상기 비신뢰 함수를 포함하는 시스템.
18. 청구항 17에 있어서,
    상기 서비스는 상기 컴바이닝 맵리듀스 연산을 상기 단일 맵리듀스 연산으로 번역하도록 구성되고,
    상기 하나 이상의 제2 보안 프로세싱 환경은 상기 하나 이상의 제2 보안 프로세싱 환경 내에서 상기 단일 맵 함수와 상기 단일 리듀스 함수를 실행하도록 구성되는 시스템.
19. 청구항 12에 있어서,
    상기 제1 보안 프로세싱 환경은 상기 제1 보안 프로세싱 환경에서 가상 머신 내에서 상기 비신뢰 어플리케이션을 실행하도록 구성되고,
    상기 하나 이상의 제2 보안 프로세싱 환경은 상기 하나 이상의 제2 보안 프로세싱 환경에서 가상 머신 내에서 상기 지연 컴바이닝 병렬 연산들과 연관된 상기 비신뢰 함수들을 실행하도록 구성되는 시스템.
20. 명령을 저장하는 컴퓨터 판독가능한 매체에 있어서,
    하나 이상의 프로세싱 장치에 의해 실행될 때, 상기 하나 이상의 프로세싱 장치가,
    지연 병렬 데이터 객체들 및 지연 병렬 연산들의 데이터플로우 그래프를 나타내는 정보를 액세스(access)하고 - 상기 지연 병렬 데이터 객체들 및 지연 병렬 연산들은 비신뢰 어플리케이션 내에 포함되는 데이터 병렬 파이프라인에 의해 특정되는 병렬 데이터 객체들 및 병렬 연산들에 대응하고, 상기 병렬 데이터 객체는 다수의 엘리먼트를 포함하고 상기 병렬 연산들은 상기 엘리먼트에 대해 연산하는 비신뢰 함수들과 연관됨 - ;
    하나 이상의 상기 비신뢰 함수들과 연관된 지연 컴바이닝 병렬 데이터 연산들 및 하나 이상의 상이 지연 병렬 데이터 객체들을 포함하는 수정 데이터플로우 그래프를 생성하도록 상기 데이터플로우 그래프를 나타내는 정보에 하나 이상의 그래프 변환을 적용하며;
    상기 지연 병렬 데이터 객체에 대응하는 실체화된 병렬 데이터 객체들을 생성하도록 상기 지연 컴바이닝 병렬 연산들을 실행 - 상기 지연 컴바이닝 병렬 연산들을 실행하기 위해, 상기 명령은 하나 이상의 처리 장치가 하나 이상의 보안프로세싱 환경을 인스턴스화하고, 상기 하나 이상의 보안 프로세싱 환경에서 상기 지연 컴바이닝 병렬 연산들과 연관된 상기 비신뢰 함수들을 실행하도록 하는 것을 포함함 - ;
    하도록 하는 컴퓨터 판독가능한 매체.
21. 청구항 20에 있어서,
    지연 병렬 데이터 객체들과 지연 병렬 연산들의 데이터플로우 그래프를 나타내는 정보를 액세스하기 위해, 상기 하나 이상의 프로세싱 장치에 의해 실행될 때, 상기 명령은 상기 프로세싱 장치가,
    상기 하나 이상의 프로세싱 장치가 상기 데이터 병렬 파이프라인을 포함하는 비신뢰 어플리케이션을 수신하고,
    초기 보안 프로세싱 환경을 인스턴스화하며,
    상기 초기 보안 프로세싱 환경에서 상기 비신뢰 어플리케이션을 실행하고 - 상기 어플리케이션을 실행하는 것은 지연 병렬 데이터 객체들 및 지연 병렬 연산들의 데이터플로우 그래프를 생성함 - ,
    상기 초기 보안 프로세싱 환경의 외부로 상기 데이터플로우 그래프를 나타내는 상기 정보를 전달하여 상기 그래프 변환이 상기 초기 보안 프로세싱 환경의 외부에서 상기 데이터플로우 그래프를 나타내는 상기 정보에 적용되도록 하는 매체.
22. 청구항 21에 있어서, 상기 하나 이상의 보안 프로세싱 환경은 가상 머신을 포함하는 매체.
23. 시스템에 있어서,
    하나 이상의 프로세싱 장치;
    상기 하나 이상의 프로세싱 장치에 의해 실행될 때 다음을 구현하는 명령들을 저장하는 하나 이상의 스토리지 장치;
    다수의 엘리먼트를 포함하는 다수의 병렬 데이터 객체들 및 상기 병렬 데이터 객체에 대해 연산하는 다수의 병렬 연산을 특정하는 데이터 병렬 파이프라인을 포함하는 어플리케이션;
    상기 데이터 병렬 파이프라인을 기초로, 상기 데이터 병렬 파이프라인에 대응하는 지연 병렬 연산들 및 지연 병렬 데이터 객체들의 데이터플로우 그래프를 생성하도록 구성된 이벨류에이터(evaluator);
    하나 이상의 지연 병렬 데이터 객체들 및 지연 컴바이닝 병렬 연산들을 포함하는 수정 데이터플로우 그래프를 생성하도록 하나 이상의 그래프 변환을 상기 데이터플로우 그래프에 적용하도록 구성된 옵티마이저(optimizer); 및
    상기 지연 병렬 데이터 객체에 대응하는 실체화된 병렬 데이터 객체를 생성하기 위해 상기 지연 컴바이닝 병렬 연산들을 실행하도록 구성된 익스큐터(executor)를 포함하는 시스템.
24. 청구항 23에 있어서,
    상기 지연 컴바이닝 병렬 데이터 연산들은 적어도 하나의 일반화된 맵 리듀스 연산을 포함하고, 상기 일반화된 맵리듀스 연산은 다수의 병렬 맵 연산 및 다수의 병렬 리듀스 연산을 포함하며, 다수의 병렬 맵 연산을 구현하는 단일 맵 함수 및 다수의 병렬 리듀스 연산을 구현하는 단일 리듀스 함수를 포함하는 단일 맵리듀스 연산으로 번역가능한 시스템.
25. 청구항 24에 있어서, 상기 일반화된 맵리듀스 연산을 실행하기 위해, 익스큐터(executor)는 상기 컴바이닝 맵리듀스 연산을 상기 단일 맵리듀스 연산으로 번역하여 상기 단일 맵리듀스 연산을 실행하도록 하는 시스템.
26. 청구항 25에 있어서, 상기 단일 맵리듀스 연산을 실행하기 위해, 상기 익스큐터는 상기 단일 맵리듀스 연산을 로컬, 순차 연산으로 실행할지 또는 원격, 병렬 연산으로 실행할지를 결정하도록 구성된 시스템.
27. 청구항 25에 있어서, 상기 일반화된 맵리듀스 연산을 상기 단일 맵리듀스 연산으로 번역하기 위해, 상기 익스큐터는 상기 다수의 맵 연산을 포함하는 맵 함수와 상기 다수의 리듀서 연산을 포함하는 리듀서 함수를 생성하도록 구성된 시스템.
28. 청구항 23에 있어서, 각각의 지연 병렬 데이터 객체는 상기 병렬 데이터 객체를 생성하는 병렬 데이터 연산에 대한 포인터를 포함하는 시스템.
29. 청구항 23에 있어서, 각각의 지연 병렬 연산은 상기 지연 병렬 연산으로의 입력인 병렬 데이터 객체에 대한 포인터와 상기 지연 병렬 연산의 출력인 지연 병렬 객체에 대한 포인터를 포함하는 시스템.
30. 청구항 23에 있어서, 각각의 실체화된 객체는 상기 객체 내에 포함된 데이터를 포함하는 시스템.
31. 청구항 23에 있어서, 상기 다수의 병렬 데이터 객체는 호스트 프로그래밍 언어의 제1 클래스 객체들인 시스템.
32. 청구항 23에 있어서, 상기 파이프라인은 단일 엘리먼트를 포함하는 단일 데이터 객체를 더 포함하고 상기 데이터플로우 그래프는 대응하는 지연 단일 데이터 객체를 포함하는 시스템.
33. 청구항 32에 있어서, 상기 파이프라인 내의 다수의 병렬 연산들 중 적어도 하나는 상기 단일 데이터 객체 및 상기 다수의 병렬 데이터 객체들 중 하나에 대해 연산하고 상기 데이터플로우 그래프는 지연 단일 데이터 객체와 지연 병렬 데이터 객체에 대해 연산하는 대응하는 지연 병렬 연산을 포함하는 시스템.
34. 청구항 23에 있어서, 상기 익스큐터는 상기 데이터 병렬 파이프라인의 미래의 실행에 사용하기 위해 상기 지연 컴바이닝 병렬 연산들의 하나 이상의 실행 결과를 캐싱(caching)하도록 구성되는 시스템.
35. 시스템에 있어서,
    하나 이상의 프로세싱 장치;
    상기 하나 이상의 프로세싱 장치에 의해 실행될 때, 다음과 같이 구현하는 명령들을 저장하는 하나 이상의 스토리지 장치; 및
    지연 병렬 데이터 객체들 및 지연 컴바이닝 병렬 데이터 연산들을 포함하는 데이터플로우 그래프를 액세스하고, 상기 지연 병렬 데이터 객체에 대응하는 실체화된 병렬 데이터 객체들을 생성하도록 상기 지연 컴바이닝 병렬 연산들을 실행하도록 구성되며, 상기 지연 컴바이닝 병렬 연산들 중 적어도 하나에 대해, 상기 적어도 하나의 지연 컴바이닝 병렬 연산과 연관된 추정 크기를 결정하고, 상기 추정된 크기가 임계 크기를 초과하는지를 판정하고, 상기 추정 크기가 임계 크기 아래이면, 상기 적어도 하나의 지연 컴바이닝 연산을 로컬, 순차 연산으로서 실행하고, 상기 추정 크기가 임계 크기를 초과하면, 상기 적어도 하나의 지연 컴바이닝 병렬 연산을 원격, 병렬 연산으로서 실행함으로써 상기 적어도 하나의 지연 컴바이닝 병렬 연산을 실행하도록 구성되는 익스큐터를 포함하는 시스템.
36. 청구항 35에 있어서, 상기 적어도 하나의 지연 컴바이닝 병렬 연산과 연관된 상기 데이터는 상기 적어도 하나의 지연 컴바이닝 병렬 연산에 대한 하나 이상의 입력 데이터, 상기 적어도 하나의 지연 컴바이닝 병렬 연산에 의해 생성된 중간 데이터(intermediary data), 또는 상기 적어도 하나의 지연 컴바이닝 병렬 연산에 의해 생성되는 출력 데이터를 포함하는 시스템.
37. 청구항 35에 있어서,
    상기 적어도 하나의 지연 컴바이닝 병렬 데이터 연산은 일반화된 맵리듀스 연산이고, 상기 일반화된 맵리듀스 연산은 다수의 병렬 맵 연산과 다수의 병렬 리듀스 연산을 포함하며 다수의 병렬 맵 연산을 구현하는 단일 맵 함수 및 다수의 병렬 리듀스 연산을 구현하는 단일 리듀스 함수를 포함하는 단일 맵리듀스 연산으로 번역가능하고,
    상기 실체화된 맵리듀스 연산을 실행하기 위해, 상기 익스큐터는 상기 컴바이닝 맵리듀스 연산을 상기 단일 맵리듀스 연산으로 번역하여 상기 맵리듀스 연산을 실행하는 시스템.
38. 청구항 37에 있어서, 상기 단일 맵리듀스 연산을 원격 병렬 연산으로서 실행하기 위해, 익스큐터는 단일 맵리듀스 연산이 데이터 센터 내의 다수의 상이한 프로세싱 모듈들 상에서 복사되고 실행되도록 구성되는 시스템.
39. 청구항 37에 있어서, 상기 일반화된 맵리듀스 연산을 상기 단일 맵리듀스 연산으로 변역하기 위해, 상기 익스큐터는 상기 다수의 맵 연산을 포함하는 맵 함수와 상기 다수의 리듀서 여산을 포함하는 리듀서 함수를 생성하도록 구성되는 시스템.
40. 청구항 35에 있어서, 상기 추정 크기를 판정하기 위해, 상기 익스큐터는 상기 적어도 하나의 지연 컴바이닝 병렬 연산과 연관된 데이터의 크기의 추정을 반영하는 데이터플로우 그래프 내에 주석 달기(annotations)를 액세스하도록 구성되는 시스템.
41. 청구항 35에 있어서, 각각의 지연 병렬 데이터 객체는 상기 병렬 데이터 객체를 생성하는 병렬 데이터 연산에 대한 포인터를 포함하는 시스템.
42. 청구항 35에 있어서, 각각의 지연 병렬 연산은 상기 지연 병렬 연산으로의 입력인 병렬 데이터 객체에 대한 포인터와 상기 지연 병렬 연산의 출력인 지연 병렬 객체에 대한 포인터를 포함하는 시스템.
43. 청구항 35에 있어서, 각각의 실체화된 객체는 상기 객체 내에 포함되는 데이터를 포함하는 시스템.
44. 시스템에 있어서,
    하나 이상의 프로세싱 장치;
    상기 하나 이상의 프로세싱 장치에 의해 실행될 때, 다음을 구현하는 명령들을 저장하는 하나 이상의 스토리지 장치; 및
    지연 병렬 데이터 객체 및 지연 컴바이닝 병렬 데이터 연산들을 포함하는 데이터플로우 그래프를 액세스하고 - 상기 지연 컴바이닝 병렬 데이터 연산들 중 적어도 하나는 일반화된 맵리듀스 연산이고, 상기 일반화된 맵리듀스 연산은 다수의 병렬 맵 연산들 및 다수의 병렬 리듀스 연산들을 포함하며 상기 다수의 병렬 맵 연산을 구현하는 단일 맵 함수와 상기 다수의 병렬 리듀스 연산을 구현하는 단일 리듀스 함수를 포함하는 단일 맵리듀스 연산으로 번역가능함 - , 상기 지연 병렬 데이터 객체들에 대응하는 실체화된 병렬 데이터 객체들을 생성하도록 상기 지연 컴바이닝 병렬 연산들을 실행하도록 구성된 익스큐터를 포함하며,
    상기 일반화된 맵리듀스 연산을 실행하기 위해, 상기 익스큐터는 상기 컴바이닝 맵리듀스 연산을 상기 단일 맵리듀스 연산으로 번역하여 상기 단일 맵리듀스 연산을 실행하도록 구성되는 시스템.
45. 청구항 44에 있어서, 상기 일반화된 맵리듀스 연산을 단일 맵리듀스 연산으로 번역하기 위해, 익스큐터는 상기 다수의 맵 연산을 포함하는 맵 함수와 상기 다수의 리듀스 연산을 포함하는 리듀스 함수를 생성하도록 구성되는 시스템.
46. 청구항 45에 있어서, 상기 익스큐터는 상기 단일 맵리듀스 연산을 원격 병렬 연산으로서 실행하도록 구성되는 시스템.
47. 청구항 46에 있어서, 상기 단일 맵리듀스 연산을 원격 병렬 연산으로서 실행하기 위해, 상기 익스큐터는 상기 단일 맵리듀스 연산이 다수의 상이한 프로세싱 모듈들 상에서 다수의 워커 프로세스에 의해 실행되도록 구성되는 시스템.
48. 청구항 46에 있어서, 상기 단일 맵리듀스 연산이 다수의 워커 프로세스에 의해 실행되도록 하기 위해, 상기 익스큐터는 다수의 맵 워커 프로세스가 상기 맵리듀스 연산들 각각에 대해 호출되도록 구성되며, 상기 다수의 맵 워커 프로세스 각각에 인덱스 넘버(index number)가 할당되는 시스템.
49. 청구항 48에 있어서, 상기 맵 워커 프로세스들 각각은 상기 다수의 맵 연산을 구현하는 맵 함수, 상기 맵 연산들 중 하나와 연관된 하나 이상의 입력, 및 맵 워커 프로세스의 연관된 인덱스를 수신하고, 상기 맵 워커 프로세스의 연관된 인덱스를 기초로 상기 입력과 연관된 맵 연산을 선택하며, 상기 하나 이상의 입력에 대해 상기 선택된 맵 연산을 호출하도록 구성되는 시스템.
50. 청구항 46에 있어서, 상기 단일 맵리듀스 연산이 다수의 워커 프로세스에 의해 실행되도록 하기 위해, 상기 익스큐터는 상기 다수의 리듀스 워커 프로세스가 상기 리듀스 연산들 각각에 대해 호출되도록 구성되며, 상기 다수의 리듀스 워커 프로세스 각각에 인덱스 넘버가 할당되는 시스템.
51. 청구항 50에 있어서, 상기 다수의 리듀스 워커 프로세스 각각은 상기 다수의 리듀스 연산을 구현하는 리듀스 함수, 상기 리듀스 연산들 중 하나와 연관된 하나 이상의 입력, 및 상기 리듀스 워커 프로세스의 연관된 인덱스를 수신하고, 상기 워커 프로세스의 연관된 인덱스를 기초로 상기 입력과 연관된 상기 리듀스 연산을 선택하며, 상기 하나 이상의 입력에 대해 상기 선택된 리듀스 연산을 호출하도록 구성되는 시스템.

Images