התנאים בגו והמוזרות שלהם

האם אתה חושב ששתי האפשרויות הללו לבדיקת תנאים בתוך לולאה שוות ערך בביצועים?

		
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 אינו נרחב במיוחד, קצת יותר משנה וחצי, השתמשתי בו, אם כי לעתים קרובות, אבל אך ורק למטרות תועלתניות (טוב, אולי חוץ מפרויקט אחד שקשור לשירות 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 לא מייעל את הקוד ותמיד בודק את התנאי השני, גם אם הראשון הוא שקר. או שאולי העיניים שלי פשוט מטושטשות ואני לא רואה שום טעות ברורה? או שאתה צריך לספק כמה הוראות מיוחדות למהדר? אשמח לתגובות הגיוניות.

נ.ב.: כן, סתם בשביל הכיף, הרצתי בדיקות דומות על Java 5 ו-Java 7/8 - הכל ברור, זמן הביצוע זהה.

מקור: www.habr.com