본 번역은 검증되지 않았습니다. AIP를 통해 영문원문으로부터 번역되었습니다.

Code Repositories를 이용한 컴퓨트 사용

Code Repositories에서 빌드를 실행하려면 Foundry 컴퓨트라는 컴퓨트-초로 측정되는 리소스를 사용해야 합니다. 이 문서에서는 빌드가 컴퓨트를 어떻게 사용하는지 설명하고 제품에서 컴퓨트 사용량을 조사하고 관리하는 방법에 대한 정보를 제공합니다.

하나 이상의 데이터셋에 대한 변환 빌드를 실행할 때, Foundry는 변환 로직을 서버리스 컴퓨트 클러스터로 가져와 코드를 실행합니다. 빌드의 길이와 크기는 코드의 복잡성, 입력 및 출력 데이터셋의 크기, 코드에 설정된 Spark 계산 프로필에 따라 다릅니다.

입력 데이터셋에서 코드를 실행하려면 Foundry 컴퓨트(병렬 컴퓨트를 실행할 때 Foundry 컴퓨트-초로 측정)와 변환 결과물이 Foundry 저장소에 기록될 때 Foundry 저장소가 필요합니다. 코드를 작성하는 것은 컴퓨트 사용량을 발생시키지 않으며, 데이터셋을 빌드하는 것만이 컴퓨트 사용량을 발생시킵니다.

Foundry 컴퓨트 측정

Code Repositories를 구동하는 변환 엔진은 백엔드에서 병렬 컴퓨트를 사용하며, 대부분의 경우 Spark 확장 가능한 컴퓨팅 프레임워크에서 사용됩니다. Code Repositories의 변환은 작업의 실행 시간 동안 사용된 Foundry 컴퓨트-초의 총 수로 측정됩니다. 이러한 컴퓨트-초는 작업의 전체 기간 동안 측정되며, 입력 데이터셋에서 읽는 시간, 코드 실행(입출력 대기 등의 작업 포함), 그리고 출력 데이터셋을 Foundry로 다시 기록하는 시간을 포함합니다.

병렬 계산을 활용하도록 변환을 구성할 수 있습니다. 컴퓨트-초는 컴퓨트 실행 시간이며 벽시계 시간이 아니기 때문에, 병렬 변환은 벽시계 초당 여러 개의 컴퓨트-초를 발생시킵니다. Code Repositories 에서 작업용 Foundry 컴퓨트-초의 병렬 컴퓨트 측정 방법에 대한 자세한 내용은 아래 예제를 참조하십시오.

Foundry 사용량을 지불할 때 기본 사용 요금은 다음과 같습니다.

vCPU / GPU사용 요금
vCPU1
T4 GPU1.2

Palantir와 기업 계약이 있는 경우 계산 사용량을 계산하기 전에 Palantir 담당자와 연락하세요.

Code Repositories

에서 Foundry 컴퓨트 사용량 조사

사용량 정보는 사용량 지표에 대한 상세 정보를 제공하는 리소스 관리 애플리케이션에서 확인할 수 있습니다.

빌드가 Foundry 컴퓨트 사용량의 주요 요인이지만, 그 사용량은 관련된 장기 리소스에 대해 기록됩니다. 데이터셋 변환의 경우, 리소스는 작업에 의해 구체화된 데이터셋(또는 데이터셋 세트)입니다. 데이터셋 세부 정보 탭에서 리소스 사용량 지표 아래의 데이터셋 사용량 타임라인을 볼 수 있습니다.

여러 출력 데이터셋을 생성하는 변환의 경우, 컴퓨트 사용량은 모든 데이터셋에 동일하게 분배됩니다. 예를 들어, 변환 작업이 두 개의 데이터셋을 생성하고, 하나는 5개의 행을 가지고 다른 하나는 500만 개의 행을 가진다면, Foundry 컴퓨트-초의 수는 두 데이터셋 사이에 동일하게 분배됩니다.

Foundry 컴퓨트 사용량의 주요 요인 이해

취소되지 않은 경우, Code Repositories 의 변환은 모든 로직이 모든 데이터에서 실행되고 결과가 Foundry로 다시 기록될 때까지 실행됩니다. 이러한 런타임에 영향을 주는 두 가지 주요 요인은 (1) 입력 데이터의 크기와 (2) 변환 로직에 의해 수행된 계산 작업의 복잡성입니다.

  • 동일한 로직이 있는 경우, 입력 데이터 크기가 더 큰 작업은 입력 데이터 크기가 더 작은 작업보다 더 많은 컴퓨트를 필요로 합니다. 예를 들어, 100GB 데이터에서 열 처리를 수행하는 작업은 10GB 데이터에서 동일한 처리를 수행하는 작업보다 더 많은 Foundry 컴퓨트-초를 사용합니다.
  • 데이터에서 더 복잡한 작업을 수행하는 작업은 비교적 적은 작업을 수행하는 작업보다 더 많은 컴퓨트를 필요로 합니다. 이것은 때때로 "작업 복잡도"라고 알려져 있습니다.
    • 기본적인 예로, 두 수학 연산 5 * 55! 사이의 작업 수를 고려해 보십시오. 5 * 5는 하나의 곱셈 작업입니다. 5!5 * 4 * 3 * 2 * 1(4개의 곱셈 작업)과 동일하며, 5 * 5 예제의 복잡성의 두 배입니다. 작업이 집계, 조인 또는 기계 학습 알고리즘과 같은 작업으로 더 복잡해지면, 작업이 데이터에서 완료해야 하는 작업 수가 증가할 수 있습니다.

Code Repositories로 Foundry 컴퓨트 사용량 관리

각 작업에 대해 성능과 컴퓨트 사용량을 주도한 기본 컴퓨트 지표를 검토할 수 있습니다. 자세한 내용은 Spark Details 이해를 참조하십시오.

작업에서 Foundry 컴퓨트-초는 크기와 병렬화된 실행 프로그램 수에 의해 주도됩니다. 이러한 설정은 작업별로 완전히 구성 가능합니다. 작업별로 어떻게 설정되는지에 대한 자세한 내용은 Spark 계산 프로필 문서를 참조하십시오. 실행 프로그램의 크기는 메모리와 vCPU 수에 의해 결정됩니다. 실행 프로그램당 증가된 vCPU 및 증가된 메모리는 해당 실행 프로그램이 발생시키는 컴퓨트-초를 증가시킵니다.

동시 작업 수는 구성된 실행 프로그램 수와 해당 vCPU 수에 의해 주도됩니다. 구성 오버라이드가 지정되지 않은 경우, 변환은 기본 Spark 프로필을 사용합니다. 결과 데이터셋에 대한 Foundry 저장소는 생성되는 데이터셋의 크기에 의해 주도됩니다.

결국, 다른 로직을 가진 작업은 매우 다른 수의 작업으로 동일한 결과를 달성할 수 있습니다.

사용량 관리를 위한 코드 최적화

작업에서 사용하는 컴퓨트-초를 최적화하고 관리하는 방법에 대한 정보를 제공하는 다양한 방법이 있습니다. 이 섹션에서는 일반적으로 사용되는 최적화 기술에 대한 추가 정보를 제공하는 링크를 제공합니다.

  • Foundry가 대부분의 Code Repository배치 컴퓨트에 채택한 분산 클러스터 컴퓨팅 프레임워크인 Spark는 다양한 최적화 기술을 허용합니다. Spark 최적화에 대해 자세히 알아보기.
  • Spark에서는 파티셔닝을 최적화하여 빌드를 가속화할 수 있습니다. 최적의 파티션 수는 행 수, 열 수, 열 유형, 그리고 콘텐츠에 따라 다릅니다. 데이터셋 크기당 약 128MB의 파티션 비율을 권장합니다.
  • 점진적 계산은 출력 데이터셋을 생성하기 위해 변환을 수행하는 효율적인 방법입니다. 변환의 빌드 이력을 활용하여 점진적 계산은 변환을 실행할 때마다 전체 출력 데이터셋을 다시 계산할 필요가 없습니다.
  • 특히 작은 크기에서 중간 크기의 데이터셋의 경우, 단일 노드 애플리케이션에 대한 벤치마크에서 Spark를 일관되게 초과하는 성능을 제공하는 Spark 이외의 여러 컴퓨트 엔진이 있습니다. 따라서 파이프라인을 실행하는 데 이러한 대안을 사용하면 처리 속도가 증가하고 컴퓨트 사용량이 감소할 수 있습니다. 이러한 옵션을 최대한 활용하려면 Lightweight 변환에 익숙해져야 합니다.
  • 빌드가 스케줄을 사용하여 조정되는 경우, 비용을 최적화하기 위해 스케줄링 모범 사례를 읽어보는 것이 좋습니다.

Foundry 컴퓨트 사용량 계산

사용 예제 1: 표준 메모리

이 예제에서는 표준 메모리 요청으로 정적 할당 작업에 대한 Foundry 컴퓨트가 어떻게 측정되는지 설명합니다.

드라이버 프로필:
    vCPUs: 1
    GiB_RAM: 6
실행자 프로필:
    vCPUs: 1
    GiB_RAM: 6
    Count: 4
전체 작업 벽시계 런타임: 
    120 초



계산
driver_compute_seconds = max(num_vcpu, GiB_RAM/7.5) * num_seconds
                       = max(1vcpu, 6gib/7.5gib) * 120sec
                       = 120 계산-초

# 실행자의 계산 시간은 실행자 수 * max(vCPU 수, RAM/7.5) * 초 수
executor_compute_seconds = num_executors * max(num_vcpu, GiB_RAM/7.5) * num_seconds 

                         = 4 * max(1, 6/7.5) * 120sec 
                         = 480 계산-초

# 총 계산 시간은 드라이버의 계산 시간 + 실행자의 계산 시간
total_compute_seconds = 120 + 480 = 600 계산-초 

사용 예제 2: 큰 메모리

이 예제는 더 큰 메모리 요청을 가진 정적으로 할당된 작업에 대해 Foundry Compute가 어떻게 측정되는지 보여줍니다.

드라이버 프로필:
    vCPUs: 2
    GiB_RAM: 6
실행자 프로필:
    vCPUs: 1
    GiB_RAM: 15
    Count: 4
전체 작업 벽시계 런타임: 
    120 초



계산:
# 드라이버 계산 초 = 최대(코어 수, RAM/7.5) * 초 수
driver_compute_seconds = max(num_vcpu, GiB_RAM/7.5) * num_seconds
                       = max(2vcpu, 6gib/7.5gib) * 120초
                       = 240 계산-초

# 실행자 계산 초 = 실행자 수 * 최대(코어 수, RAM/7.5) * 초 수 
executor_compute_seconds = num_executors * max(num_vcpu, GiB_RAM/7.5) * num_seconds 
                         = 4 * max(1, 15/7.5) * 120초 
                         = 960 계산-초

# 총 계산 초 = 드라이버 계산 초 + 실행자 계산 초
total_compute_seconds = driver_compute_seconds + executor_compute_seconds
                      = 240 + 480 = 720 계산-초 

사용 예제 3: 동적 실행기 개수

이 예제는 Foundry Compute가 동적으로 할당된 작업에 대해 측정되는 방법을 보여줍니다. 일부 작업 실행 시간은 두 개의 실행기로 수행되고, 나머지 작업 시간은 네 개의 실행기로 수행됩니다.

드라이버 프로필:
    vCPUs: 2
    GiB_RAM: 6
실행자 프로필:
    vCPUs: 1
    GiB_RAM: 6
    개수: 
        최소: 2
        최대: 4
전체 작업 벽시간 실행시간: 
    120 초:
        2 실행자: 60 초
        4 실행자: 60 초



계산:
driver_compute_seconds = max(num_vcpu, GiB_RAM/7.5) * num_seconds
                       = max(2vcpu, 6gib/7.5gib) * 120초
                       = 240 컴퓨트-초

# 2 실행자를 사용한 작업 시간에 대한 컴퓨트 초 계산
2_executor_compute_seconds = num_executors * max(num_vcpu, GiB_RAM/7.5) * num_seconds 
                           = 2 * max(1, 6/7.5) * 60초 
                           = 120 컴퓨트-초 

# 4 실행자를 사용한 작업 시간에 대한 컴퓨트 초 계산
4_executor_compute_seconds = num_executors * max(num_vcpu, GiB_RAM/7.5) * num_seconds 
                           = 4 * max(1, 6/7.5) * 60초 
                           = 240 컴퓨트-초
                         

total_compute_seconds = driver_compute_seconds + 2_executor_compute_seconds + 4_executor_compute_seconds
                      = 240 + 120 + 240 = 600 컴퓨트-초

사용 예제 4: GPU 계산

이 예제는 정적으로 할당된 작업에 대한 Foundry GPU 계산이 어떻게 측정되는지를 보여줍니다.

드라이버 프로필:
    T4 GPU: 1
실행기 프로필:
    T4 GPU: 1
    개수: 4
전체 작업 벽시계 런타임: 
    120 초

계산:
# 드라이버 계산 시간 = GPU 개수 * GPU 사용률 * 초
driver_compute_seconds = num_gpu * gpu_usage_rate * num_seconds
                       = 1gpu * 1.2 * 120sec
                       = 144 계산-초

# 실행기 계산 시간 = 실행기 개수 * GPU 개수 * GPU 사용률 * 초
executor_compute_seconds = num_executors * num_gpu * gpu_usage_rate * num_seconds 
                         = 4 * 1 * 1.2 * 120sec 
                         = 576 계산-초

# 전체 계산 시간 = 드라이버 계산 시간 + 실행기 계산 시간
total_compute_seconds = 144 + 576 = 720 계산-초