29.2. 프로그램언어 고(Go)의 CPU 이용 최적화 방법

by

프로그램언어 고(Go)에서의 고루틴 사용으로 멀티스레딩 최적화 하기

Go 언어에서 고루틴(goroutine)을 사용하면 멀티스레딩을 최적화할 수 있습니다. 고루틴은 Go 언어의 가볍고 효율적인 스레드입니다. 


package main

import (
    "fmt"
    "time"
)

func process(no int) {
    for i := 0; i < 10; i++ {
        fmt.Println(no, ":", i)
        time.Sleep(time.Millisecond * 500)
    }
}

func main() {
    
    // 고루틴 실행
    go process(1) 
    go process(2)

    time.Sleep(time.Second * 10)
}

위의 코드에서 main 함수에서 process 함수를 고루틴으로 실행합니다.
이렇게 하면 두 개의 고루틴이 병렬로 실행되어 멀티스레딩 처럼 동작합니다.

고루틴의 장점은 스레드와 달리 매우 가볍다는 것입니다.
수천 개도 수만 개도 문제없이 많은 고루틴을 생성할 수 있습니다.

따라서 Go 언어로 많은 요청을 처리하는 서버등을 구현할 때 고루틴을 활용하면 효율적인 멀티스레딩 처리가 가능합니다.
고루틴은 채널과 함께 사용되어 병렬처리 및 동기화도 효과적으로 구현할 수 있습니다.

프로그램언어 고(Go)에서의 동시성 관리를 위한 채널 사용법

프로그램 언어 Go에서 동시성을 위해 제공하는 채널은 고루틴들 간에 데이터를 안전하게 교환할 수 있는 통로입니다. 


package main

import "fmt"

func sum(s []int, c chan int) {
    sum := 0
    for _, v := range s {
        sum += v
    }
    c <- sum // sum을 채널 c로 보냅니다. 
}

func main() {
    s := []int{7, 2, 8, -9, 4, 0}

    c := make(chan int)
    go sum(s[:len(s)/2], c)
    go sum(s[len(s)/2:], c)
    x, y := <-c, <-c // 채널 c로부터 두 개의 결과를 받습니다.

    fmt.Println(x, y, x+y)
}

위 예제코드에서 채널 c를 생성하고, 배열 s를 반씩 나누어 두 고루틴에 전달합니다. 각 고루틴은 자신이 받은 배열의 합을 계산한 뒤, 그 결과값을 채널 c로 보냅니다.

main 고루틴에서는 채널 c로부터 두 결과값 x와 y를 받아서 출력합니다. 이로써 고루틴 간 데이터 전달이 안전하게 이뤄집니다.

채널을 사용할 때는 make를 사용해서 채널을 생성하고, 채널로 데이터를 보내기 위해서는 <- 연산자를 사용합니다. 반대로 채널로부터 데이터를 받기 위해서도 <- 연산자를 사용합니다. 채널을 사용하면 동기화 문제를 피할 수 있고, 데이터 경쟁을 방지할 수 있습니다. 또한 별도의 잠금 메커니즘 없이도 데이터를 안전하게 교환할 수 있어 효율적인 동시성 프로그래밍이 가능합니다. 이 외에도 채널은 방향성을 가질 수 있습니다. send only 혹은 receive only 채널로 선언할 수 있으며, 버퍼도 설정할 수 있습니다. 다양한 방식으로 동시성 문제를 효과적으로 해결할 수 있습니다.

프로그램언어 고(Go)에서의 CPU 캐시 지역성 활용하기

프로그램언어 고(Go)에서 CPU 캐시 지역성을 활용하기 위해서는 주로 배열이나 슬라이스를 사용할 때 연속적인 메모리 접근 패턴을 만드는 것이 좋습니다.

예를 들어 배열이나 슬라이스를 순차적으로 접근하는 경우 CPU 캐시에 순차적인 데이터가 올라가기 때문에 캐시 히트율이 높아지므로 성능이 좋아집니다.


package main

import "fmt"

func main() {

    // 길이가 100인 int 배열
    arr := [100]int{} 

    // 배열 순차적으로 접근
    for i := 0; i < len(arr); i++ {
        arr[i] = i 
    }

    // 배열을 다시 순차적으로 접근
    for i := 0; i < len(arr); i++ {
        fmt.Println(arr[i]) 
    }

}

위의 코드에서 볼 수 있듯이, 배열 arr을 한 번 순차적으로 접근하여 값을 저장합니다.

그리고 다시 배열을 순차적으로 접근하여 값을 출력하는데, 이 때 CPU 캐시에 이전 접근에서 순차적으로 올라갔던 데이터가 있기 때문에 캐시 히트율이 높아지게 됩니다.

반면에 배열이나 슬라이스를 무작위로 접근하는 경우에는 CPU 캐시 히트율이 낮아지므로 성능이 떨어집니다.

가능하다면 순차적인 접근 패턴을 사용하는 것이 좋습니다.

슬라이스를 사용할 때에도 마찬가지입니다. 순차적으로 append하고 접근하면 성능 이점이 있습니다.

이 외에도 다차원 배열을 순차적으로 접근하는 경우, 구조체를 연속적으로 접근하는 경우등도
CPU 캐시 지역성을 활용할 수 있는 경우이므로 활용할 수 있도록 구현하는 것이 좋습니다.

위 설명이 도움이 되셨기를 바랍니다.

프로그램언어 고(Go)에서의 최적화된 루프 작성법


// for문 사용 시
for i := 0; i < n; i++ {
  // 루프 본문
}

// 배열/슬라이스 순회 시 
for i, v := range arr {
  // i는 인덱스, v는 값
} 

// 채널 순회 시
for v := range ch {
  // v는 채널에서 받은 값 
}

// 문자열 순회 시
for i, c := range str {
  // i는 인덱스, c는 문자(rune)
}

Go언어에서 효율적인 루프 작성을 위해 몇 가지 팁이 있습니다.

첫째, for문 보다는 배열/슬라이스를 range로 순회하는 것이 더 빠릅니다. range는 배열/슬라이스의 길이를 자동으로 계산하므로 별도로 길이를 저장하거나 계산할 필요가 없습니다.

둘째, 인덱스 변수를 _로 생략할 수 있습니다. 인덱스가 필요없다면 이를 활용하는 것이 좋습니다.


for _, v := range arr {
  // v만 사용  
}

이렇게 하면 인덱스 계산이 추가로 발생하지 않아 성능 향상을 기대할 수 있습니다.

셋째, 채널이나 문자열을 순회할 때도 비슷한 원리로 range를 사용하는 것이 좋습니다. 내장 함수를 사용하는 것보다 효율적입니다.

넷째, 루프 본문에서 할당이나 호출을 최소화하는 것도 중요합니다. 특히 인터페이스처럼 추상화된 타입을 다룰 때 주의가 필요합니다. 인터페이스 타입을 직접 다루기보다는 구조체를 정의해서 사용하는 것이 더 효율적일 수 있습니다.

다섯째, defer 문의 사용도 지양해야 합니다. defer는 함수 return 시까지 처리를 지연시키기 때문에, 루프 내에서 사용 시 불필요한 오버헤드가 발생합니다.

여섯째, goroutine 을 사용하는 병렬처리도 고려할 수 있습니다. 하지만 goroutine 이 많을 경우 오히려 오버헤드가 증가하므로 적정 수준을 유지하는 것이 중요합니다.

일곱째, 벤치마크를 통해 실제 성능을 확인하는 것도 도움이 됩니다. 이를 통해 병목구간을 찾고 문제를 개선할 수 있습니다.

이상 Go언어에서 루프를 효율적으로 작성하기 위한 몇가지 팁을 소개드렸습니다. 상황에 맞게 적절히 활용한다면 성능 개선의 여지가 많다고 생각합니다.

프로그램언어 고(Go)에서의 비용가능한 함수 호출 방법

package main

import (
    "fmt"
    "time"
)

func process(i int) {
    fmt.Println(i)
    time.Sleep(time.Second)
}

func main() {

    // 병렬처리를 위한 channel 선언
    ch := make(chan int)

    // goroutine을 사용한 병렬 처리
    go func() {
        for i := 0; i < 10; i++ {
            ch <- i
        }
    }()

    for i := range ch {
        // channel을 통해 수신된 값 처리
        go process(i) 
    }

    //main goroutine 종료 대기
    time.Sleep(time.Second * 10)
}

고(Go)에서 함수를 호출할 때 goroutine을 사용하면 비동기적으로 실행할 수 있어서 비용가능한 함수 호출이 가능합니다.

위의 예제코드에서 보면 main 함수에서 for 반복문을 사용해서 goroutine을 생성하고 있습니다. 

go process(i)

이 부분이 goroutine을 사용해서 process 함수를 비동기적으로 호출하는 부분입니다.

goroutine을 사용하면 해당 함수는 별도의 고루틴에서 비동기적으로 실행되기 때문에 함수 호출에 따른 비용을 줄일 수 있습니다.
즉, 함수 호출 후 바로 다음 라인의 코드로 진행되므로 함수의 실행 결과를 기다리지 않고도 프로그램을 계속해서 진행할 수 있습니다.

다만 goroutine만 사용하면 main 함수가 종료되면서 프로그램도 같이 종료되기 때문에 

time.Sleep(time.Second * 10)

과 같이 main goroutine을 일정 시간 동안 대기시켜야 정상적으로 결과를 확인할 수 있습니다.

이와 같이 고(Go)에서는 goroutine을 사용하여 함수를 비동기적으로 호출함으로써 비용 가능한 함수 호출을 실현할 수 있습니다.
즉 다른 함수의 실행을 기다리지 않고도 프로그램을 계속해서 진행할 수 있기 때문에 효율적인 처리가 가능합니다.

Leave a Comment