KR102396002B1

KR102396002B1 - 컴퓨팅 클러스터 인터페이스 관리

Info

Publication number: KR102396002B1
Application number: KR1020207015393A
Authority: KR
Inventors: 브라이언 필 도로스; 크레이그 더블유. 스탠필
Original assignee: 아브 이니티오 테크놀로지 엘엘시
Priority date: 2017-10-31
Filing date: 2018-10-30
Publication date: 2022-05-09
Also published as: CN111373373B; AU2018357870B2; JP2021501398A; SG11202002998QA; CA3078469A1; KR20200077548A; KR20200078577A; WO2019089601A1; AU2021277733A1; CA3078483A1; EP3704578A1; CN111295643A; CN111316241B; EP3704580B1; AU2018359378B2; AU2018359378A1; US10949414B2; EP3704577A1; CN111316243A; SG11202002986TA

Abstract

분산형 데이터 처리 시스템을 사용하여 데이터를 처리하기 위한 방법은, 분산형 데이터 처리 시스템과 통신하는 분산형 데이터 처리 시스템 인터페이스 구성 요소로부터 분산형 데이터 처리 시스템으로 입력 데이터를 제공하는 단계를 포함한다. 분산형 데이터 처리 시스템은 분산형 데이터 처리 시스템 인터페이스 구성 요소에 제공되는 응답을 생성하기 위해 입력 데이터를 처리한다. 분산형 데이터 처리 시스템 인터페이스 구성 요소는 응답이 충분한 지속성 레벨에 도달했다는 표시를 분산형 데이터 처리 시스템으로부터 수신할 때까지, 에스크로에 응답을 유지한다.

Description

컴퓨팅 클러스터 인터페이스 관리

관련 출원들에 대한 상호 참조

본 출원은 본원에 참조로 포함되는 2017년 10월 31일자로 출원된 미국 출원 일련번호 제62/579,225호에 대한 우선권을 주장한다.

본 설명은 컴퓨팅 클러스터(cluster) 관리에 관한 것이다.

데이터 흐름 계산에 대한 한 가지 접근 방식은, 그래프의 노드(정점)에 해당하는 계산 구성 요소(component)가 그래프("데이터 흐름 그래프"로 지칭됨)의 링크(방향 에지)에 해당하는 데이터 흐름에 의해 연결되는 그래프 기반 표현을 사용한다. 데이터 흐름 링크에 의해 업스트림 구성 요소에 연결된 다운스트림 구성 요소는 정렬된 입력 데이터 요소 스트림을 수신하고, 수신된 순서로 입력 데이터 요소를 처리함으로써, 적어도 하나의 대응하는 출력 데이터 요소 흐름을 선택적으로 생성한다. 이러한 그래프 기반 계산을 실행하기 위한 시스템은 본원에 참조로 포함되는 "그래프로 표현되는 계산 실행"이라는 명칭의 선행 미국 특허 제5,966,072호에 기술된다. 상기 선행 특허에 기술된 접근 방식과 관련된 구현예에서, 각각의 구성 요소는 전형적으로 다수의 컴퓨터 서버 중 하나를 통해 호스팅되는 프로세스로서 구현된다. 각각의 컴퓨터 서버는 항상 활성인 다수의 그러한 구성 요소 프로세스를 가질 수 있으며, 운영 체제(예를 들어, Unix) 스케줄러는 그 서버를 통해 호스팅되는 구성 요소 간에 자원(예를 들어, 프로세서 시간, 및/또는 프로세서 코어)을 공유한다. 이러한 구현예에서, 구성 요소 간의 데이터 흐름은 운영 체제의 데이터 통신 서비스, 및 서버를 연결하는 데이터 네트워크(예를 들어, 명명된 파이프, TCP/IP 세션 등)를 사용하여 구현될 수 있다. 일반적으로, 구성 요소의 서브 세트는 예를 들어, 데이터 파일, 데이터베이스 테이블, 및 외부 데이터 흐름으로 및/또는 데이터 파일, 데이터베이스 테이블, 및 외부 데이터 흐름으로부터, 전반적인 계산으로부터의 데이터의 소스 및/또는 수신부(sink)로서 역할을 한다. 예를 들어, 조정 프로세스에 의해, 구성 요소 프로세스 및 데이터 흐름이 설정된 후에, 각각의 구성 요소에서의 입력 데이터의 이용 가능성, 및 각각의 구성 요소에 대한 컴퓨팅 자원의 스케줄링에 의해 일반적으로 제어되는 그래프로 표현된 계산을 구현하는 전반적인 계산 시스템을 통해 데이터가 흐른다. 따라서, 병렬 처리(parallelism)는 적어도, (동일하거나 상이한 서버 컴퓨터 또는 프로세서 코어를 통해 호스팅되는) 상이한 프로세스에 의해 상이한 구성 요소가 병렬로 실행될 수 있게 함으로써 달성될 수 있으며, 데이터 흐름 그래프를 통하는 상이한 경로에서 병렬로 실행되는 상이한 구성 요소는 본원에서 구성 요소 병렬 처리로 지칭되고, 데이터 흐름 그래프를 통하는 동일한 경로의 상이한 부분에서 병렬로 실행되는 상이한 구성 요소는 본원에서 파이프라인 병렬 처리로 지칭된다.

이러한 접근 방식에 의해 다른 형태의 병렬 처리도 지원된다. 예를 들어, 입력 데이터 세트는 예를 들어, 데이터 세트의 레코드에서 필드 값의 분할에 따라 분할될 수 있으며, 각각의 부분은 데이터 세트의 레코드를 처리하는 구성 요소의 별도의 복사본에 전송된다. 구성 요소의 이러한 별도의 복사본(또는 "인스턴스(instance)")은 별도의 서버 컴퓨터, 또는 서버 컴퓨터의 별도의 프로세서 코어를 통해 실행될 수 있으며, 이에 따라 본원에서 데이터 병렬 처리로 지칭되는 것을 달성할 수 있다. 별도의 구성 요소의 결과는 단일 데이터 흐름 또는 데이터 세트를 다시 형성하도록 병합될 수 있다. 구성 요소의 인스턴스를 실행하기 위해 사용되는 컴퓨터 또는 프로세서 코어의 수는 데이터 흐름 그래프가 개발될 때 개발자에 의해 지정된다.

이러한 접근 방식의 효율을 개선하기 위해 다양한 접근 방식이 사용될 수 있다. 예를 들어, 구성 요소의 각각의 인스턴스는, 예를 들어 다수의 구성 요소(예를 들어, 더 큰 그래프의 연결된 서브 그래프를 형성하는 구성 요소)를 구현하기 위해 하나의 운영 체제 프로세스를 사용하여, 반드시 그 자체의 운영 체제 프로세스로 호스팅될 필요는 없다.

전술한 접근 방식의 적어도 일부 구현은 기본 컴퓨터 서버를 통한 결과적인 프로세스의 실행 효율과 관련된 제한 사항을 받는다. 예를 들어, 제한 사항은 데이터 병렬 처리의 정도를 변경, 다양한 구성 요소를 호스팅하는 서버로 변경, 및/또는 상이한 계산 자원에 대한 부하를 상쇄시키기 위해, 그래프의 실행 인스턴스를 재구성할 때의 어려움에 관련될 수 있다. 기존의 그래프 기반 계산 시스템은 또한 느린 시동 시간을 겪는데, 이는 흔히 너무 많은 프로세스가 불필요하게 개시되어, 많은 양의 메모리를 소모하기 때문이다. 일반적으로, 프로세스는 그래프 실행의 시동 시에 시작되고, 그래프 실행이 완료되면 종료된다.

계산을 분산시키기 위한 다른 시스템이 사용되었으며, 전체 계산은 더 작은 부분들로 분할되고, 그 부분들은 하나의 마스터 컴퓨터 서버로부터 각각 독립적으로 계산을 수행하는 다양한 다른(예를 들어, "슬레이브") 컴퓨터 서버로 분산되며, 이들의 결과를 마스터 서버로 복귀시킨다. 이러한 접근 방식 중 일부는 "그리드 컴퓨팅"으로 지칭된다. 그러나, 이러한 접근 방식은, 계산 부분들 간에 데이터를 전달하기 위한 메커니즘, 또는 그러한 부분들을 호출하는 마스터 컴퓨터 서버를 통하는 것을 제외한, 부분들의 실행을 스케줄링 및/또는 시퀀싱하기 위한 메커니즘을 제공하지 않으면서, 각각의 계산의 독립성에 일반적으로 의존한다. 따라서, 이러한 접근 방식은 다수의 구성 요소 간의 상호 작용을 수반하는 계산을 호스팅하는 것에 대한 직접적이고 효율적인 솔루션을 제공하지 않는다.

대규모 데이터 세트에 대한 분산형 계산을 위한 다른 접근 방식은 예를 들어, Apache Hadoop® 시스템으로 구현되는 바와 같은 MapReduce 프레임워크를 사용한다. 일반적으로, Hadoop는 각각의 명명된 파일에 대한 부분이 분산되는 분산형 파일 시스템을 갖는다. 사용자는 2가지 기능 관점에서, 즉 명명된 입력의 모든 부분에 대해 분산형 방식으로 실행되는 맵 기능, 및 맵 기능 실행의 출력의 부분에 대해 실행되는 축소 기능의 관점에서, 계산을 명시한다. 맵 기능 실행의 출력은 분산형 파일 시스템에서 분할되어 다시 중간 부분에 저장된다. 그 다음, 축소 기능이 분산형 방식으로 실행되어 중간 부분을 처리함으로써, 전체 계산 결과를 산출한다. MapReduce 프레임워크로 표현될 수 있는 계산, 및 맵-축소 프레임워크의 파일 시스템 내에 저장을 위해 보정 가능한 이의 입력 및 출력이 효율적으로 실행될 수 있지만, 많은 계산은 이러한 프레임워크와 일치하지 않거나/일치하지 않고, 분산형 파일 시스템 내에 이들의 모든 입력 및 출력을 갖도록 쉽게 적응되지 않는다.

일반적인 양태에서, 다수의 처리 노드를 포함하는 분산형 데이터 처리 시스템을 사용하여 데이터를 처리하기 위한 방법은, 분산형 데이터 처리 시스템과 통신하는 분산형 데이터 처리 시스템 인터페이스 구성 요소에서 입력 데이터를 수신하는 단계; 및 수신된 입력 데이터를 분산형 데이터 처리 시스템에 제공하는 단계를 포함한다. 분산형 데이터 처리 시스템은 다수의 시간 간격 중 제1 시간 간격과 연관된 표시자를 입력 데이터에 할당한다.

방법은 입력 데이터를 수신하는 단계에 응답하여, 분산형 데이터 처리 시스템 내의 상태 정보를 생성하는 단계를 더 포함한다. 상태 정보는 제1 시간 간격과 연관된 표시자를 포함한다. 방법은 분산형 데이터 처리 시스템 인터페이스 구성 요소에서, 분산형 데이터 처리 시스템으로부터 입력 데이터와 연관된 결과 데이터를 수신 및 저장하는 단계를 더 포함하며, 결과 데이터는 제1 시간 간격보다 이후의 제2 시간 간격과 연관된 표시자를 포함한다. 방법은, 다수의 처리 노드 중 제1 처리 노드에서, 제2 시간 간격과 연관된 표시자를 포함하는 모든 상태 정보가 제1 지속성 레벨로 저장되는 다수의 시간 간격 중 가장 빠른 시간 간격의 표시자를 결정하는 단계를 더 포함한다. 방법은, 가장 빠른 시간 간격의 표시자를 분산형 데이터 처리 시스템 인터페이스 구성 요소에 제공하는 단계, 및 분산형 데이터 처리 시스템 인터페이스 구성 요소에서, 결과 데이터와 연관된 제2 시간 간격과 연관된 표시자와 가장 빠른 시간 간격의 표시자의 비교에 기초하여, 분산형 데이터 처리 시스템 인터페이스로부터 결과 데이터를 배포할지 여부를 결정하는 단계를 더 포함한다.

양태는 다음의 특징 중 적어도 하나를 포함할 수 있다.

방법은, 가장 빠른 시간 간격의 표시자가 제2 시간 간격과 동일하거나 제2 시간 간격보다 이후의 시간 간격에 해당하는 경우, 분산형 데이터 처리 시스템 인터페이스 구성 요소로부터 결과 데이터를 배포하는 단계를 포함할 수 있다. 입력 데이터는 인터페이스 구성 요소에서 버퍼에 저장될 수 있으며, 결과 데이터를 배포하는 단계는 버퍼로부터 입력 데이터를 제거하는 단계를 포함한다. 제1 지속성 레벨은 모든 상태 정보가 분산형 데이터 처리 시스템의 다수의 처리 노드 중 적어도 하나의 처리 노드와 연관된 휘발성 메모리에 복제됨을 나타낼 수 있다. 제1 지속성 레벨은 모든 상태 정보가 분산형 데이터 처리 시스템의 다수의 처리 노드 중 적어도 하나의 처리 노드와 연관된 지속성 메모리에 저장됨을 나타낼 수 있다.

제1 지속성 레벨은 모든 상태 정보가 분산형 데이터 처리 시스템의 외부의 지속성 메모리에 저장됨을 나타낼 수 있다. 방법은 결과 데이터를 생성하기 위해 다수의 처리 노드 중 하나의 처리 노드에서 입력 데이터를 처리하는 단계를 포함할 수 있다. 입력 데이터는 데이터 처리 작업을 포함할 수 있으며, 결과 데이터는 데이터 처리 작업의 결과를 포함한다. 입력 데이터는 인터페이스 구성 요소에서 버퍼에 저장될 수 있으며, 방법은 제1 처리 노드로부터 입력 데이터의 처리가 실패했다는 표시를 수신하는 단계, 결과를 폐기하는 단계, 및 버퍼에 저장된 입력 데이터를 분산형 데이터 처리 시스템에 다시 제공하는 단계를 포함할 수 있다.

입력 데이터는 고유 식별자와 연관될 수 있으며, 다시 제공된 입력 데이터는 원래 제공된 입력 데이터와 동일한 고유 식별자를 가질 수 있다. 방법은 제1 처리 노드에서, 제2 시간 간격과 연관된 표시자를 포함하는 모든 상태 정보가 제2 지속성 레벨로 저장되는 다수의 시간 간격 중 가장 빠른 시간 간격의 제2 표시자를 결정하는 단계를 포함할 수 있다. 제2 지속성 레벨은 제1 지속성 레벨보다 상대적으로 더 지속성일 수 있다. 제2 지속성 레벨은 제1 지속성 레벨보다 상대적으로 덜 지속성일 수 있다.

다른 일반적인 양태에서, 다수의 처리 노드를 포함하는 분산형 데이터 처리 시스템을 사용하여 데이터를 처리하기 위한 소프트웨어는 컴퓨터 판독 가능 매체에 비-일시적 형태로 저장된다. 소프트웨어는, 컴퓨팅 시스템으로 하여금, 분산형 데이터 처리 시스템과 통신하는 분산형 데이터 처리 시스템 인터페이스 구성 요소에서 입력 데이터를 수신하게 하고, 수신된 입력 데이터를 분산형 데이터 처리 시스템에 제공하게 하기 위한 명령을 포함한다. 분산형 데이터 처리 시스템은 다수의 시간 간격 중 제1 시간 간격과 연관된 표시자를 입력 데이터에 할당한다.

또한, 명령은 컴퓨터 시스템으로 하여금, 입력 데이터를 수신하는 것에 응답하여, 분산형 데이터 처리 시스템 내의 상태 정보를 생성하게 한다. 상태 정보는 제1 시간 간격과 연관된 표시자를 포함한다. 또한, 명령은 컴퓨터 시스템으로 하여금, 분산형 데이터 처리 시스템 인터페이스 구성 요소에서, 분산형 데이터 처리 시스템으로부터 입력 데이터와 연관된 결과 데이터를 수신 및 저장하게 한다. 결과 데이터는 제1 시간 간격보다 이후의 제2 시간 간격과 연관된 표시자를 포함한다. 또한, 명령은 컴퓨터 시스템으로 하여금, 다수의 처리 노드 중 제1 처리 노드에서, 제2 시간 간격과 연관된 표시자를 포함하는 모든 상태 정보가 제1 지속성 레벨로 저장되는 다수의 시간 간격 중 가장 빠른 시간 간격의 표시자를 결정하게 한다.

또한, 명령은 컴퓨터 시스템으로 하여금, 가장 빠른 시간 간격의 표시자를 분산형 데이터 처리 시스템 인터페이스 구성 요소에 제공하게 하고, 분산형 데이터 처리 시스템 인터페이스 구성 요소에서, 결과 데이터와 연관된 제2 시간 간격과 연관된 표시자와 가장 빠른 시간 간격의 표시자의 비교에 기초하여, 분산형 데이터 처리 시스템 인터페이스로부터 결과 데이터를 배포할지 여부를 결정하게 한다.

다른 일반적인 양태에서, 데이터를 처리하기 위한 장치는, 다수의 처리 노드를 포함하는 분산형 데이터 처리 시스템으로서, 각각의 처리 노드는 적어도 하나의 프로세서를 포함하는, 분산형 데이터 처리 시스템; 분산형 데이터 처리 시스템과 통신하는 분산형 데이터 처리 시스템 인터페이스 구성 요소; 및 다수의 처리 노드의 처리 노드 간에 정보를 전송 및 수신하기 위해 다수의 처리 노드를 연결하는 통신 매체를 포함한다.

장치는, 분산형 데이터 처리 시스템과 통신하는 분산형 데이터 처리 시스템 인터페이스 구성 요소에서 입력 데이터를 수신하고, 수신된 입력 데이터를 분산형 데이터 처리 시스템에 제공하도록 구성된다. 분산형 데이터 처리 시스템은 다수의 시간 간격 중 제1 시간 간격과 연관된 표시자를 입력 데이터에 할당한다. 장치는 입력 데이터를 수신하는 것에 응답하여, 분산형 데이터 처리 시스템 내의 상태 정보를 생성하도록 추가로 구성된다. 상태 정보는 제1 시간 간격과 연관된 표시자를 포함한다.

장치는 분산형 데이터 처리 시스템 인터페이스 구성 요소에서, 분산형 데이터 처리 시스템으로부터 입력 데이터와 연관된 결과 데이터를 수신 및 저장하도록 추가로 구성된다. 결과 데이터는 제1 시간 간격보다 이후의 제2 시간 간격과 연관된 표시자를 포함한다. 장치는, 제2 시간 간격과 연관된 표시자를 포함하는 모든 상태 정보가 제1 지속성 레벨로 저장되는 다수의 시간 간격 중 가장 빠른 시간 간격의 표시자를 다수의 처리 노드 중 제1 처리 노드에서 결정하도록 추가로 구성된다.

장치는, 가장 빠른 시간 간격의 표시자를 분산형 데이터 처리 시스템 인터페이스 구성 요소에 제공하고, 분산형 데이터 처리 시스템 인터페이스 구성 요소에서, 결과 데이터와 연관된 제2 시간 간격과 연관된 표시자와 가장 빠른 시간 간격의 표시자의 비교에 기초하여, 분산형 데이터 처리 시스템 인터페이스로부터 결과 데이터를 배포할지 여부를 결정하도록 추가로 구성된다.

다른 일반적인 양태에서, 다수의 처리 노드를 포함하는 분산형 데이터 처리 시스템을 사용하여 데이터를 처리하기 위한 컴퓨팅 시스템은, 분산형 데이터 처리 시스템과 통신하는 분산형 데이터 처리 시스템 인터페이스 구성 요소에서 입력 데이터를 수신하기 위한 수단; 및 수신된 입력 데이터를 분산형 데이터 처리 시스템에 제공하기 위한 수단을 포함한다. 분산형 데이터 처리 시스템은 다수의 시간 간격 중 제1 시간 간격과 연관된 표시자를 입력 데이터에 할당한다.

컴퓨팅 시스템은 입력 데이터를 수신하는 것에 응답하여, 분산형 데이터 처리 시스템 내의 상태 정보를 생성하기 위한 수단을 더 포함한다. 상태 정보는 제1 시간 간격과 연관된 표시자를 포함한다. 컴퓨팅 시스템은 분산형 데이터 처리 시스템 인터페이스 구성 요소에서, 분산형 데이터 처리 시스템으로부터 입력 데이터와 연관된 결과 데이터를 수신 및 저장하기 위한 수단을 더 포함한다. 결과 데이터는 제1 시간 간격보다 이후의 제2 시간 간격과 연관된 표시자를 포함한다.

컴퓨팅 시스템은 다수의 처리 노드 중 제1 처리 노드에서, 제2 시간 간격과 연관된 표시자를 포함하는 모든 상태 정보가 제1 지속성 레벨로 저장되는 다수의 시간 간격 중 가장 빠른 시간 간격의 표시자를 결정하기 위한 수단을 더 포함한다. 컴퓨팅 시스템은, 가장 빠른 시간 간격의 표시자를 분산형 데이터 처리 시스템 인터페이스 구성 요소에 제공하기 위한 수단, 및 분산형 데이터 처리 시스템 인터페이스 구성 요소에서, 결과 데이터와 연관된 제2 시간 간격과 연관된 표시자와 가장 빠른 시간 간격의 표시자의 비교에 기초하여, 분산형 데이터 처리 시스템 인터페이스로부터 결과 데이터를 배포할지 여부를 결정하기 위한 수단을 더 포함한다.

양태는 이하의 장점 중 적어도 하나를 가질 수 있다.

일반적으로, 본원에서 설명된 일부 특징은, 계산, 특히, 구성 요소(또는 구성 요소의 병렬 실행 복사본)가 상이한 서버를 통해 호스팅되는 전술한 접근 방식과 비교하여, 이의 기본 명세서(specification)가 그래프 기반 프로그램 명세서와 관련되는 계산의 계산 효율 증대(예를 들어, 다수의 처리 노드를 포함하는 분산형 데이터 처리 시스템은 주어진 컴퓨팅 자원의 유닛당 처리되는 레코드의 수를 증가시킬 수 있음)를 가능하게 한다. 예를 들어, 호출 클러스터 구성 요소(call cluster component)는 그래프 기반 프로그램 명세서에 배치되고, 그래프 기반 프로그램 명세서에 의해 요구되는 계산이 그래프 기반 프로그램 명세서의 처리 노드에 의해 분산형 방식으로 수행되도록, 그래프 기반 프로그램 명세서를 분산형 데이터 처리 시스템과 인터페이스하기 위해 사용된다. 또한, 본원에서 설명된 일부 특징은 다양한 계산 자원 및 계산 요건에 적응시키는 기능을 제공한다. 적어도 하나의 그래프 기반 계산의 실행 동안 이용 가능한 컴퓨팅 자원의 변동, 및/또는 예를 들어, 처리되는 데이터의 특성으로 인한, 이러한 계산의 상이한 구성 요소의 부하의 시간 변동 또는 계산 부하의 변동에 적응할 수 있게 하는 계산 접근 방식이 본원에 제공된다. 예를 들어, 양태는 분산형 데이터 처리 시스템으로부터 추가되거나 제거되는(또는 실패하여 온라인으로 복귀되는) 처리 노드에 적응시킬 수 있다. 분산형 데이터 처리 시스템이 적응을 제공하는 한 가지 방식은, 처리 노드에 의해 전송 및 수신되는 메시지의 카운트를 유지하는 단계, 및 모든 메시지가 시스템에서 복제 및/또는 지속적이게 되는 시간 간격의 표시자를 유지하는 단계를 포함하는, 시스템에서 데이터의 복제 및 지속성을 관리하는 것이다.

또한, 예를 들어, 서버당 상이한 수의 프로세서, 프로세서당 상이한 수의 프로세서 코어 등을 갖는 서버를 사용하여, 상이한 특성을 갖는 계산 자원을 효율적으로 사용할 수 있고, 동종 및 이종 환경 모두를 효율적으로 지원할 수 있는 계산 접근 방식이 제공된다. 또한, 본원에 설명된 일부 특징은 그래프 기반 계산의 시동을 신속하게 할 수 있다. 이러한 효율성 및 적응성을 제공하는 하나의 양태는 본원에 설명된 바와 같이, 처리 노드들의 클러스터의 적절한 관리를 제공하는 것이다.

또한, 분산형 데이터 처리 시스템이 처리를 시간에 맞게 복귀(roll back)시킴으로써 발생하는 임의의 처리 에러로부터 복구될 수 있다는 점에서, 양태는 유리하게는 고장 허용 한계(fault tolerant)이다. 시스템은 다수의 가능한 복귀 시나리오를 예측하고, 각각의 가능한 복귀 시나리오로 복귀를 수행하기 위한 알고리즘을 구현한다.

도 1은 데이터를 처리하기 위한 시스템의 블록도이다.
도 2는 컴퓨팅 클러스터를 포함하는 계산 시스템의 블록도이다.
도 3은 다양한 반복 시간 간격에 대한 시간을 나타내는 클록의 개략도이다.
도 4는 작동 절차에 대한 상태 전이도이다.
도 5 내지 도 12는 계산 시스템의 정상 작동을 도시한다.
도 13 내지 도 15는 제1 복귀 절차를 도시한다.
도 16 내지 도 18은 제2 복귀 절차를 도시한다.
도 19 내지 도 21은 제3 복귀 절차를 도시한다.
도 22 내지 도 25는 제4 복귀 절차를 도시한다.
도 26 내지 도 29는 제5 복귀 절차를 도시한다.
도 30 내지 도 32는 제6 복귀 절차를 도시한다.
도 33 내지 도 35는 제7 복귀 절차를 도시한다.
도 36 내지 도 37은 제8 복귀 절차를 도시한다.

도 1은 컴퓨팅 클러스터 관리 기술이 사용될 수 있는 데이터 처리 시스템(200)의 일 실시예를 도시한다. 시스템(200)은 저장 장치 또는 온라인 데이터 스트림과의 연결부와 같은 적어도 하나의 데이터 소스를 포함할 수 있는 데이터 소스(202)를 포함하며, 그 각각은 임의의 다양한 포맷(예를 들어, 데이터베이스 테이블, 스프레드시트 파일, 플랫(flat) 텍스트 파일, 또는 메인 프레임에 의해 사용되는 기본 포맷)으로 데이터를 저장 또는 제공할 수 있다. 실행 환경(204)은 전처리 모듈(206) 및 실행 모듈(212)을 포함한다. 실행 환경(204)은 UNIX 운영 체제의 버전과 같은, 적합한 운영 체제의 제어에 따라, 예를 들어, 적어도 하나의 범용 컴퓨터를 통해 호스팅될 수 있다. 예를 들어, 실행 환경(204)은, 로컬(예를 들어, 대칭 다중-처리(SMP) 컴퓨터와 같은 다중 프로세서 시스템), 또는 로컬 분산형(예를 들어, 클러스터 또는 대량 병렬 처리(MPP) 시스템으로서 연결된 다수의 프로세서, 또는 원격, 또는 원격 분산형(예를 들어, 근거리 통신망(LAN) 및/또는 광역 통신망(WAN)을 통해 연결된 다수의 프로세서)), 또는 이들의 임의의 조합인, 다수의 처리 장치(예를 들어, 중앙 처리 장치, CPU) 또는 프로세서 코어를 사용하는 컴퓨터 시스템의 구성을 포함하는 다중-노드 병렬 컴퓨팅 환경을 포함할 수 있다.

전처리 모듈(206)은, 프로그램 명세서(예를 들어, 후술되는 그래프 기반 프로그램 명세서)가 실행 모듈(212)에 의해 실행되기 전에 필요할 수 있는 임의의 구성을 수행할 수 있다. 전처리 모듈(206)은 상이한 형태의 데이터베이스 시스템을 포함하는 데이터 소스(202)를 구현할 수 있는 다양한 유형의 시스템으로부터 데이터를 수신하도록 프로그램 명세서를 구성할 수 있다. 데이터는, 가능한 널(null) 값을 포함하는, 각각의 필드("속성", "행" 또는 "열"이라고도 지칭됨)에 대한 값을 갖는 레코드로서 조직화될 수 있다. 데이터 소스로부터 데이터를 판독하기 위해, 데이터 처리 애플리케이션과 같은 컴퓨터 프로그램을 처음 구성할 때, 전처리 모듈(206)은 전형적으로 그 데이터 소스의 레코드에 관한 일부 초기 포맷 정보로 시작된다. 컴퓨터 프로그램은 본원에 설명된 바와 같은 데이터 흐름 그래프의 형태로 표현될 수 있다. 일부 상황에서, 데이터 소스의 레코드 구조는 초기에 알려지지 않을 수 있으며, 그 대신에 데이터 소스 또는 데이터의 분석 후에 결정될 수 있다. 레코드에 관한 초기 정보는 예를 들어, 개별 값을 나타내는 비트의 수, 레코드 내의 필드의 순서, 및 비트에 의해 나타낸 값의 유형(예를 들어, 문자열, 부호를 갖는/부호가 없는 정수)을 포함할 수 있다.

데이터 소스(202)를 제공하는 저장 장치는, 예를 들어, 실행 환경(204)을 호스팅하는 컴퓨터에 연결된 저장 매체(예를 들어, 하드 드라이브(208))에 저장되는 실행 환경(204)에 대해 로컬일 수 있거나, 또는 (예를 들어, 클라우드 컴퓨팅 인프라에 의해 제공되는) 원격 연결을 통해, 실행 환경(204)을 호스팅하는 컴퓨터와 통신하는 예를 들어, 원격 시스템(예를 들어, 메인 프레임(210))을 통해 호스팅되는 실행 환경(204)에 대해 원격일 수 있다.

실행 모듈(212)은 전처리 모듈(206)에 의해 구성된 및/또는 생성된 프로그램 명세서를 실행하여, 입력 데이터를 판독, 및/또는 출력 데이터를 생성한다. 출력 데이터(214)는 데이터 소스(202)에 다시 저장될 수 있거나, 실행 환경(204)에 액세스 가능한 데이터 저장 시스템(216)에 다시 저장될 수 있거나, 또는 달리 사용될 수 있다. 또한, 데이터 저장 시스템(216)은, 개발자(220)가 실행 모듈(212)을 사용하여 데이터를 처리하기 위한 애플리케이션을 개발할 수 있는 개발 환경(218)에 액세스 가능하다.

즉, 데이터 처리 시스템(200)은,

데이터 저장소(216)에 연결된 선택적인 개발 환경(218)으로서, 개발 환경(218)은, 적어도 하나의 입력 데이터 세트로부터 처리 그래프 구성 요소의 그래프를 통하여 적어도 하나의 출력 데이터 세트로 흐르는 데이터에 대해 수행되는 그래프 기반 계산을 구현하는 데이터 흐름 그래프와 연관된 데이터 처리 애플리케이션을 구축하도록 구성되고, 데이터 흐름 그래프는 데이터 저장소(216)의 데이터 구조에 의해 명시되며, 데이터 흐름 그래프는, 데이터 구조에 의해 명시되어 적어도 하나의 링크에 의해 연결된 그래프 구성 요소를 나타내는 다수의 노드를 갖고, 링크는 데이터 구조에 의해 명시되며 그래프 구성 요소 간의 데이터 흐름을 나타내는, 선택적인 개발 환경(218);

데이터 저장소(216)에 연결되어 적어도 하나의 컴퓨터를 통해 호스팅되는 실행 환경(212)을 포함할 수 있으며, 실행 환경(212)은 전처리 모듈(206)을 포함하고, 전처리 모듈(206)은, 데이터 흐름 그래프를 명시하는 저장된 데이터 구조를 판독하고, 전처리 모듈(206)에 의해 데이터 흐름 그래프에 할당된 그래프 구성 요소의 계산을 수행하기 위해, 프로세스와 같은 컴퓨팅 자원을 할당 및 구성하도록 구성되며,

실행 환경(204)은, 그래프 기반 계산이 실행되도록, 할당된 계산 또는 프로세스의 실행을 스케줄링 및 제어하기 위한 실행 모듈(212)을 포함한다. 즉, 실행 모듈은, 데이터 소스(202)로부터 데이터를 판독하고, 데이터 흐름 그래프의 형태로 표현된 실행 가능 컴퓨터 프로그램을 사용하여 데이터를 처리하도록 구성된다.

1. 컴퓨팅 클러스터

매우 일반적으로, 실행 모듈(212)을 사용하여 데이터를 처리하기 위한 일부 컴퓨터 프로그램(본원에서 "애플리케이션"으로도 지칭됨)은, 애플리케이션이 컴퓨팅 클러스터에 액세스하기 위해 사용하는 호출 클러스터 구성 요소를 포함한다. 예를 들어, 도 2를 참조하면, 파이프라인 데이터 처리에 대한 접근 방식에서, 호출 클러스터 구성 요소(110)는 컴퓨터 클러스터(120)의 구성 요소와 상호 작용하여, 이의 일부인 애플리케이션의 구성 요소(예를 들어, 데이터 흐름 그래프, 또는 다른 형태의 그래프 기반 프로그램 명세서)로부터 호출 클러스터 구성 요소(110)에 수신된 레코드(103)를 처리하고, 해당 결과(105)를 이의 일부인 애플리케이션의 적어도 하나의 다른 구성 요소로 전송한다. 각각의 입력 레코드(103)에 대해, 호출 클러스터 구성 요소(110)는 요청(113)(예를 들어, 데이터 처리 작업을 실행하기 위한 요청)을 클러스터(120)로 전송하고, 얼마 후에 클러스터(120)로부터 그 요청(113)에 대한 응답(115)을 수신한다. 응답(115)을 수신한 얼마 후에, 호출 클러스터 구성 요소(110)는, 일반적으로 요청을 처리한 결과가 클러스터(120)에서 적절하게 지속적인 것으로 알려진 후에, 호출 클러스터 구성 요소(110)는 응답(115)에 해당하는 결과(105)를 전송한다.

호출 클러스터 구성 요소(110)가 이의 일부인 그래프 기반 프로그램 명세서는 도 2에 도시되지 않는다. 도 2에서, 단일 호출 클러스터 구성 요소(110)만이 도시되지만, 일반적으로 동일한 클러스터(120)와 상호 작용할 수 있는 많은 호출 클러스터 구성 요소가 있을 수 있으며, 예를 들어, 각각의 호출 클러스터 구성 요소가 데이터 흐름 그래프와 같은 동일하거나 상이한 애플리케이션에 참여한다는 것을 인식해야 한다. 그래프 기반 프로그램 명세서는 예를 들어, 미국 특허 번호 제5,966,072호, 미국 특허 번호 제7,167,850호, 또는 미국 특허 번호 제7,716,630호에 기술된 바와 같은 데이터 흐름 그래프, 또는 미국 공개 번호 제2016/0062776호에 기술된 바와 같은 데이터 처리 그래프로서 구현될 수 있다. 이러한 데이터 흐름 그래프 기반 프로그램 명세서는 일반적으로, 그래프의 링크(방향 에지)에 해당하는 데이터 흐름에 의해 연결된 그래프("데이터 흐름 그래프"라고 지칭됨)의 노드(정점)에 해당하는 계산 구성 요소를 포함한다. 데이터 흐름 링크에 의해 업스트림 구성 요소에 연결된 다운스트림 구성 요소는 정렬된 입력 데이터 요소 스트림을 수신하고, 수신된 순서로 입력 데이터 요소를 처리함으로써, 적어도 하나의 대응하는 출력 데이터 요소 흐름을 선택적으로 생성한다. 일부 실시예에서, 각각의 구성 요소는 전형적으로 다수의 컴퓨터 서버 중 하나를 통해 호스팅되는 프로세스로서 구현된다. 각각의 컴퓨터 서버는 항상 활성인 다수의 그러한 구성 요소 프로세스를 가질 수 있으며, 운영 체제(예를 들어, Unix) 스케줄러는 그 서버를 통해 호스팅되는 구성 요소 간에 자원(예를 들어, 프로세서 시간, 및/또는 프로세서 코어)을 공유한다. 이러한 구현예에서, 구성 요소 간의 데이터 흐름은 운영 체제의 데이터 통신 서비스, 및 서버를 연결하는 데이터 네트워크(예를 들어, 명명된 파이프, TCP/IP 세션 등)를 사용하여 구현될 수 있다. 일반적으로, 구성 요소의 서브 세트는 예를 들어, 데이터 파일, 데이터베이스 테이블, 및 외부 데이터 흐름으로 및/또는 데이터 파일, 데이터베이스 테이블, 및 외부 데이터 흐름으로부터, 전반적인 계산으로부터의 데이터의 소스 및/또는 수신부로서 역할을 한다. 예를 들어, 조정 프로세스에 의해, 구성 요소 프로세스 및 데이터 흐름이 설정된 후에, 각각의 구성 요소에서의 입력 데이터의 이용 가능성, 및 각각의 구성 요소에 대한 컴퓨팅 자원의 스케줄링에 의해 일반적으로 제어되는 그래프로 표현된 계산을 구현하는 전반적인 계산 시스템을 통해 데이터가 흐른다.

클러스터(120)는 통신 네트워크(130)(도 2에 "클라우드"로서 도시되며, 시작, 공유 매체, 하이퍼큐브(hypercube) 등과 같은 다양한 상호 연결 토폴로지(topology)를 가질 수 있음)에 의해 연결된 다수의 클러스터 구성 요소(140, 150a-c)를 포함한다. 각각의 클러스터 구성 요소(또는 간단히 "구성 요소")는 클러스터에서 특정한 역할을 한다. 일부 구현예에서, 각각의 구성 요소는 별개의 컴퓨팅 자원(예를 들어, 별도의 컴퓨터 서버, 멀티-코어 서버의 별도의 코어 등)을 통해 호스팅된다. 이러한 구성 요소는 클러스터 내의 역할을 나타내며, 일부 실시형태에서, 다수의 역할이 하나의 컴퓨팅 자원을 통해 호스팅될 수 있고, 단일 역할이 다수의 컴퓨팅 자원에 걸쳐서 분산될 수 있음을 이해해야 한다.

도 2에서, 루트(root) 구성 요소(140)("루트"로 지칭됨)는 아래에 완전하게 설명되는 특정 동기화 기능을 수행하지만, 처리될 데이터의 흐름 또는 데이터에 대한 계산에 직접 관여되지 않는다. 다수의 작업자 구성 요소(150a-c)(이하에서 "작업자"로 지칭됨)는 호출 클러스터 구성 요소(110)로부터의 요청(113)을 처리한다. 데이터(165)는 각각의 작업자(150)로 액세스 가능한 저장소(160)에 중복 방식으로 저장되며, 각각의 요청(113)은, 키에 의해 결정되는 특정 서브 세트의 작업자 간에 분산되는, 요청(113)의 키에 의해 식별된 저장소(160)에 저장된 데이터의 특정 부분에 (판독 및/또는 기록을 위해) 액세스할 필요가 있을 수 있다. 특정 요청에 필요한 키에 대한 데이터를 보유한 그러한 작업자 중에서, 하나의 작업자는 요청(113)이 실행되는 1차 작업자(예를 들어, 작업자(150a))로서 지정되며, 다른 작업자는, 이들이 일반적으로 요청을 실행하지 않거나 반드시 요청을 실행할 필요는 없지만, 이들의 데이터 버전이 1차 작업자에서와 동일한 방식으로 또는 1차 작업자에 따라 업데이트된다는 점에서, 백업으로 지정된다.

도 2에서, 처리될 데이터 유닛인 것으로 간주될 수 있거나 처리될 데이터 유닛을 포함할 수 있는 특정 입력 레코드(103)의 경로는 그것이 호출 클러스터 구성 요소(110)에 입력됨에 따라 도시되며, 그 다음, 해당 요청(113)(데이터 유닛과 함께)은 구성 요소(110)에 의해, 요청에 대한 1차 작업자(150a)(작업자 A)에 전송되고, 1차 작업자(150a)로부터의 응답(115)은 요청에 대한 백업 작업자(150b)(작업자 B)에 다시 전송될 뿐만 아니라, 호출 클러스터 구성 요소(110)에 다시 전송되며, 최종적으로, 해당 결과(105)는 호출 클러스터 구성 요소(110)로부터 출력되거나 전송된다. 일반적으로, 각각의 요청에 대해 다수의 백업 구성 요소가 있을 수 있다; 그러나, 설명의 용이함을 위해, 단일 백업 구성 요소만이 아래의 많은 실시예에서 예시된다.

아래에 추가로 설명되는 바와 같이, 호출 클러스터 구성 요소(110)는 요청(113)을 리플레이(replay) 버퍼(112)에 버퍼링하고, 필요한 경우, 요청이 클러스터(120)에 의해 적절히 수신 및/또는 처리되도록 보장하기 위해, 요청을 클러스터(120)에 재전송할 수 있다. 구성 요소(110)는 또한 에스크로(escrow) 버퍼(114)에 응답(115)을 버퍼링하고, 에러 조건이 검출되는 경우, 특정 응답의 중복 복사본을 수신할 수 있다. 일반적으로, 구성 요소(110)는 응답(115)이 클러스터에서 적절하게 지속적(즉, 적합한 지속성 레벨을 갖는 데이터 저장소에 저장됨)이라는 것을 클러스터(120)가 구성 요소(110)에 통지할 때까지, "에스크로에" 응답을 유지한다.

루트(140)는, 시간(간격) 값을 유지 및 다른 구성 요소에 분산시키며, 특정 시간 값을 호출 클러스터 구성 요소(110)에 분산시킴으로써, 동기화 기능을 수행한다. 도 3을 참조하면, 루트(140)의 클록(142)은 3회 유지된다. 시간(T1)은 현재 작업 시간 또는 시간 간격이고, 예를 들어 정수 값으로 표현되며, 반복적으로 업데이트되고, 예를 들어 매초마다 한 번씩 증분된다.

호출 클러스터 구성 요소(110)로부터 클러스터(120)에 의해 수신된 요청(113), 및 응답(115)이 클러스터에 의해 생성(또는 전송)되는 경우, 이들은 이들이 각각 수신 및 생성(또는 전송)된 작업(T1) 시간(또는 동등하게는, 시간(T1)이 동일한 값을 갖는 시간 간격, 즉 T1의 증분 간의 시간 간격)과 각각 연관된다. 루트는 시간(T1)을 지연시키는 제2 시간(T2)을 유지 및 분산시킨다. 시간(T2)은, 클러스터(120)의 구성 요소들(150a-c) 간에 전송된 그 시점 또는 그 이전에 생성된 모든 요청 및/또는 응답이 다수의 구성 요소(150a-c)에서 (예를 들어, 휘발성 메모리에) 복제되어, 아래에 실질적으로 더 상세히 설명된 바와 같이, 에러를 처리하기 위한 작업의 복귀의 경우 이들이 재전송될 필요가 없도록, 시간 (간격)을 나타낸다. 일부 실시예에서, (예를 들어, 휘발성 메모리에서의) 복제는 제1 지속성 레벨을 갖는 데이터 저장소에 저장되는 것으로 지칭된다. 루트는, 그 시점에 또는 그 이전에 생성된 모든 요청 및/또는 응답이 작업자(150a-c) 중 적어도 하나 또는 심지어 전부에서 지속성 메모리에 저장되어 영구적이게 되도록 하는 시간을 나타내는, 시간(T1 및 T2)을 지연시키는 제3 시간 (간격)(T3)을 유지 및 분산시키며, 클러스터(120)에서 구성 요소의 실패를 처리하기 위한 작업의 복귀의 경우 이들이 재전송되거나 재계산될 필요가 없도록 그 데이터(165)가 저장된다. 일부 실시예에서, 지속성 메모리(예를 들어, 디스크)에 저장되는 것은 제1 지속성 레벨보다 상대적으로 더 지속성인 제2 지속성 레벨을 갖는 데이터 저장소에 저장되는 것으로 지칭된다. 데이터 저장소는, 제1 지속성 레벨을 갖는 데이터 저장소, 및 제2 지속성 레벨을 갖는 데이터 저장소보다 상대적으로 더 지속성이거나 덜 지속성인 다수의 상이한 지속성 레벨과 연관될 수 있음을 유의한다. 예를 들어, 클러스터의 외부에 있는 오프사이트 데이터 저장소는 제1 및 제2 지속성 레벨보다 상대적으로 더 지속성인 제3 지속성 레벨을 가질 수 있다. 일부 실시예에서, 시간 간격(T1, T2, 및 T3)은 대안적으로 "상태 일관성 표시자"로 지칭된다.

루트(140)가 복제(T2) 시간 또는 지속성(T3) 시간을 증분시킬 시기를 결정하기 위한 메커니즘은 시간(T1 내지 T3)의 값을 작업자(150a-c)에 분산시키기 위한 메커니즘과 같이, 본 설명에서 나중에 설명된다.

정상 작동에서, 클러스터(120)에 의해 수신된 요청(113)은 요청의 데이터 유닛의 키에 기초하여 1차 작업자로 식별된 작업자(150)에서 처리되며, 일반적으로, 또한 요구된 데이터의 키에 기초하여 식별된 적어도 하나의 백업 작업자(150)에서 처리된다. 도 4를 참조하면, 이러한 처리는 1차 및 백업 작업자(150) 및 호출 클러스터 구성 요소(110)에서 그 요청에 대한 상이한 상태들 간의 전이로서 표현될 수 있다. 상이한 요청은 상이한 상태로 있으며, 일반적으로, 참조된 데이터에 따라 상이한 작업자에서 처리되므로, 호출 클러스터 구성 요소 및 임의의 특정 작업자는 상이한 상태의 많은 요청을 가질 수 있다는 점을 유의한다.

일반적으로, 각각의 키는 예를 들어, 키에 기초하여 의사 난수 방식으로 선택된(예를 들어, 각각의 키 값에 대해 예측할 수 없게 백업을 분산시키는 키의 결정론적 기능) 해당 작업자(150) 서브 세트와 연관된다. 보다 일반적으로, 그리고 바람직하게는, 이들 서브 세트는 키 값에 따라 완전한 작업자 세트의 분할을 형성하는 대신에 다른 서브 세트와 중첩된다.

(호출 클러스터 구성 요소에 의해 할당되거나) 고유 식별자 rid를 갖는 요청(113)이 각각의 입력 레코드(103)에 대해 호출 클러스터 구성 요소(110)에서 형성되는 경우, 요청은 호출 클러스터 구성 요소에서 상태 A로 진입한다. 이하의 설명에서, 각각의 요청(113)은 요청을 처리하는 각각의 작업자(150)에서, A 내지 I로 표시된 9개의 상이한 상태 중 하나, 및 호출 클러스터 구성 요소의 A 내지 C로 표시된 3개의 상이한 상태 중 하나로 있다. 호출 클러스터 구성 요소(110)는 요청(113)을 기록한 후에, 요청에 대한 1차 작업자인 것으로 할당된 작업자(150)를 결정하고, 요청(113)을 도 2에 작업자 A로 도시된 그 작업자(150)에게 전송한다. 대안적인 실시형태에서, 호출 클러스터 구성 요소(110)는 어느 작업자가 지정된 1차인지 인지하지 못할 수 있고, 요청(113)은 지정된 1차 작업자(150a)에 도달하도록 클러스터(120)에서 내부적으로 라우팅될 수 있다는 점을 유의한다. 요청(113)은 요청에 대한 응답(115)이 클러스터(120)로부터 다시 수신될 때까지, 호출 클러스터 구성 요소(110)에서 상태 A로 유지된다.

요청(113)이 1차 작업자(도 2에서 작업자 A로 표시됨)에서 수신되는 경우, 그 요청은 1차 작업자에서 상태 A로 진입한다. 1차 작업자는, (루트가 T1을 증분시키고 작업자가 그 증분을 인지하는 시점 간에 시간 지연이 있을 수 있다는 것을 인식하는) 루트(140)로부터 분산된 것으로 이에 알려진 현재 작업 시간(T1)과 동일한 요청 시간(ta로 표시됨)을 요청에 할당한다. 이러한 상태에서, 요청(113)은 요청 id인 rid, 본 실시예에서 ta로 표시된 요청 시간과 연관된 휘발성 메모리(155)에 저장되며, 1차 작업자에서 실행을 대기하는 상태로 지정된다. 이러한 상태 A에서, 1차 작업자는 그 요청에 대한 적어도 하나의 백업 작업자(150)(즉, 키에 의해 결정됨)에게 요청(113)을 전송한다. 1차 작업자에서, 결국, 예를 들어, 요청에 할당된 시간(ta), 및 선택적으로 1차 작업자에서의 요청의 도착 순서에 따라, 순차적인 자원 할당에 기초하여, 실행할 자원이 요청에 할당된다. 요청(113)이 1차 작업자에서 실행을 시작하면, 요청은 1차 작업자에서 상태 B로 진입한다. 처리가 응답(115)을 생성하는 경우, 본 실시예에서, T1 작업 시간이 tb라고 가정하면, 1차 작업자에서의 요청 상태는 상태 C가 된다. 상태 C에서, 응답(115)은 시간 tb와 관련하여 휘발성 메모리(156)에 저장된다. 아래에서 추가로 설명되는 바와 같이, 작업자에서의 데이터 저장소(160)에 대한 임의의 업데이트 및 응답(115)은, 이전 복귀 시간에 따라, 예를 들어, 버전화(versioned) 데이터베이스 또는 다른 형태의 버전화 데이터 구조를 사용하는 효과의 제거를 허용하는 방식으로, 시간(여기서는 시간 tb)과 연관되어 저장된다. 이러한 상태 C에서, 응답(115)은 호출 클러스터 구성 요소(110) 및 백업 구성 요소(들)(150) 모두로 전송된다.

호출 클러스터 구성 요소(110)에서, 응답(115)이 1차 작업자로부터 수신되는 경우, 요청은 1차 작업자에 의해 생성된 시간(tb)과 관련하여 응답이 저장되는 상태 B로 진입한다. 응답(115)은 루트(140)로부터 tb 이상인 에스크로 시간을 수신할 때까지, 에스크로 버퍼(114)에서 호출 클러스터 구성 요소에 유지된다. 그 호출 클러스터 구성 요소로부터의 요청의 지속성 요건에 따라, 루트는 호출 클러스터 구성 요소에 대한 에스크로 시간으로서, 복제 시간(T2), 또는 지속 시간(T3)을 제공할 수 있다. 호출 클러스터 구성 요소(110)가 tb 이상인 에스크로 시간을 수신하는 경우, 호출 클러스터 구성 요소로부터 결과(105)를 전송하고, 해당 요청(113)은 요청(113) 또는 이의 응답(115)의 추가적인 레코드가 필요하지 않는(예를 들어, 이는 완전히 삭제될 수 있음) 널 상태 C로 진입한다.

백업 작업자(들)(150)에서, 백업 작업자가 1차 작업자로부터 요청(113)을 수신하는 경우, 백업 작업자는 요청이 원본 요청 시간 ta와 연관되는 상태 F로 진입하고(현재 작업 시간(T1)이 이를 초과하여 증분되었어도), 요청은 1차 작업자로부터의 응답을 대기하는 상태로 있다. 백업 작업자(150b)가 1차 작업자로부터 응답(115)을 수신하고, 이에 따라 응답(115)이 그 백업의 휘발성 메모리(156)에 복제되는 경우, 상태 G로 진입한다.

1차 또는 백업 작업자가 새롭게 생성된 응답(115)을 갖는 즉시, 디스크 기반 또는 비-휘발성 메모리 기반 데이터베이스 또는 파일 시스템과 같은, 지속성 저장소(160)에 그 응답을 저장하는 프로세스를 자유롭게 시작한다(상태 D 및 H 참조). 지속성 메모리에 대한 업데이트가 휘발성 메모리 기반 저널(journal)에서 먼저 저널링되고, 그 저널의 일부가 때때로 지속성 저장소(160)에 기록되는, 저널 기반 접근 방식이 사용될 수 있다. 업데이트의 저널의 일부가 지속성 저장소(160)에 기록되는 경우에도, 영구적인 것으로 간주되는 업데이트의 정도에 관한 명시적인 표시자가 지속성 저장소에 기록될 때까지, 이러한 업데이트가 영구적(즉, "커밋")이게 되지 않는다는 점을 유의한다.

루트(140)가 시간 tb 및 그 이전과 연관된 모든 요청 및 응답이 모든 적절한 작업자에서 복제되었다고 결정한 시점에, T2가 tb에 도달하거나 tb로 증분된다. 시간 T2=tb가 루트(140)로부터 1차 및 백업 작업자(150)로 분산된 후에, 이들 작업자는 응답을 지속성 저장소(160)에서 영구적이게 한다. 그 시간 tb 동안의 업데이트의 저널이 아직 지속성 메모리에 기록되지 않은 경우, 이들이 그 시간에 기록된다. 보다 일반적으로, 시간 tb 동안의 저널은 시간 T2가 tb에 도달하거나 tb로 증분될 때까지 작업자에 의해 지속성 저장소(160)에 기록되며, 이 시점에 수행되어야 하는 모든 것은, 지속성 저널에서의 시간 tb 동안의 업데이트가 영구적인 것으로 간주되어야 한다는 표시자를 기록함으로써, 업데이트를 영구적이게 하는 작업을 완료하는 것이다. 1차 작업자가 저널을 영구적이게 하는 잠재적으로 짧은 시간 동안, 이는 상태 D로 있다. 1차 작업자가 지속성 저장소에서 도 4에 도시된 요청에 대한 응답을 수행한 경우, 이는 상태 E로 진입한다. 유사하게, 백업이 응답을 영구적이게 하는 동안, 이는 상태 H로 있고, 백업이 응답을 지속성 메모리에서 영구적이게 한 경우, 이는 상태 I로 진입한다. 루트가 시간 tb(및 그 이전)와 연관된 모든 응답이 지속성 메모리에서 영구적이라고(즉, 모두 상태 E 또는 I로 있음) 결정하는 경우, 이는 지속 시간 T3을 tb로 증분시킨다. 상술한 바와 같이, 에스크로 시간이 호출 클러스터 구성 요소에서의 요청에 대해 지속 시간 T3인 상황의 경우, 루트(140)는 에스크로 시간이 tb 이상이 되었음을 호출 클러스터 구성 요소(110)에 통지하고, 호출 클러스터 구성 요소(110)는 그 요청(113) 및 응답(115)에 대한 해당 결과(105)를 애플리케이션 내의 적어도 하나의 다른 구성 요소(예를 들어, 그래프)에 배포한다.

상술한 바와 같이, 정상 작동에서, 루트는 호출 클러스터 구성 요소로부터의 연속적인 요청(113)이 클러스터에서 처리됨에 따라 작업 시간(T1)을 업데이트하고, 응답(115)은 호출 클러스터 구성 요소로 복귀되며, 에스크로 시간(T2 또는 T3)의 업데이트에 따라, 호출 클러스터 구성 요소로부터 그래프로 배포된다. 일반적으로, 특정 요청(113)의 처리는 작업 시간(T1)의 많은 시간 "틱(tick)", 예를 들어 수십 또는 수백 개의 틱을 취할 수 있으므로, 클러스터는 진행 중인 많은 요청을 가질 수 있고, 많은 상이한 요청 시간이 이들과 연관된다. 또한, 데이터가 작업자들 간에 분산되기 때문에, 작업자가 1차 작업자(즉, 상태 A 내지 E 중 하나)로서 작용하는 다수의 요청을 각각의 작업자가 가질 수 있도록, 그리고 또한 백업 작업자(즉, 상태 F 내지 I 중 하나)로서 작용하는 다수의 요청을 각각의 작업자가 가질 수 있도록, 그러한 요청의 키에 따라 작업자들 간에 부하가 효과적으로 분산된다.

작업을 수행하기 위한 클러스터에 대한 일부 요청은, 작업을 복제하고 그 작업을 수행한 해당 결과를 복제하기 위해, 본원에 설명된 바와 같은 절차를 사용한다는 점을 유의한다. 예를 들어, 백업 작업자에서 작업이 태깅되어(tagged) 복제된 후에(그러나 반드시 영구적이게 될 필요는 없음), 작업은 1차 작업자에서 초기화된다. 작업이 데이터 레코드에 대해 작업하는 경우, 초기화는 레코드의 원본 버전 1을 보존하는 단계를 포함할 수 있다. 그 다음, 작업은 1차 작업자를 통해 실행되지만, 백업 작업자에서는 휴면 상태로 유지된다. 처리가 완료된 후에는, 레코드의 변경된 버전 2가 있다. 그 다음, 작업의 마무리는 레코드의 변경된 버전 2를 1차 작업자로부터 백업 작업자로 전송하는 단계를 포함할 수 있다. 그 다음, 1차 작업자 및 백업 작업자 모두는 (복제된 작업과 함께) 레코드의 원본 버전 1을 삭제할 수 있다. 각각의 이러한 단계는 상당히 효율적이지만, 작업 지속 시간이 매우 짧은 경우, 이러한 초기화 및 마무리 절차와 연관된 오버헤드는 작업을 덜 효율적이게 할 수 있다.

대안적으로, 지속 시간이 상대적으로 짧은 일부 작업("단기 작업")에 대해 상이한 절차가 사용될 수 있다. 단기 작업은 백업 작업자에서 여전히 태깅되어 복제된다. 그러나, 초기화는 레코드의 원본 버전 1을 보존할 필요가 없다. 대신에, 단기 작업 및 단기 작업의 복제본 모두가 1차 및 백업 작업자에서 지속적으로 각각 저장되었음을 커밋 동작이 나타낸 후에, 두 작업자 모두에서 단기 작업이 실행된다. 그 실행의 종료 시에, 변경된 레코드를 전송하기 위해 필요한 임의의 통신 없이, 레코드의 변경된 버전 2의 복사본이 1차 및 백업 작업자 모두에 있을 것이다. 두 작업자 모두에서 중복 처리가 있지만, 이러한 중복성은 작업이 짧기 때문에 효율성에 크게 영향을 주지 않는다. 이러한 대안적인 절차는 예를 들어, 단기 작업이 결정론적이며, 어떤 작업자가 이를 실행하든지 동일한 결과를 생성하는 경우에 유용하다.

2. 정상 작동의 실시예

도 5 내지 도 12를 참조하면, 클러스터(120) 및 호출 클러스터 구성 요소(110)의 정상 작동의 일 실시예가 도시된다. 도 5에서, 입력 레코드(103)가 호출 클러스터 구성 요소(110)에 도달하고, 호출 클러스터 구성 요소(110)는 입력 레코드(103)에 대한 요청(113)을 형성한다. 호출 클러스터 구성 요소(110)는 요청(113)을 고유 요청 식별자 rid와 연관시키고, 이를 호출 클러스터 구성 요소(110)의 리플레이 버퍼(112)에 저장한다.

호출 클러스터 구성 요소(110)는 요청(113)을 클러스터(120)에 전송하고, 이는 시간 T1 = ta에서 클러스터(120)의 1차 작업자(150a)(작업자 A)에서 수신된다. 요청(113)은 1차 작업자(150a)의 휘발성 메모리(155)에 저장되고, 현재 작업 시간과 동일한 요청 시간(T1 = ta)이 할당된다. 요청(113)의 요청 시간은 호출 클러스터 구성 요소(110)에 제공되며, 호출 클러스터 구성 요소(110)는 요청 시간(즉, ta)을 리플레이 버퍼(112)에 저장된 요청(113)과 연관시킨다. 호출 클러스터 구성 요소(110)의 리플레이 버퍼(112)에 저장된 요청(113)은 클러스터(120)로부터 응답을 대기하는 상태 A(도 4 참조)로 있다. 1차 작업자의 휘발성 메모리(155)에 저장된 요청(113)은, 요청(113)의 실행을 위해 할당될 컴퓨팅 자원을 대기하는 상태 A로 있다.

도 6을 참조하면, 1차 작업자는 요청(113)을 백업 작업자(150b)(작업자 B)에 전송하고, 이는 백업 작업자(150b)의 휘발성 메모리(155)에 저장된다. 백업 작업자(150b)의 휘발성 메모리(155)에 저장된 요청(113)은 1차 작업자로부터 응답을 수신하기 위해 대기하는 상태 F로 있다.

도 7을 참조하면, 1차 작업자(105)가 (예를 들어, 1차 작업자 또는 클러스터의 다른 부분의) 컴퓨팅 자원을 요청(113)에 할당하면, 요청(113)은 1차 작업자(105)에서 상태 B로 진입하여 실행을 시작한다.

도 8을 참조하면, 시간 T1 = tb에서, 1차 작업자(105)는 요청(113)의 실행을 완료한다. 요청(113)의 실행은 1차 작업자의 휘발성 메모리(156)에 저장되는 응답(115)을 생성한다. 응답(115)은 요청(113)의 요청 식별자(rid), 및 이것이 생성된 시간(tb)과 연관된다. 1차 작업자는 응답(115)을 호출 클러스터 구성 요소(110) 및 백업 작업자(150b)에 전송하고, 그 다음에, 요청(113)은 지속 시간(T3)이 tb에 도달하도록 대기하기 위해 대기하는 상태 C로 있다.

호출 클러스터 구성 요소(110)는 응답(115)을 수신하고, 이를 이의 에스크로 버퍼(114)에 저장한다. 응답이 에스크로 버퍼(114)에 저장됨으로써, 결과(115)는 호출 클러스터 구성 요소(110)에서, 지속 시간(T3)(본 실시예에서 에스크로 시간)이 tb에 도달하도록 대기하는 상태 B로 있다. 백업 작업자(150b)는 응답(115)을 수신하고 이를 이의 휘발성 메모리(156)에 저장한다. 백업 작업자(150b)에서의 요청(113)은 지속 시간(T3)이 tb에 도달하도록 대기하는 상태 G로 진입한다.

도 8에 도시되지 않지만, 1차 작업자(150a) 및 백업 작업자(150b)의 휘발성 메모리(156)에 응답(115)이 저장(복제)되면, 복제 시간(T2)이 tb로 설정된다.

도 9를 참조하면, 1차 작업자(150a) 및 백업 작업자(150b) 중 하나 또는 둘 모두의 휘발성 메모리(156)에 응답(115)이 저장되면, 1차 작업자(150a) 및 백업 작업자(150b)는 응답(115)을 각각의 지속성 저장소(160)에 저장하기 시작하는 동시에, 각각의 휘발성 메모리(155, 156)에 저장된 상태로 또한 유지한다.

도 10을 참조하면, 응답(115)이 1차 작업자에 저장되고 백업 작업자(150b)에서 복제된 후에, 지속 시간(T3)은 tb로 설정된다. 1차 작업자(150a) 및 백업 작업자(150b)는 지속성 저장소(160)에서의 응답(115)의 영구 저장을 마무리한다. 1차 작업자에 저장된 요청(113)은 상태 D로 있고, 백업 작업자(150b)에 저장된 요청(113)은 요청(113) 및 응답(115)이 여전히 휘발성 메모리(155, 156)에 각각 저장된 상태 H로 있다.

도 11을 참조하면, 본 실시예에서의 에스크로 시간은 지속 시간 T3이므로, T3가 tb로 업데이트됨으로써, 호출 클러스터 구성 요소(110)에 저장된 요청(113)은 상태 C로 진입하고, (시간 tb와 연관되는) 응답(115)은 이의 에스크로 버퍼(114)로부터 배포된다.

도 12를 참조하면, 응답(115)이 1차 작업자(150a)의 지속성 저장소에 영구적으로 저장됨으로써, 요청(113)은 상태 E로 진입하여, 요청(113) 또는 응답(115)이 이의 휘발성 메모리(155, 156)에 각각 저장되지 않는다. 유사하게, 응답(115)이 백업 작업자(150b)의 지속성 저장소에 영구적으로 저장됨으로써, 요청(113)은 상태 I로 진입하여, 요청(113) 또는 응답(115)이 이의 휘발성 메모리(155, 156)에 저장되지 않는다.

3. 복귀 시나리오

도 4의 상태 전이도는 정상 작동을 나타내지만, 드물게는, 작업자들 간에 메시지가 성공적으로 수신되지 않을 수 있다. 또한, 작업자가 이의 휘발성 메모리를 상실한 후에 재시작해야 할 수 있거나, 작업자가 완전히 실패하여 요청을 추가로 처리하지 못할 수도 있다(즉, 1차 또는 백업 역할로). 본원에 설명된 데이터 처리 시스템의 그 일부 실시형태는 본 섹션에서 설명되는 모든 복귀 시나리오를 구현한다는 점을 유의한다. 또한, 데이터 처리 시스템의 다른 실시형태는 본 섹션에서 설명되는 복귀 시나리오 중 적어도 하나를 구현할 수 있지만, 복귀 시나리오의 전부를 구현하지는 않을 수 있다는 점을 유의한다.

3.1 시나리오 1: tr < ta

성공적으로 수신되지 않은 일부 작업자간 메시지가 있고, 그 메시지가 시간 te와 연관되었다고 클러스터가 결정하는 상황을 먼저 고려한다. 일반적으로, 루트는 te 이전의 시간 tr(즉, tr<te)로, 예를 들어 tr=te-1로, 시간이 "복귀"되어야 한다는 것을 모든 작업자에게 통지한다. 이러한 복귀의 경우에도, 호출 클러스터 구성 요소(110)에 의해 제공된 결과는 복귀가 수행되지 않은 것처럼 애플리케이션 또는 그래프에 제공되며, 작업자들 간에 분산된 데이터에 대한 업데이트는 호출 클러스터 구성 요소에 의해 제공된 결과와 일치하게 유지된다. 특히, 결과는 다수의 노드(예를 들어, 작업자들)에 저장(예를 들어, 복제 또는 지속)될 때까지 호출 클러스터 구성 요소(110)로부터 애플리케이션 또는 그래프로 배포되지 않음으로써, 결과가 리콜되거나 무효가 되지 않도록 보장한다. 달리 말하면, 수행되는 임의의 복귀는 반드시, 호출 클러스터 구성 요소(110)에 의해 결과가 애플리케이션 또는 그래프에 제공되기 전에 수행된다.

일부 작업자간 메시지가 성공적으로 수신되지 않았기 때문에 복귀가 수행되어야 한다고 루트(140)가 결정하는 경우, 루트는 복귀 시간(tr)을 호출 클러스터 구성 요소(110)에 통지한다. 현재 시간(T1)이 증분되고, 일반적으로, 시간 tr+1부터 최대 T1-1까지의 그리고 T1-1을 포함하는 모든 활동은 이들이 수행되지 않은 것처럼 간주된다. 호출 클러스터 구성 요소(110)에서의 효과는, 상태 B로(즉, 에스크로 시간에 의해 도달되지 않은 응답 시간으로), 리플레이 버퍼(112)에 저장된 모든 요청이 상태 A로 복귀되고, 에스크로 버퍼(114)의 임의의 해당 응답(115)이 폐기되는 것이다. 그 다음, 상태 A로 있는 요청(113)은 (이들이 이미 상태 A로 있었거나, 이들이 상태 B로부터 상태 A로 복귀되었기 때문에) 클러스터(120)에 재전송된다.

아직 실행을 시작하지 않았지만, 1차 작업자와 백업 작업자(즉, 1차는 상태 A로 있고, 백업은 상태 F로 있음) 간에 복제되었던 요청에 대한 클러스터에서의(즉, 작업자(150)에서의) 효과는, 요청이 복귀 시간 tr보다 더 큰 요청 시간 ta를 갖는 상황(즉, tr<ta)에 대해 먼저 고려된다. 이러한 예시의 경우, 현재 작업 시간은 tc로 표시된다. ta가 tr보다 더 크기 때문에, 호출 클러스터 구성 요소는 요청이 적절하게 복제되었다고 가정할 수 없으므로, 1차 작업자 및 백업 작업자의 휘발성 메모리(155)에 저장된 요청의 버전이 제거된다. 요청(113)은 동일한 요청 id인 rid와 함께 호출 클러스터 구성 요소(110)로부터 클러스터(120)에 수신되며, 새로운 요청 시간(tc)과 연관된다. 1차 작업자가 요청(113)을 수신하는 경우, 이의 휘발성 메모리(155)에 요청(113)을 상태 A로 저장한다. 1차 작업자는 요청(113)을 백업 작업자(들)(150)에 전송하고, 백업 작업자(들)(150)는 이의 휘발성 메모리(155)에 요청(113)을 상태 F로 저장한다. 그 다음, 1차 및 백업에서의 추가적인 처리는 도 4에 도시된 방식으로 진행된다.

1차로부터 시간 tc를 갖는 업데이트된 요청을 수신하기 전에 백업이 요청을 인지하지 못한 경우, 요청이 현재 적절하게 복제된 것과 동일한 방식으로 또한 진행된다는 점을 유의한다.

도 13 내지 도 15를 참조하면, 제1 복귀 시나리오의 일 실시예가 도시된다. 도 13에서, 시간 ta에서 발행된 요청(113)은 호출 클러스터 구성 요소(110)에서 리플레이 버퍼(112)에 저장되며, 상태 A로 있다. 요청(113)은 1차 작업자에서 휘발성 메모리(155)에 저장되고, 아직 실행을 시작하지 않았기 때문에 상태 A로 있다. 요청(113)은 또한 백업 작업자(150b)에 저장되고, 상태 F로 있다.

시스템을 시간 tr < ta로 복귀시키기 위한 복귀 요청이 수신된다. 도 14에서, 복귀 요청이 수신된 후에, 요청(113)은 1차 작업자(150a)의 휘발성 메모리(155)로부터 그리고 백업 작업자(150b)의 휘발성 메모리(155)로부터 제거된다. 원본 요청(113)과 동일한 요청 식별자(rid)와 연관된 새로운 요청(113')은 호출 클러스터 구성 요소(110)에 의해 클러스터(120)에 발행된다. 시간 tc에서, 새로운 요청(113')은 클러스터(120)에 의해 수신되고, 요청 시간 tc와 연관된다. 클러스터(120)는 새로운 요청(113')과 연관된 요청 시간 tc를 호출 클러스터 구성 요소(110)에 통지한다. 리플레이 버퍼(112)의 새로운 요청(113')은 상태 A로 있다.

클러스터에서, 새로운 요청(113')은 1차 작업자에게 전송된다. 1차 작업자(150a)는 요청 시간 tc와 함께, 새로운 요청(113')을 이의 휘발성 메모리(155)에 저장한다. 1차 작업자(150a)의 휘발성 메모리(155)에 저장된 새로운 요청(113')은 상태 A로 있다.

도 15를 참조하면, 1차 작업자는 새로운 요청(113')을 백업 작업자(150b)에 전송한다. 백업 작업자(150b)는 새로운 요청(113')을 이의 휘발성 메모리(155)에 저장하고, 요청 시간 tc와 연관시킨다. 백업 작업자의 휘발성 메모리(155)에 저장된 업데이트된 요청(113')은 상태 F로 있다.

그 다음, 클러스터는 (도 5 내지 도 12에 상술된 바와 같은) 이의 정상 작동에 따라 진행된다.

3.2 시나리오 2: tr < ta , 실행이 시작됨

제2 상황에서, 이전 요청의 요청 시간(ta)은 복귀 시간(tr)보다 더 크지만(즉, tr<ta), 요청은 실행을 시작했으며, 1차 작업자에서 실행을 완료하지 않았다(즉, 요청은 1차 작업자에서 상태 B로 있고, 가능하게는 부분 응답(115)이 계산될 수 있으며, 요청은 백업 작업자에서 상태 F로 있음). 이 경우, 1차 작업자 및 백업 작업자에서, 실행이 종료되고 부분 응답(115)이 폐기되며(또는 실행이 완료되도록 허용되고, 응답이 폐기됨), 호출 클러스터 구성 요소(110)는 요청(113)을 클러스터(120)에 재전송한다. 1차 및 백업 작업자에 저장된 요청은 상태 A 및 F로 각각 복귀한다. 1차 작업자는 요청이 1차 작업자에서 실행을 시작하지 않았던 것처럼 동일한 방식으로 요청을 백업에게 통지한다.

도 16 내지 도 18을 참조하면, 제2 복귀 시나리오의 일 실시예가 도시된다. 도 16에서, 시간 ta에서 발행된 요청(113)은 호출 클러스터 구성 요소(110)에서 리플레이 버퍼(112)에 저장되며, 상태 A로 있다. 요청(113)은 1차 작업자(150a)에서 휘발성 메모리(155)에 저장되고, 실행을 시작했기 때문에 상태 B로 있다. 요청은 또한 백업 작업자(150b)에 저장되고, 상태 F로 있다.

시스템을 시간 tr < ta로 복귀시키기 위한 복귀 요청이 수신된다. 도 17에서, 복귀 요청이 수신된 후에, 요청(113)은 1차 작업자(150a)의 휘발성 메모리(155)로부터 그리고 백업 작업자(150b)의 휘발성 메모리(155)로부터 제거된다. 원본 요청(113)과 동일한 요청 식별자(rid)와 연관된 새로운 요청(113')은 호출 클러스터 구성 요소(110)에 의해 클러스터(120)에 발행된다. 시간 tc에서, 새로운 요청(113')은 클러스터(120)에 의해 수신되고, 요청 시간 tc와 연관된다. 클러스터(120)는 새로운 요청(113')과 연관된 요청 시간 tc를 호출 클러스터 구성 요소(110)에 통지한다. 리플레이 버퍼(112)의 새로운 요청(113')은 상태 A로 있다.

클러스터에서, 새로운 요청(113')은 1차 작업자에 전송된다. 1차 작업자(150a)는 요청 시간 tc와 함께, 새로운 요청(113')을 이의 휘발성 메모리(155)에 저장한다. 1차 작업자(150a)의 휘발성 메모리(155)에 저장된 새로운 요청(113')은 상태 A로 있다.

도 18을 참조하면, 1차 작업자(150a)는 새로운 요청(113')을 백업 작업자(150b)에 전송한다. 백업 작업자(150b)는 새로운 요청(113')을 이의 휘발성 메모리(155)에 저장하고, 요청 시간 tc와 연관시킨다. 백업 작업자의 휘발성 메모리(155)에 저장된 업데이트된 요청(113')은 상태 F로 있다.

3.3 시나리오 3: tr < ta < tb , 실행이 완료됨

제3 상황에서, 다시 한번, 이전 요청의 요청 시간(ta)은 복귀 시간(tr)보다 더 크다. 그러나, 이 경우, 실행은 시간 tb에서 완료되었고(즉, tr<ta≤tb), 응답은 백업 작업자에서 복제되어 호출 클러스터 구성 요소(110)에서 수신되었다고 가정한다. 즉, 요청(113)은 호출 클러스터 구성 요소(110)에서 상태 B로 있고, 요청은 1차 작업자(150a)에서 상태 C로 있으며, 요청(113)은 백업 작업자(150b)에서 상태 G로 있다. 제2 상황에서와 같이 진행 중인 실행의 실행을 단지 종료할 필요 없이, 1차 및 백업 작업자에 저장되었던 응답(115)이 제거된다. 도 4를 참조하여 전술한 바와 같이, 시간 tb에서 생성된 응답은 특정 시간 및 그 이후의 모든 업데이트가 데이터 구조로부터 제거될 수 있는 그러한 방식으로, 시간 tb와 연관된 버전화 데이터 구조로 저장된다. 본 상황에서, 시간 tr보다 이후에 업데이트된 모든 데이터 버전을 제거함으로써, 시간 tb에 이루어진 도시된 요청에 대한 업데이트는 반드시 제거되며, 요청은 tc의 요청 시간이 실행을 대기하는, 1차 작업자에서의 상태 A로 복귀되고, 1차로부터의 응답을 대기하는, 백업 작업자에서의 상태 F로 복귀된다. 호출 클러스터 구성 요소에서, 응답은 폐기되고, 요청은 상태 A로 복귀된다.

도 19 내지 도 21을 참조하면, 제3 복귀 시나리오의 간단한 일 실시예가 도시된다. 도 19에서, 시간 ta에서 발행된 요청(113)은 호출 클러스터 구성 요소(110)에서 리플레이 버퍼(112)에 저장된다. 시간 tb에서 생성된 요청(115)에 대한 응답은 에스크로 버퍼(114)에 저장된다. 따라서, 요청(113)은 호출 클러스터 구성 요소에서 상태 B로 있다.

클러스터에서, 요청(113) 및 응답(115)은 1차 작업자(150a)에서 휘발성 메모리(155, 156)에 저장된다. 따라서, 요청(113)은 1차 작업자(150a)에서 상태 C로 있다. 요청(113) 및 응답(115)은 또한 백업 작업자에서 휘발성 메모리(155, 156)에 저장된다. 따라서, 요청은 백업 작업자(150b)에서 상태 G로 있다.

시스템을 시간 tr < ta < tb로 복귀시키기 위한 복귀 요청이 수신된다. 도 20에서, 복귀 요청이 수신된 후에, 응답(115)은 호출 클러스터 구성 요소(110)의 에스크로 버퍼(114)로부터 제거된다. 클러스터(120)에서, 요청(113) 및 응답(115) 모두는 1차 작업자(150a)의 휘발성 메모리(155)로부터 그리고 백업 작업자(150b)의 휘발성 메모리(155)로부터 제거된다.

원본 요청(113)과 동일한 요청 식별자(rid)와 연관된 새로운 요청(113')이 호출 클러스터 구성 요소(110)에 의해 클러스터(120)에 발행된다. 시간 tc에서, 새로운 요청(113')은 클러스터(120)에 의해 수신되고, 요청 시간 tc와 연관된다. 클러스터(120)는 새로운 요청(113')과 연관된 요청 시간 tc를 호출 클러스터 구성 요소(110)에 통지한다. 리플레이 버퍼(112)의 새로운 요청(113')은 상태 A로 있다.

클러스터에서, 새로운 요청(113')은 1차 작업자(150a)에 전송된다. 1차 작업자(150a)는 요청 시간 tc와 함께, 새로운 요청(113')을 이의 휘발성 메모리(155)에 저장한다. 1차 작업자(150a)의 휘발성 메모리(155)에 저장된 새로운 요청(113')은 상태 A로 있다.

도 21을 참조하면, 1차 작업자(150a)는 새로운 요청(113')을 백업 작업자(150b)에 전송한다. 백업 작업자(150b)는 새로운 요청(113')을 이의 휘발성 메모리(155)에 저장하고, 요청 시간 tc와 연관시킨다. 백업 작업자의 휘발성 메모리(155)에 저장된 업데이트된 요청(113')은 상태 F로 있다.

3.4 시나리오 4: ta < tr , 실행이 시작되지 않음

제4 상황에서, 복귀 시간(tr)은 원본 요청 시간(ta)이거나 원본 요청 시간(ta) 이후이고(즉, ta≤tr), 원본 요청은 실행을 시작하지 않았다. 요청은 클러스터(120)에 재전송되고, 1차 작업자 및 백업 작업자에서 원본 요청(즉, {rid,ta}) 뒤에 실행을 위해 대기된다. 1차 작업자는 원본 요청을 실행하고, 응답(즉, {rid, tb})을 생성한다. 그 다음, 1차 작업자는 재전송된 요청(즉, {rid, tc})의 실행을 시작하도록 진행되지만, 재전송된 요청의 rid와 연관된 응답이 이미 존재한다는 것을 감지하고, 재전송된 요청의 실행을 포기한다.

도 22 내지 도 25를 참조하면, 제4 복귀 시나리오의 일 실시예가 도시된다. 도 22에서, 시간 ta에서 발행된 원본 요청(113)은 호출 클러스터 구성 요소(110)에서 리플레이 버퍼(112)에 저장되며, 상태 A로 있다. 원본 요청(113)은 1차 작업자(150a)에서 휘발성 메모리(155)에 저장되고, 아직 실행을 시작하지 않았기 때문에 상태 A로 있다. 원본 요청(113)은 또한 백업 작업자(150b)에 저장되고, 상태 F로 있다.

시스템을 시간 ta < tr로 복귀시키기 위한 복귀 요청이 수신된다. 도 23에서, 원본 요청(113)과 동일한 요청 식별자(rid)와 연관된 새로운 요청(113')이 호출 클러스터 구성 요소(110)에 의해 클러스터(120)에 발행된다. 시간 tc에서, 새로운 요청(113')은 클러스터(120)에 의해 수신되고, 요청 시간 tc와 연관된다. 클러스터(120)는 새로운 요청(113')과 연관된 요청 시간 tc를 호출 클러스터 구성 요소(110)에 통지한다. 리플레이 버퍼(112)의 요청(113)은 상태 A로 유지된다.

클러스터에서, 새로운 요청(113')은 1차 작업자(150a)에 전송된다. 1차 작업자(150a)는 새로운 요청(113')을 수신하고, 실행을 위해 원본 요청(113) 뒤에 새로운 요청(113')을 대기시킨다. 1차 작업자(150a)의 휘발성 메모리(155)에 저장된 새로운 요청(113') 및 원본 요청(113) 모두는 상태 A로 있다.

도 24를 참조하면, 1차 작업자(150a)는 새로운 요청(113')을 백업 작업자(150b)에 전송한다. 백업 작업자(150b)는 새로운 요청(113')을 수신하고, 실행을 위해 원본 요청(113) 뒤에 새로운 요청(113')을 대기시킨다. 백업 작업자(150b)의 휘발성 메모리(155)에 저장된 새로운 요청(113') 및 원본 요청(113) 모두는 상태 F로 있다.

도 25를 참조하면, 1차 작업자(150a)는 응답(115)을 생성하기 위해 원본 요청(113)을 실행하였고, 응답(115)은 이의 지속성 저장소(160)에서 지속된다. 결과적으로, 원본 요청(113)은 1차 작업자(150a)에서 상태 D로 있다. 새로운 요청(113')은 1차 작업자(150a)에서 아직 실행을 시작하지 않았으므로, 상태 A로 있다.

응답(115)은 또한 백업 작업자(150b) 및 호출 클러스터 구성 요소(110)에 제공된다. 백업 작업자(150b)는 응답(115)을 이의 휘발성 메모리(156)에 저장하고, 이의 지속성 저장소(160)에 응답을 지속시킨다. 따라서, 원본 요청(113)은 백업 작업자에서 상태 H로 있다. 호출 클러스터 구성 요소(110)는 이의 에스크로 버퍼(114)에 응답(115)을 저장하며, 호출 클러스터의 구성 요소의 리플레이 버퍼(112)의 요청(113)은 상태 B로 있다.

새로운 요청(113')이 1차 작업자(150a)에서 실행을 시작하면, 1차 작업자(150a)는 새로운 요청(113')이 응답(115)과 동일한 요청 식별자 rid와 연관된다는 것을 인식하므로, 이것이 복제본이기 때문에, 새로운 요청(113')을 실행하지 않는다. 일부 실시예에서, 응답(115)은 호출 클러스터 구성 요소에 재전송될 수 있으며, 호출 클러스터 구성 요소는 응답(115)을 복제본으로서 무시한다.

3.5 시나리오 5: ta < tr , 실행이 시작됨

제5 상황에서, 복귀 시간(tr)은 원본 요청 시간(ta)이거나 원본 요청 시간(ta) 이후이고(즉, ta≤tr), 원본 요청은 실행을 시작했지만, 1차 작업자에서 실행을 완료하지 않았다(즉, 요청은 1차 작업자에서 상태 B로 있고, 요청은 백업 작업자에서 상태 F로 있다). 이러한 상황에서, 1차 작업자 및 백업 작업자에서 실행은 종료(또는 완료되도록 허용되고, 응답이 폐기됨)된다(즉, 1차 및 백업 작업자에 저장된 요청은 각각 상태 A 및 F로 복귀한다).

호출 클러스터 구성 요소(110)는 요청을 클러스터(120)에 재전송하며, 요청은 1차 작업자 및 백업 작업자에서 원본 요청(즉, {rid, ta}) 뒤에 실행을 위해 대기된다. 1차 작업자는 원본 요청을 실행하고, 응답(즉, {rid, tb})을 생성한다. 그 다음, 1차 작업자는 재전송된 요청(즉, {rid, tc})의 실행을 시작하도록 진행되지만, 재전송된 요청의 rid와 연관된 응답이 이미 존재한다는 것을 감지하고, 재전송된 요청의 실행을 포기한다.

도 26 내지 도 29를 참조하면, 제5 복귀 시나리오의 일 실시예가 도시된다. 도 26에서, 시간 ta에서 발행된 원본 요청(113)은 호출 클러스터 구성 요소(110)에서 리플레이 버퍼(112)에 저장되며, 상태 A로 있다. 원본 요청(113)은 1차 작업자(150a)에서 휘발성 메모리(155)에 저장되고, 실행을 시작했기 때문에 상태 B로 있다. 원본 요청(113)은 또한 백업 작업자(150b)에 저장되고, 상태 F로 있다.

시스템을 시간 ta < tr로 복귀시키기 위한 복귀 요청이 수신된다. 도 27에서, 원본 요청(113)과 동일한 요청 식별자(rid)와 연관된 새로운 요청(113')이 호출 클러스터 구성 요소(110)에 의해 클러스터(120)에 발행된다. 시간 tc에서, 새로운 요청(113')은 클러스터(120)에 의해 수신되고, 요청 시간 tc와 연관된다. 클러스터(120)는 새로운 요청(113')과 연관된 요청 시간 tc를 호출 클러스터 구성 요소(110)에 통지한다. 리플레이 버퍼(112)의 요청(113)은 상태 A로 유지된다.

클러스터(120)에서, 1차 작업자(150a)의 휘발성 메모리(155)에 저장된 원본 요청(113)의 실행이 종료되고, 원본 요청(113)은 상태 A로 복귀된다. 새로운 요청(113')은 1차 작업자(150a)에 전송된다. 1차 작업자(150a)는 새로운 요청(113')을 수신하고, 실행을 위해 원본 요청(113) 뒤에 새로운 요청(113')을 대기시킨다. 1차 작업자(150a)의 휘발성 메모리(155)에 저장된 새로운 요청(113')은 상태 A로 있다.

도 28을 참조하면, 1차 작업자(150a)는 새로운 요청(113')을 백업 작업자(150b)에 전송한다. 백업 작업자(150b)는 새로운 요청(113')을 수신하고, 실행을 위해 원본 요청(113) 뒤에 새로운 요청(113')을 대기시킨다. 백업 작업자(150b)의 휘발성 메모리(155)에 저장된 새로운 요청(113') 및 원본 요청(113) 모두는 상태 F로 있다.

도 29를 참조하면, 1차 작업자(150a)는 원본 요청(113)을 실행하였고, 응답(115)을 생성하였다. 응답(115)은 이의 지속성 저장소(160)에서 지속된다. 결과적으로, 원본 요청(113)은 1차 작업자(150a)에서 상태 D로 있다. 새로운 요청(113')은 1차 작업자(150a)에서 아직 실행을 시작하지 않았으므로, 상태 A로 있다.

응답(115)은 또한 백업 작업자(150b) 및 호출 클러스터 구성 요소(110)에 복제된다. 백업 작업자(150b)는 응답(115)을 이의 휘발성 메모리(156)에 저장하고, 이의 지속성 저장소(160)에 응답을 지속시킨다. 따라서, 원본 요청(113)은 백업 작업자에서 상태 H로 있다. 호출 클러스터 구성 요소(110)는 이의 에스크로 버퍼(114)에 응답(115)을 저장하며, 호출 클러스터의 구성 요소의 리플레이 버퍼(112)의 요청(113')은 상태 B로 있다.

새로운 요청(113')이 1차 작업자(150a)에서 실행을 시작하면, 1차 작업자(150a)는 새로운 요청(113')이 응답(115)과 동일한 요청 식별자 rid와 연관된다는 것을 인식하므로, 이것이 복제본이기 때문에, 새로운 요청(113')을 실행하지 않는다. 일부 실시예에서, 응답(115)은 호출 클러스터 구성 요소(110)에 재전송될 수 있으며, 호출 클러스터 구성 요소(110)는 응답(115)을 복제본으로서 무시한다.

3.6 시나리오 6: ta < tb < tr , 실행이 완료됨

제6 상황에서, 복귀 시간(tr)은 요청 시간(ta)이거나 요청 시간(ta) 이후이며, 요청은 또한 복귀 시간 또는 복귀 시간 이전의 시간 tb에서(즉, ta≤tb≤tr) 실행을 완료하였다. 응답이 호출 클러스터 구성 요소(110)에 성공적으로 제공된 경우(즉, 이러한 요청은 호출 클러스터 구성 요소에서 상태 B로 있음), 복귀 요청은 요청이 재전송되지 않게 하거나, 에스크로 버퍼(114)로부터 임의의 응답이 제거되지 않게 한다. 즉, ta와 연관된 임의의 요청, 및 tb와 연관된 임의의 응답은 변경되지 않는 상태로 유지된다.

그러나, 응답이 호출 클러스터 구성 요소(110)에 성공적으로 제공되지 않은 경우, 호출 클러스터 구성 요소(110)는 요청을 클러스터(120)에 재전송한다. 1차 작업자가 재전송된 요청을 수신하면, 재전송된 요청(즉, {rid, tc})의 실행을 시작하지만, 요청 식별자 rid와 연관된 응답(115)이 이미 존재한다는 것을 감지한다. 따라서, 재전송된 요청은 실행되지 않으며, 원본 요청의 실행에 의해 생성된 응답이 호출 클러스터 구성 요소(110)에 재전송된다. 호출 클러스터 구성 요소(110)는 응답 시간 tb와 함께 응답을 수신하며, 이는 호출 클러스터 구성 요소의 에스크로로부터 응답이 전송될 수 있는 시기를 결정하기 위해 사용된다.

도 30 내지 도 32를 참조하면, 제6 복귀 시나리오의 일 실시예가 도시된다. 도 30에서, 시간 ta에서 발행된 원본 요청(113)은 호출 클러스터 구성 요소(110)에서 리플레이 버퍼(112)에 저장된다. 원본 요청(113)에 대한 응답(115)은 시간 tb에 생성되었지만, 호출 클러스터 구성 요소(110)의 에스크로 버퍼(114)에 도달하지 않았다. 따라서, 요청(113)은 호출 클러스터 구성 요소(110)에서 상태 A로 있다.

시스템을 시간 ta < tb < tr로 복귀시키기 위한 복귀 요청이 수신된다. 도 31에서, 원본 요청(113)과 동일한 요청 식별자(rid)와 연관된 새로운 요청(113')이 호출 클러스터 구성 요소(110)에 의해 클러스터(120)에 발행된다. 시간 tc에서, 새로운 요청(113')은 클러스터(120)에 의해 수신되고, 요청 시간 tc와 연관된다. 클러스터(120)는 새로운 요청(113')과 연관된 요청 시간 tc를 호출 클러스터 구성 요소(110)에 통지한다.

새로운 요청(113')은 클러스터(120)의 1차 작업자(150a)에 전송된다. 1차 작업자(150a)는 새로운 요청(113')을 수신하고, 실행을 위해 휘발성 메모리(155)에 새로운 요청(113')을 대기시킨다. 1차 작업자(150a)의 휘발성 메모리(155)에 저장된 원본 요청(113)은 상태 C로 유지되고, 1차 작업자(150a)의 휘발성 메모리(155)에 저장된 새로운 요청(113')은 상태 A로 있다.

도 32를 참조하면, 1차 작업자(150a)가 새로운 요청의 실행을 시작하면, 1차 작업자(150a)는, 새로운 요청(113')이 원본 요청(113)과 동일한 요청 식별자 rid를 가지며, 요청 식별자 rid와 연관된 응답(115)이 이미 1차 작업자(150a)에 존재한다는 것을 인식한다. 따라서, 1차 작업자(150a)는 새로운 요청(113')을 실행하는 것이 아니라, 그 대신 응답(115)을 호출 클러스터 구성 요소(110)에 재전송한다. 호출 클러스터 구성 요소(110)는 응답(115)을 수신하고, 이를 에스크로 버퍼(114)에 저장한다. 호출 클러스터 구성 요소(110)의 에스크로 버퍼(114)에 응답(115)이 저장됨으로써, 호출 클러스터 구성 요소(110)는 상태 B로 있다.

3.7 시나리오 7: ta < tr < tb , 실행이 완료됨

제7 상황에서, 복귀 시간(tr)은 요청 시간(ta)이거나 요청 시간(ta) 이후이고, 요청은 복귀 시간 이후의 시간 tb에서(즉, ta≤tr<tb) 실행을 완료했으며, 작업자 간의 응답의 복제가 성공적이지 않았을 수 있다. 작업자는 tr 이후의 시간을 갖는 모든 응답(115)을 폐기한다. 백업 작업자에 저장된 요청(113)은 상태 F로 복귀하고, 1차 작업자에 저장된 요청(113)은 상태 B로 복귀한다. 호출 클러스터 구성 요소(110)는 에스크로 버퍼(114)의 모든 응답(115)을 폐기하고, 리플레이 버퍼(112)에 저장된 요청(113)을 상태 A로 복귀시키며, 요청을 재처리하는 클러스터(120)에 요청(113)을 재전송한다.

도 33 내지 도 35를 참조하면, 제7 복귀 시나리오의 일 실시예가 도시된다. 도 33에서, 시간 ta에서 발행된 요청(113)은 호출 클러스터 구성 요소(110)에서 리플레이 버퍼(112)에 저장된다. 시간 tb에서 생성된 요청(115)에 대한 응답은 에스크로 버퍼(114)에 저장된다. 따라서, 요청(113)은 호출 클러스터 구성 요소(110)에서 상태 B로 있다.

클러스터(120)에서, 요청(113) 및 응답(115)은 1차 작업자(150a)에서 휘발성 메모리(155, 156)에 저장된다. 따라서, 요청(113)은 1차 작업자(150a)에서 상태 C로 있다. 요청(113)은 또한 백업 작업자(105)에서 휘발성 메모리(155, 156)에 저장되지만, 응답(115)은 백업 작업자(150b)에 성공적으로 복제될 수 있거나 성공적으로 복제되지 않을 수 있다. 따라서, 요청은 백업 작업자(150b)에서 상태 G로 있을 수 있거나 상태 G로 있지 않을 수 있다.

시스템을 시간 ta < tr < tb로 복귀시키기 위한 복귀 요청이 수신된다. 도 34에서, 호출 클러스터 구성 요소(110)의 에스크로 버퍼(114)에 저장된 응답(115)이 제거된다. 원본 요청(113)과 동일한 요청 식별자(rid)와 연관된 새로운 요청(113')이 호출 클러스터 구성 요소(110)에 의해 클러스터(120)에 발행된다. 시간 tc에서, 새로운 요청(113')은 클러스터(120)에 의해 수신되고, 요청 시간 tc와 연관된다. 클러스터(120)는 새로운 요청(113')과 연관된 요청 시간 tc를 호출 클러스터 구성 요소(110)에 통지한다. 리플레이 버퍼(112)의 새로운 요청(113')은 상태 A로 있다.

클러스터(120)에서, 백업 작업자(150b)는 tr 이후의 시간과 연관된 이의 휘발성 메모리(156)에 저장된 임의의 응답을 제거하므로, 상태 F로 복귀한다. 1차 작업자(150a)는 상태 B로 복귀한다. 새로운 요청(113')은 1차 작업자(150a)에 전송된다. 1차 작업자는 새로운 요청(113')을 수신하고, 실행을 위해 원본 요청(113) 뒤에 새로운 요청(113')을 대기시킨다. 1차 작업자(150a)의 휘발성 메모리(155)에 저장된 새로운 요청(113')은 상태 A로 있다.

도 35에서, 1차 작업자(150a)는 원본 요청(113)의 실행을 완료하고, 시간 td에서 새로운 응답(115')을 생성한다. 1차 작업자(150a)는 새로운 응답(115')을 백업 작업자(150b) 및 호출 클러스터 구성 요소(110)에 전송함으로써, 1차 작업자(150a)의 휘발성 메모리에 저장된 원본 요청(113)의 상태가 상태 C로 전이되게 한다. 백업 작업자(150b)는 새로운 응답(115')을 수신하고, 새로운 응답(115')을 이의 휘발성 메모리(155)에 저장함으로써, 백업 작업자의 휘발성 메모리(155)에 저장된 원본 요청(113)이 상태 G로 전이되게 한다. 호출 클러스터 구성 요소(110)는 새로운 응답(115')을 수신하고, 이를 에스크로 버퍼(114)에 저장함으로써, 리플레이 버퍼(112)에 저장된 새로운 요청(113')이 상태 B로 전이되게 한다.

새로운 요청(113')이 1차 작업자(150a)에서 실행을 시작하면, 1차 작업자(150a)는 새로운 요청(113')이 원본 요청(113)과 동일한 요청 식별자 rid를 갖는다는 것을 인식하므로, 이것이 복제본이기 때문에, 새로운 요청(113')을 실행하지 않는다.

3.8 시나리오 8: ta < tr < tb , 실행이 완료됨

마지막으로, 제8 상황에서, 요청을 1차로서 처리하는 작업자가 상실된다(예를 들어, 실패인 것으로 알려짐). 매우 일반적으로, 상실된 1차가 응답을 제공하도록 대기하고 있는 백업 작업자(즉, 백업은 상태 F로 있음)에서의 임의의 요청은, 그 백업 작업자를 1차로 승격시킨다. 예를 들어, 그 작업자로부터 메시지에 대한 응답을 수신하는 데 실패함으로써, 작업자가 상실되었음을 루트(140)가 감지하는 경우, 루트는 마지막 복제된 시간과 동일한 시간 tr(즉, tr=T2)로 복귀를 개시한다. 상실된 작업자를 수용하기 위한 새로운 분할 정보가 동반될 수 있는 시간 tr로의 복귀 요청을 백업이 수신하는 경우, 백업은 자원이 요청을 실행하도록 대기하고 있는 상태 A로 요청의 상태를 변경함으로써, 새로운 1차로서 역할을 하기 시작한다.

도 36 내지 도 37을 참조하면, 제8 복귀 시나리오의 일 실시예가 도시된다. 도 36에서, 시간 ta에서 발행된 요청(113)은 호출 클러스터 구성 요소(110)에서 리플레이 버퍼(112)에 저장되며, 상태 A로 있다. 요청(113)은 1차 작업자(150a)에서 휘발성 메모리(155)에 저장되고, 실행을 시작했으나 실행을 완료하지 않았기 때문에 상태 B로 있다. 요청은 또한 백업 작업자(150b)에 저장되고, 상태 F로 있다. 요청(113)의 실행 동안, 1차 작업자(150a)는 실패하거나 상실된다.

도 37에서, 루트는 마지막 복제 시간과 동일한 시간 tr로의 복귀를 요청했다. 그 시점에, 백업 작업자(150b)는 1차 작업자(150a)로 승격되어, 이의 상태를 상태 A로 변경한다. 다른 작업자(150c)는 상태 F로 백업 작업자로서 할당된다.

4. 루트 노드

이제 루트(140)의 작동으로 돌아가면, 전술한 바와 같이, 루트는 현재 작업 시간(간격) T1(144)을 주기적으로 증분시킨다. 일반적으로, 루트가 작업 시간을 업데이트하면, 시간(T1, T2, T3)의 투플(tuple)(144 내지 146)을 모든 작업자에게 분산(예를 들어, 브로드캐스트)시킨다. 이에 응답하여, 작업자는 어떤 것이 T2 및/또는 T3 시간을 업데이트할 수 있는지에 기초하여 정보를 루트에 제공한다.

각각의 작업자는 특정 작업 시간과 연관된 카운터 세트(151 내지 152)를 유지한다. 하나의 카운터(151)는 Sent(t1)로 지칭되는 작업 시간(t1)과 연관되며, 백업 작업자에 전송된 요청 시간(t1)을 갖는 요청에 대한 그 작업자로부터의 통신의 수, 및 백업 작업자에 전송된 응답 시간(t1)을 갖는 응답의 수를 카운트한다. 도 4에서, Sent(ta)는 백업 작업자에 전송된 요청 시간 ta를 갖는 각각의 요청에 대해 상태 A로 업데이트되고, Sent(tb)는 백업 작업자에서의 복제를 위해 전송되는 시간 tb에서 생성된 각각의 응답에 대해 증분된다. Sent( ) 카운터는 작업자로부터 호출 클러스터 구성 요소로 전송된 메시지에 대해 증분되지 않는다는 점을 유의한다. 다른 카운터(152), Rec(t1)은 시간 t1과 연관된 작업자에 수신된 통신의 수를 카운트한다. 특히, 백업 작업자는, 상태 F로 진입할 때 요청 시간 ta를 갖는 요청의 복제본을 수신하는 경우 Rec(ta)를 증분시키고, 상태 G로 진입할 때 시간 tb에서 생성된 응답의 복제본을 수신하는 경우 Rec(tb)를 증분시킨다. 각각의 작업자는 이러한 카운터의 그 자체의 로컬 복사본을 가지며, 작업자 w의 경우 Sentw(t) 및 Recw(t)로 표시된다. 시간 t1과 연관되어 전송된 모든 통신이 이들의 목적지에서 또한 수신되는 한, 모든 작업자 w에 걸친 Sentw(t)의 그 총합은 작업자 w에 걸친 Recw(t)의 총합과 동일하다는 것은 명백할 것이다.

때때로, 예를 들어 루트(140)로부터 현재 시간(T1, T2, T3)의 브로드캐스트를 수신하는 것에 응답하여, 각각의 작업자(150)는 복제 시간 T2보다 더 큰 모든 시간에 대해 이의 현재 카운트 Sent(t)(151) 및 Rec(t)(152)를 전송한다. 이러한 카운트는 루트에서 수신되어 집계됨으로써, 루트는 T2보다 더 큰 각각의 시간 t에 대해 Sent(t) 및 Rec(t)의 합을 결정하고, 해당 시간과 관련하여 카운터(141 및 142)를 이들에 저장한다. Sent(T2+1)이 Rec(T2+1)과 동일한 경우, 시간 T2+1로부터의 모든 전송이 수신되고, T2는 증분되어 다음 복제 시간이 된다. 이러한 프로세스는 Sent(T2+1)이 Rec(T2+1)과 동일하지 않거나 T2+1이 T1에 도달할 때까지 반복된다. 그 다음, 이러한 증분된 T2 시간(145)은 루트로부터의 다음 브로드캐스트에 사용된다.

전술한 바와 같이, 작업자에서의 데이터 업데이트는 먼저 휘발성 메모리에서 저널링되며, 저널은 때때로 지속성 저장소에 기록된다. 각각의 작업자는 복제 시간 T2까지의 변경에 대해 지속성 메모리의 저널링된 변경 사항을 자유롭게 영구적이게 한다. 일반적으로, 각각의 작업자 w는 일반적으로 상이한 작업자가 상이한 시간에 도달하는, 시간 T3(w) 동안 모든 변경 사항을 영구적이게 할 기회를 갖는다. 현재 시간의 브로드캐스트에 응답하여 Rec( ) 및 Sent( )를 루트로 복귀시키는 것과 더불어, 각각 작업자는 또한 이의 T3(w) 시간을 복귀시키며, 이는 루트에서 또는 다시 루트로의 통신 경로에서 min( ) 연산에 따라 집계된다. 즉, 루트는 T3 = minw T3(w)를 결정한 다음, 다음번에 현재 시간을 분산시킬 때 이러한 새로운 T3 값을 분산시킨다.

일부 실시형태에서, 루트는 루트와 각각의 작업자 간의 직접(예를 들어, 유니캐스트) 통신으로 시간 투플(T1, T2, T3)을 분산시킨다. 다른 실시형태에서, 투플은 플러딩(flooding) 기반 브로드캐스트와 같은 다른 방식으로 분산된다. 다른 실시형태에서, 투플의 각각의 수신자가 투플을 다수의 추가적인 수신자에게 전달하는 미리 결정된 트리 구조화 분산 네트워크를 따라 투플이 분산됨으로써, 궁극적으로 모든 작업자가 시간 투플을 수신한다.

작업자로부터의 카운트의 집계는 각각의 작업자와 루트 노드 간의 유니캐스트 통신에 의해 수행될 수 있으며, 루트는 모든 작업자에 걸쳐서 완전한 합산을 수행한다. 보다 효율적인 솔루션으로서, 카운트는 시간 투플과 동일한 경로를 따라 다시 전송될 수 있으며, 경로의 중간 노드는 카운트의 합의 부분 집계를 수행함으로써, 루트를 통한 합산의 부담을 분산시켜서, 그럼에도 불구하고 모든 작업자에 걸친 카운트의 합을 달성한다.

대안적인 작동 모드에서, 응답 시간이 지속성인 대신에 복제되는 경우, 호출 클러스터 구성 요소로부터 응답이 배포될 수 있다. 이러한 방식으로, 응답은 더 적은 지연으로 그래프에 제공될 수 있으며, 이에 따라 응답은 클러스터 저장소에서 아직 지속성이 아닐 수 있는 가능성이 있다.

전술한 바와 같이, 요청의 실행의 응답의 저장은 버전화 데이터 구조로 저장된다. 하나의 이러한 데이터 구조에서, 데이터 항목의 각각의 업데이트는 별도로 복구 가능한 버전으로서 저장되고, 그 버전은 업데이트와 연관된 시간으로 태깅된다. 예를 들어, 데이터 구조는 적어도 개념적으로, 각각의 액세스 키에 대해, 투플 리스트(tb, 값)로서 저장될 수 있으며, 여기서 tb는 값의 업데이트 시간이다. 상이한 시간에 대한 값은 서브 구조를 공유할 수 있거나, 다른 저장소 최적화를 사용할 수 있다. 일부 실시예에서, 값은 시간 간의 데이터 값의 편집에 기초하여 저장된다. 일 실시예로서, 값은 트리 기반 구조로 표현될 수 있고, 각각의 버전은 이전 버전으로부터 다음 버전을 생성하기에 충분한 "순방향" 증분 연산으로서 저장될 수 있거나, 또는 현재 버전으로부터 이전 버전을 재구성하기에 충분한 "역방향" 증분 연산으로서 저장될 수 있다. 전술한 바와 같이, 이러한 종류의 버전화 데이터 구조는 복귀 시간 후의 모든 업데이트를 복귀시킬 수 있게 한다. 데이터 항목에 대한 모든 업데이트를 유지하는 대신에, 업데이트 시간의 시작과 관련된 업데이트만이 유지됨으로써, 임의의 업데이트 시간의 시작으로 복귀가 달성될 수 있다.

루트가 복제 시간(T2)을 증분시킨 후에, 작업자는 그 시간 또는 그 시간 이전의 버전으로 복귀하도록 요청되지 않을 것임을 인식해야 한다. 따라서, 버전화 데이터 구조의 최적화는 복제 시간(T2) 또는 복제 시간(T2) 이전의 버전이 데이터 구조로부터 제거될 수 있다는 것이다.

일부 실시형태에서, 일부 요청은 이들의 실행 시간이 적다는 점에서 "경량"이므로, 백업 작업자에서 요청의 실행은 1차 작업자로부터 백업 작업자로의 응답의 복제보다 더 적은 자원을 소비할 수 있다. 이러한 실시형태에서, 1차로부터 백업(들)으로의 응답의 복제는 수행되지 않는다. 각각의 작업자는 상이한 시간에 처리를 완료할 수 있다. 작업자 간의 데이터의 동기화를 유지하기 위해, 1차는 전술한 바와 같이, 완료 시간 tb를 분산시키고, 백업 작업자는 이들이 그 시간에 계산된 것처럼 이들의 로컬로 계산된 응답을 간주한다.

대안적인 실시형태에서, 호출 클러스터 구성 요소는, 루트로부터 시간 투플을 수신하고, Sent( ) 및 Rec( ) 카운트를 루트로 복귀시킨다는 점에서 클러스터에 참여한다. 이러한 실시형태에서, 호출 클러스터 구성 요소는 요청의 복제 동안 작업자에 의해 사용되는 요청에 대해 요청 시간을 할당한다. 복귀가 수행되는 경우, 호출 클러스터 구성 요소는 보유 중인 요청에 대한 요청 시간을 인지하기 때문에, 복귀 시간 이후에만 요청을 재전송해야 하며, 복귀 시간 또는 복귀 시간 이전에 생성된 응답을 폐기하지 않는다. 작업자의 작업은 호출 클러스터 구성 요소의 이러한 작업을 수용하도록 변경된다.

5. 대안

보다 일반적으로, ta < tr인 위의 복귀 시나리오 4 내지 8에서, 호출 클러스터 구성 요소(110)가 요청을 재전송하는 경우, 원본 요청이 시간 ta에서 전송되었음을 인지하지 않는다(또는 상관하지 않음). 반면에, 클러스터(120)는 복귀시킬지 여부를 결정하기 위해 그 시간을 사용하기 때문에, 원본 요청의 요청 시간을 고려할 필요가 있다. 따라서, ta < tr < tc이도록 호출 클러스터 구성 요소(110)가 (요청 식별자 rid를 갖는) 요청을 클러스터(120)에 재전송하는 경우, 요청은 1차 작업자(150a)에서 수신되고, 시간 tc와 연관된다. 1차 작업자(150a)는 요청을 백업 작업자(150b)에 전달한다. 이러한 상황에서, 1차 작업자는 재전송 요청(즉, {rid, tc})을 실행하기 전에, 원본 요청(즉, {rid, ta})을 실행할 수 있다. 1차 작업자(150a)가 재전송 요청(즉, {rid, tc})을 실행하도록 진행되는 경우, 이는 원본 요청(즉, {rid, ta})에 대한 응답이 이미 지속되었기 때문에, 재전송 요청을 복제본으로 간주할 것이다.

일부 실시예에서, 요청은 후속적인 작업을 산출한다(때로는 '작업 체이닝(chaining)'으로 지칭됨). 이러한 실시예에서, 요청에 대한 응답은 산출된 작업이 완료된 이후까지 생성되지 않는다. 일부 실시예에서, 요청 {rid, ta)에 대한 응답이 저장된 경우, 이의 응답을 호출 클러스터 구성 요소로 복귀시킨다. 그러나, 요청 {rid, ta}가 아직 완료되지 않았기 때문에, 요청 {rid, ta}에 대한 응답이 아직 존재하지 않는 경우, 원본 요청이 결국에는 완료되어 호출 클러스터 구성 요소로 복귀되는 응답을 생성할 것임을 클러스터가 인지하기 때문에, 복제본 rid를 갖는 후속적인 요청 {rid, tc}는 무시된다.

전술한 실시예에서, 클러스터가 요청을 수신하는 경우, 클러스터는 시간(예를 들어, ta)을 요청과 연관시킨 다음에, 그 시간을 호출 클러스터 구성 요소에 통지한다. 호출 클러스터 구성 요소는 시간을 이의 리플레이 버퍼에 저장된 요청과 연관시킨다. 호출 클러스터 구성 요소의 리플레이 버퍼의 요청과 연관된 시간은 복귀의 경우 요청을 선택적으로 재현하기 위해 호출 클러스터 구성 요소에 의해 사용될 수 있다. 그러나, 일부 실시예에서, 클러스터 또는 호출 클러스터 구성 요소는 요청을 시간과 연관시키지 않는다. 이러한 실시예에서, 복귀 시나리오의 경우 요청을 재현할 때, 호출 클러스터 구성 요소는 덜 선택적이다. 예를 들어, 호출 클러스터 구성 요소는 복귀 요청의 경우 이의 리플레이 버퍼의 모든 요청을 체계적으로 재현할 수 있다.

6. 구현예

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

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

본 발명의 다수의 실시형태가 설명되었다. 그럼에도 불구하고, 전술한 설명은 이하의 청구범위의 범위에 의해 정의되는 본 발명의 범위를 예시하는 것으로 의도되며 제한하려는 의도가 아님을 이해해야 한다. 따라서, 다른 실시형태도 이하의 청구범위의 범위 내에 있다. 예를 들어, 본 발명의 범위를 벗어나지 않으면서 다양한 변형이 이루어질 수 있다. 추가적으로, 전술한 단계 중 일부는 순서와 무관할 수 있으므로, 설명된 것과 상이한 순서로 수행될 수 있다.

Claims

복수의 처리 노드를 포함하는 분산형 데이터 처리 시스템을 사용하여 데이터를 처리하기 위한 방법으로서, 상기 방법은:
상기 분산형 데이터 처리 시스템과 통신하는 분산형 데이터 처리 시스템 인터페이스 구성 요소에서 입력 데이터를 수신하는 단계;
상기 수신된 입력 데이터를 상기 분산형 데이터 처리 시스템에 제공하는 단계 - 상기 분산형 데이터 처리 시스템은 복수의 시간 간격 중 제1 시간 간격과 연관된 표시자를 상기 입력 데이터에 할당함 -;
상기 입력 데이터를 수신하는 단계에 응답하여, 상기 분산형 데이터 처리 시스템 내의 상태 정보를 생성하는 단계 - 상기 상태 정보는 상기 제1 시간 간격과 연관된 상기 표시자를 포함함 -;
상기 분산형 데이터 처리 시스템 인터페이스 구성 요소에서, 상기 분산형 데이터 처리 시스템으로부터 상기 입력 데이터와 연관된 결과 데이터를 수신 및 저장하는 단계 - 상기 결과 데이터는 상기 제1 시간 간격보다 이후의 제2 시간 간격과 연관된 표시자를 포함함 -;
상기 제2 시간 간격과 연관된 상기 표시자를 포함하는 모든 상태 정보가 제1 지속성 레벨로 저장되는 상기 복수의 시간 간격 중 가장 빠른 시간 간격의 표시자를 상기 복수의 처리 노드 중 제1 처리 노드에서 결정하는 단계;
상기 가장 빠른 시간 간격의 상기 표시자를 상기 분산형 데이터 처리 시스템 인터페이스 구성 요소에 제공하는 단계; 및
상기 분산형 데이터 처리 시스템 인터페이스 구성 요소에서, 상기 결과 데이터와 연관된 상기 제2 시간 간격과 연관된 상기 표시자와 상기 가장 빠른 시간 간격의 상기 표시자의 비교에 기초하여, 상기 분산형 데이터 처리 시스템 인터페이스로부터 상기 결과 데이터를 배포할지 여부를 결정하는 단계를 포함하는, 방법.
제1항에 있어서,
상기 가장 빠른 시간 간격의 상기 표시자가 상기 제2 시간 간격과 동일하거나 상기 제2 시간 간격보다 이후의 시간 간격에 해당하는 경우, 상기 분산형 데이터 처리 시스템 인터페이스 구성 요소로부터 상기 결과 데이터를 배포하는 단계를 더 포함하는, 방법.
제2항에 있어서,
상기 입력 데이터는 상기 인터페이스 구성 요소에서 버퍼에 저장되며,
결과 데이터를 배포하는 단계는 상기 버퍼로부터 입력 데이터를 제거하는 단계를 포함하는, 방법.
제1항에 있어서,
상기 제1 지속성 레벨은 모든 상태 정보가 상기 분산형 데이터 처리 시스템의 상기 복수의 처리 노드 중 적어도 하나의 처리 노드와 연관된 휘발성 메모리에 복제됨을 나타내는, 방법.
제1항에 있어서,
상기 제1 지속성 레벨은 모든 상태 정보가 상기 분산형 데이터 처리 시스템의 상기 복수의 처리 노드 중 적어도 하나의 처리 노드와 연관된 지속성 메모리에 저장됨을 나타내는, 방법.
제1항에 있어서,
상기 제1 지속성 레벨은 모든 상태 정보가 상기 분산형 데이터 처리 시스템의 외부의 지속성 메모리에 저장됨을 나타내는, 방법.
제1항에 있어서,
상기 결과 데이터를 생성하기 위해 상기 복수의 처리 노드 중 하나의 처리 노드에서 상기 입력 데이터를 처리하는 단계를 더 포함하는, 방법.
제1항에 있어서,
상기 입력 데이터는 데이터 처리 작업을 포함하며, 상기 결과 데이터는 상기 데이터 처리 작업의 결과를 포함하는, 방법.
제1항에 있어서,
상기 입력 데이터는 상기 인터페이스 구성 요소에서 버퍼에 저장되며,
상기 방법은, 상기 제1 처리 노드로부터 상기 입력 데이터의 처리가 실패했다는 표시를 수신하는 단계, 상기 결과를 폐기하는 단계, 및 상기 버퍼에 저장된 상기 입력 데이터를 상기 분산형 데이터 처리 시스템에 다시 제공하는 단계를 더 포함하는, 방법.
제9항에 있어서,
상기 입력 데이터는 고유 식별자와 연관되며, 상기 다시 제공된 입력 데이터는 원래 제공된 입력 데이터와 동일한 고유 식별자를 갖는, 방법.
제1항에 있어서,
상기 제2 시간 간격과 연관된 상기 표시자를 포함하는 모든 상태 정보가 제2 지속성 레벨로 저장되는 상기 복수의 시간 간격 중 가장 빠른 시간 간격의 추가적인 표시자를 상기 제1 처리 노드에서 결정하는 단계를 더 포함하는, 방법.
제11항에 있어서,
상기 제2 지속성 레벨은 상기 제1 지속성 레벨보다 상대적으로 더 지속성인, 방법.
제11항에 있어서,
상기 제2 지속성 레벨은 상기 제1 지속성 레벨보다 상대적으로 덜 지속성인, 방법.
복수의 처리 노드를 포함하는 분산형 데이터 처리 시스템을 사용하여 데이터를 처리하기 위해, 컴퓨터 판독 가능 매체에 비-일시적 형태로 저장된 소프트웨어로서,
상기 소프트웨어는 컴퓨팅 시스템으로 하여금, 제1항 내지 제13항 중 어느 한 항의 모든 상기 단계를 수행하게 하기 위한 명령을 포함하는, 소프트웨어.
데이터를 처리하기 위한 장치로서, 상기 장치는:
복수의 처리 노드를 포함하는 분산형 데이터 처리 시스템 - 각각의 처리 노드는 적어도 하나의 프로세서를 포함함 -;
상기 분산형 데이터 처리 시스템과 통신하는 분산형 데이터 처리 시스템 인터페이스 구성 요소; 및
상기 복수의 처리 노드의 처리 노드 간에 정보를 전송 및 수신하기 위해 상기 복수의 처리 노드를 연결하는 통신 매체를 포함하며,
상기 장치는,
상기 분산형 데이터 처리 시스템과 통신하는 상기 분산형 데이터 처리 시스템 인터페이스 구성 요소에서 입력 데이터를 수신하고;
상기 수신된 입력 데이터를 상기 분산형 데이터 처리 시스템에 제공하고 - 상기 분산형 데이터 처리 시스템은 복수의 시간 간격 중 제1 시간 간격과 연관된 표시자를 상기 입력 데이터에 할당함 -;
상기 입력 데이터를 수신하는 것에 응답하여, 상기 분산형 데이터 처리 시스템 내의 상태 정보를 생성하고 - 상기 상태 정보는 상기 제1 시간 간격과 연관된 상기 표시자를 포함함 -;
상기 분산형 데이터 처리 시스템 인터페이스 구성 요소에서, 상기 분산형 데이터 처리 시스템으로부터 상기 입력 데이터와 연관된 결과 데이터를 수신 및 저장하고 - 상기 결과 데이터는 상기 제1 시간 간격보다 이후의 제2 시간 간격과 연관된 표시자를 포함함 -;
상기 제2 시간 간격과 연관된 상기 표시자를 포함하는 모든 상태 정보가 제1 지속성 레벨로 저장되는 상기 복수의 시간 간격 중 가장 빠른 시간 간격의 표시자를 상기 복수의 처리 노드 중 제1 처리 노드에서 결정하고;
상기 가장 빠른 시간 간격의 상기 표시자를 상기 분산형 데이터 처리 시스템 인터페이스 구성 요소에 제공하고; 그리고
상기 분산형 데이터 처리 시스템 인터페이스 구성 요소에서, 상기 결과 데이터와 연관된 상기 제2 시간 간격과 연관된 상기 표시자와 상기 가장 빠른 시간 간격의 상기 표시자의 비교에 기초하여, 상기 분산형 데이터 처리 시스템 인터페이스로부터 상기 결과 데이터를 배포할지 여부를 결정하도록 구성되는, 장치.
복수의 처리 노드를 포함하는 분산형 데이터 처리 시스템을 사용하여 데이터를 처리하기 위한 컴퓨팅 시스템으로서, 상기 컴퓨팅 시스템은:
상기 분산형 데이터 처리 시스템과 통신하는 분산형 데이터 처리 시스템 인터페이스 구성 요소에서 입력 데이터를 수신하기 위한 수단;
상기 수신된 입력 데이터를 상기 분산형 데이터 처리 시스템에 제공하기 위한 수단 - 상기 분산형 데이터 처리 시스템은 복수의 시간 간격 중 제1 시간 간격과 연관된 표시자를 상기 입력 데이터에 할당함 -;
상기 입력 데이터를 수신하는 것에 응답하여, 상기 분산형 데이터 처리 시스템 내의 상태 정보를 생성하기 위한 수단 - 상기 상태 정보는 상기 제1 시간 간격과 연관된 상기 표시자를 포함함 -;
상기 분산형 데이터 처리 시스템 인터페이스 구성 요소에서, 상기 분산형 데이터 처리 시스템으로부터 상기 입력 데이터와 연관된 결과 데이터를 수신 및 저장하기 위한 수단 - 상기 결과 데이터는 상기 제1 시간 간격보다 이후의 제2 시간 간격과 연관된 표시자를 포함함 -;
상기 제2 시간 간격과 연관된 상기 표시자를 포함하는 모든 상태 정보가 제1 지속성 레벨로 저장되는 상기 복수의 시간 간격 중 가장 빠른 시간 간격의 표시자를 상기 복수의 처리 노드 중 제1 처리 노드에서 결정하기 위한 수단;
상기 가장 빠른 시간 간격의 상기 표시자를 상기 분산형 데이터 처리 시스템 인터페이스 구성 요소에 제공하기 위한 수단; 및
상기 분산형 데이터 처리 시스템 인터페이스 구성 요소에서, 상기 결과 데이터와 연관된 상기 제2 시간 간격과 연관된 상기 표시자와 상기 가장 빠른 시간 간격의 상기 표시자의 비교에 기초하여, 상기 분산형 데이터 처리 시스템 인터페이스로부터 상기 결과 데이터를 배포할지 여부를 결정하기 위한 수단을 포함하는, 컴퓨팅 시스템.
제15항에 있어서,
상기 가장 빠른 시간 간격의 상기 표시자가 상기 제2 시간 간격과 동일하거나 상기 제2 시간 간격보다 이후의 시간 간격에 해당하는 경우, 상기 분산형 데이터 처리 시스템 인터페이스 구성 요소로부터 상기 결과 데이터를 배포하도록 추가적으로 구성되는, 장치.
제17항에 있어서,
상기 입력 데이터는 상기 인터페이스 구성 요소에서 버퍼에 저장되며,
상기 결과 데이터를 배포하도록 구성되는 상기 장치는 상기 버퍼로부터 상기 입력 데이터를 제거하도록 추가적으로 구성되는, 장치.
제15항에 있어서,
상기 제1 지속성 레벨은 a) 모든 상태 정보가 상기 분산형 데이터 처리 시스템의 상기 복수의 처리 노드 중 적어도 하나의 처리 노드와 연관된 휘발성 메모리에 복제됨, b) 상기 제1 지속성 레벨은 모든 상태 정보가 상기 분산형 데이터 처리 시스템의 상기 복수의 처리 노드 중 적어도 하나의 처리 노드와 연관된 지속성 메모리에 저장됨, 또는 c) 상기 제1 지속성 레벨은 모든 상태 정보가 상기 분산형 데이터 처리 시스템의 외부의 지속성 메모리에 저장됨 중 적어도 하나를 나타내는, 장치.
제15항에 있어서,
상기 입력 데이터는 상기 인터페이스 구성 요소에서 버퍼에 저장되며,
상기 장치는, 상기 제1 처리 노드로부터 상기 입력 데이터의 처리가 실패했다는 표시를 수신하고, 상기 결과를 폐기하고, 그리고 상기 버퍼에 저장된 상기 입력 데이터를 상기 분산형 데이터 처리 시스템에 다시 제공하도록 추가적으로 구성되는, 장치.
제15항에 있어서,
상기 제2 시간 간격과 연관된 상기 표시자를 포함하는 모든 상태 정보가 제2 지속성 레벨로 저장되는 추가적인 표시자를 상기 제1 처리 노드에서 결정하도록 추가적으로 구성되는, 장치.
제21항에 있어서,
상기 제2 지속성 레벨은 상기 제1 지속성 레벨보다 더 지속성 또는 상기 제1 지속성 레벨보다 덜 지속성 중 어느 하나인, 장치.
제16항에 있어서,
상기 가장 빠른 시간 간격의 상기 표시자가 상기 제2 시간 간격과 동일하거나 상기 제2 시간 간격보다 이후의 시간 간격에 해당하는 경우, 상기 분산형 데이터 처리 시스템 인터페이스 구성 요소로부터 상기 결과 데이터를 배포하기 위한 수단을 더 포함하는, 컴퓨팅 시스템.
제23항에 있어서,
상기 입력 데이터는 상기 인터페이스 구성 요소에서 버퍼에 저장되며,
상기 결과 데이터를 배포하기 위한 수단은 상기 버퍼로부터 상기 입력 데이터를 제거하기 위한 수단을 포함하는, 컴퓨팅 시스템.
제16항에 있어서,
상기 제1 지속성 레벨은 a) 모든 상태 정보가 상기 분산형 데이터 처리 시스템의 상기 복수의 처리 노드 중 적어도 하나의 처리 노드와 연관된 휘발성 메모리에 복제됨, b) 상기 제1 지속성 레벨은 모든 상태 정보가 상기 분산형 데이터 처리 시스템의 상기 복수의 처리 노드 중 적어도 하나의 처리 노드와 연관된 지속성 메모리에 저장됨, 또는 c) 상기 제1 지속성 레벨은 모든 상태 정보가 상기 분산형 데이터 처리 시스템의 외부의 지속성 메모리에 저장됨 중 적어도 하나를 나타내는, 컴퓨팅 시스템.
제16항에 있어서,
상기 입력 데이터는 상기 인터페이스 구성 요소에서 버퍼에 저장되며,
상기 컴퓨팅 시스템은, 상기 제1 처리 노드로부터 상기 입력 데이터의 처리가 실패했다는 표시를 수신하기 위한 수단, 상기 결과를 폐기하기 위한 수단, 및 상기 버퍼에 저장된 상기 입력 데이터를 상기 분산형 데이터 처리 시스템에 다시 제공하기 위한 수단을 더 포함하는, 컴퓨팅 시스템.
제16항에 있어서,
상기 제2 시간 간격과 연관된 상기 표시자를 포함하는 모든 상태 정보가 제2 지속성 레벨로 저장되는 추가적인 표시자를 상기 제1 처리 노드에서 결정하기 위한 수단을 더 포함하는, 컴퓨팅 시스템.
제27항에 있어서,
상기 제2 지속성 레벨은 상기 제1 지속성 레벨보다 더 지속성 또는 상기 제1 지속성 레벨보다 덜 지속성 중 어느 하나인, 컴퓨팅 시스템.