본문으로 건너뛰기
잠그고 기다려도 놓치기 쉬운 우버 Go 코드의 데이터 레이스
목차

잠그고 기다려도 놓치기 쉬운 우버 Go 코드의 데이터 레이스 (2022-06)

원문 정보

  • 원문: Data Race Patterns in Go
  • 매체 · 게시일: Uber Engineering Blog · 2022-06-02
  • 저자: Milind Chabbi(Programming Systems Research 팀 Senior Staff Researcher), Murali Krishna Ramanathan(Senior Staff Software Engineer, 코드 품질 이니셔티브 총괄)
  • 원문 내용을 바탕으로 재구성한 요약입니다.

슬라이스에 값을 덧붙이는 코드는 잠갔습니다. 그런데 고루틴에 슬라이스를 인자로 넘기는 곳에서 데이터 레이스가 났습니다. WaitGroup으로 자식 작업을 기다리는 코드에서는 기다림이 너무 일찍 끝났습니다. 동기화 코드는 있었지만, 개발자가 생각한 보호 범위와 실행 순서가 실제 동작과 어긋난 사례입니다.

우버가 찾아 고친 Go 데이터 레이스에는 이런 문제가 반복해서 나타났습니다. 클로저가 참조하는 바깥 변수, 인자를 넘길 때 일어나는 복사, 상수를 반환하는 문장에 숨은 쓰기까지, 익숙한 문법이 동시성 버그를 알아보기 어렵게 만들었습니다.

손쉽게 늘어나는 Go 고루틴

2022년 6월 원문이 소개한 우버의 Go 모노레포는 약 5천만 줄에 고유 서비스 약 2,100개 규모였으며 계속 커지고 있었습니다. 우버는 이 코드베이스에 동적 데이터 레이스 탐지 시스템을 적용해 6개월 동안 약 2,000건을 찾았습니다. 그중 개발자들이 고친 레이스는 약 1,100건입니다. 이번 분석은 개발자 210명이 6개월간 수정한 1,100건 이상의 사례를 바탕으로 합니다.

Go에서는 함수 호출 앞에 go를 붙이면 비동기로 실행하는 고루틴을 만들 수 있습니다. I/O나 다른 서비스로 보내는 RPC의 지연을 감추려는 개발자에게 편리한 기능입니다. 고루틴끼리 데이터를 주고받는 방법에는 채널을 쓰는 메시지 전달과 공유 메모리가 있는데, 가장 널리 쓰이는 쪽은 공유 메모리입니다.

고루틴은 가볍다고 여겨지고 만들기도 쉬워서 개발자들이 많이 사용합니다. 우버가 데이터센터의 마이크로서비스 인스턴스 수십만 개를 조사했을 때, Go 서비스에서 관찰한 동시성은 Java 서비스의 약 8배였습니다. 동시성이 많아지면 동시성 버그가 생길 여지도 커집니다.

데이터 레이스는 여러 고루틴이 같은 데이터에 접근하고, 적어도 하나가 쓰기를 수행하며, 그 접근 사이에 순서가 정해져 있지 않을 때 발생합니다. 교묘하고 반드시 피해야 할 버그입니다. 우버 엔지니어들은 수정한 사례를 하나씩 살펴보며, Go의 언어 기능과 관용구가 이런 접근을 어떻게 만들어 내는지 추적했습니다.

잠금으로 막지 못한 값의 복사

인자로 넘기는 순간의 슬라이스

슬라이스의 append를 mutex로 보호하면 충분해 보입니다. 우버에서 발견한 예제도 그렇게 작성돼 있었습니다. 놓친 곳은 슬라이스를 다른 고루틴의 인자로 넘기는 호출 지점입니다.

슬라이스는 동적 배열이자 참조 타입이지만, 내부에는 기반 배열을 가리키는 포인터와 현재 길이, 용량이 들어 있습니다. 이 값들이 슬라이스의 메타 필드입니다. append로 크기를 늘리다가 용량에 닿으면 새 배열을 할당하고 메타 필드도 갱신합니다. 새 할당 크기는 예를 들어 현재 크기의 두 배가 될 수 있습니다.

인자로 슬라이스를 넘길 때도 이 필드들을 읽습니다. 호출 지점에서 호출 대상에 메타 필드를 값으로 복사하기 때문입니다. 예제에서는 append가 메타 필드를 바꾸는 코드는 잠갔지만, 인자를 복사하는 곳에는 잠금이 없었습니다. 그 결과 한쪽의 갱신과 다른 쪽의 복사가 경합했습니다.

참조 타입이라는 설명만으로는 놓치기 쉬운 부분입니다. 슬라이스는 포인터 하나와 같지 않으며, 기반 배열을 공유하더라도 슬라이스를 전달할 때는 메타 필드의 복사가 일어납니다.

각자 다른 잠금을 거는 sync.Mutex

복사한 대상이 잠금 자체인 사례도 있었습니다. sync.Mutex와 sync.RWMutex는 Go에서 값 타입인 구조체입니다. mutex를 만들어 여러 고루틴에 값으로 넘기면 각 고루틴은 내부 상태를 공유하지 않는 별개의 mutex를 받습니다. 잠금은 있지만 서로 다른 잠금입니다.

따라서 각 고루틴이 자기 mutex로 공유 메모리를 보호하려 해도 상호 배제가 성립하지 않습니다. 코드에는 Lock()과 Unlock()이 모두 있으므로, 잠금이 빠진 곳만 찾아서는 문제를 알아채기 어렵습니다.

Go가 값 전달을 권하는 데는 이유가 있습니다. 탈출 분석이 단순해지고 변수가 스택에 할당될 가능성이 높아져 가비지 컬렉터의 부담을 줄입니다. 모든 객체가 참조 타입인 Java와 달리, Go에서는 struct 같은 값 타입과 interface 같은 참조 타입을 함께 사용합니다. 여기에 값과 포인터의 메서드 호출 문법이 같다는 점이 혼동을 더합니다.

m.Lock()만 보아서는 m이 의도한 mutex인지 그 복사본인지 두드러지지 않습니다. Lock()과 Unlock()은 포인터를 받지만, mutex 값에 호출해도 컴파일러가 그 값의 주소를 넘겨 줍니다. 이 자동 처리가 없었다면 타입 불일치로 잡혔을 버그가 그대로 실행되는 것입니다.

복사본을 의도했는데 공유가 생기는 경우도 있습니다. 개발자가 값 리시버 대신 포인터 리시버로 메서드를 작성하면, 여러 고루틴의 호출이 같은 구조체 내부 상태를 사용하게 됩니다. 이때도 호출 문법에는 차이가 없어, 호출자는 의도하지 않은 공유를 놓치기 쉽습니다.

고루틴이 함께 참조하는 바깥 변수

Go의 중첩 함수인 클로저는 내부에서 사용하는 바깥 변수, 즉 자유 변수를 참조로 캡처합니다. 어떤 변수를 캡처하는지 클로저 문법에 따로 적지 않습니다. 클로저가 길어질수록 개발자는 내부의 변수가 바깥에서 선언됐다는 사실부터 놓치기 쉽습니다.

Java 람다는 동시성 버그를 피하려는 설계 선택으로 값 캡처만 허용하고, C++은 값으로 캡처할지 참조로 캡처할지 명시하게 합니다. Go에서는 암묵적인 참조 캡처에 고루틴 실행이 더해집니다. 클로저를 고루틴으로 쓰는 일이 많으므로, 명시적으로 동기화하지 않으면 바깥 함수와 고루틴이 같은 변수에 순서 없이 접근할 수 있습니다.

다음 반복에서 바뀌는 job

원문에 나온 예제는 jobs 슬라이스를 순회하며 각 job을 ProcessJob으로 처리합니다. 비용이 큰 처리를 비동기로 실행하려고 항목마다 익명 고루틴을 만들었습니다. 그런데 고루틴이 참조하는 것은 반복마다 따로 보관한 항목이 아니라 루프 변수 job입니다.

첫 반복에서 만든 고루틴이 job을 읽는 동안, 부모 고루틴의 루프는 다음 요소로 넘어가며 같은 job을 갱신합니다. 자식의 읽기와 부모의 쓰기 사이에는 순서가 없습니다.

이 예제의 문제는 고루틴이 항목을 수정할 때만 생기지 않습니다. 고루틴 안에서 읽기만 해도 부모가 루프 변수를 바꾸므로 레이스가 됩니다. 원문이 다룬 이 패턴은 값 타입과 참조 타입, 슬라이스와 배열과 맵에 모두 해당합니다. 당시 Go가 권한 관용구는 루프 본문 안에서 바깥 루프 변수를 가리는 변수를 만들어 반복마다 따로 쓰는 방식이었지만, 개발자들이 늘 따르지는 않았습니다.

여러 호출이 돌려 쓰는 err

더 평범한 변수도 공유됩니다. Go 함수는 반환값과 에러 객체를 함께 돌려주는 경우가 많고, 호출자는 에러를 err에 받아 nil인지 검사합니다. 이 관용구에서는 에러가 nil일 때만 실제 반환값을 유효하게 취급합니다.

함수 안에서 이런 호출이 이어지면 같은 err에 할당하고 검사하는 코드도 반복됩니다. 그중 일부를 고루틴으로 옮겼을 때, 클로저가 바깥의 err를 참조로 캡처하면 문제가 생깁니다. 고루틴이 err를 읽거나 쓰는 동안 바깥 함수의 다음 호출이 같은 변수를 갱신할 수 있습니다. 같은 클로저로 만든 여러 고루틴끼리도 그 변수를 공유합니다.

에러를 확인한다는 익숙한 코드가, 고루틴을 섞는 순간 공유 변수에 접근하는 코드가 된 사례입니다.

상수 반환에 숨은 result

이름 있는 반환값은 쓰기 자체를 감춥니다. 원문의 NamedReturnCallee 함수에는 정수 반환 변수 result가 있습니다. 이 변수는 함수 맨 위에서 선언한 것처럼 본문에서 읽고 쓸 수 있습니다.

result=10을 실행한 뒤 인자 없는 return을 만나면 반환값은 10입니다. 이런 반환을 naked return이라고 부르며, 컴파일러는 result를 호출자의 retVal로 복사하도록 처리합니다. 이름 있는 반환값을 선언한 함수에서도 return 20처럼 일반적인 반환 문법을 쓸 수 있습니다.

함정은 여기에 있습니다. 예제에서는 고루틴이 result를 캡처해 읽고, 바깥 함수는 return 20을 실행합니다. 소스만 보면 상수를 반환할 뿐 result에 쓰는 문장은 없어 보입니다. 동시성 전문가도 읽기가 안전하다고 오해할 수 있는 대목입니다.

하지만 컴파일러는 return 20의 값을 먼저 이름 있는 반환 변수 result에 대입합니다. 고루틴의 읽기와 반환문이 만드는 쓰기가 같은 변수를 대상으로 겹칩니다. 상수를 반환하는 문장에도 데이터 레이스를 일으키는 쓰기가 숨어 있었던 것입니다.

배열처럼 보이는 Go 맵

맵에서는 서로 다른 키를 쓴다는 사실이 개발자를 안심시켰습니다. table[key]라는 문법이 배열 접근과 같으니, 키가 다르면 서로 겹치지 않는 요소를 다룬다고 생각하기 쉽습니다. 우버에서 자주 발견한 오해입니다.

Go의 내장 맵은 스레드 안전하지 않습니다. 여러 고루틴이 같은 맵에 접근하면서 하나라도 항목을 삽입하거나 삭제하면 레이스가 발생합니다. 맵은 배열이나 슬라이스와 달리 희소 자료구조인 해시 테이블입니다. 한 항목에 접근하는 과정에서 다른 항목에 접근할 수 있고, 그 사이에 삽입이나 삭제로 내부 자료구조가 바뀌면 접근이 충돌합니다. 키가 다르다고 내부 접근까지 분리되는 것은 아닙니다.

호출 경로가 길어지면 공유를 추적하기도 어려워집니다. 같은 맵을 여러 함수에 전달한 뒤, 깊은 호출 경로 안에서 비동기 고루틴이 맵을 변경하는 사례도 있었습니다. 개발자는 호출을 따라가면서 그 맵이 계속 공유되고 수정된다는 사실을 놓쳤습니다.

해시 테이블의 레이스는 Go에만 있는 문제가 아닙니다. 다만 Go에서는 맵이 언어에 내장돼 있어 더 자주 쓰입니다. 우버 저장소에서 코드 백만 줄(MLoC)당 맵 구성 요소는 Java가 4,389개, Go가 5,950개였으며, 원문은 Go의 사용 빈도가 1.34배 높다고 제시합니다.

사용 문법도 관대합니다. Java의 get·put API와 달리 배열처럼 접근하고, 없는 키를 table[key]로 조회해도 오류 없이 기본값을 돌려줍니다. 이렇게 쉽게 쓸 수 있는 문법과 오류를 내지 않는 동작이, 개발자가 맵을 안이하게 다루는 데 영향을 줬다는 것이 저자들의 관찰입니다.

아직 끝나지 않은 작업을 남긴 WaitGroup

각 고루틴이 슬라이스의 서로 다른 인덱스에 결과를 쓰더라도, 부모가 너무 일찍 읽기 시작하면 레이스가 납니다. 우버에서 발견한 WaitGroup 사례가 그랬습니다. 개발자는 기다리는 코드를 넣었지만, 기다림에 참여할 작업을 등록하는 위치가 잘못돼 있었습니다.

sync.WaitGroup은 작업들의 완료를 기다리는 그룹 동기화 도구입니다. C++ barrier, pthreads, Java의 barrier나 latch와 달리 참가자 수를 생성 시점에 정하지 않고 동적으로 갱신합니다. Add(int)로 수를 늘리면 Wait()는 그 수만큼 Done()이 호출될 때까지 기다립니다. 우버에서 그룹 동기화 사용은 Go가 Java의 1.9배였습니다.

예제의 WaitGrpExample은 itemIds의 원소 수만큼 고루틴을 만듭니다. 각 고루틴은 처리 성공 여부를 results의 서로 다른 인덱스에 기록하고, 부모 함수는 Wait() 뒤에 슬라이스를 순서대로 읽어 성공한 항목 수를 셉니다. 의도한 순서는 분명합니다. 자식들이 쓰기를 마친 다음 부모가 읽어야 합니다.

그런데 wg.Add(1)이 고루틴 본문 안에 있었습니다. 부모가 wg.Wait()를 호출할 때는 일부 고루틴이 아직 Add()까지 실행하지 못했을 수 있습니다. 등록된 참가자 수가 itemIds 길이보다 적으면 기다림이 일찍 풀리고, 부모가 results를 읽는 동안 뒤늦게 실행된 자식이 같은 슬라이스에 결과를 씁니다.

이 예제에서는 각 고루틴을 시작하기 전에 wg.Add(1)을 실행해야 합니다. Wait()를 호출하는 시점에 기다릴 작업이 모두 등록돼 있어야 하기 때문입니다.

완료를 너무 일찍 알리는 코드도 문제였습니다. 특히 defer와 wg.Done()을 함께 쓰면 소스에 적힌 순서와 실행 순서를 혼동하기 쉽습니다. 여러 defer는 나중에 등록한 것부터 실행합니다.

원문의 다른 예제에서는 이 순서 때문에 doCleanup()보다 wg.Done()이 먼저 실행됩니다. 부모의 wg.Wait()는 풀렸지만 자식의 정리는 아직 남아 있습니다. 부모가 locationErr에 접근하는 동안 자식의 지연 실행 함수 doCleanup()이 같은 변수에 쓰면서 레이스가 발생합니다. 이 코드에서 완료 신호는 마지막 쓰기보다 앞서 있었습니다.

취소 경로에서 충돌한 Future

채널로 완료를 알리는 코드에서도 공유 메모리의 레이스가 나왔습니다. 우버 개발자가 만든 범용 Future는 Start()로 작업을 시작하고 Wait()로 완료를 기다리는 구현입니다. 채널은 신호를 주고받는 데 쓰고, 결과는 객체의 필드에 저장했습니다.

Start()는 고루틴을 만들어 등록된 함수를 실행합니다. 고루틴은 반환값인 response와 err를 기록한 뒤 채널 ch에 메시지를 보내 완료를 알립니다. Wait()는 그 메시지를 기다립니다. 이 경로에서는 결과 기록 뒤에 완료 신호가 옵니다.

하지만 Wait()가 기다리는 사건은 작업 완료만이 아닙니다. Go의 context는 API 경계와 프로세스 사이로 마감 시간, 취소 신호, 요청 범위의 값을 전달합니다. 작업에 시간 제한을 두는 마이크로서비스에서 흔한 사용 방식입니다. 이 Future의 Wait()도 select로 완료 메시지와 context 취소 중 하나를 기다리도록 작성돼 있었습니다.

context가 타임아웃되면 취소를 처리하는 분기가 Future의 err에 ErrCancelled를 기록합니다. 그때 작업 고루틴도 함수의 반환 에러를 같은 err 필드에 쓰고 있을 수 있습니다. 채널로 완료를 기다리는 코드는 있었지만, 취소 분기의 쓰기와 작업 고루틴의 쓰기 사이에는 순서가 없었습니다.

메시지 전달과 공유 메모리를 섞으면서, 완료 경로에서는 드러나지 않던 충돌이 취소 경로에서 나타난 사례입니다.

직렬 실행 가정이 남은 병렬 테스트

레이스의 원인이 항상 제품 코드에 있지는 않았습니다. 우버가 발견한 큰 부류 중 하나는 테스트를 병렬로 실행하면서 생긴 레이스였고, 문제는 테스트 코드와 제품 코드 양쪽에서 나왔습니다.

Go에서는 _test.go로 끝나는 파일에 Test로 시작하는 함수를 작성해 테스트를 실행합니다. 테스트 코드가 testing.T.Parallel()을 호출하면 같은 방식으로 지정한 다른 테스트와 병렬로 실행됩니다. 표 기반 테스트 관용구에 따라 한 Test 함수 안에 여러 하위 테스트를 작성하는 방식도 널리 사용합니다.

우버 개발자들은 테스트 하나에 수십에서 수백 개의 하위 테스트를 작성했고, 시스템은 이를 병렬로 실행했습니다. 개발자가 직렬 실행을 전제로 작성했거나, 커진 테스트 스위트 안에서 공유 객체를 쓰고 있다는 사실을 놓쳤다면 이 실행 방식이 문제가 됩니다.

제품 API의 가정이 깨진 경우도 있었습니다. 원래 스레드 안전성이 필요하지 않아 그렇게 작성하지 않은 API를 테스트가 병렬로 호출한 것입니다. 이런 사례에서는 테스트가 공유하는 객체뿐 아니라, 테스트가 호출하는 제품 API가 어떤 실행 방식을 전제로 했는지도 원인에 포함됐습니다.

우버 모노레포에 한정된 관찰 범위

이 패턴들의 분류는 서로 배타적이지 않습니다. 원문에는 수정한 레이스의 원인을 분류한 도표와 각 패턴의 예제를 모은 링크가 있습니다.

관찰 범위에도 한계가 있습니다. 분석 대상은 우버의 Go 모노레포이므로 다른 코드베이스에서 생기는 패턴을 놓쳤을 수 있습니다. 동적 레이스 탐지 역시 실행한 코드와 고루틴 실행 순서의 조합에 따라 탐지 범위가 달라집니다. 가능한 모든 레이스를 찾지는 못하므로, 이 분석에도 드러나지 않은 패턴이 남을 수 있습니다.

이런 한계가 여기서 관찰한 패턴과 탐지 시스템의 배포 경험까지 무효로 만들지는 않습니다. 다만 모든 환경의 레이스를 빠짐없이 분류한 결과는 아니라는 범위 안에서 읽어야 합니다.

이 글은 Go 데이터 레이스 경험을 다룬 2부작의 두 번째 글입니다. 첫 번째 글은 Go 코드에 동적 레이스 탐지를 대규모로 배포하며 배운 점을 다룹니다. 2022년 6월 게시 당시 저자들은 더 자세한 연구 내용을 ACM SIGPLAN PLDI 2022에 발표할 예정이라고 밝혔습니다.

원문의 주요 수치
항목값
Go 모노레포 규모약 5천만 줄, 고유 Go 서비스 약 2,100개
동시성 비교Go 서비스가 Java 서비스보다 약 8배
6개월간 탐지한 데이터 레이스약 2,000건 (수정 약 1,100건)
분석 대상개발자 210명이 6개월간 수정한 1,100건 이상
MLoC당 맵 구성 요소Java 4,389개, Go 5,950개 (1.34배)
그룹 동기화 사용Go가 Java의 1.9배
마지막 수정 일자