Go의 조건과 그 특징

루프 내부의 조건을 테스트하기 위한 이 두 가지 옵션이 성능 면에서 동일하다고 생각하시나요?

		
if a > b && c*2 > d {
	....
}
// и
if a <= b  { 
  continue;
}
if c*2 > d {
 ....
}

모든 것은 "뇌 준비 운동"으로 시작되었습니다; 정수 배열 [-x....x]에서 가장 큰 짝수에 대한 최적 검색의 예를 제시해야 했습니다. 숫자가 짝수인지 아닌지 알아내기 위해 1의 논리적 곱셈을 사용하면 얼마나 더 나은 성능이 나올지 궁금했습니다.

//у четных чисел последний бит всегда равен 0
value & 1 == 0
//vs классический метод
value % 2 == 0

Go에서의 내 프로그래밍 경험은 그다지 광범위하지 않습니다. XNUMX년 반이 조금 넘었고 자주 사용했지만 순전히 실용적인 목적으로 사용했습니다(음, 아마도 고부하 http 서비스와 관련된 프로젝트 하나를 제외하고). 그것으로 시작되었습니다. GoLand를 열고 간단한 테스트 작성

package main
import (
	"fmt"
	"log"
	"math"
	"math/rand"
	"time"
)
const size = 100000000 //math.MaxInt32*2
type Result struct {
	Name     string
	Duration time.Duration
	Value    int32
}

func main() {
	log.Println("initial array capacity: " + fmt.Sprint(size))
	var maxValue int32
        // Будем варьировать диапазон чисел от минимального 
        // до максимального. Чем меньше диапазон, тем больше 
        // процессорного времени будет уходить на операцию 
        // сравнения текущего числа, с ранее найденным и наоборот
	for maxValue = 128; maxValue < math.MaxInt32/2+1; maxValue = maxValue * 2 {
		test(maxValue)
	}
}

func test(maxValue int32) {
	log.Println("max threshold: " + fmt.Sprint(maxValue))
	arr := make([]int32, size)
	for i := range arr {
		arr[i] = rand.Int31n(maxValue)
                // в тестовых данных нам нужны и отрицательные числа 
		sign := rand.Intn(2)
		if sign == 1 {
			arr[i] = -arr[i]
		}
	}

        // запускаем тест "деление с остатком"
	result := maxEvenDividing("maxEvenDividing", arr)
	log.Printf(result.Name+"t result: "+fmt.Sprint(result.Value)+"ttduration %s", result.Duration)

        // запускаем тест "конъюнкции"
	result = maxEvenConjunction("maxEvenConjunction", arr)
	log.Printf(result.Name+"t result: "+fmt.Sprint(result.Value)+"ttduration %s", result.Duration)
}

func maxEvenDividing(name string, arr []int32) Result {
	start := time.Now()
	var current int32 = math.MinInt32
	for _, value := range arr {
		if value > current && value%2 == 0 {
			current = value
		}
	}
	duration := time.Since(start)
	result := Result{name, duration, current}
	return result
}

func maxEvenConjunction(name string, arr []int32) Result {
	start := time.Now()
	var current int32 = math.MinInt32
	for _, value := range arr {
		if value > current && value&1 == 0 {
			current = value
		}
	}
	duration := time.Since(start)
	result := Result{name, duration, current}
	return result
}

임계값이 높을수록 성능 변동이 더 자주 나타나는 것을 보여주는 결과를 얻었습니다.

비교max threshold: 128
maxEvenDividing result: 126 duration 116.0067ms
maxEvenConjunction result: 126 duration 116.0066ms

max threshold: 16384
maxEvenDividing result: 16382 duration 115.0066ms
maxEvenConjunction result: 16382 duration 111.0064ms

......

max threshold: 8388608
maxEvenDividing result: 8388606 duration 109.0063ms
maxEvenConjunction result: 8388606 duration 109.0062ms

max threshold: 16777216
maxEvenDividing result: 16777214 duration 108.0062ms
maxEvenConjunction result: 16777214 duration 109.0062ms

max threshold: 33554432
maxEvenDividing result: 33554430 duration 114.0066ms
maxEvenConjunction result: 33554430 duration 110.0063ms

max threshold: 67108864
maxEvenDividing result: 67108860 duration 111.0064ms
maxEvenConjunction result: 67108860 duration 109.0062ms

max threshold: 134217728
maxEvenDividing result: 134217726 duration 108.0062ms
maxEvenConjunction result: 134217726 duration 109.0063ms

max threshold: 268435456
maxEvenDividing result: 268435446 duration 111.0063ms
maxEvenConjunction result: 268435446 duration 110.0063ms

이 경우 다양한 임계값에 대해 다양한 테스트 데이터 세트가 있고 프로세서 로드(i5-2540M 노트북)는 약 20..30% 정도 다양하며 GoLand에서 실행되는 애플리케이션이 차지하는 메모리는 평균입니다. 약 813MB - 이는 결과의 신뢰성에도 영향을 미치므로 테스트 사례를 디스크에 저장하고 각 임계값에 대해 모든 테스트를 서로 격리하여 실행해야 합니다.

그리고 이제 이 모든 것을 어떻게 하면 최소한의 비용으로 구현할 수 있을까 고민하다가 자동으로 상태체크를 수정해줍니다

		
if value > current && value&1 == 0 {
	current = value
}

에

		
if value <= current {
        continue;
}
if value&1 == 0 {
	current = value
}

테스트를 다시 실행했는데... 아무것도 이해가 안 되네요 :)

실행에 소요되는 시간은 더 이상 백분율/분율이 아니라 10..15%로 달라지기 시작합니다. 신속하게 2개의 테스트를 더 추가합니다.

		
func maxEvenDividing2(name string, arr []int32) Result {
	start := time.Now()
	var current int32 = math.MinInt32
	for _, value := range arr {
		if value <= current {
			continue
		}

		if value%2 == 0 {
			current = value
		}
	}
	duration := time.Since(start)
	result := Result{name, duration, current}
	return result
}

func maxEvenConjunction2(name string, arr []int32) Result {
	start := time.Now()
	var current int32 = math.MinInt32
	for _, value := range arr {
		if value <= current {
			continue
		}
		if value&1 == 0 {
			current = value
		}
	}
	duration := time.Since(start)
	result := Result{name, duration, current}
	return result
}

나는 그것을 실행하고 다음 그림을 얻습니다.초기 어레이 용량: 100000000

최대 임계값: 128
maxEvenDividing 결과: 126 지속 시간 116.0066ms
maxEvenDividing2 결과: 126 지속 시간 79.0045ms
maxEvenConjunction 결과: 126 지속 시간 114.0065ms
maxEvenConjunction2 결과: 126 지속 시간 83.0048ms

최대 임계값: 256
maxEvenDividing 결과: 254 지속 시간 111.0063ms
maxEvenDividing2 결과: 254 지속 시간 77.0044ms
maxEvenConjunction 결과: 254 지속 시간 110.0063ms
maxEvenConjunction2 결과: 254 지속 시간 80.0046ms

최대 임계값: 512
maxEvenDividing 결과: 510 지속 시간 114.0066ms
maxEvenDividing2 결과: 510 지속 시간 80.0045ms
maxEvenConjunction 결과: 510 지속 시간 110.0063ms
maxEvenConjunction2 결과: 510 지속 시간 80.0046ms

최대 임계값: 1024
maxEvenDividing 결과: 1022 지속 시간 109.0063ms
maxEvenDividing2 결과: 1022 지속 시간 77.0044ms
maxEvenConjunction 결과: 1022 지속 시간 111.0063ms
maxEvenConjunction2 결과: 1022 지속 시간 81.0047ms

최대 임계값: 2048
maxEvenDividing 결과: 2046 지속 시간 114.0065ms
maxEvenDividing2 결과: 2046 지속 시간 79.0045ms
maxEvenConjunction 결과: 2046 지속 시간 113.0065ms
maxEvenConjunction2 결과: 2046 지속 시간 81.0046ms

최대 임계값: 4096
maxEvenDividing 결과: 4094 지속 시간 114.0065ms
maxEvenDividing2 결과: 4094 지속 시간 80.0046ms
maxEvenConjunction 결과: 4094 지속 시간 111.0063ms
maxEvenConjunction2 결과: 4094 지속 시간 78.0045ms

최대 임계값: 8192
maxEvenDividing 결과: 8190 지속 시간 107.0062ms
maxEvenDividing2 결과: 8190 지속 시간 77.0044ms
maxEvenConjunction 결과: 8190 지속 시간 111.0063ms
maxEvenConjunction2 결과: 8190 지속 시간 77.0044ms

최대 임계값: 16384
maxEvenDividing 결과: 16382 지속 시간 109.0063ms
maxEvenDividing2 결과: 16382 지속 시간 77.0044ms
maxEvenConjunction 결과: 16382 지속 시간 108.0062ms
maxEvenConjunction2 결과: 16382 지속 시간 77.0044ms

최대 임계값: 32768
maxEvenDividing 결과: 32766 지속 시간 112.0064ms
maxEvenDividing2 결과: 32766 지속 시간 77.0044ms
maxEvenConjunction 결과: 32766 지속 시간 109.0062ms
maxEvenConjunction2 결과: 32766 지속 시간 78.0045ms

최대 임계값: 65536
maxEvenDividing 결과: 65534 지속 시간 109.0062ms
maxEvenDividing2 결과: 65534 지속 시간 75.0043ms
maxEvenConjunction 결과: 65534 지속 시간 109.0063ms
maxEvenConjunction2 결과: 65534 지속 시간 79.0045ms

최대 임계값: 131072
maxEvenDividing 결과: 131070 지속 시간 108.0061ms
maxEvenDividing2 결과: 131070 지속 시간 76.0044ms
maxEvenConjunction 결과: 131070 지속 시간 110.0063ms
maxEvenConjunction2 결과: 131070 지속 시간 80.0046ms

최대 임계값: 262144
maxEvenDividing 결과: 262142 지속 시간 110.0063ms
maxEvenDividing2 결과: 262142 지속 시간 76.0044ms
maxEvenConjunction 결과: 262142 지속 시간 107.0061ms
maxEvenConjunction2 결과: 262142 지속 시간 78.0044ms

최대 임계값: 524288
maxEvenDividing 결과: 524286 지속 시간 109.0062ms
maxEvenDividing2 결과: 524286 지속 시간 78.0045ms
maxEvenConjunction 결과: 524286 지속 시간 109.0062ms
maxEvenConjunction2 결과: 524286 지속 시간 80.0046ms

최대 임계값: 1048576
maxEvenDividing 결과: 1048574 지속 시간 109.0063ms
maxEvenDividing2 결과: 1048574 지속 시간 80.0045ms
maxEvenConjunction 결과: 1048574 지속 시간 114.0066ms
maxEvenConjunction2 결과: 1048574 지속 시간 78.0044ms

최대 임계값: 2097152
maxEvenDividing 결과: 2097150 지속 시간 111.0064ms
maxEvenDividing2 결과: 2097150 지속 시간 79.0045ms
maxEvenConjunction 결과: 2097150 지속 시간 112.0064ms
maxEvenConjunction2 결과: 2097150 지속 시간 77.0044ms

최대 임계값: 4194304
maxEvenDividing 결과: 4194302 지속 시간 111.0063ms
maxEvenDividing2 결과: 4194302 지속 시간 78.0045ms
maxEvenConjunction 결과: 4194302 지속 시간 111.0063ms
maxEvenConjunction2 결과: 4194302 지속 시간 77.0044ms

최대 임계값: 8388608
maxEvenDividing 결과: 8388606 지속 시간 109.0062ms
maxEvenDividing2 결과: 8388606 지속 시간 78.0045ms
maxEvenConjunction 결과: 8388606 지속 시간 114.0065ms
maxEvenConjunction2 결과: 8388606 지속 시간 78.0045ms

최대 임계값: 16777216
maxEvenDividing 결과: 16777214 지속 시간 109.0062ms
maxEvenDividing2 결과: 16777214 지속 시간 77.0044ms
maxEvenConjunction 결과: 16777214 지속 시간 109.0063ms
maxEvenConjunction2 결과: 16777214 지속 시간 77.0044ms

최대 임계값: 33554432
maxEvenDividing 결과: 33554430 지속 시간 113.0065ms
maxEvenDividing2 결과: 33554430 지속 시간 78.0045ms
maxEvenConjunction 결과: 33554430 지속 시간 110.0063ms
maxEvenConjunction2 결과: 33554430 지속 시간 80.0045ms

최대 임계값: 67108864
maxEvenDividing 결과: 67108860 지속 시간 112.0064ms
maxEvenDividing2 결과: 67108860 지속 시간 77.0044ms
maxEvenConjunction 결과: 67108860 지속 시간 112.0064ms
maxEvenConjunction2 결과: 67108860 지속 시간 80.0046ms

최대 임계값: 134217728
maxEvenDividing 결과: 134217726 지속 시간 109.0063ms
maxEvenDividing2 결과: 134217726 지속 시간 78.0044ms
maxEvenConjunction 결과: 134217726 지속 시간 114.0065ms
maxEvenConjunction2 결과: 134217726 지속 시간 81.0047ms

최대 임계값: 268435456
maxEvenDividing 결과: 268435446 지속 시간 111.0064ms
maxEvenDividing2 결과: 268435446 지속 시간 79.0045ms
maxEvenConjunction 결과: 268435446 지속 시간 114.0065ms
maxEvenConjunction2 결과: 268435446 지속 시간 79.0045ms

최대 임계값: 536870912
maxEvenDividing 결과: 536870910 지속 시간 107.0062ms
maxEvenDividing2 결과: 536870910 지속 시간 76.0043ms
maxEvenConjunction 결과: 536870910 지속 시간 109.0062ms
maxEvenConjunction2 결과: 536870910 지속 시간 80.0046ms

Go 컴파일러가 코드를 최적화하지 않고 첫 번째 조건이 false인 경우에도 항상 두 번째 조건을 확인하는 이유에 대한 명확한 설명을 찾을 수 없습니다. 아니면 내 눈이 흐릿해서 뚜렷한 실수가 보이지 않는 걸까요? 아니면 컴파일러에 특별한 지침을 제공해야 합니까? 합리적인 의견을 주시면 기쁘겠습니다.

추신: 예, 재미삼아 Java 5와 Java 7/8에서 유사한 테스트를 실행했습니다. 모든 것이 명확하고 실행 시간도 동일합니다.

출처 : habr.com