---
ai_assisted: true
title: '[PGConf.Asia 2026] PostgreSQL 인덱스 뒤에 GPU 두기'
description: >-
  pg_cuvs의 구조와 측정 결과, 그 과정에서 드러난 비용. 2026년 11월 홍콩 PGConf.Asia에서 발표한 내용을 정리하고,
  recall 0.99 이상에서 A100 한 장과 64 vCPU 서버의 pgvector HNSW를 비교한 수치를 조건과 함께 싣습니다.
pubDate: '2026-11-19'
category: DB
tags:
  - PostgreSQL
  - pgvector
  - pg_cuvs
  - cuVS
  - GPU
  - vector search
  - CAGRA
  - PGConf.Asia
  - Benchmark
heroImage: ''
draft: false
published: true
serial: 47
---

2026년 11월 18일, 홍콩에서 열린 PGConf.Asia 2026의 45분 세션에서 "pg_cuvs: GPU Vector Search as a PostgreSQL Index Access Method"라는 제목으로 발표했습니다. pg_cuvs는 [pgvector](https://github.com/pgvector/pgvector)와 NVIDIA의 오픈소스 GPU 벡터 검색 라이브러리 [cuVS](https://github.com/NVIDIA/cuvs) 위에 만든 오픈소스 PostgreSQL 확장이고, 벡터 인덱스 뒤에 GPU를 둡니다. 이 글은 그 발표의 내용을 글로 옮긴 것입니다. 초록과 슬라이드는 [PGConf.Asia 세션 페이지](https://pgconf.asia/EN/2026/proposals/?id=e6900fd2-1ccd-4735-9116-7bd5c8dda914)에, 코드는 [pg-cuvs/pg_cuvs](https://github.com/pg-cuvs/pg_cuvs)에 있습니다. 초록은 9월에 제출할 때의 측정을 바탕으로 쓴 것이어서 거기 적힌 수치는 이 글과 다릅니다. 이 글의 수치는 발표에서 보인 11월의 측정입니다.

발표의 주장은 하나입니다. PostgreSQL의 인덱스 접근 메서드(index access method) 뒤에 GPU를 둘 수 있고, 그렇게 해도 SQL과 플래너와 트랜잭션은 PostgreSQL이 그대로 맡으며 GPU는 후보만 제안합니다.

결과를 조건과 함께 먼저 적습니다. 100만 개의 768차원 벡터에서 양쪽을 모두 recall 0.99 이상으로 맞춰 쟀을 때, A100 한 장이 달린 24 vCPU 서버의 pg_cuvs는 200 µs 배칭 창을 켠 상태로 클라이언트 32개에서 초당 약 6,520개의 질의를 p99 7.7 ms로 처리했습니다. 이 창은 기본값이 꺼짐이고, 창이 없을 때의 최고는 약 1,560 QPS였습니다. 별도의 64 vCPU 서버에서 돌린 pgvector HNSW는 클라이언트 64개에서 최고 약 3,550 QPS였고 그때의 p99는 약 27 ms였습니다. GPU 서버 자신의 24 vCPU와 비교한 별도 측정(단일 실행)에서는 recall 0.99 이상에서 GPU 쪽이 약 3배 많은 질의를 처리했고, 0.95 부근에서는 둘이 비슷했으며, 그 아래에서는 CPU가 더 많은 질의를 처리했습니다. 모두 프로젝트 안에서 한 측정이며 외부에서 독립적으로 재현되지는 않았습니다. 자세한 조건은 아래에 적습니다.

## 어떤 질문에서 출발했나

벡터 검색의 그래프 인덱스는 B-tree와 달리 행을 놓칠 수 있습니다. 데이터의 일부만 보고 가까운 이웃을 찾기 때문입니다. 얼마나 찾았는지는 recall로 잽니다. 진짜 상위 10개 가운데 9개를 찾았다면 recall은 0.9입니다. 정확도를 조금 낮추면 언제든 더 빨라질 수 있으므로, 이 글의 수치에는 모두 recall을 함께 적습니다.

높은 recall은 비쌉니다. 100만 벡터의 pgvector HNSW 인덱스에 질의를 하나씩 보냈을 때, 중앙값 지연은 recall 0.91에서 약 1.2 ms였고 recall 0.99에서 약 10.2 ms였습니다(pgvector 0.8.7, `m = 16`, `ef_construction = 256`, 64 vCPU 서버, 클라이언트 하나, 단일 실행). `hnsw.ef_search`를 키우면 검색이 후보를 더 많이 유지하고, 후보마다 768개의 수로 거리를 계산해야 합니다. 코어가 많으면 더 많은 클라이언트를 받을 수 있지만 질의 하나가 빨라지지는 않습니다. GPU는 이런 거리 계산을 한꺼번에 많이 할 수 있습니다.

벡터 검색에 GPU를 붙이는 시도는 이미 여럿 있고, 크게 세 가지로 나뉩니다. 첫째는 GPU로 인덱스를 짓고 검색은 CPU에서 하는 방식입니다. 둘째는 검색을 별도의 GPU 서비스로 보내는 방식인데, 저희가 아는 한 이 경우에는 행의 가시성과 권한을 두 시스템 사이에서 맞춰야 합니다. 셋째는 GPU를 다른 데이터베이스 엔진 안에 넣는 방식이고, 이때는 PostgreSQL을 떠나게 됩니다. 세 방식 모두 무언가를 포기합니다.

pg_cuvs는 이 시도들에서 배우면서 질문 하나를 던집니다. 질의 시점의 검색을 GPU가 맡으면서도 PostgreSQL이 결정권을 유지할 수 있는가?

## pg_cuvs의 구조

pg_cuvs는 PostgreSQL License로 공개한 C 확장입니다. pgvector를 대체하지 않고 pgvector의 인터페이스 위에 GPU 계층을 얹습니다. 벡터 타입과 연산자는 pgvector의 것을 그대로 쓰고, GPU 쪽 일은 cuVS에 맡깁니다. cuVS 안의 그래프 인덱스가 CAGRA입니다. pg_cuvs에서 새로 만든 것은 그 둘 사이를 잇는 부분입니다. pg_cuvs는 AI 코딩 에이전트와 함께 데이터베이스 확장을 만들어 보는 저의 실험이기도 했습니다.

![pg_cuvs의 구성도. PostgreSQL 백엔드에 로드되는 확장이 Unix 소켓과 공유 메모리로 GPU 데몬 하나와 통신하고, 데몬은 디스크의 인덱스 파일을 GPU 메모리에 한 번 적재한다](https://media.jaesolshin.com/media/83d3ec8769c99f34c7ece6fe6f8ac67d36eb7db341977abdb98f4d2972e9d7e3.png)

*그림 1. pg_cuvs의 구성. 발표 슬라이드의 그림입니다.*

구성 요소는 둘입니다. 하나는 모든 PostgreSQL 백엔드에 로드되는 확장으로, 인덱스 접근 메서드와 비용 추정을 구현합니다. 다른 하나는 별도 프로세스인 GPU 데몬(`pg_cuvs_server`)으로, GPU 자원과 인덱스 목록을 갖습니다. 데몬을 하나만 두는 이유는 PostgreSQL이 연결마다 프로세스를 하나씩 쓰기 때문입니다. 백엔드가 저마다 GPU를 쓰면 GPU 메모리가 금방 바닥나고, 인덱스는 GPU 메모리에 한 번만 올려 모든 연결이 함께 쓰는 편이 맞습니다. GPU를 가진 프로세스를 하나만 두는 방식은 PG-Strom에서 온 생각입니다. 백엔드와 데몬은 Unix 소켓과 공유 메모리로 통신합니다.

인덱스 접근 메서드는 PostgreSQL이 모든 종류의 인덱스에 같은 질문을 던지는 인터페이스입니다. 스스로 빌드할 수 있는지, 스캔 비용이 얼마인지, 다음 행 주소가 무엇인지를 묻습니다. B-tree와 GiST와 pgvector는 이 질문에 CPU로 답하고, pg_cuvs는 검색 질문에 GPU를 뒤에 두고 답합니다. pg_cuvs가 바로 이 인터페이스에 연결되므로 플래너는 여전히 가장 싸다고 추정한 계획을 고릅니다.

`CREATE INDEX`는 네 단계로 진행됩니다. 백엔드가 테이블을 스캔해 벡터와 행 주소의 쌍을 모으고, 벡터를 공유 메모리 파일로 데몬에 넘깁니다. cuVS가 GPU 메모리에서 CAGRA 그래프를 짓습니다. 데몬은 인덱스 파일을 임시 이름으로 쓰고 디스크에 동기화한 뒤 이름을 바꾸고, 그 다음에야 응답합니다. 빌드나 파일 쓰기가 실패하면 `CREATE INDEX`는 오류를 내고 카탈로그 변경은 롤백됩니다.

`SELECT`에서는 인덱스 스캔이 질의 벡터 하나를 데몬에 보냅니다. 768개의 float이고 약 3 KB입니다. GPU가 100만 벡터의 그래프를 탐색하고, 데몬은 후보 100개의 행 주소(TID)와 거리를 돌려줍니다. 100은 `cuvs.k` 설정의 기본값입니다. PostgreSQL은 그 행들을 순서대로 읽으면서 스냅샷과 WHERE 절로 하나씩 확인하고, 10행이 차면 멈춥니다. GPU는 제안하고 PostgreSQL이 결정합니다. 그래서 볼 권한이 없는 행은 결과에 나오지 않습니다. 반대로 PostgreSQL은 데몬이 제안한 후보 안에서만 고를 수 있으므로, 데몬의 파일은 PostgreSQL과 어긋나지 않아야 합니다. 이 점은 뒤에서 다시 다룹니다.

사용하는 쪽에서 새로 쓰는 것은 `USING` 절뿐입니다.

```sql
CREATE EXTENSION IF NOT EXISTS vector;
CREATE EXTENSION pg_cuvs;

CREATE INDEX ON items USING cagra (embedding vector_l2_ops);

SELECT id FROM items ORDER BY embedding <-> $1 LIMIT 10;
```

질의가 바뀌지 않으므로 애플리케이션도 바뀌지 않습니다. 설치할 것은 확장과 데몬 둘이고, `shared_preload_libraries`에 pg_cuvs를 넣은 뒤 PostgreSQL과 데몬이 같은 소켓 경로와 인덱스 디렉터리를 보게 합니다. 지금은 Linux와 PostgreSQL 16을 대상으로 합니다.

인덱스 타입은 넷이고 모두 pgvector의 `vector` 타입과 연산자를 씁니다.

| 타입 | 질의에 답하는 쪽 | 특징 |
|---|---|---|
| `cagra` | GPU | 그래프 인덱스 |
| `flat` | GPU | 모든 벡터와 비교하는 정확한 검색 |
| `ivfpq` | GPU | 벡터를 압축해 더 많이 담습니다 |
| `pg_cuvs_hnsw` | CPU(pgvector의 코드) | GPU는 그래프만 짓고 결과를 pgvector의 HNSW 페이지 형식으로 씁니다. 데몬은 빌드할 때만 필요합니다 |

## 가장 어려웠던 문제: 질의가 하나씩 온다

GPU가 잘 쓰이려면 두 가지가 맞아야 합니다. 데이터가 이미 GPU 옆에 있어야 하고, 한 번 부를 때 일이 많아야 합니다. 데이터베이스는 둘 다 반대입니다. 데이터는 크고 PostgreSQL의 테이블에 있으며, 질의 하나는 GPU에게 작은 일입니다. 첫째는 데몬이 인덱스의 사본을 GPU 메모리에 올려 두는 것으로 풀었습니다. 발표의 중심은 둘째였습니다.

PostgreSQL의 인덱스 스캔은 질의 벡터 하나를 싣고 오고, 호출마다 행 주소 하나를 돌려줍니다. 반면 cuVS의 검색 호출은 질의 여러 개를 한 묶음으로 받도록 설계되어 있습니다. 그래서 백엔드마다 자기 질의를 따로 보내고, 데몬은 질의마다 GPU를 한 번씩 부릅니다.

부하를 걸면 이렇게 보입니다. recall 0.99 이상인 CAGRA 인덱스 하나에서 처리량은 클라이언트가 하나일 때 약 1,180 QPS, 둘일 때 약 1,550 QPS였고, 넷일 때도 약 1,560 QPS였습니다. 64개까지 늘려도 약 1,530 QPS에 머물렀습니다. 그동안 서버의 24 vCPU는 약 6%만 쓰였습니다. 서버 전체로 보면 CPU가 모자란 것이 아니었습니다.

지금 릴리스는 짧게 기다리는 방법으로 이 문제를 우회합니다. 데몬이 최대 200 µs 동안 같은 인덱스로 들어온 검색을 모아 GPU 호출 하나로 보냅니다. 이것을 배칭 창이라고 부르고 `cuvs.cagra_batch_wait_us` 설정으로 켭니다. 기본값은 0, 곧 꺼짐입니다. 창을 200 µs로 두면 같은 인덱스가 32 클라이언트에서 약 6,520 QPS에 이르렀고, 이는 창이 없을 때의 약 4배입니다. 대가도 있습니다. 클라이언트가 하나뿐이면 함께 기다릴 질의가 없어서 지연만 늘어납니다. 클라이언트 하나에서 처리량은 약 1,180 QPS에서 약 890 QPS로 내려갔습니다. 어느 쪽이 맞는 기본값인지는 워크로드에 달려 있습니다.

그런데 배칭이 없을 때의 이 상한은 저희 코드와 관련이 있었습니다. 지금 릴리스의 데몬은 검색이 GPU에서 도는 동안 잠금 하나를 쥐고 있습니다([#233](https://github.com/pg-cuvs/pg_cuvs/issues/233)). 그래서 GPU 호출만 그 잠금 밖으로 옮긴 실험 빌드를 만들어, 다른 A100 서버에서 같은 데이터로 쟀습니다.

![클라이언트 수에 따른 처리량 그래프. 배칭 없는 릴리스 v0.9.2는 약 1,530 QPS에서 평평하고, GPU 호출을 잠금 밖으로 옮긴 실험 빌드는 64 클라이언트에서 9,743 QPS에 이른다](https://media.jaesolshin.com/media/cc61f53efb6f69aaf7c45ef4ab51b31524dc25adf8ceeab8edc93000a0b8245d.png)

*그림 2. 릴리스와 실험 빌드의 처리량. 두 번째 A100 서버, 100만 벡터, 점마다 3회 실행입니다.*

배칭 없이 64 클라이언트에서 릴리스는 약 1,530 QPS에 머물렀고 실험 빌드는 약 9,740 QPS였습니다. 릴리스의 약 6배이고, 같은 서버에서 배칭 창을 켠 릴리스(약 7,100~7,260 QPS)보다도 높습니다. 다만 64 클라이언트의 p99는 배칭 창을 켠 릴리스가 11.6 ms로, 실험 빌드의 14.6 ms보다 낮았습니다. 이 수치는 조심해서 읽어야 합니다. 실험 빌드는 릴리스에 들어 있지 않고, 측정하는 동안 인덱스를 지우거나 다시 짓거나 갱신하거나 GPU 메모리에서 내리지 않을 때만 안전하며, 점마다 GPU 한 장에서 3회 실행한 결과입니다. 그래도 이 결과는 처리량의 상한을 만든 것이 GPU가 아니라 저희의 잠금이라는 쪽을 가리킵니다. 배칭과 이 변경을 함께 쓴 경우는 아직 재지 않았습니다.

## 측정 조건

아래 결과의 조건은 다음과 같습니다.

- 데이터: Wikipedia 임베딩 100만 개(wiki_all), 768차원, L2 거리, `LIMIT 10`
- 정확도: 양쪽 모두 recall 0.99 이상(pgvector 0.993, CAGRA 0.994~0.995)
- 부하: pgbench, prepared 문, closed loop, 클라이언트 수마다 60초, 5회 반복의 중앙값
- GPU 쪽: A100(80GB) 한 장이 달린 24 vCPU 서버, PostgreSQL 16.15, pg_cuvs 0.9.2, `cuvs.k = 100`
- CPU 쪽: 별도의 64 vCPU 서버(m8id.16xlarge), PostgreSQL 16.16, pgvector 0.8.7, HNSW `m = 16`, `ef_construction = 200`, `hnsw.ef_search = 640`

CPU 쪽은 GPU 서버에 딸린 작은 CPU가 아니라 별도의 큰 서버로 잡았습니다. "recall 0.99의 pgvector"는 하나의 수가 아니고 인덱스 설정에 따라 달라지므로, 사용한 설정을 위에 밝혔습니다.

발표 자료에는 저희 벤치마크 설정의 실수 두 가지도 실었습니다. 하나는 pgvector의 병렬 인덱스 빌드가 63개가 아니라 6개의 워커로 돈 것입니다. 이때 100만 벡터의 빌드가 180초로 나왔고, 고친 뒤에는 67초였습니다. 다른 하나는 `hnsw.ef_search`를 pgvector의 상한인 1000보다 크게 준 것입니다. 이 값은 기본값 40으로 돌아갔고, 그때 잰 클라이언트 하나의 867 QPS는 recall 0.90의 수치였습니다. recall 0.99 이상으로 맞춘 정식 측정에서는 87 QPS였습니다. 아래 수치는 모두 이 둘을 고친 뒤의 것입니다.

## 결과

| | 최고 처리량 | 그때의 클라이언트 수 | p99 |
|---|---|---|---|
| pgvector HNSW (64 vCPU 서버) | 3,553 QPS | 64 | 26.7 ms |
| CAGRA, 배칭 없음 | 1,561 QPS | 4 | 2.8 ms |
| CAGRA, 200 µs 창 | 6,520 QPS | 32 | 7.7 ms |

![클라이언트 수에 따른 처리량 그래프. pgvector HNSW는 64 클라이언트에서 3,553 QPS로 최고점에 이르고, 배칭 없는 CAGRA는 약 1,560 QPS에서 평평하며, 200 µs 창을 켠 CAGRA는 32 클라이언트에서 6,520 QPS에 이른다](https://media.jaesolshin.com/media/39a754225a17e55c2013630d61b121547195157de778e2265d34ec446b2545e6.png)

*그림 3. 클라이언트 수에 따른 처리량. recall 0.99 이상, 5회 중앙값입니다. pgvector는 64 vCPU 서버에서, CAGRA는 A100 한 장이 달린 24 vCPU 서버에서 쟀습니다.*

같은 recall에서, 200 µs 창을 켠 CAGRA는 A100 한 장이 달린 24 vCPU 서버에서 64 vCPU 서버의 pgvector보다 초당 약 1.8배 많은 질의를 처리했습니다. 지연 예산으로 보면 차이가 더 분명합니다. p99 10 ms를 예산으로 잡으면, 이번에 잰 인덱스 설정의 pgvector에는 그 안에 드는 점이 없습니다. 클라이언트가 하나일 때도 p99가 약 17 ms였습니다.

질의를 하나씩 보낼 때의 차이가 가장 큽니다. 클라이언트 하나에서 중앙값 지연은 pgvector가 약 11.5 ms, CAGRA가 약 0.84 ms였습니다. CAGRA의 지연이 pgvector의 약 14분의 1입니다. 클라이언트가 늘면 이 격차는 줄어듭니다.

recall을 바꿔 가며 보면 GPU가 앞서는 구간이 드러납니다. 다음 비교는 GPU 서버 자신의 24 vCPU에서 pgvector를 돌리고 64 클라이언트로 잰 것입니다. 위 표의 64 vCPU 서버가 아니고 단일 실행입니다.

![recall에 따른 처리량 그래프. 200 µs 창을 켠 CAGRA는 recall 0.85부터 0.99까지 약 6,400 QPS로 거의 일정하고, pgvector HNSW는 recall 0.85의 약 12,450 QPS에서 0.99의 2,076 QPS로 내려간다. 두 선은 0.95 부근에서 만난다](https://media.jaesolshin.com/media/fafcc9fc38a5d9706bffa92333eff24b5ee290367191f478708f498f0bb344fa.png)

*그림 4. 해당 recall 이상에서 얻은 최고 처리량. 64 클라이언트, 같은 GPU 서버의 24 vCPU에서 돌린 pgvector와 비교한 단일 실행입니다.*

각 점은 그 recall 이상을 내는 설정 가운데 가장 높은 처리량입니다. recall 0.99 이상에서는 배칭 창을 켠 CAGRA가 약 6,370 QPS, pgvector가 약 2,080 QPS로 약 3배였습니다. 0.95 이상에서는 약 6,470 QPS 대 약 6,490 QPS로 거의 같았습니다. 0.90 이상에서는 pgvector가 약 10,390 QPS로 앞섰습니다. pgvector는 정확도를 조금 내주면 훨씬 빨라지는데 CAGRA는 그렇지 않았습니다. GPU는 매우 높은 정확도가 필요한 구간에서 앞섭니다.

인덱스를 짓는 시간은 100만 벡터에서 pgvector HNSW가 약 67초(병렬 워커 63개, `m = 16`, `ef_construction = 200`), CAGRA가 약 31초, GPU로 짓는 HNSW(`pg_cuvs_hnsw`, `ef_construction = 128`)가 약 27초였습니다. 모두 `CREATE INDEX` 전체 시간이고 5회 중앙값입니다. 두 HNSW의 `ef_construction` 값은 서로 다릅니다.

## PostgreSQL을 거치는 비용

PostgreSQL이 결정권을 갖게 하는 데에는 비용이 듭니다. 일부는 PostgreSQL의 인터페이스에서 왔고, 많은 부분은 저희 코드에서 왔습니다.

같은 설정으로 한 번은 cuVS를 직접 부르고 한 번은 PostgreSQL을 거쳐 쟀습니다. 315쌍의 설정 모두에서 PostgreSQL과 데몬을 거치는 경로는 질의당 0.25~0.32 ms를 더했습니다. 이 비용은 거의 일정해서 검색이 무거워져도 커지지 않았습니다. 빌드는 9개 설정 모두에서 약 15초씩 더 걸렸습니다. 이 비교는 단일 실행이고, 직접 호출 쪽은 배치 크기 1의 평균 지연, PostgreSQL 쪽은 클라이언트 하나의 중앙값이며, 두 쪽의 libcuvs 빌드가 달랐습니다(공개판과 패치판).

그 15초가 어디로 갔는지는 같은 종류의 다른 서버에서 나눠 쟀습니다. 테이블을 읽어 데몬에 넘기는 데는 약 0.2초가 들었습니다. 나머지 약 15초는 데몬이 파일을 저장하는 시간이었고, 그 절반 이상(약 8.3초)이 스레드 하나로 계산하는 체크섬이었습니다. 응답 전에 파일을 디스크에 동기화하는 데는 약 1.5초가 들었습니다.

GPU로 짓는 HNSW도 같은 모양이었습니다. 한 진단 빌드에서 `CREATE INDEX`가 약 82초 걸렸는데(1회 측정), 그중 약 49초가 그래프를 pgvector의 인덱스 페이지에 쓰는 저희 코드에 있었습니다. 이 단계를 여러 번 고친 지금 릴리스에서는 같은 조건에서 약 26초이고, 그 과정에서 GPU 쪽 작업은 건드리지 않았습니다. 앞 절의 약 27초와는 다른 측정입니다. 두 경우 모두 비용은 GPU가 아니라 결과를 디스크와 PostgreSQL 페이지에 쓰는 쪽에 있었습니다.

차트에 나오지 않는 비용이 하나 더 있습니다. 인덱스가 PostgreSQL 자신의 페이지에 있으면 PostgreSQL의 커밋, 롤백, 크래시 복구를 그대로 따릅니다. pg_cuvs의 GPU 인덱스는 별도 프로세스에 있어서 데몬이 그 약속을 스스로 지켜야 합니다. PostgreSQL은 틀린 후보를 걸러낼 수 있지만 빠진 후보는 알아챌 수 없습니다. 발표 직전에 지금 릴리스가 이 약속을 지키지 못하는 지점들을 찾았고, 공개 이슈로 올렸습니다. 예를 들어 REINDEX 도중 두 파일의 이름을 바꾸는 사이에 데몬이 죽으면 재시작 뒤 오류 없이 틀린 결과가 나오고([#235](https://github.com/pg-cuvs/pg_cuvs/issues/235)), 데몬이 강제 종료되면 extend 경로로 들어간 INSERT 행이 인덱스 검색에서 빠집니다([#236](https://github.com/pg-cuvs/pg_cuvs/issues/236)). 데몬이 파일을 저장하고 커밋하는 방식의 새 설계는 있지만 아직 릴리스에 들어가지 않았습니다. 지금 릴리스를 써 보려는 분은 [열린 이슈](https://github.com/pg-cuvs/pg_cuvs/issues)를 먼저 확인하시기 바랍니다.

이 비용을 치르고 얻는 것은 다음과 같습니다. SQL이 바뀌지 않습니다. 플래너가 여전히 계획을 고르고 그 선택을 `EXPLAIN`으로 볼 수 있습니다. 인덱스 스캔 안에서 가시성, 필터, 조인, 권한 검사는 여전히 PostgreSQL의 일입니다.

## 어떤 경우에 쓸 만한가

발표에서는 네 가지 질문으로 정리했습니다.

1. recall 0.99 이상의 매우 높은 정확도가 필요한가? 아니라면 pgvector를 먼저 튜닝하고, 그것으로 충분하면 그대로 씁니다. GPU 서버의 24 vCPU와 비교한 측정에서는 recall 약 0.95 아래에서 CPU가 더 많은 질의를 처리했습니다.
2. 필요하다면, 데이터가 GPU 메모리보다 큰가? 그렇다면 GPU로 짓는 HNSW를 고려합니다. 빌드는 디스크를 써서 하고 서빙은 CPU에서 합니다. 디스크를 쓰는 빌드 경로에는 지금 패치한 cuVS와 넉넉한 호스트 메모리(100만 벡터에서 17~21 GiB)가 필요합니다.
3. GPU 메모리에 들어간다면, CPU에서 서빙하면서 인덱스를 자주 다시 짓는가? 이때도 GPU로 짓는 HNSW가 후보입니다. 이 인덱스는 pgvector의 페이지 형식에 의존하므로 pgvector를 올린 뒤에는 다시 시험해야 합니다.
4. 그 밖의 경우에는 CAGRA를 고려합니다. 여러 클라이언트가 동시에 들어오면 배칭 창을 켜 봅니다.

어느 경우든 `EXPLAIN`으로 실제 계획을 확인하고 자신의 임베딩으로 재 봐야 합니다.

## 발표에서 얻은 것

질의응답에서는 데몬과 백엔드 사이에서 인덱스 갱신이 어떻게 이루어지는지를 묻는 질문이 있었습니다. CAGRA 인덱스에 행이 삽입되면 먼저 데몬이 GPU의 그래프를 확장하려고 시도하고, 그것이 실패하면 백엔드가 `.delta` 파일에 행 주소와 벡터를 덧붙입니다. 검색은 기존 그래프의 후보와 이 delta를 검색한 결과를 합칩니다.

커뮤니티에 한 가지를 요청하기도 했습니다. 인덱스 접근 메서드가 질의 벡터 여러 개를 한 번에 받을 수 있다면, 조인처럼 벡터 여러 개를 싣고 오는 질의는 기다림 없이 한 묶음으로 GPU에 보낼 수 있습니다. 지금은 그러려면 `pg_cuvs_batch_search`라는 별도 함수를 써야 하고 SQL이 바뀝니다.

발표의 마지막 부분에서는 이 프로젝트에서 제가 배운 것을 이야기했습니다. 저는 "GPU를 붙인 PostgreSQL"이라는 생각 하나에 몰두해 있었고, 그래서 누가 무엇 때문에 이것을 필요로 하는지는 충분히 상상하지 못했습니다. 설계를 하다 보면 계속 같은 종류의 선택에 이릅니다. 질의 하나의 지연을 줄일 것인가, 부하가 걸렸을 때의 처리량을 늘릴 것인가. 데몬 하나가 모든 연결을 받을 것인가, GPU 작업을 PostgreSQL의 프로세스 안에서 할 것인가. 데몬이 자기 파일로 인덱스를 PostgreSQL과 맞출 것인가, 인덱스를 PostgreSQL의 페이지와 WAL에 둘 것인가. 데이터가 GPU 한 장을 넘으면 GPU에 계속 둘 것인가, GPU로 짓고 CPU에서 서빙할 것인가. 측정은 각 선택이 무엇을 주는지 알려 주지만 어느 쪽이 더 중요한지는 알려 주지 않습니다. 그것은 실제 워크로드와 그 워크로드를 가진 사람만 정할 수 있습니다. 이런 프로젝트에는 수요 쪽에서 함께 고민할 파트너가 필요하다는 것을 배웠습니다.

이번 발표를 통해 PostgreSQL 컨트리뷰터 커뮤니티와 연결되고 교류하게 된 것도 좋았습니다.

GPU를 붙인 PostgreSQL이 도움이 될 만한 워크로드가 있다면 무엇이 필요한지 듣고 싶습니다. [GitHub 이슈](https://github.com/pg-cuvs/pg_cuvs/issues)와 풀 리퀘스트를 환영합니다.

## 감사

WeDataLab, 시간을 내어 피드백을 준 NVIDIA의 Corey Nolet, 그리고 Steve Choi와 Yujin Oh에게 감사드립니다.
