KR20170073659A - 계산적인 불확정 하에서의 결함 허용 및 복구 - Google Patents

Abstract

적어도 하나의 처리 노드를 포함하는 컴퓨팅 시스템 내에서 결함 허용 및 복구를 촉진하기 위한 방법은, 제 1 처리 노드에서, 제 1 생성 지시자를 할당받은 스포너를 이용하여 제 1 스폰을 생성하여 그것의 스폰은 제 1 생성 지시자를 물려받도록 하는 것, 노드 복구 정보를 생성하기 위해 체크포인트 간격을 시작하는 것, 스포너가 스폰을 생성하는 것을 중단시키는 것, 상기 스포너로, 상기 제 1 생성 지시자와 상이한 제 2 생성 지시자를 할당하는 것, 스포너가 제 2 생성 지시자를 물려받는 제 2 스폰을 생성하도록 스포너를 재개하는 것, 제 2 스폰이 메모리에 기록하는 규모를 제어하는 것, 및 체크포인트 동안 획득된 노드 복구 정보를 내구성 있는 스토리지에 수용한 이후에, 제 2 스폰이 메모리에 기록할 수 있는 규모에 대한 제어를 릴리즈하는 것에 의해 제 1 처리 노드의 가용성 (availability) 및 복구 (recovery) 를 촉진하는 것을 포함한다.

Description

계산적인 불확정 하에서의 결함 허용 및 복구{RECOVERY AND FAULT-TOLERANCE UNDER COMPUTATIONAL INDETERMINISM}

본 출원은 미국 특허 출원 번호 62/065,941 의 2014년 10월 20일자 우선일의 이익을 주장하고, 상기 미국 특허 출원의 내용들은 참조로서 본 출원에 원용된다.

본 출원은 계산적인 불확정 (computational indeterminism) 이 존재하는 경우의 복구 및 결함 허용 (fault-tolerance) 에 관한 것이다.

계산 시스템들은 때때로 다양한 원인에 의해 실패한다. 이러한 시스템들이 실패할 때, 데이터가 손실될 수 있다. 이러한 데이터의 손실을 방지하거나, 또는 적어도 최소화하기 위한 조치를 취하는 것이 바람직하다.

이러한 조치들의 예시들은 데이터베이스 내의 ACID (Atomic, Consistent, Isolated until committed, Durable when committed) 처리를 포함한다. 이러한 알려진 조치들은 매우 강인하다. 그들은 또한 결함 허용성을 가지도록 만들어지는 반면에, 정확성의 매우 높은 기준을 충족시키도록 만들어질 수 있다.

그러나 이러한 강인함 전부는 대가를 치른다. 실패로부터 보호하기 위한 알려진 방법들은 높은 지연을 가지고 때때로 장치가 이용 불가능한 확대된 기간들을 야기한다. 그리하여, 처리들의 높은 볼륨을 위한 최적에 이르지 못한다.

추가로, 어떤 알려진 방법들은 결정론적 (deterministic) 인 계산을 요구한다. 결정론적인 계산에서, 태스크들이 수행되는 순서는 고정되고, 계산의 결과는 그것이 수행되는 각각의 시간에서 동일하게 남아있는다. 이러한 알려진 방법들이 비 결정론적인 계산 환경들을 효율적으로 다루기 위해 어떻게 적응되어야 하는가는 분명하지 않다.

컴퓨팅 장치가 서로 협력하는 복수의 처리 노드들을 포함할 때 추가적인 복잡성 (complexity) 이 발생한다. 이러한 장치에서, 장치의 하나의 노드는 실패하고 나머지들은 작업을 유지하는 것이 가능하다. 그 실패한 노드가 복구할 때, 다른 노드들이 그것에 예상하고 있는 상태로 그 자신을 회복하였는지에 대해 보장하지 않는다.

일 측면에서, 본 발명은 적어도 하나의 처리 노드를 포함하는 컴퓨팅 시스템 내에서 결함 허용 및 복구를 촉진하기 위한 방법을 특징으로 포함한다. 이러한 방법은, 제 1 처리 노드의 가용성 (availability) 및 복구 (recovery) 를 촉진하는 단계로서, 제 1 처리 노드에서, 상기 노드에서 스포너 (spawner) 를 실행 - 상기 스포너는 실행 동안 제 1 스폰 (spawn) 을 생성함 - 하는 단계로서, 상기 스포너로 제 1 생성 지시자를 할당하는 단계를 포함하고, 상기 제 1 스폰은 상기 제 1 생성 지시자를 물려받는, 상기 스포너를 실행하는 단계; 체크포인트 간격을 시작하는 단계로서, 상기 체크포인트 간격의 종점에서, 상기 노드의 복구를 위해 사용 가능한 노드 복구 정보가 내구성 있는 (durable) 스토리지에 수용되고, 스포너가 스폰을 생성하는 것을 중단시키는 단계, 상기 스포너로, 상기 제 1 생성 지시자와 상이한 제 2 생성 지시자를 할당하는 단계, 상기 스포너가 제 2 스폰을 생성하는 것을 가능하게 하도록, 상기 스포너를 재개하는 단계로서, 상기 제 2 스폰은 상기 제 2 생성 지시자를 물려받는, 상기 스포너를 재개하는 단계, 및 상기 제 2 스폰이 메모리에 기록하는 규모를 제어하는 단계를 포함하는, 상기 체크포인트 간격을 시작하는 단계; 및 상기 노드 복구 정보의 수용 이후에, 상기 제 2 스폰이 메모리에 기록할 수 있는 상기 규모에 대한 제어를 릴리즈 (release) 하는 단계를 포함하는, 상기 가용성 및 복구를 촉진하는 단계를 포함한다.

일부 구현들에서, 상기 제 2 스폰이 메모리에 기록하는 규모를 제어하는 단계는, 상기 제 2 스폰이 상기 메모리로의 기록을 완성 (consummating) 하는 것을 방지하는 단계를 포함한다. 이들에 포함되는 것은, 상기 복구 정보가 수용된 이후에 상기 제 2 스폰이 그것의 최종적인 완성을 위한 메모리로의 기록을 대기 (queue) 하는 것을 허용하는 단계를 더 포함하는 구현들이다.

다른 구현들에서, 상기 제 2 스폰이 메모리에 기록하는 규모를 제어하는 단계는, 상기 기록의 동작이 교체 가능한 (commutable) 동작이라고 결정하는 단계, 및 상기 교체 가능한 동작의 완성을 허용하는 단계를 포함한다. 이들에 포함되는 구현들은, 상기 기록의 동작이 교체 가능한 동작이라고 결정하는 단계는, 상기 기록의 동작이 변수를 증가시키는 것을 포함한다고 결정하는 단계를 포함하는 것들, 그리고 상기 기록의 동작이 교체 가능한 동작이라고 결정하는 단계는, 상기 기록의 동작이 구체적인 장소에서 기록을 삽입하는 것을 포함한다고 결정하는 단계를 포함하는 것들이다.

또한 본 발명의 구현들에 포함되는 것은, 상기 스포너를 중단시킨 이후에, 데드라인을 설정함으로써, 제 1 태스크 생성 지시자를 가지는 임의의 스폰에게 완료하기 위한 실행을 위한 시간을 제공하고, 그리고 상기 제 1 생성 지시자를 가지는 스폰의 상태들을 저장해야 하는 것과 연관된 오버헤드를 회피하는 단계를 더 포함하는 것들이다. 이러한 구현들에 포함되는 것은, 상기 제 1 스폰이 상기 데드라인에서 여전히 실행하고 있는 경우 상기 제 1 스폰을 중단시키는 단계를 더 포함하는 것, 그리고 예를 들어, 상기 제 1 스폰이 상기 데드라인에서 여전히 실행하고 있는 경우 상기 제 1 스폰 내에서 상기 제 1 태스크 생성 지시자를 상기 제 2 태스크 생성 지시자로 변경하는 것에 의해, 상기 데드라인까지 실행을 완료하는 것에 실패한 결과로서 상기 제 1 스폰이 중단을 회피하는 것을 가능하게 하는 단계를 더 포함하는 것들이다.

상기 제 1 노드가 노드 생성 지시자를 가지는 경우들에서, 본 발명의 추가적인 구현들은, 스폰으로 하여금 제 2 노드로 이주하는 이주자가 되도록 하는 단계를 더 포함하고, 상기 제 2 노드는 노드 생성 지시자를 가진다. 이러한 구현들에 포함되는 것은 상기 제 2 노드의 노드 생성 카운터는, 상기 제 2 노드가 상기 제1 노드보다 젊은 세대임을 나타내는 것이고, 이러한 경우 방법은 상기 이주자의 이민 (immigration) 측면의 젊게 만드는 것, 또는 상기 이주자의 이주 (emigration) 측면의 젊게 만드는 것에 의해 상기 이주자를 젊게 만드는 (youthening) 단계를 더 포함한다.

일부 경우들에서, 제 1 노드는 각각의 노드가 노드 생성 카운트를 가지는 멀티 노드 시스템 내의 노드이고, 상기 멀티 노드 시스템은 적어도 제 2 노드를 포함한다. 이러한 경우들에서, 상기 제 2 노드의 실패에 후속하는 복구에 이어, 상기 제 1 노드는 상기 제 2 노드의 노드 생성 카운트에 대응하는 상태로 되돌아가는, 본 발명의 구현들이 존재한다.

다른 경우들에서, 상기 제 1 노드는 각각의 노드가 노드 생성 카운트를 가지는 멀티 노드 시스템 내의 노드이고, 상기 멀티 노드 시스템은 적어도 제 2 노드를 포함한다. 이러한 경우들에서, 본 발명의 일부 구현들은 상기 제 2 노드의 실패에 후속하는 복구에 이어, 상기 제 1 노드는 체크포인트로부터 수용된 작업 (work) 을 회복시키고 저널 (journal) 로부터 수용되지 않은 작업을 회복시키는 것에 의해 상기 제 2 노드의 노드 생성 카운트에 대응하는 상태로 나아가도록 하는 것을 포함한다.

제 1 노드는 각각의 노드가 노드 생성 카운트를 가지는 멀티 노드 시스템 내의 노드인 이러한 경우들에서, 본 발명의 구현들은 제 1 노드가 특정한 행동들을 수행하는 것을 포함한다. 이러한 것들은, 마스터 노드로부터, 체크포인트가 수행될 것임을 지시하는 메시지를 수신하는 단계, 응답하여, 상기 제 1 노드의 노드 생성 카운트를 젊게 하는 단계, 스포너들이 스폰을 생성하는 것을 중단시키는 단계, 스포너 상태들을 복구하기 위한 스포너 복구 정보를 저장하는 단계, 상기 스포너들을 재개하는 단계, 상기 제 1 노드에서 추가적인 이전 세대 이민자 (immigrant) 들이 예상되지 않는다고 결정하는 단계, 및 상기 결정에 응답하여, 상기 내구성 있는 스토리지로, 상기 노드 복구 정보를 수용하는 단계를 포함한다. 이러한 구현들에 속하는 것은 또한 데드라인을 설정하고, 그리고 상기 데드라인의 경과에 이어, 젊은 세대 스폰이 실행을 계속하는 반면 여전히 실행하고 있는 모든 이전 세대 스폰을 중단시키는 단계를 포함하는 것이다.

일부 경우들에서, 제 1 노드는 멀티 노드 시스템의 노드이다. 이러한 경우들에서, 본 발명의 대안적인 구현들은 상기 제 2 노드에 상기 제 1 노드의 작업중인 메모리의 복제본 (replica copy) 을 저장하는 단계, 상기 제 1 노드의 실패에 이어, 상기 제 1 노드에 의해 수행될 수 있었던 처리 (processing) 를 위해 상기 복제본을 일시적으로 사용하는 단계, 및 상기 제 1 노드의 복구에 이어, 상기 제 1 노드 내의 메모리를 업데이트하기 위해 요구되는 정보를 상기 제 1 노드로 통신하여 상기 제 1 노드에 의해 후속하는 계산이 수행될 수 있도록 하는 단계를 포함한다.

다른 측면에서, 본 발명은 적어도 하나의 처리 노드를 포함하는 컴퓨팅 시스템 내의 결함 허용 및 복구를 촉진하기 위한, 컴퓨터 판독 가능한 매체에 비 일시적인 형태로 저장된 소프트웨어를 특징으로 포함한다. 상기 소프트웨어는 컴퓨팅 시스템으로 하여금, 제 1 처리 노드의 가용성 (availability) 및 복구 (recovery) 를 촉진하는 것으로서, 상기 제 1 처리 노드에서, 상기 노드에서 스포너 (spawner) 를 실행 - 상기 스포너는 실행 동안 제 1 스폰 (spawn) 을 생성함 - 하는 것으로서, 상기 스포너로 제 1 생성 지시자를 할당하는 것을 포함하고, 상기 제 1 스폰은 상기 제 1 생성 지시자를 물려받는, 상기 스포너를 실행하는 것; 체크포인트 간격을 시작하는 것으로서, 상기 체크포인트 간격의 종점에서, 상기 노드의 복구를 위해 사용 가능한 노드 복구 정보가 내구성 있는 (durable) 스토리지에 수용되고, 상기 스포너가 스폰을 생성하는 것을 중단시키는 것, 상기 스포너로, 상기 제 1 생성 지시자와 상이한 제 2 생성 지시자를 할당하는 것, 상기 스포너가 제 2 스폰을 생성하는 것을 가능하게 하도록, 상기 스포너를 재개하는 것으로서, 상기 제 2 스폰은 상기 제 2 생성 지시자를 물려받는, 상기 스포너를 재개하는 것, 및 상기 제 2 스폰이 메모리에 기록하는 규모를 제어하는 것을 포함하는, 상기 체크포인트 간격을 시작하는 것; 및 상기 노드 복구 정보의 수용 이후에, 상기 제 2 스폰이 메모리에 기록할 수 있는 상기 규모에 대한 제어를 릴리즈 (release) 하는 것을 포함하는, 상기 가용성 및 복구를 촉진하는 것을 수행하게 하기 위한 명령어들을 가진다.

또 다른 측면에서, 본 발명은 내구성 있는 (durable) 스토리지를 포함하는 데이터 스토리지 시스템; 및 적어도 하나의 프로세서를 포함하는 하나 이상의 처리 노드들을 특징으로 포함하고, 상기 적어도 하나의 프로세서는, 제 1 처리 노드의 가용성 (availability) 및 복구 (recovery) 를 촉진하는 것으로서, 상기 제 1 처리 노드에서, 상기 노드에서 스포너 (spawner) 를 실행 - 상기 스포너는 실행 동안 제 1 스폰 (spawn) 을 생성함 - 하는 것으로서, 상기 스포너로 제 1 생성 지시자를 할당하는 것을 포함하고, 상기 제 1 스폰은 상기 제 1 생성 지시자를 물려받는, 상기 스포너를 실행하는 것; 체크포인트 간격을 시작하는 것으로서, 상기 체크포인트 간격의 종점에서, 상기 노드의 복구를 위해 사용 가능한 노드 복구 정보가 내구성 있는 (durable) 스토리지에 수용되고, 상기 스포너가 스폰을 생성하는 것을 중단시키는 것, 상기 스포너로, 상기 제 1 생성 지시자와 상이한 제 2 생성 지시자를 할당하는 것, 상기 스포너가 제 2 스폰을 생성하는 것을 가능하게 하도록, 상기 스포너를 재개하는 것으로서, 상기 제 2 스폰은 상기 제 2 생성 지시자를 물려받는, 상기 스포너를 재개하는 것, 및 상기 제 2 스폰이 메모리에 기록하는 규모를 제어하는 것을 포함하는, 상기 체크포인트 간격을 시작하는 것; 및 상기 노드 복구 정보의 수용 이후에, 상기 제 2 스폰이 메모리에 기록할 수 있는 상기 규모에 대한 제어를 릴리즈 (release) 하는 것을 포함하는, 상기 가용성 및 복구를 촉진하는 것을 수행하도록 구성된다.

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

본원에 개시된 결함 허용 및 복구를 촉진하기 위한 기법들은 컴퓨팅 시스템으로 하여금 매우 높은 이용 가능성을 유지하는 것을 가능하게 한다. 특정한 ACID 제약들을 전략적으로 완화함으로써, 컴퓨팅 시스템은 여전히 복구 가능성을 제공하지만, 보다 극단의 조치들의 높은 오버헤드를 가지지 않는다. 그리하여, 유용한 작업에 대해 이용할 수 있는 더 많은 컴퓨팅 자원들이 존재한다. 또한, 스폰 (spawn) (예를 들어, 운영 체계 프로세스들 또는 스레드들) 이 메모리에 기록하는 규모를 제어하는 것에 의해, 결함 허용 메커니즘들에 대한 완전성이 유지되는 것을 보장하면서, 유용한 작업이 체크포인트 간격 동안 여전히 달성될 수 있다. 그리하여, 이러한 기법들은 결함들의 이벤트 내에서, 그리고 일반적인 결함이 없는 동작 동안의 양쪽 모두에서 컴퓨팅 시스템의 내부 기능을 향상시킨다.

도 1 은 계산적인 불확정의 현존 하에 결함 허용 및 복구를 수행하기 위한 단일 노드 컴퓨팅 장치를 도시한다.
도 2 는 도 1 의 노드의 동작 동안 마주하는 체크포인트 간격들 및 작업 간격들을 도시한다.
도 3 은 도 2 의 체크포인트 간격 동안 완료를 위해 스폰이 실행하도록 허용되는 방법을 도시한다.
도 4 는 도 2 의 체크포인트 간격 동안 스포닝 (spawning) 처리가 스폰을 생성하는 것을 계속할 수 있는 방법을 도시한다.
도 5 는 메모리에 대한 기록을 대기 (queue) 하는 것에 의해 체크포인트 간격 동안 스폰이 작업하는 것을 계속할 수 있는 방법을 도시한다.
도 6 은 멀티 노드 컴퓨팅 장치를 도시한다.
도 7 은 도 7 의 장치로부터의 노드 내에 공존 (co-existing) 하는 2 개의 세대를 나타낸다.
도 8 은 체크포인트 메시지에 응답하여 슬레이브 노드에 의해 수행되는 방법의 단계들을 도시한다.
도 9 는 이주자 세대 카운트를 증가시키는 것을 포함하는 방법의 단계들을 도시한다.
도 10 은 실패 이후의 복구를 위한 방법의 단계들을 도시한다.
도 11 은 더욱 빠른 복구를 가능하게 하기 위한 다른 노드에서 유지되는 복제본을 도시한다.
도 12 는 빠른 복구를 위한 도 11 에 도시된 복제본을 이용하기 위한 절차를 도시한다.
도 13 은 도 9 에 도시된 바와 같은 복수의 노드들과 연관된 도 5 에 도시된 방법의 실행의 예시를 도시한다.

도 1 은 계산적인 불확정의 현존 하에 결함 허용 및 복구를 위한 기법들이 사용될 수 있는 데이터 처리 시스템의 예시를 도시한다. 데이터 처리 시스템은 작업 메모리 (12) 를 포함하는 노드 (10) 를 가지는 단일 노드 컴퓨팅 장치 (8) 를 포함한다. 이 노드 (10) 상에서 작동하는 처리 (14) 들은 그들의 개별적인 처리 상태들을 저장하고 그들의 개별적인 계산들의 즉각적인 결과들을 저장하기 위해 이러한 작업 메모리 (12) 를 사용한다. 다른 실시예에서, 처리 (14) 들은 노드 (10) 상에서 작동하고 있는 운영 체계 내의 컴퓨팅 자원들의 다양한 유형들 중 임의의 것으로서 구현될 수도 있다. 예를 들어, 처리 (14) 들은 그들의 고유의 어드레스 공간을 가지는 운영 체계 '처리들'로서, 또는 그들의 고유의 실행 컨텍스트 (예를 들어, 스테이지, 레지스터 등) 를 가지는 운영 체계 '스레드들'로서, 또는 수행되어야 하는 동작들의 시퀀스를 포함하지만 그것에 전속하는 특정한 운영 체계 처리 또는 스레드를 반드시 가지는 것은 아닌 어떤 다른 유형의 '태스크'로서 구현될 수도 있다.

작업 메모리 (12) 는 종종 휘발성이므로, 내구성 있는 (durable) 스토리지 (16) 에 저장된 체크포인트 파일들 (18) 내에 그것의 상태를 주기적으로 저장하는 것이 현명하다. 이러한 체크포인트 파일들 (18) 은 노드 (10) 의 동작이 중단된 경우에 상태 정보를 복구하기 위해 사용될 수 있다.

노드 상에서 실행하는 처리 (14) 들에 속하는 것은 스포너들 (20) 이다. "스포너 (spawner)" 는 그것의 속성들 중, 하나 이상의 다른 처리들을 생성하는 능력을 가지는 처리의 유형이다. 스포너에 의해 생성되는 처리들은 단일로, 및 복수의 양쪽 모두로 "스폰 (spawn)" 으로서 본원에서 지시된다. 이러한 스폰을 생성하는 행동은 동사 "스폰하다" 의 적절한 변형들에 의해 지시된다. 도 1 은 스폰 (22A, 22B) 를 생성한 스포너 (20) 를 도시한다. 스포너 (20) 는 일반적으로 오래 지속되는 처리이고, 반면에 스폰 (22A, 22B) 은, 많음에도 불구하고, 훨씬 짧게 지속되는 경향이 있다. 일부 경우에서, 스포너는 그 스포너에 의해 생성된 스폰보다 오래 지속되는 처리이다. 스폰 (22A, 22B) 은 또한 서로 독립적이고 비동기적으로 관련되어, 스폰 (22A, 22B) 이 그것의 계산을 완료한 규모는 최초 장소에서 스포너 (20) 가 스폰 (22A, 22B) 을 언제 생성했는가 여부와는 관련이 없다. 그 결과, 스폰 (22A, 22B) 이 계산들을 수행한 순서는 쉽게 가늠할 수 없다. 계산들이 수행된 순서가 종종 결과들에 영향을 미칠 수 있기 때문에, 이것은 전체로서의 계산을 쉽게 가늠할 수 없게 만든다.

그것의 동작 동안, 컴퓨팅 장치 (8) 는 외부의 세계와 통신한다. 예를 들어, 컴퓨팅 장치 (8) 는 들어오는 메시지들 (24) 의 하나 이상의 스트림들을 수신하고 나가는 메시지들 (28) 의 하나 이상의 스트림들을 생성할 수도 있다. 하기에서 보다 구체적으로 개시되는 바와 같이, 이러한 메시지들 (24, 28) 은 내구성 있는 스토리지 (16) 내의 장치 (8) 에 의해 일시적으로 저장된다. 이러한 메시지들 (24, 28) 은 물리적으로 및/또는 논리적으로 분리된 개별적인 영역들 내에서 에스크로 (escrow) 를 위해 일시적으로 저장될 수도 있다. 들어오는 메시지들 (24) 은 내구성 있는 스토리지 (16) 내의 들어오는 메시지 에스크로 영역 (26) 에 저장될 수 있고, 나가는 메시지들 (28) 은 내구성 있는 스토리지 (16) 내의 나가는 메시지 에스크로 영역 (30) 에 저장될 수 있다.

도 2 를 참조하면, 노드의 동작이 체크포인트 간격들 (32) 및 작업 간격들 (34) 에 의해 마크된다. 작업 간격들 (34) 동안, 노드는 완료를 향해 나아가는 처리들로서 유용한 작업을 수행한다. 체크포인트 간격 (32) 동안, 노드 (10) 는 모든 처리들을 중단하고, 그들을 직렬화 (serialize) 하고, 결과를 내구성 있는 스토리지 (16) 에 저장한다. 노드 (10) 는 이어서 내구성 있는 스토리지 (16) 로 작업 메모리 내에 있는 그밖의 모든 것을 저장한다. 이 지점에서, 체크포인트는 "수용"되었다고 불리며 처리들 (14) 은 "체크포인트"되었다고 불린다.

체크포인트 간격 (32) 은 작업 간격 (34) 에 비해 훨씬 짧은 것이 바람직하다. 본원에 개시된 방법 및 장치는 체크포인트 간격 (32) 의 길이를 감소시키는 것에 의해 작업 간격들 (34) 내에서 수행될 수 있는 처리의 양을 증가시키고자 한다.

체크포인트가 수용되면, 노드 (10) 는 처리들 (14) 이 재개하고 나가는 메시지 에스크로 영역 (30) 내의 나가는 메시지들 (28) 을 릴리즈 (release) 하는 것을 허용한다.

나가는 메시지들 (28) 을 즉시 전송하기보다 나가는 메시지 에스크로 영역 (30) 에 저장하는 것은, 노드 (10) 의 실패로부터 유래할 수도 있는 불일치를 막는데에 유용한다. 예를 들어, 처리 (14) 가 어떤 계산의 결과를 알리는 나가는 메시지 (28) 를 전송하는 것이 상당히 가능할 수 있다. 만약 이러한 메시지 (28) 가 이미 전송된 이후이지만 계산 결과가 내구성 있는 스토리지 (16) 에 수용되기 전에 노드 (10) 가 실행한 경우, 노드 (10) 는 재시작하고 수용되지 않은 계산을 재실행할 수도 있다. 완료되면, 이러한 제 2 계산의 결과를 알리는 다른 메시지 (28) 가 전송될 수 있다. 비 결정론적 계산들의 경우에서 가능성이 없지 않는, 두 결과들이 상이한 경우에, 메시지들의 하나는 타당하지 않을 것이다.

구체적인 실시예로서, 처리 (14) 가 랜덤 수 생성기의 결과에 기초하여 고객에게 상을 수여하는 경우를 고려하면, 나가는 메시지 에스크로 영역 (30) 없이, 처리 (14) 는 상이 마련되었음을 알리는 메시지 (28) 를 제 1 고객에게 전송할 수도 있다. 노드 (10) 는 이어서 정지 (crash) 하고 재시작할 수도 있다. 처리 (14) 의 상태가 전혀 저장되지 않았기 때문에, 그 고객이 어떠한 상을 수여 받았는지의 기록, 또는 처리 (14) 가 실행을 성공적으로 완료했는지의 기록이 존재하지 않는다. 노드 (10) 는 처리 (14) 를 재실항할 수도 있고, 이는 상이한 랜덤 수를 생성하여 상이 마련되었음을 알리는 제 2 메시지 (28) 가 상이한 고객에게 전송되도록 한다. 이것은 단지 하나가 의도되었음에도 두 상을 수여하는 것 또는 적어도 하나의 실망한 고객을 관리하는 것을 요구할 수도 있다.

실패 이후에 복구하기 위해, 노드 (10) 는 내구성 있는 스토리지 (16) 로부터 모든 처리들 (14) 의 상태 및 작업 메모리 (12) 의 상태를 회수한다. 그것은 이어서 나가는 메시지 에스크로 영역 (30) 에 저장된 임의의 나가는 메시지들 (28) 을 재전송하고 처리를 위해 들어오는 메시지 에스크로 영역 (16) 으로부터 들어오는 메시지들을 회수하고, 이어서 라이브 데이터 상에서 보통의 동작을 재개한다.

나가는 메시지 에스크로 영역 (30) 내의 모든 메시지들 (28) 의 재전송은 똑같은 메시지들을 수신하는 수신자들을 초래할 수 있다. 일 실시예에서, 수신자는 반복된 메시지들 (28) 을 무시하도록 구성된다. 다른 실시예에서, 복구에 이어, 수신자 및 복구된 노드 (10) 는 수신된 메시지들 (28) 을 식별하기 위해 통신한다. 이것은 노드 (10) 가 똑같은 메시지들 (28) 을 전송하는 것을 피하도록 한다.

상기 개시된 절차는 너무 긴 체크포인트 간격 (32) 을 초래하고, 이는 차례로 낮은 출력 또는 들어오는 메시지의 수신 및 대응하는 나가는 메시지의 생성 간의 증가된 지연을 초래할 수도 있다. 이러한 지연을 감소시키고/감소시키거나 출력을 증가시키기 위해 다양한 방법들이 사용될 수 있다.

제 1 최적화 방법은 백그라운드 내의 저널 (journal, 36) 의 유지를 특징으로 포함한다. 작업 메모리 (12) 내의 아이템이 대응하는 엔트리로 변경되는 모든 시간은 저널 (36) 에 기록되어, 저널 엔트리는 복구 시간에 변경을 재생산하기 위해 사용될 수 있다. 저널 (36) 은 내구성 있는 스토리지 (16) 로 동기적으로 전송될 수도 있다. 체크포인트 간격 (32) 동안 노드 (10) 는 모든 저널 엔트리들이 실제로 내구성을 가지도록 하였음을 보장할 것이다. 복구는 이어서 작업 메모리 (12) 의 스냅샷을 포함하고 저널 (36) 에 기록된 바에 따른 변화들을 적용하는 이전 체크포인트 파일 (18) 을 이용하여 달성될 수 있다.

이러한 최적화는 체크포인트 간격 (32) 의 길이를 감소시키지만 복구를 위한 시간 증가의 대가를 치른다. 특히, 작업 메모리 (12) 의 최종 총 이미지가 획득된 이후로 오래 경과할 수록, 저널 (36) 내에 더 많은 수의 엔트리들이 존재할 것이다. 이것은 복구 시간을 증가시킬 것이다.

제 2 최적화 방법은 노드 (10) 가 단지 매우 적은 스포닝 처리들 (20) - 그 각각은 매우 많은 짧게 지속하는 처리들을 생성 (또는 "스폰") 하고, 여기에서 단일 및 복수 양쪽 모두의 "스폰 (22A, 22B)" 로서 지시됨 - 을 가진다는 사실에 의존한다.

스폰 (22A, 22B) 의 생애 (lifetime) 는 랜덤하지만, 스포너 (20) 의 생애의 기대값보다 훨씬 짧은 기대값을 가진다. 보통 말하는 바와 같이, 체크포인트 동안 스폰 (22A, 22B) 을 직렬화하는데 적은 시간을 소비하는 것으로 이해된다. 실제로, 일부 경우들에서, 스폰 (22A, 22B) 을 직렬화하는데 요구되는 시간은 스폰의 기대되는 생애에서 주목할 만한 비율이다. 그러므로 대신 스포너 (20) 중단하여, 새로운 스폰의 생성을 방지하고 존재하는 스폰 (22A, 22B) 이 자연스럽게 종료하는 것을 허용하는 것은 종종 유리하다.

시간을 절약하기 위해, 도 3 에 도시된 바와 같은 체크포인트 생성 방법은, 스포너 (20) 를 중단하는 단계 (단계 38) 및 그것을 직렬화하는 단계 (단계 40) 를 포함한다. 그러나, 존재하는 스폰 (22A) 은 실행을 계속한다 (단계 42). 이후, 대부분의 스폰 (22A) 이 실행을 종료하는 것을 허용하기에 충분히 길지만 지연에 눈에 띄게 영향을 줄만큼 너무 길지는 않은 유휴 (idle-down) 간격을 충분히 길게 정의하기 위해 선택되는 낙오자 (straggler) 들의 데드라인 이후 (단계 46) 에, "낙오자 스폰"으로 지시되는 여전히 실행하고 있는 스폰은 중단되고 (단계 48), 그리고 직렬화 (단계 50) 된다.

앞서 말한 방법은 그리하여 직렬화될 필요가 있는 처리들 (14) 의 수를 감소시키는 것에 의해 체크포인트 간격 (32) 의 길이를 감소시킨다. 그것은 빨리 종료할 것으로 예상되는 처리들 (22) 에게 그렇게 하도록 허용함으로써, 유효한 체크포인트를 생성하는 것의 일부로서 이러한 처리들 (22) 을 직렬화할 필요를 제거한다.

제 3 최적화 절차는 피해야 할 폐해 (evil) 는 실은 체크포인트 간격 (32) 동안 작업 메모리 (12) 에 대한 변경이라는 인식으로부터 발현한다. 그러므로 만약 절차 (14) 가 실은 작업 메모리 (12) 에 기록할 필요는 없지만 대신 단지 작업 메모리 (12) 를 판독할 필요가 있는 경우에, 그것을 중단하는 것은 이해되지 않는다.

이러한 제 3 최적화 절차를 구현하기 위해, 노드 (10) 는 각 처리와 연관된 세대 (generation) 카운트에 의존한다. 스포너 (20) 는 처리이기 때문에, 그것은 세대 카운트를 가진다. 스포너의 스폰 (22A, 22B) 역시 처리이기 때문에, 이 역시도 세대 카운트를 가진다. 스폰 (22A) 및 그 스폰 (22A) 을 스폰한 스포너 (20) 의 세대 카운트들은 연관된다. 특히, 스폰 (22A, 22B) 의 세대 카운트는 그것을 스폰한 스포너 (20) 의 세대 카운트와 동일하다. 스폰 (22A, 22B) 의 세대 카운트를 그것을 스폰한 스포너의 세대 카운트와 연관시키거나, 또는 그것으로부터 유도될 수 있도록 하는 행동은 동사 "물려주다"의 적절한 형태로서 서술될 수 있다. 특정한 세대 카운트를 가지는 스포너 (20) 가 스폰 (22A, 22B) 을 생성할 때, 스폰 (22A, 22B) 은 스포너의 세대 카운트를 물려 받았다고 불린다.

동작 중에, 체크포인트 간격 (32) 의 시작에 앞서, 스포너 (20) 는 이전 세대의 스폰 (22A) 을 생성하였을 것이다. 체크포인트 간격 (32) 의 시작에서, 스포너 (20) 는 "젊어진다".

동사 "젊어지게 하다 (to youthen)" 및 그것의 변형들 및 유사한 것들은 정수 (integer) 상에서 수행될 수 있는 특정한 계산적인 동작을 서술한다. 본원에서 사용되는 바와 같이, 젊어지게 하는 동작이 동작하는 특정한 정수는 세대 카운트이다. 세대 카운트 상에서 수행될 수 있는 동작을 서술한다.

본원에서 개시된 특정한 실시예에서, 스포너 (20) 를 젊어지게 하는 동작은 그것의 세대 카운트를 증가시키는 동작을 의미한다. 젊어지게 된 이후에, 스포너 (20) 는 이어서 체크포인트 간격 (32) 동안 스폰을 생성하는 것을 계속하고, 현재에만, 그것은 젊은 세대의 스폰 (22B) 을 생성한다. 이것의 결과는 스포너 (20) 가 젊어지기 전에 생성한 이전 세대 스폰 (22A), 및 스포너 (20) 가 젊어진 이후에 생성한 젊은 세대 스폰 (22B) 의 두 종류의 스폰 (22) 이 노드 (10) 내에서 공존하는 것이다.

도 4 를 참조하면, 체크포인트 간격의 시작에서, 스포너 (20) 는 중단되고 (단계 52), 그리하여 그것은 중단된 동안에 어떠한 새로운 스폰도 생성하지 않으며, 그것의 처리 상태가 저장된다 (단계 54). 스포너 (20) 는 이어서 그것의 세대 카운트를 증가되도록 하고 (단계 56), 그 이후 스포너 (20) 가 재개 (즉, 중단을 해제) 한다. 재개 이후에, 스포너 (20) 는 다시 스폰 (22) 을 생성할 수 있게 되고, 이러한 시간 동안, 그것의 모든 스폰 (22B) 은 젊은 세대 스폰 내에 존재할 것이다.

작업 메모리 (12) 에 기록하는 것을 시도하는 임의의 젊은 세대 스폰 (22B) 은 체크포인트 간격 (32) 이 완료될 때까지 가로막힌다. 그리하여, 젊은 세대 스폰 (22B) 은 완료를 위해 실행할 수 없다. 그들은 작업 메모리 (12) 에 처음으로 실제 기록하는 시간 까지만 실행할 수 있다. 그럼에도 불구하고, 젊은 세대 스폰 (22B) 은 적어도 완료를 위한 도중까지 실행할 수 있다. 이것은 체크포인트 간격 (32) 동안임에도 일부 처리가 발생할 수 있도록 허용한다.

일반적으로, 체크포인트 간격 (32) 동안, 메모리 (12) 내의 모든 처리들 (14) 은 직렬화 (serialized) 될 것이다. 그러나, 도 4 의 최적화 방법 내에서, 이전 세대 스폰 (22A) 만을 직렬화하는 것이 바람직하다.

세대 카운트는 노드 (10) 가 어느 스폰이 젊은 세대 스폰 (22B) 인지 식별하고 그리하여 그들의 상태를 저장하는 것을 방지하는 것을 가능하게 한다.

불행하게도, 모든 이전 세대 스폰 (22A) 이 완료되거나 낙오자 데드라인이 이전 세대 스폰 (22A) 으로부터의 낙오자들의 중단을 트리거할 때까지 젊은 세대 스폰 (22B) 은 전면적으로 진행할 수 없기 때문에, 이전 세대 스폰 (22A) 이 처리를 완료하는 것을 기다리도록 하는 것은 지연을 증가시키는 경향이 있다.

제 2 최적화 방법의 다양한 변형들에서, 작업 메모리 (12) 를 수정하려고 시도하는 젊은 세대 스폰 (22B) 을 가로막아 유용한 작업을 수행하는 것을 계속할 기회를 잃는 것을 대신하여, 노드 (10) 는 세대 넘버와 함께 작업 메모리 (12) 내에 각각의 데이터 아이템을 태그할 수 있다. 만약 젊은 세대 스폰 (22B) 이 메모리 위치를 수정하면, 체크포인트 이후까지 가로막기보다는, 노드 (10) 는 그것의 세대 넘버를 업데이트하는 것에 의해 메모리 위치를 젊어지게 할 것이다. 이어서, 만약 이전 세대 스폰 (22A) 이 이러한 젊어진 메모리 위치를 판독하거나 기록하려고 시도하면 이전 세대 스폰 (22A) 은 그 자신을 중단하는 것, 그것의 상태를 체크포인트에 기록하는 것, 그것의 세대 넘버를 업데이트하는 것, 그리고 젊어진 상태에서 실행을 재개하는 것에 의해 그 자신을 자발적으로 젊어지게 할 것이다. 노드 (10) 는 또한 세대 넘버와 함께 저널에 기록한 엔트리들을 태그하여 그것은 젊은 세대 의 스폰에 대응하는 저널 엔트리들로부터 이전 세대의 스폰에 대응하는 저널 엔트리들을 구별할 수 있다.

제 4 최적화 방법은 젊은 세대 스폰 (22B) 이 작업 메모리 (12) 에 기록하는 것을 처음 시도한 이후에도 처리를 계속할 수 있도록 허용하는 아이디어에 근거한다. 이 방법은 때때로 계산적인 결과들이 작업 메모리 (12) 로 기록되는 순서는 문제되지 않는다는 사실에 근거한다. 이러한 경우에, 작업 메모리 (12) 로의 기록은 나중까지 단순하게 대기될 수 있다. 이러한 방법은 젊은 세대 스폰 (22B) 이 작업 메모리 (12) 에 대해 처음으로 기록을 시도한 이후에도 체크포인트 간격 (32) 동안 작업을 유지할 수 있도록 한다.

일반적으로, 작업들의 시퀀스를 수행할 때마다 발생하는 의문점은 시퀀스 내의 작업들의 순서가 시퀀스의 결과에 차이점을 발생시키는지 또는 아닌지 여부이다. 이러한 시퀀스 내의 작업은 시퀀스 내의 작업의 위치가 결과에 영향을 끼치지 않는 경우에 "교체 가능하다 (commutable)" 고 불린다. 그렇지 않으면, 작업은 "교체 불가능 (non-commutable)"하다. 교체 가능한 동작들의 예는 값을 증가시키거나 감소시키는 명령들, 어떤 정의된 위치에서 기록을 리스트에 삽입하는 명령들, 그리고 일반적으로, 수행되어야 할 값을 판독할 것을 요구하지 않는 임의의 동작들이다. 제 4 최적화 방법은 이러한 교체 가능한 동작들을 이용한다.

도 5 를 참조하면, 이러한 제 4 최적화 방법에서, 노드 (10) 는 통상적으로 젊은 세대 스폰 (22B) 이 메모리 (12) 에 기록하는 것이 허용되지 않는 시점에 젊은 세대 스폰 (22B) 으로부터 기록 요청을 수신한다 (단계 60). 그러나, 이러한 방법에서, 노드 (10) 는 교체 가능한 동작들과 교체 불가능한 동작들을 구분한다 (단계 62). 만약 제안된 기록이 교체 가능하면, 노드 (10) 는 그것을 대기 (queue) 한다 (단계 64). 젊은 세대 스폰 (22B) 은 이어서 실행을 계속한다 (단계 66). 이것은 젊은 세대 스폰 (22B) 이 그것이 처음으로 작업 메모리 (12) 에 기록을 시도한 이후에도 처리를 계속하는 것을 가능하게 한다. 그 결과, 젊은 세대 스폰 (22B) 은 그 젊은 세대 스폰 (22B) 이 교체 가능한 것에 의해 임의의 기록 동작들이 수행되는 동안은 체크포인트 간격 (32) 동안 실행을 계속한다. 다른 한편, 만약 제안된 기록이 교체 불가능한 기록이라면, 노드 (10) 는 젊은 세대 스폰 (22B) 의 실행을 중단한다 (단계 68).

교체 불가능한 기록 이외에도, 스폰 (22B) 이 일반적으로는 그렇게 할 수 없는 조건 하에서 기록하는 것이 허용될 수도 있는 다른 조건들이 존재할 수도 있다. 하나의 다른 예시는 메모리 (12) 를 점검한 이후에, 젊은 세대 스폰 (22B) 이 이전 세대 스폰 (22A) 에 의한 메모리 액세스가 더 이상 가능하지 않다고 인식한 경우에 발생한다.

제 5 최적화 방법은 체크포인트 간격 (32) 을 완료하고, 나가는 메시지 (28) 를 생성하는 것과 연관된 모든 계산들이 내구성 있는 스토리지 (16) 에 수용될 때까지 나가는 메시지 에스크로 영역 (30) 이 나가는 메시지들 (28) 을 릴리즈하지 않기 때문에 발생하는 지연을 감소시키는 것이다. 나가는 메시지 에스크로 영역 (30) 으로부터 메시지들 (28) 을 릴리즈하기 전에 체크포인트 간격 (32) 의 종료까지 기다리는 개념은 잘못된 메시지를 전송하는 것의 결과들이 심각한 경우에 유용하다. 그러나, 부정확한 메시지를 전송하는 것의 결과가 아주 적고, 지연된 메시지를 전송하는 것의 결과가 심각한 시점들이 존재한다.

일 예시로서, 나가는 메시지 (28) 가 특정한 리테일 상점 내의 상품들에 대한 쿠폰인 경우를 고려한다. 장치가 사용자가 특정한 시점에 특정한 리테일 상점 부근에 있음을 감지하였다고 가정한다. 명백하게, 사용자가 리테일 상점을 떠날 기회를 가지기 전에 즉시 메시지 (28) 를 전송하는 것이 바람직할 것이다. 만약 이러한 메시지 (28) 가 나가는 메시지 에스크로 영역 (30) 에서 전송될 것을 기다리며 머무른다면 쿠폰이 유용해질 기회는 사라질 수도 있다. 다른 한편, 만약 그 쿠폰이 노드 (10) 의 실패에 의해 나중에 사라질 계산의 결과였다면, 누구도 불평하지 않을 것이다. 이후에, 상점은 그렇지 않으면 만들지 않았을 세일을 만들 수 있고, 사용자는 일부 할인하여 상품을 획득할 수 있었을 것이다.

내구성 있는 스토리지 (16) 에 수용될 기본 (underlying) 데이터를 기다리지 않고 나가는 메시지들 (28) 이 릴리즈되는 이러한 제 5 최적화 방법은, 나가는 메시지 (28) 를 전달하는 시간이 절대적으로 중요하고, 부정확하거나 일치하지 않는 나가는 메시지 (28) 의 비용이 그것의 늦은 전달의 부정적인 결과들과 비교할 때 최소화된다는 것을 상정한다. 제 5 최적화 방법에서, 나가는 메시지들 (28) 은 체크포인트 간격 (32) 의 완료에 앞서 나가는 메시지 에스크로 영역 (30) 으로부터 릴리즈되거나 나가는 메시지 에스크로 영역 (30) 을 완전히 바이패스한다.

도 6 은 도 1 내지 6 과 관련하여 개시된 유형의 복수의 노드들 (72, 74, 76, 78) 이 서로 통신하고 데이터 처리를 수행함에 있어서 서로 협력하는 멀티 노드 장치 (70) 를 도시한다. 이러한 경우, 태스크는 제 1 노드 (72) 로부터 제 2 노드 (74) 로 메시지를 전송할 수도 있다.

일부 경우에, 메시지는 태스크를 제 1 노드 (72) 로부터 제 2 노드 (74) 로 이주시키는 효과를 가질 수도 있다. 하나의 노드로부터 다른 노드로 이주하는 태스크는 "이주 (migrant)" 태스크로서 지칭될 수 있다. 관점에 의존하여, 이주 테스크는 "이민자 (immigrant)" 태스크 또는 "이주자 (emigrant)" 태스크일 수 있다. 제 1 노드 (72) 의 관점으로부터, 태스크는 제 1 노드를 떠나기 때문에 이주 태스크는 "이주자 (emigrant)" 태스크이다. 반대로, 제 2 노드 (74) 의 관점으로부터, 태스크는 제 2 노드 (74) 에서 도착하기 때문에 이주 태스크는 "이민자 (immigrnat)" 태스크이다.

다른 경우들에서, 메시지는 원격 절차 콜 또는 원격 데이터 액세스 요청일 수 있고 그리하여 요청 태스크는 그것이 돌아오는 메시지를 수신하기 전까지 진행할 수 없다. 다른 경우들에서 태스크는 메시지를 사용하여 제 1 노드 (72) 로부터 제 2 노드 (74) 로 단순히 비동기적으로 정보를 전송하는 것일 수 있다. 본원에 참조로서 원용되는, 2015년 9월 2일자로 출원된, "EXECUTING GRAPH-BASED PROGRAM SPECIFICATIONS" 라는 제목의 미국 특허 출원 번호 14/842,956 에 개시된 바와 같은 컴퓨팅 시스템은 예를 들어, 본원에 개시된 결함 허용 및 복구를 촉진하기 위한 기법들을 사용하여 구성될 수 있다.

이러한 경우, 다음 체크포인트 간격 (32) 의 완료에서 메시지 (80) 가 에스크로로부터 릴리즈되기 전까지 제 1 노드 (72) 로부터 제 2 노드 (76) 로의 메시지 (80) 는 전송될 수 없기 때문에, 앞서 말한 방법들의 어플리케이션은 어느 정도는 최적 미만일 수 있다. 이것은 상당한 지연을 유도한다. 이러한 지연은 멀티 노드 장치 (70) 내의 노드로부터 노드로 전송되는 메시지들을 에스크로되는 것으로부터 면제하는 것에 의해 잠재적으로 감소될 수 있는 반면에, 이러한 면제는 불확정에 기인하여 충분하지 않다.

예를 들어, 많은 계산들이 비 결정론적이기 때문에 복수의 노드들 (72, 74, 76, 78) 이 존재할 때 이러한, 그리고 다른 어려움들이 발생한다. 이러한 비 결정론적 계산들의 예시들은 결과가 판독들과 기록들이 발생하는 순서에 의존하는 것, 그것이 실시간 클록들에 의존하는 것, 그리고 나가는 메시지 에스크로 영역 (30) 의 바람직한 상황과 관련하여 앞서 이미 개시된 예시와 같이, 그것이 랜덤 넘버 생성기의 결과에 의존하는 것이다.

만약 제 1 노드 (72) 가 제 2 노드 (74) 와 통신하고, 이어서 다음 체크포인트 간격 (32) 이전에 접촉을 상실 (예를 들어, 실패에 기인) 하면, 장치 (70) 는 하기와 같은 이러한 비-결정론 (non-determinism) 때문에 결국 불일치들과 함께 하게 될 수도 있다. 실패 이후에 장치 (70) 는 가장 최근의 체크포인트로부터 제 1 노드 (72) 를 복구하고 계산을 재시작할 것이다. 계산은 제 1 노드 (72) 로부터 제 2 노드 (74) 로의 메시지의 전송 이전의 계산의 지점으로부터 재시작될 수도 있다. 계산들의 비 결정론적 속성들 때문에, 제 1 노드 (72) 는 체크포인트로부터의 복구 이후에 제 2 노드 (74) 로 완전히 상이한 메시지를 전송할 수도 있다. 그러나, 제 2 노드 (74) 는 이미 수신된 오리지널 메시지를 가질 수도 있고, 두 노드들 (72 및 74) 을 잠재적으로 불일치 상태에 있게할 수 있다. 예를 들어, 노드 (72) 는 메시지의 "새로운" 버전을 노드 (74) 로 전송한 상태에 있지만, 노드 (74) 는 메시지의 "이전" 버전 상에서 이미 동작한 상태에 있다. 더 나아가, 노드 (74) 는 노드 (72) 로부터 수신한 오리지널 메시지에 기초하여 또 다른 노드 (76) 로 메시지를 전송하였을 수도 있고, 따라서 노드 (72) 및 노드 (76) 은 역시 불일치 상태에 있을 수도 있다. 그리하여, 불일치는 바이러스와 같이 장치 (70) 내의 모든 노드들에 걸쳐 퍼질 수도 있다.

앞서 말한 어려움을 피하기 위한 하나의 방법은 아래와 같이, 예를 들어 '장벽 싱크 (barrier sync)' 동작을 이용하여, 모든 노드들 (72, 74, 76, 78) 이 그들의 체크포인트들을 동기화하는 것을 보장하는 것이다. '체크포인트 리더'는 체크포인트 간격을 시작할 것을 명령하는 메시지를 모든 노드들로 전송한다. 이어서, 각 체크포인트가 완료된 이후에, 각 노드는 체크포인트가 완료되었음을 확인하여 체크포인트 리더로 응답한다. 체크포인트 리더가 모든 노드들로부터 확인들을 수신하였을 때, 그것은 모든 노드들로 체크포인트를 수용하고 처리를 재개할 것을 명령할 것이다. 이러한 접근은 멀티 노드 체크포인트에 대한 해결책의 기초를 형성하지만, 두 가지 이유로 인해 그것을 완전히 해결하지는 않는다. 첫째, 멀티 노드 장치 내에서 어떤 노드들이 위기를 이겨내는 것이 가능하고, 이러한 경우 이겨낸 노드들은 (체크포인트 상태로 나아가는 것 (roll forward) 보다는) 그들의 현재 상태로부터 체크포인트 상태로 롤 백 (roll back) 되어야 한다. 둘째, 체크포인트가 수행될 때, 전송 중인 메시지들이 존재할 수도 있고, 이는 이전 처리 간격으로부터의, 체크포인트에 걸친, 그리고 새로운 처리 간격으로의 누출 (leak) 에 비-결정론 (non-determinism) 을 허용할 수도 있다.

단일 노드 장치에서, 만약 노드 (10) 가 실패하면, 수용되지 않은 작업을 복구하기 위해 단지 나아갈 수 있다. 그러나 멀티 노드 장치 (70) 에서는, 실패하지 않은 다른 노드들 (72, 74, 76) 은 노드 (78) 가 실패한 경우 롤 백 (roll backward) 해야만 한다. 분산된 장치 (70) 가 일부 노드 (78) 는 앞으로 나아가고 다른 노드들 (72, 74, 76) 은 록 백하도록 하는 것에 의해 복구하는 이러한 메커니즘은, 사실상 모든 노드들 (72, 74, 76, 78) 이 특정 체크포인트에서 재시작하도록 할 수 있음을 의미한다. 결과적인 장치 (70) 는 그리하여 모든 노드들에 걸친 동시의 체크포인트들의 효과를 달성한다. 그러나, 이것은 상기에서 어렵다고 언급된 바와 같은 모든 노드들에 걸친 동기화 동작을 실제로 수행하려고 시도하는 것에 의해 그렇게 하지 아니한다. 대신에, 이것은 이러한 체크포인트들을 실제로 제공해야만 하지 않고서도 동기화된 체크포인트들의 이점을 획득하기 위해 노드들 (72, 74, 76, 78) 의 상태들을 조정하는 것에 의해 그렇게 한다.

앞서 말한 복구 방법을 구현하기 위해, 노드들 (72, 74, 76, 78) 은 하기에 상세하게 개시되는 바와 같은 분산된 체크포인트 방법을 실행한다. 도 7 을 참조하면, 분산된 체크포인트 방법을 구현할 때, 모든 처리 및 모든 메시지는 세대 카운트 (82) 를 획득한다. 나아가, 각 체크포인트와 연관된 태스크들 중에서 실행 카운트 (84) 가 유지된다. 각 노드는 또한 그것의 스포너 (20) 들의 스포너 레지스트리 (86) 를 유지한다. 추가적으로, 각 노드 (72) 는 노드 세대 카운트 (88) 를 유지한다.

노드 세대 카운트 (88) 는 노드 (76) 가 젊은 세대 스폰 (22A) 에 의해 수행되는 작업과 이전 세대 스폰 (22B) 에 의해 수행되는 작업이 서로 간섭하지 않는 세대 갭 (gap) 을 시행하는 것을 허용한다. 세대 갭의 결과로서, 이전 세대와 젊은 세대는 더욱 또는 덜 서로 무시할 수 있다. 실제로는, 노드 (76) 가 이전 세대 스폰 (22A) 에 의해 보여지는 하나와 젊은 세대 스폰 (22B) 에 의해 보여지는 다른 것의 두 개의 가상 머신이 된다. 이러한 두 가상 머신은 동일한 물리적 플랫폼 상에서 공존하지만 그렇지 않으면 서로 직교한다.

추가로, 각 노드 (76) 는 또한 노드 (76) 가 요구되는 특정한 상태로 롤 백 하거나 나아갈 수 있도록 허용하는 양방향 저널 (90) 을 구현한다. 양방향 저널 (90) 은 작업 스토리지에 대한 변화들 (92), 체크포인트 된 태스크 상태들의 목록 (94), 및 체크포인트 된 메시지들 (96) 을 포함한다. 이러한 엘리먼트들은 시간에 맞춰 나아갈 수 있는 방법을 제공한다. 추가로, 양방향 저널 (90) 은 노드 (76) 가 시간에 맞춰 롤 백 하는 것을 가능하게 하기 위해 메모리 (12) 내에 무효화 로그 (undo log, 98) 를 특징으로 포함한다. 일반적으로, 시간에 맞춰 앞으로 나아가는 것은 어떻게 실패한 노드가 복구하는가이다. 시간에 맞춰 롤 백 하는 것은 장치 (70) 내의 다른 노드가 실패한 경우 노드가 수행하는 것이다.

동작 중에, 도 6 에 도시된 바와 같이, 마스터 노드 (72) 는 체크포인트가 예정되었음을 지시하는 체크포인트 메시지 (100) 를 다른 모든 노드들 (74, 76, 78), 즉, "슬레이트 노드들"로 전송한다. 그러나, 이러한 체크포인트가 모든 노드들 (72, 74, 76, 78) 내에서 동일한 시간에 발생할 필요는 없다.

도 8 은 계산적 불확정의 존재하에서 예시적인 결함 허용 및 복구 절차에 대한 흐름도를 도시한다. 체크포인트 메시지를 수신하는 것 (단계 102) 에 응답하여, 슬레이브 노드 (76) 는 체크포인트 간격을 즉시 시작하지는 않을 것이다. 상기 개시된 바와 같이, 이것은 비실용적이다. 대신에, 슬레이브 노드 (76) 는 그것의 노드 세대 카운트 (88) 를 증가시키고 (단계 104), 그것의 노드 세대 카운트 (88) 의 증가를 지시하는 저널 엔트리를 생성한다 (단계 106).

슬레이브 노드 (76) 는 이어서 그것의 모든 스포너 (20) 들을 중단하고 (단계 108), 그들의 상태를 양방향 저널 (90) 에 기록한다 (단계 110). 이어서, 그것의 스포너 (20) 들 각각에 대해, 슬레이브 노드 (76) 는 그 스포너의 세대 카운트 (82) 를 증가시킨다 (단계 112). 증가된 그것의 세대 카운트 (82) 와 함께, 스포너 (20) 는 동작을 재개하는 것이 허용된다 (단계 114). 그러나, 스포너의 세대 카운트 (82) 는 증가될 것이기 때문에, 임의의 결과적인 스폰 (22B) 은 더 젊은 세대에 있을 것이다.

이러한 지점에서, 두 세대들은 슬레이브 노드 (76) 내에서 공존할 것이다. 이전 세대 스폰 (22A), 다시 말해 노드의 세대 카운트보다 하나 적은 세대 카운트를 가지는 스폰은 필요에 따라 메모리 (12) 에 기록하여 완료를 위해 처리를 계속할 수 있다. 젊은 세대 스폰 (22B), 다시 말해 그것의 세대 카운트가 노드 세대 카운트 (88) 와 매치하는 스폰은 메모리 (12) 에 기록하기 위한 시간이 될 때까지 처리할 수도 있다. 이러한 지점에서, 젊은 세대 스폰 (22B) 은 가로막힌다.

여기까지의 개시 내에서, 그것의 세대 카운트가 노드 세대 카운트 (88) 보다 하나 적은 이전 세대 스폰 (22A), 그리고 그것의 세대 카운트가 노드 세대 카운트 (88) 와 매치하는 젊은 세대 스폰 (22B) 을 포함하는 단지 두 세대의 스폰 만이 존재하였음을 주목해야 한다. 그러나 동일한 플랫폼 상에서 두 세대 이상이 공존할 수 없을 이유는 이론적으로 존재하지 않는다.

도 9 를 참조하면, 멀티 노드 장치 (70) 내에서, 태스크 (79) 가 전송 노드 (78) 로부터 이주하는 것 및 수신 노드 (76) 로 이민가는 것이 가능하다. 도 6 과 관련하여 개시된 바와 같이, 이러한 태스크 (79) 는 "이주 태스크" 또는 "이주"로서 지칭될 수 있다.

하기의 논의에서, 특정한 객체들과 연관된 값들을 참조하는 것이 반드시 필요하다. 도면 내의 숫자들과 연관된 모호성을 방지하고 표준 수학 표기법과 어느 정도 일치시키기 위해, 괄호는 "~의"를 의미하기 위해 사용될 것이다. 그리하여, "88"은 "노드 세대 카운트"에 할당되었고 "76"은 노드이기 때문에, 노드 (76) 의 노드 생성 카운트 (88) 는 88(76) 로서 기록될 것이다.

이주자들의 생성 카운트 (82(79)) 가 수신 노드 (76) 의 노드 생성 카운트 (88(76)) 와 동일하지 않을 때 어려움이 발생할 수 있다. 이러한 어려움들은 노드들 간의 메시지 에스크로 영역들을 구현하는 것에 의해 방지될 수 있다. 그러나 이것은 제 1 위치 내에서 분산된 체크포인트 방법이 피하고자 했었던 지연을 다시 유발할 수도 있다.

분산된 체크포인트 방법에 따르면, 전송 노드의 노드 카운트 (88(78)) 가 수신 노드의 노드 카운트 (88(76)) 와 동일; 전송 노드 (78) 가 수신 노드의 노드 카운트 (88(76)) 보다 낮은 노드 세대 카운트 (88(78)) 를 가짐; 그리고 전송 노드 (78) 가 수신 노드의 노드 카운트 (88(76)) 보다 높은 노드 세대 카운트 (88(78)) 를 가짐의 세 가지 가능성들을 가진다.

제 1 가능성에서, 이주자는 전송 노드 (78) 의 노드 카운트 (88(78)) 와 동일한 세대 카운트 (82(79)) 를 가질 것이다. 그러므로, 전송 노드 (78), 수신 노드 (76), 및 이주자 (79) 는 전부 동일한 세대 카운트를 가진다. 이 경우에, 특별히 수행되어야 하는 것은 없다.

제 2 가능성은 이주자 (79) 가 전송 중인 동안 수신 노드 (76) 가 그것의 세대 카운트 (88(76)) 를 증가시킬 때 발생할 수 있다. 이것은 수신 노드 (76) 로의 이민에 이어, 이주자 (79) 는 이제 수신 노드 (76) 의 이전 세대가 된 것의 멤버로서 스스로를 표시함을 의미한다. 이 경우, 수신 노드 (76) 는 이주자의 세대 카운트 (82(79)) 를 증가시키는 것에 의해 이주자 (79) 를 젊어지게 할 것이다. 그 결과, 이주자 태스크 (79) 는 처리를 계속할 수 있지만, 젊은 세대 스폰 (22B) 의 나머지들과 같이, 그것은 메모리 (12) 에 기록하는 것으로부터 가로막힐 것이다. 이주자 (79) 를 젊어지게 하는 것은 수신 노드 (76) 에서 저널화 (journalized) 될 것이다. 젊어지게 하는 행동은 수신 노드 (76) 에서 벌어지기 때문에, 이것은 "이민 측면의 젊게 만드는 것"으로 지칭된다.

제 3 가능성은 이주자 (79) 가 이주하기에 앞서 전송 노드 (78) 가 그것의 세대 카운트 (88(78)) 를 증가시킬 경우에 발생할 수 있다. 이 경우, 전송 노드 (78) 는 이주자의 세대 카운트 (82(79)) 를 그것이 전송되기 전에 증가시키는 것에 의해 이주자 (79) 를 젊어지게 하고, 전송 노드에서 젊어지게 하는 사건을 저널화 (jornalize) 한다. 젊어지게 하는 행동은 전송 노드 (78) 에서 벌어지기 때문에, 이것은 "이주 측면의 젊게 만드는 것"으로 지칭된다.

어느 경우에도, 마스터 노드로부터 체크포인트 메시지를 수신한 노드 (76) 는 이전 세대 스폰 (22A) 이 실행을 종료하는 것을 허용하기 위한 데드라인을 설정하여 이전 세대의 거의 소멸을 보장하고, 그들의 상태들을 기록할 필요를 방지할 것이다 (단계 116). 그럼에도 불구하고, 종료가 느린 이전 세대의 스폰 (22A) 이 존재할 수도 있다. 데드라인에 도달하였을 때 만큼은 노드 (76) 가 연장된 기간을 기다리는 것은 비실용적이고, 여전히 실행하고 있는 임의의 이전 세대 스폰 (22) 은 중단되고, 직렬화되고, 저널화되고, 그리고 젊어지게 될 것이고, 실행을 재개하는 것이 허용된 이후에는, 작업 메모리 (12) 가 내구성 있는 스토리지 (16) 에 수용된 이후 까지는 작업 메모리 (12) 에 기록하지 않도록 하는 제약을 받을 것이다.

슬레이브 노드 (76) 는 그것이 더 이상의 이전 세대의 이민자들이 도착할 것으로 기대되지 않는다는 것을 알 때까지 실제 체크포인트를 개시하지 않을 것이다. 이것을 구현하기 위해, 노드 (72) 가 모든 이전 세대의 이민자들이 성공적으로 이주하였음을 인식할 때마다, 그것은 플러쉬 메시지를 모든 다른 노드들 (74, 76, 78) 로 브로드캐스트한다. 슬레이브 노드 (76) 가 모든 노드들 (72, 74, 78) 로부터 플러쉬 메시지들을 수신하면, 그것은 이전 세대 이민자들의 흐름이 끝났다는 것을 안다 (단계 118). 젊은 세대 이주자들이 슬레이브 노드 (76) 로부터 여전히 떠나갈 수 있는 것과 같이, 젊은 세대 이민자들은 여전히 슬레이브 노드 (76) 에 도착할 수도 있다. 그러나, 이러한 젊은 세대 이주자들은 체크포인트 처리에 적절하지 않다.

이러한 지점에서, 슬레이브 노드 (76) 는 이제 그것의 작업 메모리 (12) 를 내구성 있는 스토리지 (16) 로 수용할 준비가 된다 (단계 120). 이것은 단일 노드 경우에서 상기 개시된 바와 동일한 방법으로 수행된다.

도 10 에 도시된, 노드의 실패 이후 재시작을 위한 절차는 연관된 노드가 실패한 것인지 아닌지 여부에 의존한다. 재시작을 위한 명령을 수신한 이후 (단계 122), 노드는 그것이 실패한 노드인지, 또는 장치 (70) 내의 다른 노드가 실패하였는지를 결정한다 (단계 124). 만약 노드가 실패한 것이라면, 그것은 로그를 회수하고 그것의 마지막 유효한 체크포인트로부터 나아간다 (단계 126). 만약 노드가 실패한 것이 아니라면, 그것은 그것의 마지막 체크포인트로 롤 백 한다 (단계 128).

"롤 백" 동작의 예시는 (1) 현재 실행하고 있는 모든 태스크들을 종료 (스포너들 및 스폰 양쪽 모두를 포함); (2) 메모리에 대한 임의의 변화들을 무효화하기 위해 양방향 저널 엔트리들을 이용의 단계들을 포함한다.

임의의 실패한 노드들이 나아가고 (roll forward) 임의의 견뎌낸 노드들이 롤 백 된 이후에, 장치 (70) 는 태스크들의 재시작의 일부로서 다른 동작들을 수행할 수도 있다. 예를 들어, 장치 (70) 는 (1) 실패가 폐기되는 것에 앞서 모든 메시지들을 보장하기 위해 통신 네트워크를 플러쉬, (2) 저널로부터 그들의 저장된 상태를 회수하고 그들을 재시작하는 것에 의해 체크포인트의 일부였던 모든 태스크들을 재시작, (3) 체크포인트에 앞서 전송되지 않았던 임의의 메시지들을 재전송, 그리고 (4) 수신되었으나 체크포인트로서 아직 처리되지 않은 임의의 메시지들을 처리의 동작들을 수행할 수도 있다.

실패한 노드 상에서 최종 유효한 체크포인트로부터 나아가는 태스크는 잠재적으로 시간을 소비하는 것이다. 도 11 을 참조하면, 일부 구현들에서, 제 2 노드 (134) 상에서 제 1 노드 (132) 로부터의 메모리 (130) 의 복제본 (128) 을 유지하는 것이 유용하다. 바람직하게는, 제 2 노드 (134) 는 제 1 노드 (132) 와 동일한 실패 모드를 가지지 않는다. 통상적인 동작에서, 복제본 (128) 은 각각의 체크포인트에서 제 1 노드 (132) 에서의 메모리 (130) 와 동기화된다. 복제본 (128) 은 또한 그것이 가장 최근의 체크포인트에서의 그것의 상태로 롤 백 할 수 있도록 하기 위해 연관된 무효화 로그 (136) 를 가진다.

이제 도 12 를 참조하면, 제 1 노드 (132) 의 실패에 이어, 제 2 노드 (124) 에서의 복제본 (128) 마스터로 지정된다 (단계 138). 제 2 노드 (124) 상의 모든 처리들은 제거된다 (단계 140). 그 이후, 제 2 노드 (134) 는 재시작된다 (단계 142). 현재 마스터 카피로서 서빙하는 이전의 복제본 (128) 은 무효화 로그 (136) 의 도움으로 최종 체크포인트로 롤 백 된다 (단계 144). 멀티 노드 장치 (70) 의 동작은 이어서 롤 백 시간의 순서에 따른 복구를 기다리는 것과 함께 재개될 수 있다. 이는 앞으로 나아가는 (roll forward) 시간에 비해 일반적으로 훨씬 짧다. 한편, 복구된 제 1 노드 (132) 는 멀티 노드 장치 (70) 의 전체적인 복구를 느리게 하지 않고서 정확한 상태로 나아가기 위해 진행할 수 있다. 제 1 노드 (132) 가 준비되면, 그것은 마스터로서 다시 인계받고, 이전의 복제본 (128) 은 다시 복제본이 된다.

도 11 이 비록 하나의 제 2 노드 (134) 를 도시할지라도, 각각 복제본 (128) 및 무효화 로그 (136) 를 가지는 하나 이상의 제 2 노드가 존재할 수 있다고 이해된다. 이 경우에, 제 1 노드 (132) 의 실패에 이어, 제 2 노드들 중 하나는 제 1 노드의 메모리의 새로운 마스터 카피의 소유자로서 서빙하도록 선택되어야만 한다.

일부 경우들에서, 많은 멱등의 (idempotent) 동작들이 존재할 수도 있다. 이러한 경우에, 나아가는 것 대신에, 멱등의 동작들을 수행할 수도 있는 계산들을 단순히 반복하는 것은 이러한 계산들이 어떠한 피해도 야기하지 않을 것이므로 불합리하다.

복구의 최종 결과는 모든 지점들이 하나의 세대로부터 다음으로의 전이와 일치하는 상태에 있는 것이다. 그 결과, 이전 세대 처리들로부터의 작업이 어느 것도 손실되지 않지만, 젊은 세대 처리들에 의해 수행된 모든 작업은 손실된다. 이것은 모든 노드들에 걸쳐 일치하는 상태를 보장한다. 본원에서, 상태는 어떠한 결함도 없이 그것이 도착할 수 있을 때 "일치"한다. 반대로, 상태는 그것이 하나 이상의 결함들에 의해서만 설명될 수 있을 때 "불일치"한다.

도 13 은, 도 6 내지 9 와 관련하여 참조된 멀티 노드 장치 (70) 내의 전송 노드 (78) 및 수신 노드 (76) 양쪽 모두의 복수의 스폰된 처리들의 상태들을 도시한다. 도 13 에서, 시간은 수직 축을 따라 아래쪽으로 증가한다. 시간 축은 제 1 간격 (146), 제 1 간격을 뒤따르는 제 2 간격 (148), 그리고 제 2 간격 (148) 을 뒤따르는 제 3 간격 (150) 을 도시한다.

도 13 은 각각 연관된 세대 카운트를 가지는 복수의 스폰된 처리들 (22A-H) 을 도시한다. 세대 카운트 N 을 가지는 스폰은 이하 "제 1 세대 스폰"으로서 지칭될 것이다. 세대 카운트 N+1 을 가지는 스폰은 이하 "제 2 세대 스폰"으로서 지칭될 것이다. 형용사 "제 1 세대" 및 "제 2 세대"는 노드들, 이주자 태스크들, 및 스폰된 처리들을 포함하여, 세대 카운트와 함께 태그되는 다른 엔티티들을 지칭하기 위해 또한 사용될 것이다.

제 1 간격 (146) 동안, 전송 노드 (78) 는 제 1 세대 노드이다. 제 2 및 제 3 간격 (150) 동안, 전송 노드 (78) 는 제 2 세대 노드이다. 이러한 노드들의 진행은 주기적이어서, 제 3 간격 (150) 은 제 2 세대에 대해 동일한 역할을 수행하는 간격에 의해 뒤이어질 것이고, 제 2 간격 (148) 은 제 1 세대에 대해 수행할 것임을 유의해야 한다. 전송 노드 (78) 에서 발생하는 진행과 반드시 동기화되어야 하는 것은 아닐지라도, 이러한 동일한 진행은 수신 노드 (76) 상에서 발생한다. 편의를 위해, 전송 및 수신 노드 (78, 76) 양쪽 모두에서 간격들을 지정하기 위해 동일한 참조 번호가 사용된다. 그러나, 이것이 그들이 동기화된다는 것을 의미하는 것은 아니다.

제 1 간격 (146) 동안, 스포닝 처리 (20) 는 다양한 제 1 세대 스폰된 처리들 (22A-22E) 을 스폰한다. 이러한 제 1 간격 (146) 에 걸쳐, 임의의 제 1 세대 스폰된 처리들 (22A-22E) 는 자유롭게 전송 노드 메모리 (12A) 에 기록할 수 있다.

제 2 간격 (148) 동안, 전송 노드 (78) 는 제 2 세대 노드가 된다. 그리하여, 스포닝 처리 (20) 는 이제 단지 제 2 세대 스폰된 처리들만을 스폰한다. 이러한 제 2 간격 (148) 에 걸쳐, 임의의 제 1 세대 스폰된 처리들 (22A-22E) 은 여전히 전송 노드 메모리 (12A) 에 자유롭게 기록할 수 있다. 제 2 세대 스폰된 처리들 (22F-22G) 은 자유롭게 실행할 수 있지만, 전송 노드 메모리 (12A) 에 기록하는 것이 금지된다. 이러한 제 2 간격 (148) 의 목적은 그러므로 임의의 잔여 제 1 세대 스폰 (22C, 22D, 22E) 이 체크포인트 간격 (32) 이 발생하기 전에 언젠가 실행을 종료하는 것을 허용하는 것이다.

제 3 간격 (150) 동안, 스포닝 처리 (20) 는 다른 제 2 세대 스폰된 처리 (22H) 를 스폰한다. 이러한 제 3 간격 (150) 동안, 제 1 세대 스폰은 남아있지 않고, 모든 제 2 세대 스폰 (22F-22H) 은 전송 노드 메모리 (12A) 에 자유롭게 기록할 수 있다.

전송 노드 (78) 에서, 제 1 의 제 1 세대 스폰된 처리 (22A), 제 2 의 제 1 세대 스폰된 처리 (22B), 제 3 의 제 1 세대 스폰된 처리 (22C), 제 4 의 제 1 세대 스폰된 처리 (22D), 제 5 의 제 1 세대 스폰된 처리 (22E) 전부는 제 1 간격 (146) 동안에 실행을 시작한다. 그러나, 이것들 중, 제 1 의 제 1 세대 스폰된 처리 (22A) 및 제 2 의 제 1 세대 스폰된 처리 (22B) 만 제 1 간격 (146) 동안 겨우 실행을 완료한다. 제 3 의 제 1 세대 스폰된 처리 (22C) 는 제 2 간격 (148) 동안 겨우 완료한다. 제 4 의 제 1 세대 스폰된 처리 (22D) 는 매우 길게 소요되어 제 3 간격 (150) 이 이미 시작할 때까지 종료하지 못한다. 제 5 의 제 1 세대 스폰된 처리 (22E) 는 전송 노드 (78) 에서 실제로 종료하지 못한다. 대신, 제 2 간격 (148) 동안에 수신 노드 (76) 로 이주한다. 그것은 수신 노드 (76) 가 여전히 그것의 제 2 간격 (148) 인 동안에 그렇게 한다.

실행 동안, 제 1 의 제 1 세대 스폰된 처리 (22A)는 제 1 간격 (146) 동안 전송 노드 메모리 (12A) 에 기록하고 제 3 의 제 1 세대 스폰된 처리 (22C) 는 제 2 간격 (148) 동안 전송 노드 메모리 (12A) 에 기록한다. 제 2 의 제 1 세대 스폰된 처리 (22B) 는 모든 실행 동안에 전송 노드 메모리 (12A) 에 기록하지 않는다. 제 5 의 제 1 세대 스폰된 처리 (22E) 는 결국 오직 수신 노드 (76) 에서, 전송 노드 메모리 (12A) 에 기록한다.

제 2 간격 (148) 동안, 제 1 의 제 2 세대 스폰된 처리 (22F) 및 제 2 의 제 2 세대 스폰된 처리 (22G) 양쪽 모두는 실행을 시작한다. 때때로 제 2 간격 (148) 동안에, 제 1 의 제 2 세대 스폰된 처리 (22F) 는 그것이 반드시 전송 노드 메모리 (12A) 에 기록해야만 하는 지점에 도달한다. 그러나, 여전히 제 2 간격 (148) 이기 때문에, 그것은 전송 노드 메모리 (12A) 에 기록하는 것이 금지된다. 그러므로, 그것은 대쉬 라인에 의해 지시된 바와 같이 그것은 중단된다. 제 3 간격 (150) 이 시작하면, 제 1 의 제 2 세대 스폰된 처리 (22F) 는 전송 노드 메모리 (12A) 에 기록하고 실행을 완료한다.

한편, 제 2 의 제 2 세대 스폰된 처리 (22G) 는 제 2 간격 (148) 동안 충분히 늦게 시작하여 그때까지 그것은 전송 노드 메모리 (12A) 에 기록해야 하고, 제 3 간격 (150) 은 이미 시작한다. 따라서, 제 2 의 제 2 세대 스폰된 처리 (22G) 는 중단 없이 실행한다.

제 3 의 제 2 세대 스폰된 처리 (22H) 는 제 3 간격 (150) 동안 시작한다. 이것은 근본적으로 제 1 의 제 1 세대 스폰된 처리 (22A) 의 미러 이미지이다.

실행 동안, 제 1 의 제1 세대 스폰된 처리 (22A) 는 제 1 태스크 (152) 가 수신 노드 (76) 로 이주하는 것을 야기한다. 제 1 태스크 (152) 는 제 1 의 제 1 세대 스폰된 처리 (22A) 의 세대 넘버를 물려받는다. 그리하여, 그것은 제 1 세대 태스크로서의 존재를 시작한다. 이러한 제 1 태스크 (152) 는 수신 노드 (76) 가 여전히 제 1 간격 (146) 에서 동작하고 있을 때 수신 노드 (76) 에 도착한다. 수신 노드 (76) 는 그리하여 제 1 세대 노드로서 동작하고 있다. 따라서, 제 1 태스크 (152) 는 자유롭게 실행하고 제공된 수신 노드 메모리 (12B) 에 기록할 수 있고, 그것은 수신 노드 (76) 상에서 제 3 간격 (150) 이전에 그렇게 할 수 있다.

또한 동작 중에, 제 2 의 제 1 세대 스폰된 처리 (22B) 는 제 2 태스크 (154) 가 수신 노드 (76) 로 이주하도록 한다. 제 2 태스크 (154) 는 제 1 의 제 1 세대 스폰된 처리 (22A) 의 세대 넘버를 물려받는다. 그리하여, 그것은 제 1 세대 태스크로서의 존재를 시작한다. 그러나, 이러한 제 2 태스크 (154) 는 수신 노드 (76) 가 이미 그것의 제 2 간격 (148) 에서 동작하고 있을 때 수신 노드 (76) 에 도착한다. 따라서, 제 2 태스크 (154) 는 제 1 세대 태스크로부터 제 2 세대 태스크로 변경된다. 이것은 수신 노드 저널 파일 (156) 내에서 제 2 태스크 (154) 를 저널화하는 수반하는 단계를 포함한다.

유사한 사건이 제 5 의 제 1 세대 스폰된 처리 (22E) 와 관련하여 전송 노드 (78) 에서 발생한다. 이러한 제 5 의 제 1 세대 스폰된 처리 (22E) 는 실행을 거치는 동안에 수신 노드 (76) 로 이주한다. 그러나, 그것이 수신 노드 (76) 에 도착하였을 때, 수신 노드 (76) 는 그것의 제 2 간격 (148) 을 이미 시작하였다. 그리하여, 제 2 노드는 제 2 세대 노드가 되었다. 그러므로, 제 5 의 제 1 세대 스폰된 처리 (22E) 는 제 2 세대 스폰된 처리로 변경된다. 이러한 변경은 전송 노드 저널 파일 (158) 내에서 제 5 의 제 1 세대 스폰된 처리 (22E) 를 저널화하는 것을 수반한다. 이어서 제 5 의 제 1 세대 스폰된 처리 (22E) 는 제 2 세대 스폰된 처리로서 이지만, 수신 노드 (76) 상에서의 실행을 계속한다.

한편, 다시 전송 노드 (78) 에서, 제 4 의 제 1 세대 스폰된 처리 (22D) 는 제 2 간격 (148) 의 종료까지 아직 실행을 종료하지 않았다. 이러한 지점에서, 제 4 의 제 1 세대 스폰된 처리 (22D) 는 전송 노드 저널 파일 (158) 에서 저널화되고 그것의 세대 카운트가 증가 되도록 하여 그것은 이제 제 2 세대 스폰된 처리가 된다. 제 4 의 제 1 세대 스폰된 처리 (22D) 는 이어서 제 3 간격 (150) 동안의 실행을 계속한다.

제 4 의 제 1 세대 스폰된 처리 (22D) 는 제 5 의 제 1 세대 스폰된 처리 (22E) 에 의해 그것의 수신 노드 (76) 로의 이주 동안에 유지되었던 동일한 두 단계들, 다시말해 저널화 단계, 그리고 세대 변경을 유지하였다는 점에 주목해야 한다. 그리하여, 제 4 의 제 1 세대 스폰된 처리 (22D) 는 어떤 의미에서는 또한 이주하였다고 하는 것은 합리적이지 않다. 주요한 차이점은 제 5 의 제 1 세대 스폰된 처리 (22E) 는 인터-노드 (inter-node) 이주를 겪은 반면에, 제 4 의 제 1 세대 스폰된 처리 (22D) 는 인트라-노드 (intra-node) 이주를 겪었다는 것이다.

본원에 개시된 체크포인트 및 복구 방법은 그리하여, 복수의 노드들에 걸친 체크포인트들을 동시에 실행하는 것의 바람직한 상황은 시간적 동시 실행 (synchronicity) 으로부터 기인하기보다는 시간적 동시 실행의 부수적인 효과로부터 기인한다는 인식에 기반한다. 방법은 그리하여 실제로 그것을 달성해야만 하지 않고서도 복수의 노드들에 걸친 체크포인트의 시간적 동시 실행의 부수적인 효과를 재현한다.

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

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

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

청구항들은 본 발명을 설명하고 특허로서 보호되고 새로운 것으로서 주장된다.

Claims (21)

1. 적어도 하나의 처리 노드를 포함하는 컴퓨팅 시스템 내에서 결함 허용 및 복구를 촉진하기 위한 방법으로서, 상기 방법은,
   제 1 처리 노드의 가용성 (availability) 및 복구 (recovery) 를 촉진하는 단계로서, 제 1 처리 노드에서,
   상기 노드에서 스포너 (spawner) 를 실행 - 상기 스포너는 실행 동안 제 1 스폰 (spawn) 을 생성함 - 하는 단계로서, 상기 스포너로 제 1 생성 지시자를 할당하는 단계를 포함하고, 상기 제 1 스폰은 상기 제 1 생성 지시자를 물려받는, 상기 스포너를 실행하는 단계;
   체크포인트 간격을 시작하는 단계로서, 상기 체크포인트 간격의 종점에서, 상기 노드의 복구를 위해 사용 가능한 노드 복구 정보가 내구성 있는 (durable) 스토리지에 수용되고,
   상기 스포너가 스폰을 생성하는 것을 중단시키는 단계;
   상기 스포너로, 상기 제 1 생성 지시자와 상이한 제 2 생성 지시자를 할당하는 단계;
   상기 스포너가 제 2 스폰을 생성하는 것을 가능하게 하도록, 상기 스포너를 재개하는 단계로서, 상기 제 2 스폰은 상기 제 2 생성 지시자를 물려받는, 상기 스포너를 재개하는 단계; 및
   상기 제 2 스폰이 메모리에 기록하는 규모를 제어하는 단계를 포함하는, 상기 체크포인트 간격을 시작하는 단계; 및
   상기 노드 복구 정보의 수용 이후에, 상기 제 2 스폰이 메모리에 기록할 수 있는 상기 규모에 대한 제어를 릴리즈 (release) 하는 단계를 포함하는,
   상기 가용성 및 복구를 촉진하는 단계를 포함하는, 결함 허용 및 복구를 촉진하기 위한 방법.
   
2. 제 1 항에 있어서,
   상기 제 2 스폰이 메모리에 기록하는 규모를 제어하는 단계는, 상기 제 2 스폰이 상기 메모리로의 기록을 완성 (consummating) 하는 것을 방지하는 단계를 포함하는, 결함 허용 및 복구를 촉진하기 위한 방법.
   
3. 제 2 항에 있어서,
   상기 복구 정보가 수용된 이후에 상기 제 2 스폰이 그것의 최종적인 완성을 위한 메모리로의 기록을 대기 (queue) 하는 것을 허용하는 단계를 더 포함하는, 결함 허용 및 복구를 촉진하기 위한 방법.
   
4. 제 1 항에 있어서,
   상기 제 2 스폰이 메모리에 기록하는 규모를 제어하는 단계는, 상기 기록의 동작이 교체 가능한 (commutable) 동작이라고 결정하는 단계, 및 상기 교체 가능한 동작의 완성을 허용하는 단계를 포함하는, 결함 허용 및 복구를 촉진하기 위한 방법.
   
5. 제 4 항에 있어서,
   상기 기록의 동작이 교체 가능한 동작이라고 결정하는 단계는, 상기 기록의 동작이 변수를 증가시키는 것을 포함한다고 결정하는 단계를 포함하는, 결함 허용 및 복구를 촉진하기 위한 방법.
   
6. 제 4 항에 있어서,
   상기 기록의 동작이 교체 가능한 동작이라고 결정하는 단계는, 상기 기록의 동작이 구체적인 장소에서 기록을 삽입하는 것을 포함한다고 결정하는 단계를 포함하는, 결함 허용 및 복구를 촉진하기 위한 방법.
   
7. 제 1 항에 있어서,
   상기 스포너를 중단시킨 이후에, 데드라인을 설정함으로써, 제 1 태스크 생성 지시자를 가지는 임의의 스폰에게 완료하기 위한 실행을 위한 시간을 제공하고, 그리고 상기 제 1 생성 지시자를 가지는 스폰의 상태들을 저장해야 하는 것과 연관된 오버헤드를 회피하는 단계를 더 포함하는, 결함 허용 및 복구를 촉진하기 위한 방법.
   
8. 제 7 항에 있어서,
   상기 제 1 스폰이 상기 데드라인에서 여전히 실행하고 있는 경우 상기 제 1 스폰을 중단시키는 단계를 더 포함하는, 결함 허용 및 복구를 촉진하기 위한 방법.
   
9. 제 7 항에 있어서,
   상기 데드라인까지 실행을 완료하는 것에 실패한 결과로서 상기 제 1 스폰이 중단을 회피하는 것을 가능하게 하는 단계를 더 포함하는, 결함 허용 및 복구를 촉진하기 위한 방법.
   
10. 제 9 항에 있어서,
    상기 데드라인까지 실행을 완료하는 것에 실패한 결과로서 상기 제 1 스폰이 중단을 회피하는 것을 가능하게 하는 단계는, 상기 제 1 스폰이 상기 데드라인에서 여전히 실행하고 있는 경우 상기 제 1 스폰 내에서 상기 제 1 태스크 생성 지시자를 상기 제 2 태스크 생성 지시자로 변경하는 단계를 포함하는, 결함 허용 및 복구를 촉진하기 위한 방법.
    
11. 제 1 항에 있어서,
    상기 제 1 노드는 노드 생성 지시자를 가지고,
    상기 방법은, 스폰으로 하여금 제 2 노드로 이주하는 이주자가 되도록 하는 단계를 더 포함하고,
    상기 제 2 노드는 노드 생성 지시자를 가지는, 결함 허용 및 복구를 촉진하기 위한 방법.
    
12. 제 11 항에 있어서,
    상기 제 2 노드의 노드 생성 카운터는, 상기 제 2 노드가 상기 제1 노드보다 젊은 세대임을 나타내고,
    상기 방법은, 상기 이주자를 젊게 만드는 (youthening) 단계를 더 포함하는, 결함 허용 및 복구를 촉진하기 위한 방법.
    
13. 제 12 항에 있어서,
    상기 이주자를 젊게 만드는 단계는, 상기 이주자의 이민 (immigration) 측면의 젊게 만드는 것을 포함하는, 결함 허용 및 복구를 촉진하기 위한 방법.
    
14. 제 12 항에 있어서,
    상기 이주자를 젊게 만드는 단계는, 상기 이주자의 이주 (emigration) 측면의 젊게 만드는 것을 포함하는, 결함 허용 및 복구를 촉진하기 위한 방법.
    
15. 제 1 항에 있어서,
    상기 제 1 노드는 각각의 노드가 노드 생성 카운트를 가지는 멀티 노드 시스템 내의 노드이고,
    상기 멀티 노드 시스템은 적어도 제 2 노드를 포함하고,
    상기 제 2 노드의 실패에 후속하는 복구에 이어, 상기 제 1 노드는 상기 제 2 노드의 노드 생성 카운트에 대응하는 상태로 되돌아가는, 결함 허용 및 복구를 촉진하기 위한 방법.
    
16. 제 1 항에 있어서,
    상기 제 1 노드는 각각의 노드가 노드 생성 카운트를 가지는 멀티 노드 시스템 내의 노드이고,
    상기 멀티 노드 시스템은 적어도 제 2 노드를 포함하고,
    상기 제 2 노드의 실패에 후속하는 복구에 이어, 상기 제 1 노드는 체크포인트로부터 수용된 작업 (work) 을 회복시키고 저널 (journal) 로부터 수용되지 않은 작업을 회복시키는 것에 의해 상기 제 2 노드의 노드 생성 카운트에 대응하는 상태로 나아가는, 결함 허용 및 복구를 촉진하기 위한 방법.
    
17. 제 1 항에 있어서,
    상기 제 1 노드는 각각의 노드가 노드 생성 카운트를 가지는 멀티 노드 시스템 내의 노드이고,
    상기 방법은, 상기 제 1 노드에서,
    마스터 노드로부터, 체크포인트가 수행될 것임을 지시하는 메시지를 수신하는 단계;
    응답하여, 상기 제 1 노드의 노드 생성 카운트를 젊게 하는 단계;
    스포너들이 스폰을 생성하는 것을 중단시키는 단계;
    스포너 상태들을 복구하기 위한 스포너 복구 정보를 저장하는 단계;
    상기 스포너들을 재개하는 단계;
    상기 제 1 노드에서 추가적인 이전 세대 이민자 (immigrant) 들이 예상되지 않는다고 결정하는 단계; 및
    상기 결정에 응답하여, 상기 내구성 있는 스토리지로, 상기 노드 복구 정보를 수용하는 단계를 포함하는, 결함 허용 및 복구를 촉진하기 위한 방법.
    
18. 제 17 항에 있어서,
    데드라인을 설정하고, 그리고 상기 데드라인의 경과에 이어, 젊은 세대 스폰이 실행을 계속하는 반면 여전히 실행하고 있는 모든 이전 세대 스폰을 중단시키는 단계를 더 포함하는, 결함 허용 및 복구를 촉진하기 위한 방법.
    
19. 제 1 항에 있어서,
    상기 제 1 노드는 멀티 노드 시스템 내의 노드이고,
    상기 방법은, 상기 제 2 노드에 상기 제 1 노드의 작업중인 메모리의 복제본 (replica copy) 을 저장하는 단계;
    상기 제 1 노드의 실패에 이어, 상기 제 1 노드에 의해 수행될 수 있었던 처리 (processing) 를 위해 상기 복제본을 일시적으로 사용하는 단계; 및
    상기 제 1 노드의 복구에 이어, 상기 제 1 노드 내의 메모리를 업데이트하기 위해 요구되는 정보를 상기 제 1 노드로 통신하여 상기 제 1 노드에 의해 후속하는 계산이 수행될 수 있도록 하는 단계를 포함하는, 결함 허용 및 복구를 촉진하기 위한 방법.
    
20. 적어도 하나의 처리 노드를 포함하는 컴퓨팅 시스템 내의 결함 허용 및 복구를 촉진하기 위한, 컴퓨터 판독 가능한 매체에 비 일시적인 형태로 저장된 소프트웨어로서, 상기 소프트웨어는 컴퓨팅 시스템으로 하여금,
    제 1 처리 노드의 가용성 (availability) 및 복구 (recovery) 를 촉진하는 것으로서, 상기 제 1 처리 노드에서,
    상기 노드에서 스포너 (spawner) 를 실행 - 상기 스포너는 실행 동안 제 1 스폰 (spawn) 을 생성함 - 하는 것으로서, 상기 스포너로 제 1 생성 지시자를 할당하는 것을 포함하고, 상기 제 1 스폰은 상기 제 1 생성 지시자를 물려받는, 상기 스포너를 실행하는 것;
    체크포인트 간격을 시작하는 것으로서, 상기 체크포인트 간격의 종점에서, 상기 노드의 복구를 위해 사용 가능한 노드 복구 정보가 내구성 있는 (durable) 스토리지에 수용되고,
    상기 스포너가 스폰을 생성하는 것을 중단시키는 것;
    상기 스포너로, 상기 제 1 생성 지시자와 상이한 제 2 생성 지시자를 할당하는 것;
    상기 스포너가 제 2 스폰을 생성하는 것을 가능하게 하도록, 상기 스포너를 재개하는 것으로서, 상기 제 2 스폰은 상기 제 2 생성 지시자를 물려받는, 상기 스포너를 재개하는 것; 및
    상기 제 2 스폰이 메모리에 기록하는 규모를 제어하는 것을 포함하는, 상기 체크포인트 간격을 시작하는 것; 및
    상기 노드 복구 정보의 수용 이후에, 상기 제 2 스폰이 메모리에 기록할 수 있는 상기 규모에 대한 제어를 릴리즈 (release) 하는 것을 포함하는,
    상기 가용성 및 복구를 촉진하는 것을 수행하게 하기 위한 명령어들을 포함하는, 소프트웨어.
    
21. 컴퓨팅 시스템으로서,
    내구성 있는 (durable) 스토리지를 포함하는 데이터 스토리지 시스템; 및
    적어도 하나의 프로세서를 포함하는 하나 이상의 처리 노드들을 포함하고,
    상기 적어도 하나의 프로세서는,
    제 1 처리 노드의 가용성 (availability) 및 복구 (recovery) 를 촉진하는 것으로서, 상기 제 1 처리 노드에서,
    상기 노드에서 스포너 (spawner) 를 실행 - 상기 스포너는 실행 동안 제 1 스폰 (spawn) 을 생성함 - 하는 것으로서, 상기 스포너로 제 1 생성 지시자를 할당하는 것을 포함하고, 상기 제 1 스폰은 상기 제 1 생성 지시자를 물려받는, 상기 스포너를 실행하는 것;
    체크포인트 간격을 시작하는 것으로서, 상기 체크포인트 간격의 종점에서, 상기 노드의 복구를 위해 사용 가능한 노드 복구 정보가 내구성 있는 (durable) 스토리지에 수용되고,
    상기 스포너가 스폰을 생성하는 것을 중단시키는 것;
    상기 스포너로, 상기 제 1 생성 지시자와 상이한 제 2 생성 지시자를 할당하는 것;
    상기 스포너가 제 2 스폰을 생성하는 것을 가능하게 하도록, 상기 스포너를 재개하는 것으로서, 상기 제 2 스폰은 상기 제 2 생성 지시자를 물려받는, 상기 스포너를 재개하는 것; 및
    상기 제 2 스폰이 메모리에 기록하는 규모를 제어하는 것을 포함하는, 상기 체크포인트 간격을 시작하는 것; 및
    상기 노드 복구 정보의 수용 이후에, 상기 제 2 스폰이 메모리에 기록할 수 있는 상기 규모에 대한 제어를 릴리즈 (release) 하는 것을 포함하는,
    상기 가용성 및 복구를 촉진하는 것을 수행하도록 구성되는, 컴퓨팅 시스템.
    

Images