KR102208867B1

KR102208867B1 - 이종 디바이스 유형들을 위한 피어-투-피어 분산 컴퓨팅 시스템

Info

Publication number: KR102208867B1
Application number: KR1020197003669A
Authority: KR
Inventors: 올리버 엠. 윌리암스
Original assignee: 애플 인크.
Priority date: 2016-09-23
Filing date: 2017-09-12
Publication date: 2021-01-27
Also published as: EP3458956A1; CN109791502B; WO2018057352A1; CN109791502A; US10768979B2; US20210034418A1; AU2017330520B2; US20180088986A1; CN117591299A; EP3458956B1; EP4242846A2; KR20190026860A; AU2017330520A1; EP4242846A3

Abstract

상이한 유형들의 디바이스들을 포함하는 분산 컴퓨팅 네트워크를 제공하기 위한 프레임워크(또는 기술 또는 방법) 및 시스템이 설명된다. 프레임워크는 피어 디바이스들이 네트워크 전체에 걸쳐 정보(예를 들어, 메시지들)의 "패키지들"을 작업(job) 또는 데이터의 개념적 단위들로서 송신할 수 있게 한다. 프레임워크는 하나 이상의 작업들을 수행하는 데 사용되는 포터블 코드(portable code)가 피어 디바이스들 사이에서 전송가능하게 한다. 디바이스가 계산을 설명하는 포터블 코드를 다른 디바이스에 전송할 수 있고, 수신 디바이스는 이어서 특정 디바이스의 아키텍처와 호환가능한 실행가능 형태로 코드를 컴파일링할 수 있다. 컴파일링된 코드는 분산 컴퓨팅 프로토콜의 일부로서 작업 요청들을 이행하기 위해 하나 이상의 계산들을 수행하는 함수들을 실행할 수 있다.

Description

이종 디바이스 유형들을 위한 피어-투-피어 분산 컴퓨팅 시스템

본 발명은 일반적으로 분산 컴퓨팅 시스템들의 분야에 관한 것이다. 보다 구체적으로, 본 발명은 상이한 유형들의 디바이스들의 네트워크 내의 분산 컴퓨팅 시스템을 제공하기 위한 프레임워크에 관한 것이다.

휴대용 컴퓨팅 디바이스들의 증가된 수의 출현으로, 다양한 디바이스들 사이의 통합에 대한 필요성이 점점 더 중요해지고 있다. 예를 들어, 사용자는 주어진 시간에서 다수의 유형들의 디바이스들(예를 들어, 스마트폰, 랩톱 등)에 액세스할 수 있고, 따라서, 이들 디바이스들은 서로 간에 통신하여 향상된 사용자 경험을 제공할 수 있다. 이러한 향상된 사용자 경험은 프로세싱 용량, 배터리 사용, 네트워크 대역폭, 저장 등과 같은 능력들을 증가시키기 위해 디바이스들 간에 리소스들을 공유하는 것을 포함할 수 있다. 따라서, 이러한 디바이스들은 분산 컴퓨팅 환경의 일부를 형성할 수 있다. 그러나, 그러한 컴퓨팅 환경들은 종종 디바이스들이 리소스들을 공유하게 하기 위해 특정 요건들에 대한 부담을 갖는다. 예를 들어, 이러한 환경들은 종종 통신 연결의 연속성을 요구하는데, 이는 종종 많은 유형들의 현대 컴퓨팅 디바이스들의 휴대성과 충돌한다. 따라서, 디바이스들 사이의 통신 링크는, 예를 들어, 디바이스가 영역으로부터 물리적으로 제거될 때(예를 들어, 사용자가 수반되는 휴대용 디바이스를 가지고 위치를 떠날 때), 종종 분리된다. 또한, 휴대용 디바이스들은 종종 배터리에 의존하고, 따라서, 종종 전력 소비에 대해 제약된다. 더욱이, 특수화된 아키텍처들(예를 들어, 모바일 디바이스 특정 프로세서들 및 운영 체제들)의 수의 증가에 의해, 디바이스들이 분산 환경 내에서 심지어 통합될 수 없을 수 있는 경우가 종종 있다. 따라서, 전통적인 분산 컴퓨팅 프레임워크들은 종종 현재의 사용자 디바이스들의 환경들에 부적합하다.

다양한 유형들의 디바이스들 및 구성들을 갖는 환경들에서 전개될 수 있는 분산 컴퓨팅 네트워크를 구현하기 위한 탄력적 프레임워크(또는 기술 또는 방법) 및 시스템이 설명된다. 프레임워크는 환경(예를 들어, 디바이스 에코시스템) 내에서 리소스들을 효율적으로 활용하기 위해 다양한 문맥들에서 사용될 수 있다. 예를 들어, 디바이스는 프로세싱 용량, 저장, 전력 리소스들 등과 같은 더 큰 능력들을 가질 수 있는 다른 디바이스에 일부 프로세싱 태스크들을 분담(offload)할 수 있다. 예를 들어, 사용자가 스마트폰과 같은 개인용 디바이스를 랩톱 또는 데스크톱 컴퓨터에 근접하게 갖는 것은 드문 일이 아닐 수 있으며, 이들 중 어느 하나는 연속 전원에 연결될 수 있다(예를 들어, 전기 콘센트에 플러그인됨). 따라서, 스마트폰은 잠재적으로 더 강력한 프로세서를 이용하고 배터리 전력을 절약하기 위해 멀티미디어(예를 들어, 사진들) 편집과 같은 프로세싱 태스크들을 데스크톱 또는 랩톱 컴퓨터에 분담할 수 있다. 프레임워크는 또한 계산들을 다른 디바이스에 분담함으로써 하나 이상의 디바이스들이 환경으로부터 제거(예를 들어, 로컬 무선 네트워크로부터 제거)되는 것을 고려하도록 구현될 수 있다. 또한, 프레임워크는 디바이스가 환경에 다시 조인(rejoined)했다는 것을 인식하도록 구현될 수 있고, 따라서, 보류되었던 계산들을 재개할 수 있다. 따라서, 프레임워크는 다양한 유형들의 디바이스들 및 구성들을 갖는 환경들을 포함하는 탄력적 방식으로 활용될 수 있다. 더욱이, 프레임워크는 개발자에 의해 구상되는 다양한 네트워킹 환경들을 수용하도록 구성될 수 있다.

하나의 실시예에서, 분산 컴퓨팅 시스템 내에서 작업들(jobs)을 수행하도록 피어 디바이스들 사이에서 전송될 수 있는 포터블 실행가능 코드(portable executable code)(예를 들어, LLVM IR)를 레버리징하는 프레임워크가 설명된다. 하나의 실시예에서, 프레임워크는 제1 디바이스 상에서 제1 레벨 프로토콜을 사용하여, 그리고 데몬 프로세스에 의해, 제2 디바이스로부터 제1 메시지를 수신하는 것을 포함하는 동작들을 수행하는 방법을 포함할 수 있다. 예를 들어, 제1 메시지는, 제1 디바이스에 의해 컴파일링될 때, 분산 컴퓨팅 시스템 내에서 제1 디바이스에 의한 계산을 수행하기 위한 하나 이상의 함수들을 제공하는 포터블 코드를 포함할 수 있다. 동작들은 또한 제2 레벨 프로토콜을 사용하여 제2 디바이스로부터 제2 메시지를 수신하는 것을 포함할 수 있다. 예를 들어, 제2 메시지는 제1 작업 요청을 포함할 수 있으며, 제1 작업 요청은 계산을 수행하기 위한 하나 이상의 함수들 중 제1 함수의 표시, 및 제1 함수를 수행하기 위한 입력 데이터의 필요한 세트의 표시를 포함한다. 또한, 동작들은 제1 디바이스가 입력 데이터의 필요한 세트를 획득하는 것에 응답하여, 제1 함수를 실행하여 제1 작업 요청을 이행하기 위한 계산을 수행하는 것을 포함할 수 있다.

따라서, 프레임워크는 본 명세서에 추가로 설명되는 바와 같이 분산 환경 내에서 리소스들을 효율적으로 공유하기 위해 다양한 문맥들에서 사용될 수 있다.

도 1a 및 도 1b는 본 발명의 일 실시예에 따른 데이터 노드들 및 작업 노드들에 대한 그래프 추상화들의 예를 도시한다.
도 2는 본 발명의 일 실시예에 따른 예시적인 분산 컴퓨팅 시스템 개요를 도시한 블록도이다.
도 3은 본 발명의 일 실시예에 따른, 피어 디바이스에 포터블 코드를 제공하는 예시적인 프로세스 흐름을 도시한 블록도이다.
도 4는 본 발명의 일 실시예에 따른 피어 디바이스들의 예시적인 구성을 도시한 블록도이다.
도 5는 본 발명의 일 실시예에 따른, 피어 디바이스들 사이의 메시징 프로세스 흐름을 도시한 도면이다.
도 6은 본 발명의 일 실시예에 따른, 데몬 레벨 메시지에 대한 예시적인 구조를 도시한 도면이다.
도 7은 본 발명의 일 실시예에 따른, 워커 레벨(worker-level) 메시지에 대한 예시적인 구조를 도시한 도면이다.
도 8은 본 발명의 일 실시예에 따른 예시적인 데이터 컨테이너를 도시한 도면이다.
도 9는 본 발명의 일 실시예에 따른, 데이터 컨테이너 내의 선형화된 데이터의 예를 예시한 도면이다.
도 10은 본 발명의 실시예에 따른, 1개 또는 2개의 컨테이너들을 사용하는 블렌드(blend) 함수의 예를 도시한 도면이다.
도 11은 본 발명의 일 실시예에 따른, 입력 데이터의 필요한 세트를 획득하는 것에 응답하여 프로세스를 수행하는 방법의 흐름도이다.
도 12는 본 발명의 일 실시예에 따른, 포터블 코드를 분석 및 컴파일링하는 방법의 흐름도이다.
도 13은 예시적인 컴퓨팅 시스템을 도시한 블록도로서, 예시적인 컴퓨팅 시스템은 본 발명의 실시예들 중 하나 이상과 함께 사용될 수 있다.

아래에서 논의되는 상세사항들을 참조하여 다양한 실시예들 및 양태들이 설명될 것이고, 첨부된 도면들은 다양한 실시예들을 예시할 것이다. 하기의 설명 및 도면들은 예시적이며, 제한적인 것으로 해석되어서는 안 된다. 많은 구체적인 상세사항들이 다양한 실시예들의 철저한 이해를 제공하기 위해 설명된다. 그러나, 특정 예들에서, 주지된 또는 종래의 상세사항들은 실시예들의 간결한 논의를 제공하기 위해 설명되지 않는다. 본 명세서에서의 "하나의 실시예", "일 실시예" 또는 "일부 실시예들"에 대한 언급은 그 실시예와 관련하여 설명된 특정한 특징, 구조, 또는 특성이 적어도 하나의 실시예에 포함될 수 있음을 의미한다. 본 명세서 내의 여러 곳에 나오는 문구 "하나의/일 실시예에서"는 반드시 모두 동일한 실시예를 언급하는 것은 아니다. 다음의 도면들에 도시된 프로세스들은 하드웨어(예를 들어, 회로부, 전용 로직 등), 소프트웨어, 또는 이 둘의 조합을 포함하는 프로세싱 로직에 의해 수행된다. 프로세스들이 일부 순차적 동작들의 관점에서 하기에 설명되지만, 설명된 동작들 중 일부는 상이한 순서로 수행될 수 있음이 이해되어야 한다. 또한, 일부 동작들은 순차적인 대신에 동시에 수행될 수 있다.

상이한 유형들의 디바이스들을 포함하는 분산 컴퓨팅 네트워크를 제공하기 위한 프레임워크(또는 기술 또는 방법) 및 시스템이 본 명세서에 설명된다. 본 명세서에 추가로 설명되는 바와 같이, 프레임워크는 디바이스들이 네트워크 전체에 걸쳐 정보(예를 들어, 메시지들)의 "패키지들"을 작업 또는 데이터의 개념적 단위들로서 송신하게 할 수 있다. 예를 들어, 작업은 디바이스에 의해 수행될 계산들을 포함할 수 있고, 데이터는 작업을 수행하는 데 필요한 입력들의 세트를 포함할 수 있다. 프레임워크는 본 명세서에 추가로 설명되는 바와 같이 상이한 유형들의 디바이스들의 세트 간에 작업들이 수행되게 하는 능력을 제공한다. 그러한 능력을 제공하기 위해, 일부 실시예들에서, 프레임워크는 하나 이상의 작업들을 수행하는 데 사용되는 포터블 코드가 피어 디바이스들 사이에서 전송가능하게 한다. 예를 들어, 디바이스는 다른 피어 디바이스에 포터블 코드를 송신하여 그 피어 디바이스에 의해 작업이 수행되게 할 수 있다. 이어서, 수신 디바이스는 특정 수신 디바이스의 아키텍처와 호환가능한 실행가능 형태로 코드를 컴파일링할 수 있고, 이어서 작업 요청을 이행하는 데 필요한 하나 이상의 계산들을 수행할 수 있다.

본 명세서에서 언급되는 바와 같이, 작업은 디바이스에 의해 수행될 계산 또는 계산의 표시를 포함할 수 있다. 예를 들어, 디바이스는 함수, 프로세스, 객체 등으로부터의 하나 이상의 명령어들을 실행함으로써 계산을 수행할 수 있다. 따라서, 하나의 실시예에서, 작업은 출력들의 세트를 제공하기 위해 하나 이상의 명령어들을 실행하는 (포터블 코드로부터 컴파일링된) 함수에 대한 레퍼런스(예를 들어, 포인터)를 포함할 수 있다. 본 명세서에 추가로 설명되는 바와 같이, 데이터는 작업을 수행하는 데 요구될 수 있는 임의의 형태의 정보(또는 데이터), 또는 작업에 의해 출력으로서 생성될 수 있는 임의의 정보(또는 데이터)를 포함할 수 있다. 데이터와 작업들 사이의 관계의 표현은 추상적인 계산 그래프로 표시될 수 있다.

도 1a 및 도 1b는 본 발명의 일 실시예에 따른 데이터 노드들 및 작업 노드들에 대한 그래프 추상화들의 예를 도시한다. 도시된 바와 같이, 그래프들(10 및 15)은 2개 유형들의 노드들, 즉 데이터 노드(12)(원형 노드로 도시됨) 및 작업 노드(14)(정사각형 노드로 도시됨)를 포함할 수 있다. 작업 노드(14)는 하나 이상의 출력 데이터 노드들(12)을 생성하기 위해 영(0)개 이상의 입력 데이터 노드들을 소비할 수 있다. 예를 들어, 작업들은 데이터를 데이터에(예를 들어, 입력 데이터를 출력 데이터에) 매핑하는 함수들을 표현할 수 있다. 도 1a는 작업(F)이 출력(y)을 생성하기 위해 입력(x)에 적용되는 간단한 예를 도시한다. 예를 들어, 수학적 문맥에서, 이는 y = F(x)로 표현될 수 있다. 그러나, 그래프는 데이터 노드(x)가 작업 노드(F) 내로 입력되어 출력 데이터(y)를 생성하는 방향성 그래프(directed graph)로서 표현될 수 있다. 도 1b는 더 복잡한 예를 도시한다. 수학적 문맥에서, 이러한 계산은 다음과 같이 표현될 수 있다:

w = E(u, v) s = G(v) z = H(w, s)

또는 내부 노드들이 다음과 같이 접히는 경우:

z = H(E(u, v), G(v))

이들 예들에 도시된 바와 같이, 그래프는 양분적(bipartite)이다(예를 들어, 모든 에지는 일 단부에 작업을, 그리고 타 단부에 데이터를 가짐). 따라서, 데이터 노드들은 0 또는 1의 진입차수(in-degree)를 가질 수 있고(예를 들어, 데이터는 이미 존재하거나, 정확히 하나의 실행 작업의 출력으로서 생성됨), 작업 노드들은 임의의 진입차수를 가질 수 있다. 따라서, 그래프는 방향성 비순환 그래프(directed acyclic graph, DAG)이고, 따라서, 작업 노드들 내의 계산들이 완료된 것으로 알려져 있는 경우, 전체 계산은 완료되도록 실행되어야 한다. 다시 말하면, DAG는 작업들에 대한 순서적 제약을 부과한다. 따라서, 작업은 일단 그의 입력들의 필요한 세트가 이용가능해야만 실행될 수 있다. 더욱이, DAG들의 특성으로 인해, 효율적인 토폴로지 순서가 도출될 수 있다. 도출된 순서에 기초하여, 디바이스는 하나 이상의 작업들을 수행하기 위한 효율적인 시퀀스를 결정할 수 있다.

일부 실시예들에서, 프레임워크는 포터블 코드가 디바이스들의 네트워크 내의 다른 형태들의 데이터와 동일하게 전송가능하게 될 수 있게 한다. 그러한 능력은 본 명세서에 추가로 설명되는 바와 같이 하나 이상의 메시징 프로토콜들(또는 프로토콜들의 계층)을 사용함으로써 제공될 수 있다. 따라서, 프레임워크는 필요에 따라 디바이스들 사이에서 작업들, 또는 작업들에 필요한 데이터를 효율적으로 전송하기 위한 메커니즘을 제공할 수 있다. 예를 들어, 특정 작업에 필요한 데이터가 특정 디바이스 상에 저장되는 경우, 프레임워크는 그 작업이 그 특정 디바이스로 전송되게 한다. 유사하게, 다른 예에서, 작업이 특정 디바이스 상에 저장되는 경우, 데이터의 필요한 세트가 그 특정 디바이스에 제공될 수 있다.

일부 실시예들에서, 본 명세서에 설명된 프레임워크 및 시스템은 보다 상위 레벨들의 기능성(예를 들어, 애플리케이션들)이 그 상부에 구현될 수 있는 보다 하위 레벨 기판 또는 플랫폼으로서 구현될 수 있다는 것에 유의해야 한다. 또한, 일부 실시예들에서, 프레임워크는 런타임(runtime)(또는 런타임 라이브러리)으로서 구현될 수 있다. 예를 들어, 하나의 실시예에서, 프레임워크는 (예를 들어, C-스타일 프로그래밍 언어를 사용하여) 런타임 시스템으로서 구현될 수 있으며, 컴파일러에 의해 실행가능한 이미지 내에 삽입된 명령어들의 특정 세트로서 구현될 수 있다. 본 명세서에 추가로 설명되는 바와 같이, 프레임워크는 분산 컴퓨팅 시스템 내에서 구현될 수 있다.

도 2는 본 발명의 일 실시예에 따른 예시적인 분산 컴퓨팅 시스템 개요를 도시한 블록도이다. 분산 컴퓨팅 시스템(100)은 통신 채널들(120)을 통해 연결될 수 있는 디바이스들(110)(예를 들어, 디바이스들(110a 내지 110f))을 포함할 수 있다. 하나의 실시예에서, 분산 컴퓨팅 시스템은 디바이스들의 피어-투-피어 네트워크를 포함할 수 있다. 디바이스들(110)(또는 피어 디바이스들)은 임의의 적합한 디바이스일 수 있고, 다양한 디바이스 유형들을 포함할 수 있다. 예를 들어, 디바이스의 "유형"은 예를 들어 스마트폰(예를 들어, 디바이스(110a)), 태블릿(예를 들어, 디바이스(110b)), 텔레비전(예를 들어, 디바이스(110c)), 랩톱(예를 들어, 디바이스(110d)), 스마트워치와 같은 웨어러블 디바이스(예를 들어, 디바이스(110e)), 데스크톱(예를 들어, 디바이스(110f)), VR 헤드셋, 셋톱 박스, 또는 컴퓨팅 디바이스의 임의의 다른 유형을 포함할 수 있는 디바이스의 카테고리에 관한 것일 수 있다. 상이한 유형의 디바이스는 또한 상이한 운영 체제들을 포함하는 상이한 아키텍처들을 갖는 디바이스들을 포함할 수 있다. 상이한 운영 체제들은, 예를 들어, 상이한 변종들(예를 들어, 모바일 변종), 상이한 버전들(예를 들어, 릴리스 번호들), 또는 상이한 플랫폼들(예를 들어, iOS, UNIX, 윈도우즈 등)을 포함할 수 있다. 따라서, 본 명세서에 설명된 바와 같이, 일부 실시예들에서, 시스템은 상이한 운영 체제들을 갖는 디바이스들에 걸쳐 전개될 수 있다. 다른 예에서, 상이한 유형의 디바이스는 또한 프로세서, 메모리 능력들, 저장소 등과 같은 하나 이상의 상이한 컴포넌트들을 갖는 디바이스들을 포함할 수 있다.

통신 채널들(120)은 2개의 피어들 사이의 통신 경로를 포함할 수 있으며, 이를 따라 정보가 전달(또는 전송)될 수 있다. 통신 채널들(120)은, 예를 들어, 물리적 통신 링크(예를 들어, 데이터 전송 케이블)를 포함하는 디바이스들(110) 사이의 임의의 유선 또는 무선 통신 링크, 로컬 영역 네트워크(LAN), 광역 네트워크(WAN), 단거리 통신 링크(예를 들어, 블루투스)일 수 있는 임의의 적합한 유형의 유선 또는 무선 네트워크(예를 들어, WiFi, 셀룰러 등)를 포함하는 네트워크 링크, 또는 이들의 임의의 조합일 수 있다.

도 3은 본 발명의 일 실시예에 따른, 피어 디바이스에 포터블 코드를 제공하는 예시적인 프로세스 흐름을 도시한 블록도이다. 도시된 바와 같이, 구성(300)은 제2 유형의 디바이스(304)(또는 제2 디바이스(304))로부터 제1 유형의 디바이스(302)(또는 제1 디바이스(302))로 포터블 코드를 제공하기 위한 프로세스 흐름을 도시한다. 분산 시스템의 일부로서, 제2 디바이스(304)는 하나 이상의 작업들이 피어 디바이스(예를 들어, 제2 디바이스(304))에 의해 수행되도록 요청할 수 있다. 제2 디바이스(304)는 어떤 피어 디바이스들을 하나 이상의 작업들을 수행하도록 선택할지를 결정할 때 임의의 적합한 정책 또는 특성들의 세트를 사용할 수 있다. 하나의 예에서, 피어 디바이스는 디바이스의 특성들(예를 들어, 프로세싱 전력, 저장소 등), 배터리 소스 또는 연속 전원(즉, 전기 콘센트에 플러그됨)과 같은 현재의 전원, 디바이스의 근접성(예를 들어, 가장 가까운 물리적 디바이스), 네트워크 연결의 유형(예를 들어, 송신 대역폭), 현재 실행 중인 애플리케이션들, 또는 다른 특성들에 기초하여 선택될 수 있다. 다른 예에서, 제2 디바이스(304)는 그것이 제1 디바이스(302)의 사용자와 연관되는지 여부에 기초하여 선택될 수 있다. 예를 들어, 디바이스들의 세트가 동일한 사용자 계정과 연관될 수 있고(예를 들어, 사용자가 2개의 디바이스들 상의 특정 서비스에 로그인됨), 따라서, 작업들이 동일한 사용자와 연관된 디바이스들에 분산될 수 있다.

프로세스 흐름의 일부로서, 제2 디바이스(304)는 하나 이상의 작업들에 대한 계산들(410)의 필요한 세트를 결정할 수 있다. 예를 들어, 이러한 계산들은 작업 요청을 이행하는 데 필요한 출력을 제공할 수 있다. 따라서, 제2 디바이스(304)는, 예를 들어, 결정된 계산들을 수행하기 위한 명령어들 또는 커맨드들(예를 들어, 함수들)을 포함하는 소스 코드(420)를 생성할 수 있다. 제2 디바이스(304)는 제2 디바이스(304)에 고유한 언어를 사용하여 소스 코드를 생성할 수 있다. 상이한 유형들의 디바이스들이 본 명세서에 설명된 바와 같이 작업들을 수행하게 하기 위해, 제2 디바이스(304)는 소스 코드로부터 포터블 코드(430)를 생성할 수 있다. 포터블 코드는 네트워크 내의 피어 디바이스에 의해 컴파일링될 수 있는 임의의 적합한 코드일 수 있다. 하나의 실시예에서, 포터블 코드는 모듈형 및 재사용가능 컴파일러 및 툴체인(toolchain) 기술들의 집합을 포함할 수 있는 LLVM(Low Level Virtual Machine) 기술들을 사용하여 구현될 수 있다. 예를 들어, 하나의 실시예에서, 구현예들은 LLVM IR(intermediate representation)을 포터블 코드로서 사용할 수 있다. 예를 들어, 제2 디바이스(304)는 그의 소스 코드로부터 기계-독립적 중간 코드(예를 들어, LLVM IR)를 생성할 수 있고, 그 중간 코드는 제1 디바이스(302)에 의해 그의 고유 기계 코드로 컴파일링될 수 있다. 또한, 구현예들은 비트스트림 컨테이너 포맷을 생성하고 LLVM IR을 컨테이너 포맷으로 인코딩하는 것을 포함할 수 있는 LLVM 비트코드(또는 바이트 코드)를 사용할 수 있다. 예를 들어, 비트스트림은 본 명세서에 추가로 설명된 바와 같은 포맷으로 구조화된 데이터의 인코딩을 포함할 수 있다. 그의 설계에 의해, LLVM 구현예들은 언어에 구속 받지 않고, 따라서 임의의 적합한 프로그래밍 언어와 함께 사용될 수 있다. 예를 들어, 구현예들은 LLVM(예를 들어, Common Lisp, Delphi, Fortran, OpenGL, Haskell, Java bytecode, Julia, Objective -C, Python, Ruby, Swift 등)을 사용하는 컴파일러들을 이용한 다양한 프론트-엔드 언어들을 사용할 수 있다. 따라서, 수신 피어 디바이스의 타겟 아키텍처로부터의 소스 언어의 디커플링은 전술한 바와 같이 상이한 유형들의 디바이스들 상에서 작업들이 수행되게 한다.

일단 생성되면, 포터블 코드는 제1 디바이스(302)(예를 들어, 다른 피어 디바이스)에 (요청 또는 검색에 의해) 전송될 수 있다. 전술된 바와 같이, 제1 디바이스(302)는 제2 디바이스(304)와 상이할 수 있다(예를 들어, 상이한 운영 체제를 사용함). 일부 실시예들에서, 포터블 코드는 하나 이상의 프로토콜들(예를 들어, 본 명세서에서 추가로 설명되는 바와 같은 제1 레벨 프로토콜(350))을 사용하여 메시지로서 전송될 수 있다. 전통적인 원격 절차 호출(remote procedure call, RPC) 구성에 의해, 디바이스는 전형적으로 이미 원격 절차를 실행하는 데 필요한 임의의 코드를 가져야 한다는 것에 유의하여야 한다. 대조적으로, 도시된 바와 같은 구성(400)에 의해, 제1 디바이스(302)는 작업을 수행하기 위해 포터블 코드(440)를 수신(및 컴파일링)하는 능력만을 요구할 수 있다. 예를 들어, 일부 실시예들에서, 포터블 코드를 수신하기 위해, 제1 디바이스(302)는 그것이 특정 프로세스(예를 들어, 본 명세서에서 추가로 설명되는 바와 같은 데몬(310))를 실행하고 있다는 것만 필요로 할 수 있다. 예를 들어, 프로세스는 포터블 코드를 수신하고, 동적으로 링크시킬 수 있다.

일단 포터블 코드가 수신되면, 제1 디바이스(302)는 포터블 코드(450)를 분석할 수 있다. 수신된 데이터의 실행가능한 특성으로 인해, 제1 디바이스(302)는 보안을 위해 포터블 코드를 분석할 수 있다(예를 들어, 멀웨어, 바이러스, 리소스들에 대한 승인된 액세스, 비신뢰 소스 등). 하나의 실시예에서, 포터블 코드(450)를 분석하는 것은 코드의 제어 흐름 무결성의 검사를 포함할 수 있다. 예를 들어, 제어 흐름 무결성의 검사는, 그것이 디바이스에 의해 허용되지 않는 방식으로 작업의 실행 흐름을 재지향하지 않는 것을 보장하기 위해 코드를 분석함으로써 매우 다양한 허가되지 않은 액세스를 방지하는 것을 포함할 수 있다. 또한, 포터블 코드(450)를 분석할 때, 제1 디바이스(302)는 디바이스들 사이의 신뢰 관계에 따라 다양한 검증 기술들을 채용할 수 있다. 예를 들어, 분석은 포터블 코드가 실행하기에 안전하다는 것을 보장하기 위해 인증서들, 서명들을 검증하는 것, 또는 다양한 암호화 스킴들을 이용하는 것을 포함할 수 있다. 하나의 실시예에서, 시스템은 또한, 본 명세서에 추가로 설명되는 바와 같은 그들 자신의 "샌드박스" 기법들과 같은 빌트인(built-in) 제한 정책들을 갖는 포터블 코드의 변종들 또는 파생어들을 사용할 수 있다. 또한, 일부 실시예들에서, 시스템은 수신 디바이스에 의해 잠재적으로 더 제한적이고 더 효율적으로 분석될 수 있는 보다 상위 레벨의 도메인 특정 언어(DSL)를 사용할 수 있다.

일단 코드가 분석되고 안전한 것으로 간주되면, 시스템은 코드를 컴파일링할 수 있다(460). 하나의 실시예에서, 제2 디바이스(304)는 포터블 코드가 안전하다고 간주되는 것에 응답하여 작업 요청을 수신할 때 하나 이상의 계산이 수행되게 하도록 포터블 코드를 컴파일링할 수 있다. 코드를 컴파일링할 때, 제2 디바이스(304)는 코드의 전부 또는 단지 일부분을 컴파일링할 수 있다. 하나의 실시예에서, 제2 디바이스(304)는 포터블 코드의 전부 또는 일부분을 JIT(just-in-time) 컴파일링할 수 있다. 예를 들어, 제2 디바이스(304)는 작업 요청을 수신한 것에 응답하여 필요한 계산들을 수행하기 위해 포터블 코드의 필요한 부분만을 JIT 컴파일링할 수 있다.

일단 포터블 코드가 컴파일링되면, 제1 디바이스(302)는 작업 요청을 수행하기 위해 계산들을 수행할 수 있다(470). 예를 들어, 계산들은 분산 컴퓨팅 시스템의 일부로서 제2 디바이스(304)를 대신하여 수행될 수 있다. 하나의 실시예에서, 컴파일링된 코드는 데이터를 출력하는 계산을 수행하는 하나 이상의 함수들을 제공할 수 있다. 본 명세서에 추가로 설명되는 바와 같이, 출력된 데이터는 이어서 분산 컴퓨팅 시스템의 일부로서 다른 피어 디바이스들 상에서 수행될 다른 작업들에 대해 사용될 수 있다.

도 4는 본 발명의 일 실시예에 따른 피어 디바이스들의 예시적인 구성을 도시한 블록도이다. 설명된 바와 같이, 구성(400)은 다수의 협력 디바이스들(또는 피어들)을 포함할 수 있다. 도시된 바와 같이, 구성(400)은 도 3에 도시된 바와 같이 제1 유형의 디바이스(302)(제1 디바이스(302)) 및 제2 유형의 디바이스(304)(제2 디바이스(304))를 포함할 수 있다. 하나의 실시예에서, 제1 디바이스(302)는 전술된 바와 같이 제2 디바이스(304)와는 상이한 유형의 디바이스일 수 있다. 하나의 실시예에서, 프레임워크는 컴포넌트들의 계층구조를 포함할 수 있다. 하나의 실시예에서, 프레임워크는 제1 레벨(예를 들어, 상위 레벨) 데몬(310)을 포함할 수 있다. 본 명세서에서 언급된 바와 같이, 데몬(310)은 데몬(310)이 상주하는 디바이스(또는 호스트 디바이스) 상에서 프로세스(예를 들어, 백그라운드 프로세스)를 실행할 수 있는 프로세스(또는 모듈, 프로그램, 애플리케이션, 객체, 컴포넌트 등)를 포함할 수 있다.

하나의 실시예에서, 데몬(310)은 제1 유형의 디바이스(302)와 제2 유형의 디바이스(304) 사이의 네트워크 연결들을 (예를 들어, 통신 채널(120)을 통해) 관리할 수 있다. 데몬(310)은 제2 유형의 디바이스(304) 상에 호스팅되는 다른 데몬(310)과 통신함으로써 네트워크 연결을 관리할 수 있다. 하나의 실시예에서, 디바이스들은 제1 레벨 프로토콜(350)(또는 데몬 레벨 프로토콜)을 사용하여 액세스 연결을 생성하기 위해 서로 통신할 수 있다. 하나의 실시예에서, 디바이스는 물리적 디바이스 당 단일의 액세스 연결을 호스팅할 수 있고, 이어서, 디바이스는 다수의 액세스 연결들을 갖는 다수의 디바이스들을 호스팅할 수 있다.

하나의 실시예에서, 디바이스에 대한 액세스 연결이 데몬(310)에 의해 허가된 후(예를 들어, 디바이스(302)가 디바이스(304)에 대한 액세스를 허가했거나, 그 역으로도 성립함), 각각의 데몬(310)은 각각의 호스트 디바이스 상에 워커(320)(또는 워커(320)의 인스턴스)를 생성할 수 있다. 본 명세서에서 언급되는 바와 같이, 워커(320)는 데이터를 관리하고 본 명세서에 추가로 설명되는 바와 같이 작업들을 수행하기 위한 프로세스(또는 모듈, 프로그램, 애플리케이션, 객체, 컴포넌트 등)를 포함할 수 있다. 일부 실시예들에서, 워커(320)는 데몬(310)의 서브 프로세스 또는 서브 모듈로서 구현될 수 있다. 하나의 실시예에서, 워커(320)는 제2 레벨 프로토콜(355)(예를 들어, 워커 레벨 프로토콜)을 사용하여 다른 디바이스들 상에 생성된 다른 워커들(320)과 통신할 수 있다. 따라서, 워커(320)(또는 데몬(310))는 데이터를 저장 및 관리하는 것, 작업들의 실행을 스케줄링하는 것, 및 필요에 따라 다른 동작들을 포함하는 그의 각각의 디바이스(예를 들어, 호스트 디바이스)의 동작들을 조정할 수 있다. 하나의 실시예에서, 디바이스는 추가적인 보안 층을 제공하기 위해 그의 각각의 워커들(320)을 "샌드박스"할 수 있다. 예를 들어, "샌드박스"는 워커(320)가 그의 각각의 호스트 디바이스 상에서 액세스하도록 허용되는 리소스들(예를 들어, 데이터, 메모리 어드레스들, 프로세스들, 특징부들 등)을 구획화하는 것을 포함할 수 있다. 하나의 실시예에서, "샌드박스"는 데몬(310)에 의해 집행될 수 있다. 하나의 실시예에서, 워커(320)는 데이터 저장소(340) 및 웨이터(waiter) 세트(345)를 포함할 수 있는 상태 정보(330)와 연관될 수 있다. 워커들(320)은 상태 정보(330)를 다른 워커들과 공유할 수 있거나, 또는 각각의 워커는 상태 정보(330)의 자신의 인스턴스와 연관될 수 있다.

실시예들은 액세스 연결들을 관리하고 디바이스들 사이의 통신을 관리하기 위해 전술된 구성과는 상이한 구성들을 가질 수 있다는 것에 유의해야 한다. 예를 들어, 하나의 실시예에서, 데몬 프로세스(310)는 또한 디바이스들 사이의 통신들(예를 들어, 전술된 바와 같이 워커(320)에 의해 핸들링된 통신들)을 직접 관리할 수 있다. 또한, 다른 프로세스들, 서브 프로세스들, 애플리케이션들, 객체들 등은 또한 본 명세서에 설명된 바와 같이 프레임워크를 구현하는 데 활용될 수 있다.

도 5는 본 발명의 일 실시예에 따른, 피어 디바이스들 사이의 메시징 프로세스 흐름을 도시한 도면이다. 설명된 바와 같이, 피어 디바이스들 간에 통신할 때, 프레임워크는 프로토콜들의 계층구조를 사용할 수 있다. 도 3에 도시된 바와 같이, 예시적인 메시징 흐름은 제1 디바이스(302)(제1 유형의 디바이스(302)) 및 제2 디바이스(304)(제2 유형의 디바이스(304))를 포함할 수 있다. 하나의 실시예에서, 제2 디바이스(302)는 액세스 연결 생성 메시지(510)를 제1 디바이스(304)(예를 들어, 호스트 디바이스)로 전송할 수 있다. 액세스 연결 생성 메시지(510)를 수신하는 것에 응답하여, 제1 디바이스(304)는 워커(515)(예를 들어, 워커(320))를 생성할 수 있다. 하나의 실시예에서, 액세스 연결 생성 메시지(510)는 하나 이상의 작업들을 수행하기 위한 포터블 코드를 포함할 수 있다. 또한, 제1 디바이스(304)는 액세스 연결 확인 메시지(520)를 제공할 수 있다. 하나의 실시예에서, 액세스 연결 생성 메시지(510) 및 액세스 연결 확인 메시지(520)는 제1 레벨 프로토콜(예를 들어, 제1 레벨 프로토콜(350))에 부합할 수 있고, 본 명세서에 추가로 설명되는 바와 같은 하나 이상의 미리 정의된 커맨드들을 포함할 수 있다. 또한, 하나의 실시예에서, 메시지들(510 및 520)은 각각 개개의 디바이스 상의 데몬(310)에 의해 관리될 수 있다.

하나의 실시예에서, 워커(예를 들어, 워커(320))가 생성되면, 제1 디바이스(304)(또는 생성된 워커)는 제2 레벨 프로토콜(355)에 부합하는 메시지들을 수신할 수 있다. 이는 제2 디바이스(304)로부터의 제1 작업 요청 메시지(530)를 포함할 수 있다. 제1 작업 요청 메시지(530)는 본 명세서에 추가로 설명되는 바와 같이 제2 레벨 프로토콜(355)에 대한 메시징 커맨드들의 하나 이상의 미리정의된 세트를 포함할 수 있다. 제1 디바이스(304)가 제1 작업 요청(530)을 수신하는 것에 응답하여, 제1 디바이스(304)는 제1 작업을 수행하는 데 필요한 데이터(535)를 획득할 수 있다. 본 명세서에 추가로 설명되는 바와 같이, 제1 디바이스(304)가 (예를 들어, 제1 디바이스(304)의 데이터 저장소에 저장된) 데이터에 대한 액세스를 갖는 경우, 제1 디바이스는 제1 작업(550)을 수행하도록 진행할 수 있다. 필요한 데이터가 예를 들어 데이터 저장소에 저장되어 있지 않은 경우, 제1 디바이스(304)는 필요한 데이터를 출력하기 위해 (예를 들어, 큐(queue) 내에 있는) 제2 작업을 수행할 수 있다. 다른 예에서, 제1 디바이스(304)는 제3 디바이스(506)로부터 데이터를 검색할 수 있다. 예를 들어, 이것은 데이터 메시지(536)에 대한 요청을 제3 디바이스(506)에 전송하는 것을 포함할 수 있다. 따라서, 제1 디바이스(304)는 분산 컴퓨팅 시스템의 일부로서, 제3 디바이스(304)에 의해 제공된 메시지 내에서 데이터(537)를 수신할 수 있다. 일단 필요한 데이터가 제1 디바이스(304)에 의해 획득되면, 제1 디바이스는 제1 작업(550)을 수행할 수 있다. 또한, 분산 컴퓨팅 시스템의 일부로서, 제1 디바이스(304)는 이어서 제1 작업으로부터의 출력 데이터를 다른 피어 디바이스(예를 들어, 제4 디바이스(508))에 전송할 수 있다. 예를 들어, 제4 디바이스(508)는 제1 디바이스(304)에 대해, 전술된 바와 같이 작업을 수행하기 위한 데이터를 요구할 수 있다.

설명된 바와 같이, 메시징 프로토콜들(제1 레벨 프로토콜(350) 및 제2 레벨 프로토콜(355))은 도 6 및 도 7의 예시적인 실시예들에서, 그리고 도 5를 참조하여 도시된 바와 같이 메시징 커맨드들의 미리정의된 세트를 포함할 수 있다. 도 6은 본 발명의 일 실시예에 따른, 제1 레벨 메시지(600)(예를 들어, 데몬 레벨 메시지)에 대한 예시적인 구조를 도시한 도면이다. 예를 들어, 제1 레벨 메시지(600)는 페이로드(615)가 뒤따르는 커맨드(610)를 포함할 수 있다. 일부 실시예들에서, 프레임워크는 또한 커맨드의 크기(예를 들어, 32 비트 정수)를 특정할 수 있다. 도시된 바와 같이, 커맨드들은 워커를 생성하라는 커맨드(예를 들어, CREATE), 생성 커맨드가 실패했다는 표시(예를 들어, CREATE FAILED), 워커에 조인하라는 커맨드(예를 들어, JOIN), 생성 또는 조인 커맨드가 성공적이었다는 확인(예를 들어, CREATE/JOIN OK), 및 피어 디바이스가 미지의 워커에 조인하려고 시도하고 있다는 표시(예를 들어, UNKNOWN WORKER)를 포함할 수 있다.

예를 들어, 워커 생성(예를 들어, CREATE) 커맨드는 제1 디바이스(304)(또는 데몬(310))에게 워커(515)를 생성하도록 지시할 수 있는 워커 생성 메시지(510) 내에 포함될 수 있다. 워커 생성 커맨드의 페이로드는 전술한 바와 같이 포터블 코드(예를 들어, LLVM IR)를 포함할 수 있다. 디바이스(예를 들어, 제1 디바이스(304))는 코드를 분석할 수 있고, 일단 포터블 코드가 안전하다고 간주되면, 포터블 코드를 실행가능한 형태로 컴파일링할 수 있다. 예를 들어, 컴파일링된 코드는 작업을 위한 하나 이상의 계산들을 수행하기 위한 하나 이상의 함수들을 포함할 수 있다. 하나의 실시예에서, 포터블 코드로부터 제공되는 설정 함수들은 함수들의 대응하는 테이블 또는 인덱스(예를 들어, func_table)를 포함할 수 있다. 예를 들어, 테이블 또는 인덱스는 작업을 수행하도록 워커에 의해 호출될 수 있는 작업 엔트리 포인트들에 대응하는 함수 포인터들의 어레이에 대한 포인터로서 취급될 수 있다. 일단 포터블 코드가 성공적으로 컴파일링되면, 데몬은 생성된 워커에 식별자(ID)를 할당하고 ID를 확인 메시지(예를 들어, CREATE/JOIN OK) 내에 페이로드로서 반환할 수 있다. 예를 들어, 확인은 제2 디바이스(302)로 전송되는 액세스 연결 확인 메시지(520) 내에전송될 수 있다. 생성이 성공적이지 않은 경우(예를 들어, 코드가 안전하지 않은 것으로 간주되는 경우), 디바이스는 실패에 대한 이유를 나타내는 이유 코드(예를 들어, CREATE FAILED)가 수반되는, 그러한 고장을 나타내는 커맨드를 이용해 응답할 수 있다.

또한, 커맨드들은 다른 디바이스가 기존의 워커에 대한 새로운 연결로서 추가될 수 있게 하는, 워커로의 조인 또는 연결 커맨드(예를 들어, JOIN)를 포함할 수 있다. 인식되지 않는 워커 ID에 대해 조인 커맨드가 수신되는 경우, 디바이스(예를 들어, 제1 디바이스(304))는 UNKNOWN WORKER 커맨드를 이용해 응답할 수 있다. 그렇지 않으면, 디바이스는 CREATE/JOIN OK 커맨드를 이용해 요청에 확인응답할 수 있다. 디바이스가 생성 또는 조인 커맨드를 성공적으로 처리한 후에, 생성된 워커는 생성된 액세스 연결을 통해 수신된 작업들 및 데이터를 관리할 수 있다. 예를 들어, 워커는 제2 레벨 프로토콜(355)(예를 들어, 워커 레벨 프로토콜)에 부합하는 메시지들을 관리할 수 있다.

도 7은 본 발명의 일 실시예에 따른, 제2 레벨 메시지(650)(예를 들어, 워커 레벨 메시지)에 대한 예시적인 구조를 도시한 도면이다. 예를 들어, 제2 레벨 메시지(650)(예를 들어, 워커 레벨 메시지)는 페이로드(665)가 뒤따르는 커맨드(660)를 포함할 수 있다. 이러한 예에 도시된 바와 같이, 워커 레벨 커맨드들은 데이터 전송(예를 들어, PUSH), 데이터 검색(예를 들어, FETCH), 작업 요청(예를 들어, JOB), 데이터 삭제(예를 들어, DELETE), 및 워커 제거(예를 들어, DESTROY)를 포함할 수 있다.

전송(예를 들어, PUSH) 커맨드가 수신 데이터 메시지(537) 내에 포함되고 데이터를 다른 피어로 전송하는 데 사용될 수 있다. 예를 들어, 워커가 전송 커맨드를 수신하는 경우, 그의 페이로드는 데이터 저장소에 추가되는 데이터 ID k 및 컨테이너(x)를 포함할 수 있다:

D ← D ∪ (k, x).

따라서, 워커 세트(W)의 각각의 요소는 이어서 모든 의존성들이 만족되는 서브 세트(W 0 ⊆ W)를 찾기 위해 검토될 수 있고, 이어서 이들은 제거된다:

W ← W＼W 0.

W 0 내의 이제 차단해제된 동작들은 실행을 위해 그들 각각의 큐들 상에 배치된다.

검색(예를 들어, FETCH) 커맨드가 요청 데이터 메시지(536) 내에 포함될 수 있고, 전송 커맨드(예를 들어, PUSH)의 반대로서 설명될 수 있다. 예를 들어, 워커는 피어에게 데이터 ID k를 갖는 검색 커맨드를 발행하여 피어에게 k에 대응하는 컨테이너(x)를 전송하라고 요청한다. 따라서, 이러한 유형의 메시지가 수신되는 경우, 먼저 워커는 요청된 데이터 ID에 대응하는 컨테이너가 데이터 저장소(예를 들어, 워커에 대응하는 디바이스의 로컬 데이터 저장소)에 이미 저장되어 있는지 여부를 결정한다. 컨테이너가 이미 데이터 저장소에 저장되어 있는 경우, 워커는 직렬 전송 큐를 통해 전송하기 위해 전송 메시지(예를 들어, PUSH)를 스케줄링함으로써 그것을 요청 피어에게 다시 제공할 수 있다. 요청된 데이터 ID가 데이터 저장소 내에 이미 저장되어 있지 않은 경우, 웨이터 세트는 업데이트될 수 있다. 예를 들어, 업데이트된 웨이터 세트는 다음과 같이 표현될 수 있다:

W ← W ∪({k}, q _s , send(p, k, ·))

여기서 p는 데이터를 요청하는 피어에 대한 연결이고, 전송(p, k, x)은 연결(p)을 통해 전송될 수 있는 페이로드(k, x)를 갖는 전송 메시지를 제공하는 함수이다.

작업 요청 커맨드(예를 들어, JOB)가 피어로 전송되어 피어에게 일부 워크(work)를 수행하라고 요청할 수 있다. 예를 들어, 작업 요청 커맨드는 도 5에 도시된 바와 같이 제1 작업 요청 메시지(530) 내에 포함될 수 있다. 하나의 실시예에서, 작업 메시지의 페이로드는 도 1a 및 도 1b와 관련하여 전술된 바와 같이 추상적인 계산 그래프 내의 작업 노드의 연결성을 설명할 수 있다. 하나의 실시예에서, 페이로드는: 작업에서 전제조건들로서 요구하는 입력 데이터 ID들의 리스트(K _in); 작업이 실행을 완료할 때 생성될 데이터 ID들의 리스트(K _out); 및 포터블 코드로부터 획득된 엔트리 포인트들의 인덱스(예를 들어, func_ table) 어레이 내로의 인덱스일 수 있는 함수 인덱스(j)를 포함할 수 있다. 예를 들어, 엔트리 포인트들은 작업을 위한 계산을 수행하기 위해 컴파일 포터블 코드로부터 제공되는 함수들에 대응할 수 있다.

데이터 검색에서와 같이, 작업 요청을 수신하는 경우, 워커는 먼저 입력 의존성들이 이미 만족되는지를 알아보기 위해 검사할 수 있고, 만약 그렇다면, 병렬 워크 큐(concurrent work queue) 상에 실행을 위한 엔트리 포인트를 스케줄링할 수 있다. 작업이 차단되는 경우, 그것은 웨이터로서 추가될 수 있다:

W ← W ∪ (Ki_n , qw _, func_table [j]).

하나의 구현예에서, 워크 큐 상의 항목들은 동시에 실행될 수 있다. 이러한 동시 실행은 시스템이 작업 구현들에서 순도(purity)의 수준을 보장하는 것으로 인해 효율적인 방식으로 제공될 수 있다. 이는 동시에 실행되고 있을 수 있는 작업 실행이 서로에 대해 구속 받지 않도록 유지할 수 있게 한다. 따라서, 작업이 완료될 때, 그것은 하나 이상의 출력 컨테이너들에 저장될 데이터를 생성할 수 있다. 따라서, 시스템은 이들을 데이터 저장소에 추가하고, 그러한 데이터를 대기하고 있는 임의의 웨이터들을 차단해제할 수 있다. 따라서, 마치 네트워크 상에 수신된 새롭게 생성된 컨테이너들과 같이, 전송 데이터 커맨드들이 수신 큐를 통해 호출될 수 있다. 따라서, 하나의 실시예에서, 프레임워크는 워커의 상태를 조작하기 위해 직렬 수신 큐만을 허용할 수 있다.

데이터 삭제(예를 들어, DELETE) 커맨드는 특정 ID k′를 갖는 데이터를 그의 데이터 저장소로부터 삭제하도록 워커에게 지시할 수 있다:

D ← {(k, x) ∈ D | k ／= k′}.

메시지가 수신될 시점에 데이터가 데이터 저장소에 있지 않은 경우, 커맨드는 아무것도 하지 않는다. DELETE 커맨드가 반드시 웨이터로서 큐잉될 필요가 없음에 유의해야 한다.

워커와 함께 그의 연관된 데이터가 더 이상 요구되지 않는 경우, 워커 제거(예를 들어, DESTROY) 커맨드가 워커에 제공될 수 있다. 따라서, 이러한 커맨드는, 시스템이 워커가 호스트 디바이스 상에서 점유하고 있는 리소스들을 릴리스하고자 할 때 사용될 수 있다. 이는, 웨이터 세트가 비워지고 전송 및 워크 큐들 상의 모든 스케줄링된 동작들이 완료될 때까지 워커가 대기하므로 매우 좋은 이그짓(exit)으로 특징지어질 수 있다. 따라서, 하나의 구현예에서, 일단 destroy 커맨드가 발행되면, 미래의 PUSH 또는 JOB 커맨드들은 수용되지 않을 수 있다.

전술된 바와 같은 커맨드 명칭들은 예들이고, 동등한 기능들을 갖는 다른 커맨드 명칭들(예를 들어, "new" 커맨드와 동등한 "create" 커맨드 등)이 또한 실시예들 내에서 고려된다는 것에 유의해야 한다.

도 4와 관련하여 위에서 논의된 바와 같이, 워커(예를 들어, 워커(320))는 상태(D, W)로서 저장될 수 있는 상태 정보(330)를 유지할 수 있다. 상태는 데이터 저장소(D)(예를 들어, 데이터 저장소(340)) 및 웨이터 세트(W)(예를 들어, 웨이터 세트(345))를 포함할 수 있다. 하나의 실시예에서, 데이터 저장소는 데이터 ID들을 컨테이너들에 매핑하는 연관 어레이일 수 있다. 따라서, 데이터가 네트워크를 통해 수신되거나 호스트에 의해 수행되는 작업에 의해 생성될 때, 데이터는 데이터 저장소에 저장될 수 있다. 하나의 구현예에서, 데이터 저장소는 키(id k) 값(컨테이너(x)) 쌍들의 세트로서 모델링될 수 있다.

D = {(k ₁ , x ₁),..., (k _n , x _n )}.

웨이터 세트는 워커가 하나 이상의 컨테이너들이 이용가능해질 때까지 수행할 수 없는 동작들(예를 들어, 계산들)을 포함할 수 있다. 이것은 작업 노드들 및 다른 피어들에 의해 이루어진 데이터에 대한 요청들을 포함할 수 있다. 따라서, 하나의 구현예에서, 이는 웨이터들의 세트로서 모델링될 수 있다.

W = {w ₁ ,..., w _m }.

하나의 구현예에서, 웨이터(wi)는 입력 의존성들의 세트, 의존 동작, 및 의존성들이 만족되면 동작을 수행하도록 하는 실행 큐를 포함하는 트리플일 수 있다. 예를 들어, 작업을 실행하기 전에 컨테이너들(x _a , x _b , 및 x _c )을 필요로 하는 작업은 다음과 같이 표현되는 웨이터일 수 있다:

w = ({k _a , k _b , k _c }, q, f)

여기서, k _a,b,c 는 3개의 입력들에 대응하는 데이터 ID들이고, f (·, ·, ·)는 적절한 컨테이너를 구비할 때 필요한 작업을 수행할 수 있는 함수이고, q는 f (x _a , x _b , x _c )를 계산할 수 있는 실행 큐이다.

하나의 실시예에서, 워커는 직렬 수신 큐(serial receive queue, qr); 직렬 전송 큐(serial send queue, qs); 및 병렬 워크 큐(qw)를 포함할 수 있는 3개의 실행 큐들과 연관될 수 있다. 하나의 실시예에서, 실행 큐들 중 하나 이상은 실행의뢰된(submitted) 태스크들(예를 들어, 작업들)을 관리하는 객체 구조일 수 있는 디스패치 큐(예를 들어, libdispatch 큐)로서 구현될 수 있다. 하나의 구현예에서, 디스패치 큐는 선입선출 데이터 구조일 수 있고, 따라서 실행의뢰된 태스크들은 그들이 큐에 추가된 동일한 순서로 수행될 수 있다. 하나의 실시예에서, 디스패치 큐들은 호출자(예를 들어, 워커)에 대해 비동기식으로 또는 동기식으로 코드의 임의의 블록들을 실행할 수 있다. 예를 들어, 디스패치 큐들은 전형적으로 별개의 스레드들 상에서 수행될 수 있는 태스크들을 수행하는 데 사용될 수 있다. 예를 들어, 일부 구현예들에서, 디스패치 큐의 하나의 이점은 그들이 대응하는 포스(threaded code)보다 관리하기가 더 단순하거나 태스크들을 실행하는 데 있어서 더 효율적일 수 있다는 것이다.

전술된 바와 같이, 인입 메시지들은 그들이 직렬 수신 큐에 의해 수신되는 순서로 처리될 수 있다. 따라서, 워커는 상태(D, W)를 업데이트하고, 후술되는 바와 같은 커맨드들을 사용하여 이러한 메시지들과의 동작들을 수행할 수 있다.

전술된 바와 같이, 데이터 노드들은 작업에 요구될 수 있는 정보를 포함한다. 데이터는 임의의 적합한 포맷으로 구조화될 수 있다. 일부 실시예들에서, 데이터 노드는 작업을 실행하는 데 필요한 정보를 캡슐화하는 컨테이너로서 구현될 수 있다. 단일 컨테이너는 작업에 의해 요구되는 데이터를 전부 포함할 수 있거나, 또는 데이터는 여러 개의 컨테이너들에 걸쳐 분할될 수 있다. 따라서, 데이터 노드는 고유 식별자 및 대응하는 컨테이너를 가질 수 있다. 또한, 데이터 노드에 대한 식별자를 알고 있지만, 로컬적으로 저장된 대응하는 컨테이너를 갖지 않는 피어는 그의 값 상에 플레이스홀더(또는 퓨처(future))를 가질 수 있다. 따라서, 데이터는 계산을 어셈블리화할 때 참조될 수 있고, 작업들은 구체화된(materialized) 컨테이너가 필요할 때까지 계속 진행될 수 있다. 따라서, 전술된 구성들은 시스템 내의 피어들 사이의 레이턴시의 영향을 완화할 수 있고, 일단 컨테이너가 존재하면, 그것은 다른 피어들에 복제될 수 있다(예를 들어, 일시적으로).

설명된 바와 같이, 데이터는 컨테이너 구조를 사용하여 시스템 내에 분배될 수 있다. 하나의 실시예에서, 컨테이너 구조는 본 명세서에 추가로 설명되는 바와 같이 바디(body) 및 0개 이상의 익스텐트들(extent)을 포함할 수 있다. 바디는 루트 객체로서의 역할을 할 수 있고 알려진 길이를 갖는 메모리의 연속적인 어레이일 수 있다. 바디는 원시 데이터 유형들(또는 그의 집합체들)을 저장할 수 있다. 하나의 실시예에서, 컨테이너 구조의 구현은 포인터들(예를 들어, C-스타일 프로그래밍 언어들)의 광범위한 사용을 행하는 언어들을 프로그래밍하는 것을 고려할 수 있다. 포인터는 특정 프로그램의 문맥에서는 유의미할 수 있지만, 그것은 전형적으로 런타임에 의해 사용될 때 의미론(semantics)을 포함하지 않는다. 예를 들어, 포인터가 하나의 아이템 또는 어레이를 가리키는지, 또는 포인터가 가리키는 객체가 어떻게 할당되었는지, 또는 객체 레퍼런스가 실행, 수정 등을 하기에 안전한지 여부가 알려지지 않을 수 있다. 컨테이너는 피어들 사이에서 전달될 수 있으며, 따라서, 그 내부의 데이터가 직렬화되고 명확한 소유권을 가질 수 있는 것이 필요할 수 있다. 베어 포인터(bare pointer)들에 의한 결함들로 인해, 하나의 실시예에서, 컨테이너의 바디 내에 나타나는 임의의 포인터들이 익스텐트에 대응할 수 있고, 연관된 익스텐트 기록을 가질 수 있다. 예를 들어, 익스텐트 기록이 베어 포인터에 대한 누락된 의미론을 제공할 수 있다. 익스텐트들의 유형들은 특정 사용 사례에 기초하여 제공될 수 있다. 예를 들어, 익스텐트 유형은 디스패치 블랍(dispatch blob)들 및 객체들을 포함할 수 있다. 디스패치 블랍은 디스패치(예를 들어, libdispatch)에 사용되는 관리된 데이터 객체일 수 있다. 이들은 레퍼런스-카운트된 객체(reference-counted object)일 수 있으며, 그의 기본 관리는 libdispatch 런타임에 의해 수행될 수 있다. 객체(예를 들어, objective-C 객체)는 런타임(예를 들어, Objective-C 런타임)에 의해 관리될 수 있고, 또한 레퍼런스-카운트될 수 있다. 전형적으로, 이들 익스텐트들의 메모리 크기는 시스템에 알려지지 않지만, 예를 들어, 클래스의 인스턴스들이 인코딩되고 디코딩될 수 있음을 선언하는 프로토콜의 구현을 이용하여 또한 결정될 수 있다(예를 들어, NSCoding). 따라서, 이는 클래스가 이들 익스텐트들을 직렬화(serialize)하고 역직렬화(deserialize)할 수 있게 한다.

하나의 실시예에서, 컨테이너는 컨테이너의 크기 및 소유권을 설명하는 헤더를 포함하는 메모리의 연속 블록으로서 저장될 수 있다. 이를 바디가 뒤따르고 이어서 익스텐트 기록이 뒤따를 수 있다. 예를 들어, C-스타일 프로그래밍 언어를 사용하여, 헤더는 다음의 포맷을 가질 수 있다:

typedef struct {

uint64_t body_size;

uint64_t extent_count;

void (*destructor)(void*); char body[];

} octopus_header_t;

따라서, body_size 는 바이트들 내의 컨테이너의 바디의 길이에 대응할 수 있고; extent_count 는 익스텐트 기록들의 수에 대응하고, 따라서 바디에서 나타나는 포인터들의 수에 대응할 수 있고, destructor는 완료 시에 컨테이너를 파괴하는 방식에 대해 시스템에게 통지하는 함수 포인터에 대응할 수 있다. 또한, 헤더의 단부에서의 탄력적 어레이 바디는 플랫 바디 어레이(flat body array) 및 익스텐트 테이블을 포함할 수 있다. 바디 어레이는 런타임 레벨에서 형식화되지 않을 수 있지만, 익스텐트 기록들은 다음의 C-스타일 프로그래밍 언어 유형에 부합할 수 있다:

typedef struct {

unsigned long offset : 56;

unsigned char type : 6;

} octopus_extent_t;

enum { EXTENT_TYPE_BLOB=1, EXTENT_TYPE_OBJC=2 };

여기서 offset 은 대응하는 포인터가 어디에 위치하는지를 나타낼 수 있고, 바디 어레이의 시작으로부터 바이트 단위로 측정된다.

일 예로서, 아래에 나타낸 것은 Objective-C struct 유형 Foo이다:

struct Bar {

int32_t val;

NSString* name;

};

struct Foo {

uint64_t x;

float y[6];

dispatch_data_t blob;

struct Bar z;

};

도 8은 본 발명의 일 실시예에 따른 예시적인 데이터 컨테이너를 도시한 도면이다. 컨테이너는 바디 크기(721), 익스텐트 카운트(722), 바디(723), 및 익스텐트 기록들(724)을 포함할 수 있다. 이 예에 도시된 바와 같이, 도면은 본 발명의 하나의 실시예에 따라 유형 Foo의 데이터가 데이터 컨테이너(720) 내에서 구조화될 방식을 보여준다. 따라서, 멤버 Foo.blob은 libdispatch 블랍에 대응하고(예를 들어, dispatch_data_t는 불투명 유형 struct dispatch_data_s에 대한 포인터로서 형식화됨), Foo.bar.name은 유형 NSString의 Objective-C 객체에 대한 포인터에 대응할 수 있다. 따라서, 이들 포인터들 둘 모두는 익스텐트 기록들을 필요로 할 수 있다. 이 예에 도시된 바와 같이, 유형 Foo에 대한 컨테이너 레이아웃은 연속적인 바디 어레이로부터 구성될 수 있다. 따라서, 바디 내에 나타나는 임의의 포인터들은 메모리 내의 분리 영역(disjoint region)들을 가리킬 수 있고, 대응하는 객체의 특성들을 설명하는 수반되는 익스텐트 기록을 가질 수 있다.

도 9는 본 발명의 일 실시예에 따른, 데이터 컨테이너(예를 들어, 컨테이너(720)) 내의 선형화된 데이터의 예를 예시한 도면이다. 하나의 구현예에서, 시스템은 파일 또는 네트워크 연결과 같은 스트림-유사 디바이스에 컨테이너를 기록하는 것의 직렬화를 수행할 수 있다. 컨테이너들에 저장될 수 있는 것에 대한 제한들로 인해, 그들의 직렬화는 시스템에 의해 효율적으로 구현될 수 있다. 예를 들어, 컨테이너의 헤더, 바디 및 익스텐트 테이블은 메모리(730)의 연속적인 어레이일 수 있고, 따라서, 이미 직렬화된 상태에 있을 수 있다. 또한, 임의의 익스텐트들이 있는 경우, 이들은 다른 메모리 위치들에 저장될 수 있고, 따라서, 플랫 어레이로 변환되고 바디에 첨가될 필요가 있을 수 있다. 이는 익스텐트의 유형에 따라 행해질 수 있다.

전술된 바와 같이, 시스템 내의 작업 노드는 0개 이상의 데이터 노드들을 하나 이상의 다른 데이터 노드들로 변환할 수 있다. 따라서, 작업에 대한 입력 전제조건들이 작업 노드가 실행될 수 있기 전에 계산될 수 있다.

하나의 구현예에서, 시스템은 작업 노드들이 순수한 함수들을 표현하는 경우 실행을 최적화하기 위해 증가된 유연성을 가질 수 있다. 예를 들어, 이는 작업의 출력들이 그의 입력들에만 의존할 수 있는 것을 포함할 수 있다(예를 들어, 부수 효과들(side-effects)이 없음). 예를 들어, 표준 C 라이브러리에서, 함수

float sin(float x)

는 그의 반환값이 x의 값에만 의존하기 때문에 순수하다. 다른 한편으로는,

void* malloc(size_t size)

는 그의 반환값이 사이즈의 값뿐만 아니라 하부 플랫폼의 메모리 상태에도 의존하기 때문에 순수하지 않다. 또한, 할당이 성공하면, 히프(heap)가 호출 후에 상이할 것이라는 사실로 인한 부수 효과들을 갖는다.

전형적으로, 순수 작업들은 계산의 출력을, 계산에 대한 설명과 함께 그 입력 값들로의 교환을 가능하게 하는 참조 투명성(referential transparency)을 제공한다. 전술한 바와 같이, 데이터 노드들은 플레이스홀더로서 명명된, 그러나 구체화되지 않은 데이터 노드들을 사용할 수 있다. 이는 참조 투명성으로 인해 가능하다(예를 들어, 클라이언트는 그의 출력 값 대신에 계산의 설명을 사용할 수 있음).

설명된 바와 같이, 작업은 시스템 내에서 워크를 수행할 수 있다. 하나의 실시예에서, 작업은 2개의 전달인자들(arguments)을 수용하는 엔트리 포인트로서 단일 함수를 가질 수 있다. 예를 들어, C-스타일 프로그래밍 언어 구현에서, 작업은 다음과 같은 엔트리 포인트를 포함할 수 있다:

typedef void (octopus_job_func*)(

const octopus_header_t** inputs,

octopus_header_t** outputs

);

이 예에서, 제1 전달인자는 작업 노드로의 n개의 정렬된 입력들을 나타내는 데이터 컨테이너들의 어레이이다. 이 예에서, 이들은 상수들로서 처리되어야 하며, 작업에 의해 수정되지 않을 수 있다. 제2 전달인자는 m개의 빈 컨테이너들의 어레이이다. 이는 오버라이팅(overwrite)되도록 의도된 출력들에 대한 목적지일 수 있다. 관계차수들(cardinalities) m 및 n은 암시적일 수 있다. 다시 말하면, 시스템은 이들이 작업 구현자에게 정적으로 알려진 것으로 가정할 수 있다. 일 예로서, 2개의 어레이들에서 바이트 값들을 평균화하는 함수를 고려한다.

dispatch_data_t blend(dispatch_data_t im1,

dispatch_data_t im2)

이는 동일한 길이의 바이트 어레이들을 포함하는 입력들로서 2개의 libdispatch 블랍들을 취하고, 2개 입력들의 평균을 포함하는 블랍을 반환한다. 시스템이 이러한 동작을 수행할 때, 시스템은 먼저 작업의 토폴로지를 결정할 수 있다. 작업이 정확히 하나의 출력을 갖는다고 결정될 수 있지만, 시스템은 얼마나 많은 입력들이 요구되는지를 결정할 필요가 있을 수 있다. 전술된 바와 같이, 데이터 컨테이너는 하나 초과의 값을 보유할 수 있다. 따라서, im1 및 im2 둘 모두를 포함하는 단일 입력 컨테이너가 있을 수 있거나, 이들은 2개의 입력들로 분할될 수 있다.

도 10은 본 발명의 실시예에 따른, 1개 또는 2개의 컨테이너들을 사용하는 블렌드 함수의 예를 도시한 도면이다. 도시된 바와 같이, 토폴로지들은 하나의 컨테이너(820), 또는 2개(또는 그 이상)의 컨테이너(830)들의 사용을 포함할 수 있다. 작업 토폴로지들의 선택은 보다 상위 레버 애플리케이션에 의해 결정될 수 있다. 예를 들어, 2개의 입력들이 있는 경우, 관리하기에 보다 복잡한 계산 그래프의 비용이 들지만, 입력 객체들이 생성될 수 있는 위치 및 시간에 보다 많은 유연성이 있다. 예로서, 작업에 2개의 입력 객체들이 있는 제2 작업 토폴로지가 선택되는 경우(예를 들어, 830); 다음의 코드는 작업 엔트리 포인트 내부에 제공된 블렌드의 예시적인 구성이다.

void blend_job(

const octopus_header_t** inputs,

octopus_header_t** outputs)

{

// Extract input data

dispatch_data_t im1 = (dispatch_data_t)inputs[0]->body;

dispatch_data_t im2 = (dispatch_data_t)inputs[1]->body;

// Call blend function

dispatch_data_t result = blend(im1, im2);

// Get the size of the output container

const size_t len =

sizeof(octopus_header_t) +

sizeof(result) +

sizeof(octopus_extent_t[1]);

// Get pointers to header, body, and extent table octopus_header_t* output = malloc(len);

dispatch_data_t* body = (dispatch_data_t*)output->body;

octopus_extent_t* extent = (octopus_extent_t*)(body + 1);

// Fill-in the required information

output->body_size = sizeof(result);

output->extent_count = 1;

output->destructor = free;

*body = result;

extent->type = EXTENT_TYPE_BLOB;

extent->offset = 0;

outputs[0] = output;

}

위의 예시 코드는 예를 들어 시스템의 런타임의 설계를 예시하는 것임을 유의해야 한다. 그러나, 다른 구현예들이 또한 고려된다.

도 11은 본 발명의 일 실시예에 따른, 입력 데이터의 필요한 세트를 획득하는 것에 응답하여 프로세스를 수행하는 방법의 흐름도이다. 프로세스(900)는 소프트웨어, 하드웨어, 또는 이들의 조합을 포함할 수 있는 프로세싱 로직을 사용할 수 있다. 예를 들어, 프로세스(900)는 시스템(또는 디바이스(110))에 의해 수행될 수 있다. 910에서, 제1 디바이스(예를 들어, 디바이스(304))는, 제1 레벨 프로토콜(예를 들어, 제1 레벨 프로토콜(350))을 사용하여, 제2 디바이스(예를 들어, 디바이스(302))로부터 제1 메시지를 수신할 수 있다. 제1 메시지는, 컴파일링될 때, 분산 컴퓨팅 시스템 내에서 제1 디바이스에 의한 계산을 수행하는 하나 이상의 함수들을 제공하는 포터블 코드를 포함할 수 있다. 920에서, 제1 디바이스는 포터블 코드가 제1 디바이스 상에서 실행하는 데 안전하다고 결정한 후에 작업을 위한 하나 이상의 함수들을 제공하도록 포터블 코드를 컴파일링할 수 있다. 930에서, 제1 디바이스는 제2 레벨 프로토콜(예를 들어, 제2 레벨 프로토콜(350))을 사용하여, 제2 디바이스로부터 제2 메시지를 수신할 수 있고, 제2 메시지는 제1 작업 요청을 포함한다. 제1 작업 요청은 제1 디바이스에 의해 수행될 제1 함수의 표시, 및 제1 함수를 수행하기 위한 입력 데이터의 필요한 세트의 표시를 포함할 수 있다. 940에서, 제1 디바이스는 또한, 제2 레벨 프로토콜을 사용하여, 제3 디바이스(예를 들어, 디바이스(506))로부터 제3 메시지를 수신할 수 있다. 제3 메시지는 데이터의 제1 컨테이너를 포함할 수 있고, 제1 디바이스는 제1 디바이스의 데이터 저장소 내에 데이터를 저장할 수 있다. 950에서, 제1 디바이스는 제1 함수를 실행하여, 제1 디바이스가 입력 데이터의 필요한 세트를 획득하는 것에 응답하여 제1 작업 요청을 이행하도록 계산을 수행할 수 있다. 하나의 실시예에서, 입력 데이터의 필요한 세트를 획득하는 것은, 입력 데이터의 필요한 세트가 제1 디바이스의 데이터 저장소에 저장된다고 결정하는 것, 및 데이터 저장소로부터 입력 데이터의 필요한 세트를 검색하는 것을 포함할 수 있다. 그에 부가하여, 하나의 실시예에서, 입력 데이터의 필요한 세트를 획득하는 것은 입력 데이터의 필요한 세트의 적어도 일부분이 제1 디바이스의 데이터 저장소에 저장되지 않았음을 결정하는 것, 및 이에 응답하여, 데이터 저장소에 저장되지 않은 입력 데이터의 필요한 세트의 일부분을 제3 디바이스로부터 검색하는 것을 포함할 수 있다.

960에서, 제1 디바이스는 제1 프로세스로부터의 출력을 데이터의 제2 컨테이너에 저장할 수 있다. 따라서, 970에서, 제1 디바이스는 제2 컨테이너를 포함하는 제4 메시지를 제4 디바이스(예를 들어, 디바이스(508))로 전송할 수 있다.

도 12는 본 발명의 일 실시예에 따른, 포터블 코드를 분석 및 컴파일링하는 방법의 흐름도이다. 프로세스(1000)는 소프트웨어, 하드웨어, 또는 이들의 조합을 포함할 수 있는 프로세싱 로직을 사용할 수 있다. 예를 들어, 프로세스(1000)는 시스템(또는 디바이스(110))에 의해 수행될 수 있다. 1010에서, 제1 디바이스는 무선 프로토콜을 사용하여 수신할 수 있다. 제1 메시지는, 실행가능하지 않은 데이터로서 수신되고, 실행될 때, 제1 디바이스가 분산 컴퓨팅 시스템 내의 리소스들을 제2 디바이스를 포함하는 하나 이상의 다른 디바이스들과 공유하게 하는 포터블 코드를 포함할 수 있다. 1020에서, 제1 디바이스는 포터블 코드를 분석하여 그것이 컴파일링하고 실행하기에 안전한지 여부를 결정할 수 있다. 하나의 실시예에서, 분석하는 것은 포터블 코드에 대한 제어 흐름 무결성의 검사를 포함할 수 있다. 1030에서, 제1 디바이스는 데이터의 제1 컨테이너를 수신하고 데이터를 데이터 저장소에 저장할 수 있다. 1040에서, 제1 디바이스는 포터블 코드를 컴파일링하여, 제1 디바이스가 작업 요청에 대한 하나 이상의 계산들을 수행하게 할 수 있다. 작업 요청은 제1 계산의 표시, 및 입력 데이터의 필요한 세트의 표시를 포함할 수 있다. 따라서, 1050에서, 제1 디바이스는 입력 데이터의 필요한 세트를 획득하는 것에 응답하여 제1 계산을 수행할 수 있다.

도 13은 예시적인 컴퓨팅 시스템을 도시한 블록도로서, 예시적인 컴퓨팅 시스템은 본 발명의 실시예들 중 하나 이상과 함께 사용될 수 있다. 예를 들어, 컴퓨팅 시스템(1200)(또는 시스템, 또는 컴퓨팅 디바이스, 또는 디바이스)은 본 발명의 프로세스들, 동작들, 또는 방법들 중 임의의 것을 수행하는 본 명세서에 설명된 시스템들, 또는 디바이스들(예를 들어, 디바이스(110)) 중 임의의 것을 나타낼 수 있다. 컴퓨팅 시스템이 다양한 컴포넌트들을 도시하고 있지만, 그것은 그러한 상세사항이 본 발명과 밀접한 관련이 없기 때문에, 그 컴포넌트들을 상호연결하는 임의의 특정 아키텍처 또는 방식을 나타내도록 의도되지 않는다는 것에 유의한다. 도시된 것보다 더 적거나 더 많은 컴포넌트들을 갖는 다른 유형들의 시스템들이 또한 본 발명에서 사용될 수 있음이 또한 이해될 것이다.

도시된 바와 같이, 컴퓨팅 시스템(1200)은 프로세서(1210), ROM(Read Only Memory)(1220), RAM(또는 휘발성 메모리)(1225), 및 저장소(또는 비휘발성 메모리)(1230)에 연결될 수 있는 버스(1205)를 포함할 수 있다. 프로세서(1210)는 메모리들(1220, 1225, 및 1230) 중 하나 이상으로부터 저장된 명령어들을 검색할 수 있고, 본 명세서에 설명된 프로세스들, 동작들, 또는 방법들을 수행하도록 명령어들을 실행할 수 있다. 이들 메모리들은 컴퓨팅 시스템(또는 프로세서)에 의해 실행될 때, 컴퓨팅 시스템(또는 프로세서)이 본 명세서에 설명된 동작들, 프로세스들, 또는 방법들을 수행하게 하는 명령어들을 포함하는 비일시적 기계 판독가능 매체(또는 비일시적 컴퓨터 판독가능 매체, 또는 저장소)의 예들을 나타낸다. RAM(1225)은, 예를 들어, 동적 RAM(DRAM), 또는 데이터를 메모리에 리프레시하거나 유지하기 위해 전력을 계속해서 필요로 하는 다른 유형들의 메모리로서 구현될 수 있다. 저장소(1230)는, 예를 들어, 전원이 시스템으로부터 제거된 후에도 데이터를 유지하는 자기, 반도체, 테이프, 광학, 이동식, 비-이동식, 및 다른 유형들의 저장소를 포함할 수 있다. 저장소(1230)가 시스템으로부터 원격에 있을 수 있음을 인식해야 한다(예를 들어, 네트워크를 통해 액세스가능함).

본 명세서에 설명된 사용자 인터페이스 특징부들 또는 실시예들 중 임의의 하나를 디스플레이할 수 있고 로컬 또는 원격 디스플레이 디바이스일 수 있는 디스플레이 디바이스(1255) 상에 디스플레이될 디스플레이 데이터를 수신하기 위해, 디스플레이 제어기(1250)가 버스(1205)에 연결될 수 있다. 컴퓨팅 시스템(1200)은 또한 마우스들, 키보드들, 터치 스크린, 네트워크 인터페이스들, 프린터들, 스피커들, 및 다른 디바이스들을 포함하는 하나 이상의 입력/출력(I/O)컴포넌트들(1265)을 포함할 수 있다. 통상적으로, 입력/출력 컴포넌트들(1265)은 입력/출력 제어기(1260)를 통해 시스템에 연결된다.

모듈들(1270)(또는 컴포넌트들, 유닛들, 또는 로직)은 본 명세서에 설명된 컴포넌트들(예를 들어, 데몬(310)또는 워커(320)) 중 임의의 것을 나타낼 수 있다. 모듈들(1270)은, 완전히 또는 적어도 부분적으로, 전술된 메모리들 내에, 또는 컴퓨팅 시스템에 의한 그의 실행 동안 프로세서 내에 상주할 수 있다. 또한, 모듈들(1270)은 컴퓨팅 시스템 내의 소프트웨어, 펌웨어, 또는 기능성 회로로서, 또는 이들의 조합들로서 구현될 수 있다.

본 명세서에 설명된 실시예들로부터 벗어남이 없이 흐름도들 또는 그 안에서 설명된 단계들(또는 동작들)에 대한 변형들이 있을 수 있다는 것에 유의해야 한다. 예를 들어, 단계들은 병렬로, 동시에, 상이한 순서로 수행될 수 있거나, 또는 단계들이 추가, 삭제, 또는 수정될 수 있다. 유사하게, 본 명세서에 설명된 블록도들은 예들로서 포함된다. 이들 구성들은 모든 구성요소들을 망라하는 것은 아니며, 이들 도면들에 대한 변형들이 있을 수 있다. 본 명세서에 설명된 실시예로부터 벗어남이 없이 다른 배열들 및 구성요소들이 사용될 수 있다. 예를 들어, 구성요소들은 추가되고, 생략되고, 당업자에게 알려진 다양한 방식들로 상호작용할 수 있다. "제1", "제2" 등과 같은 용어들이 본 명세서에서 다양한 요소들을 설명하는 데 사용될 수 있고, 이들 요소들은 이들 용어들로 제한되어서는 안 된다. 이들 용어들은 하나의 요소를 다른 요소와 구별하는 데에 사용될 수 있다. 예를 들어, 제1 디바이스는 제2 디바이스로 지칭될 수 있고, 유사하게, 제2 디바이스는 제1 디바이스로 지칭될 수 있다.

전술한 명세서에서, 본 발명의 예시적인 실시예들이 설명되었다. 다음의 청구범위에 기재된 바와 같은 본 발명의 보다 넓은 사상 및 범주로부터 벗어남이 없이 그에 대해 다양한 수정들이 이루어질 수 있음이 명백할 것이다. 이에 따라서, 명세서 및 도면들은 한정적 의미보다는 오히려 예시적 의미에서 고려되어야 한다.

Claims

컴퓨팅 장치의 하나 이상의 프로세서들에 의해 실행될 때, 상기 컴퓨팅 장치가 동작들을 수행하게 하는 명령어들을 저장하는 비일시적 기계 판독가능 매체로서, 상기 동작들은:
제1 디바이스 상에서 제1 레벨 프로토콜을 사용하여, 그리고 데몬(daemon) 프로세스에 의해, 제2 디바이스로부터 제1 메시지를 수신하는 것 - 상기 제1 메시지는, 컴파일링될 때, 분산 컴퓨팅 시스템 내에서 상기 제1 디바이스에 의한 계산을 수행하기 위한 하나 이상의 함수들을 제공하는 포터블 코드(portable code)를 포함함 -;
제2 레벨 프로토콜을 사용하여, 그리고 워커(worker) 프로세스와 별개인 상기 데몬 프로세스에 의해 생성된 상기 워커 프로세스에 의해, 상기 제2 디바이스로부터 제2 메시지를 수신하는 것 - 상기 제2 메시지는 제1 작업(job) 요청을 포함하고, 상기 제1 작업 요청은 상기 하나 이상의 함수들 중 제1 함수의 표시, 및 상기 제1 함수를 수행하기 위한 입력 데이터의 필요한 세트의 표시를 포함하고, 상기 워커 프로세스는 상기 제1 레벨 프로토콜의 메시지들과 상이한 상기 제2 메시지를 포함하는 상기 제2 레벨 프로토콜의 메시지들을 관리하고, 상기 워커 프로세스는 상기 데몬 프로세스에 의해 인스턴스화됨 -; 및
상기 제1 디바이스가 상기 입력 데이터의 필요한 세트를 획득하는 것에 응답하여, 상기 제1 디바이스가 상기 제1 작업 요청을 이행하기 위해 상기 계산을 수행하도록 상기 제1 함수를 실행하는 것을 포함하는, 비일시적 기계 판독가능 매체.
제1항에 있어서, 상기 동작들은, 상기 포터블 코드가 상기 제1 디바이스 상에서 실행하기에 안전하다고 결정하는 것에 응답하여, 상기 데몬 프로세스에 의해, 상기 포터블 코드의 적어도 일부분을 컴파일링하는 것을 더 포함하는, 비일시적 기계 판독가능 매체.
제2항에 있어서, 상기 포터블 코드는 LLVM IR(low level virtual machine intermediate representation)이며, 상기 제1 디바이스 및 상기 제2 디바이스는 상이한 유형들의 디바이스들이고, 각각은 상이한 운영 체제를 사용하여 동작하는, 비일시적 기계 판독가능 매체.
제1항에 있어서, 상기 동작들은 상기 제1 작업 요청을 수신하는 것에 응답하여, 상기 제1 함수에 대응하는 상기 포터블 코드의 일부분만을 JIT(just-in-time) 컴파일링하는 것을 더 포함하는, 비일시적 기계 판독가능 매체.
제1항에 있어서, 상기 제1 메시지는 상기 하나 이상의 함수들에 대한 인덱스를 포함하고, 상기 제1 작업 요청의 상기 제1 함수의 상기 표시는 상기 제1 함수에 대응하는 상기 인덱스 내의 값을 포함하는, 비일시적 기계 판독가능 매체.
제1항에 있어서, 상기 제2 디바이스는 상기 제1 디바이스의 하나 이상의 특성들에 기초하여 상기 제1 작업 요청을 수행하기 위한 상기 제1 디바이스를 선택하고, 상기 하나 이상의 특성들은 상기 제1 디바이스에 대한 프로세싱 능력 및 현재 전원을 포함하는, 비일시적 기계 판독가능 매체.
제1항에 있어서, 상기 동작들은
상기 제2 레벨 프로토콜을 사용하고, 그리고 상기 제1 디바이스에서, 제3 디바이스로부터 제3 메시지를 수신하는 것 - 상기 제3 메시지는 데이터의 제1 컨테이너를 포함함 -, 및
상기 데이터를 상기 제1 디바이스의 데이터 저장소에 저장하는 것을 더 포함하는, 비일시적 기계 판독가능 매체.
제7항에 있어서, 상기 입력 데이터의 필요한 세트를 획득하는 것은
상기 입력 데이터의 필요한 세트가 상기 제1 디바이스의 상기 데이터 저장소에 저장된다고 결정하는 것, 및
상기 데이터 저장소로부터 상기 입력 데이터의 필요한 세트를 검색하는 것을 포함하는, 비일시적 기계 판독가능 매체.
제8항에 있어서, 상기 제1 작업 요청은 상기 제1 함수로부터의 출력 데이터를 저장하기 위한 데이터의 제2 컨테이너에 대한 레퍼런스를 더 포함하며, 상기 동작들은:
상기 실행된 제1 함수로부터의 상기 출력 데이터를 상기 데이터의 제2 컨테이너에 저장하는 것; 및
상기 제2 레벨 프로토콜을 사용하여, 상기 데이터의 제2 컨테이너를 포함하는 제4 메시지를 제4 디바이스로 전송하는 것을 더 포함하는, 비일시적 기계 판독가능 매체.
제1항에 있어서, 상기 입력 데이터의 필요한 세트를 획득하는 것은
상기 입력 데이터의 필요한 세트의 적어도 일부분이 상기 제1 디바이스의 데이터 저장소에 저장되지 않았음을 결정하는 것, 및 이에 응답하여, 데이터 저장소에 저장되지 않은 상기 입력 데이터의 필요한 세트의 상기 일부분을 제3 디바이스로부터 검색하는 것을 포함하는, 비일시적 기계 판독가능 매체.
제10항에 있어서, 상기 입력 데이터의 필요한 세트의 상기 일부분을 검색하는 것은
상기 제2 레벨 프로토콜을 사용하고, 그리고 상기 제1 디바이스로부터, 제3 메시지를 상기 제3 디바이스로 전송하는 것 - 상기 제3 메시지는 데이터의 제1 컨테이너에 대한 요청을 포함하며, 상기 요청은 상기 입력 데이터의 필요한 세트의 상기 일부분을 식별하는 하나 이상의 레퍼런스들을 포함함 -, 및
상기 제2 레벨 프로토콜을 사용하고, 그리고 상기 제1 디바이스에서, 상기 제3 디바이스로부터 제4 메시지를 수신하는 것 - 상기 제4 메시지는 상기 입력 데이터의 필요한 세트의 상기 일부분을 포함하는 상기 데이터의 제1 컨테이너를 포함함 -을 포함하는, 비일시적 기계 판독가능 매체.
제1항에 있어서, 상기 입력 데이터의 필요한 세트를 획득하는 것은
상기 입력 데이터의 필요한 세트의 적어도 일부분이 상기 제1 디바이스의 데이터 저장소에 저장되지 않는다고 결정하는 것, 및 이에 응답하여, 상기 제1 디바이스의 작업 큐 내에서 제2 작업에 대한 상기 계산을 수행하도록 상기 하나 이상의 함수들 중 제2 함수를 실행하는 것을 포함하며, 상기 실행된 제2 함수는 상기 입력 데이터의 필요한 세트의 상기 일부분을 출력하는, 비일시적 기계 판독가능 매체.
제1항에 있어서, 상기 제1 레벨 프로토콜은 적어도 상기 워커 프로세스를 생성하기 위한 제1 커맨드, 및 상기 분산 컴퓨팅 시스템 내의 다른 디바이스가 상기 워커 프로세스에 연결하게 하는 제2 커맨드를 포함하는, 비일시적 기계 판독가능 매체.
제1항에 있어서, 상기 제2 레벨 프로토콜은 적어도 상기 분산 컴퓨팅 시스템 내의 다른 디바이스로 데이터의 컨테이너를 전송하라는 제1 커맨드, 및 상기 분산 컴퓨팅 시스템 내의 다른 디바이스로부터의 데이터의 컨테이너를 검색하기 위한 제2 커맨드를 포함하는, 비일시적 기계 판독가능 매체.
제9항에 있어서, 상기 출력 데이터를 저장하기 위한 상기 제2 컨테이너는 컨테이너들의 어레이인, 비일시적 기계 판독가능 매체.
제1 디바이스로서,
명령어들을 저장하는 메모리; 및
상기 메모리에 연결되어 상기 메모리로부터의 상기 명령어들을 실행하는 프로세서를 포함하고, 상기 프로세서는:
데몬 프로세스에 의해, 제1 레벨 프로토콜을 사용하여 제2 디바이스로부터 제1 메시지를 수신하고 - 상기 제1 메시지는, 컴파일링될 때, 분산 컴퓨팅 시스템 내에서 상기 제1 디바이스에 의한 계산을 수행하기 위한 하나 이상의 함수들을 제공하는 포터블 코드를 포함함 -;
상기 데몬 프로세스에 의해 인스턴스화되는 워커 프로세스에 의해, 제2 레벨 프로토콜을 사용하여 상기 제2 디바이스로부터 제2 메시지를 수신하고 - 상기 제2 메시지는 제1 작업 요청을 포함하며, 상기 제1 작업 요청은
상기 하나 이상의 함수들 중 제1 함수의 표시,
상기 제1 함수를 수행하기 위한 입력 데이터의 필요한 세트의 표시, 및
상기 제1 함수로부터의 출력 데이터를 저장하기 위한 데이터의 제1 컨테이너에 대한 레퍼런스를 포함함 -;
상기 제2 메시지를 수신하는 것에 응답하여, 상기 제1 디바이스 상에서 상기 포터블 코드를 분석함으로써 상기 포터블 코드가 상기 제1 디바이스 상에서 실행되기에 안전하다고 결정한 후에 상기 제1 함수를 생성하도록 상기 포터블 코드를 컴파일링하고;
상기 제1 디바이스가 상기 입력 데이터의 필요한 세트를 획득하는 것에 응답하여 그리고 상기 포터블 코드가 실행되기에 안전하다고 결정한 후에, 상기 제1 디바이스가 상기 제1 작업 요청을 이행하기 위해 상기 계산을 수행하도록 상기 제1 함수를 실행하도록 구성되는, 제1 디바이스.
제16항에 있어서, 상기 제1 레벨 프로토콜은 상기 데몬 프로세스에 의해 사용되고, 상기 제2 레벨 프로토콜은 상기 데몬 프로세스에 의해 인스턴스화되는 상기 워커 프로세스에 의해 사용되는, 제1 디바이스.
제16항에 있어서, 상기 프로세서는:
상기 제1 디바이스에 의해 수행된 상기 제1 함수로부터의 상기 출력 데이터를 상기 데이터의 제1 컨테이너에 저장하고;
상기 데이터의 제1 컨테이너를 제3 디바이스로 전송하도록 더 구성되는, 제1 디바이스.
컴퓨터 구현 방법으로서,
데몬 프로세스에 의해, 무선 프로토콜을 사용하고, 그리고 제1 디바이스 상에서, 포터블 코드를 포함하는 제1 메시지를 수신하는 단계 - 상기 포터블 코드는 실행가능하지 않은 데이터로서 수신되며, 실행될 때, 상기 제1 디바이스가 분산 컴퓨팅 시스템 내의 리소스들을 제2 디바이스를 포함하는 하나 이상의 다른 디바이스들과 공유하게 함 -;
상기 제1 디바이스 상에서, 상기 포터블 코드를 컴파일링하기 전에 상기 포터블 코드를 분석하여 상기 포터블 코드가 상기 제1 디바이스 상에서 실행되기에 안전한지 여부를 결정하는 단계;
상기 데몬 프로세스에 의해 인스턴스화되는 워커 프로세스에 의해, 상기 제1 디바이스에서, 데이터의 제1 컨테이너를 수신하는 단계, 및 상기 데이터를 상기 제1 디바이스의 데이터 저장소에 저장하는 단계;
상기 제1 디바이스에서, 상기 제1 디바이스가 작업 요청에 대한 하나 이상의 계산들을 수행하게 하도록 상기 포터블 코드를 컴파일링하는 단계 - 상기 작업 요청은 상기 제1 디바이스에 의해 수행될 제1 계산의 표시, 및 상기 데이터의 제1 컨테이너 내의 상기 제1 계산을 수행하기 위한 입력 데이터의 필요한 세트의 표시를 포함함 -; 및
상기 제1 디바이스가 상기 입력 데이터의 필요한 세트를 획득하는 것에 응답하여, 상기 제1 디바이스에 의해 제1 작업에 대한 상기 제1 계산을 수행하는 단계를 포함하는, 컴퓨터 구현 방법.
제19항에 있어서, 상기 분석하는 단계는 제어 흐름 무결성의 검사를 포함하고, 상기 제1 디바이스는 상기 제1 작업으로부터의 출력 데이터를 저장하기 위한 데이터의 제2 컨테이너를 생성하며, 상기 컴퓨터 구현 방법은:
상기 제1 디바이스에 의해 수행된 상기 제1 작업으로부터의 상기 출력 데이터를 상기 데이터의 제2 컨테이너에 저장하는 단계; 및
상기 데이터의 제2 컨테이너를 상기 제2 디바이스로 전송하는 단계를 더 포함하는, 컴퓨터 구현 방법.