Почему простой цикл на c++ выполняется медленнее, чем на golang?

Question

[kr_ilya]

Цикл инкрементирующий значение переменной на C++

int main(){
    long long c = 0;
    for(long long i = 0; i < 1000000000; i++){
        c++;
    }
   
    return 1;
}

Аналогичный цикл на Go

package main
func main(){
	var f int64 = 0

	for i := 0; i < 1000000000; i++{
		f++
	}
}

Время выполнения, слева C++, справа Go


Как видно, время выполнения на плюсах почти 2 секунды, в то время как на Go около 300 мс.

В чем причина медлительности плюсов и как можно ускорить выполнение?

Версии компиляторов

Comments

[d'Ivan]

Надо прогнать несколько раз для "разогрева".

[shurshur]

Для начала время надо считать в самой программе: взять время до цикла и после. А то тут неясно сколько времени занял запуск и завершения программы.

[Андрей Антропов]

В плюсах оптимизации не включены, да и собирать лучше с помощью clang, он банально лучше оптимизирует. Да и меня смущает рантайм в 2 секунды. Советую прогнать ещё пару раз

[dollar]

Хм, быстрый онлайн тест:
Go: https://rextester.com/FHPG59554 - примерно 0.5 сек
C++: https://rextester.com/NXO73899 - примерно 0.2 сек

P.S. По этим ссылкам каждый следующий замер лучше делать через 10 сек, а то там походу автоматом понижается приоритет, если большую нагрузку давать.

[kr_ilya]

shurshur, Román Mirilaczvili,

[rPman]

я в шоке!
жесть жесть жесть, подписываюсь под вопросом, добавил в код вывод и усложнил логику чуть чуть (мало ли компилятор вырежет все), вывод листинга

package main

import (
    "fmt"
    "os"
)

func main(){
  var f int64 = 0

  for i := 0; i < 1000000000; i++{
    f+=f ^ 0x82fc012dd
  }
  fmt.Fprintln(os.Stdout, f)
}

#include <stdio.h>

int main(){
    long long c = 0;
    for(long long i = 0; i < 10000000000; i++){
        c+=c xor 0x82fc012dd;
    }
    printf("result: %llu",c);
    return 1;
}

echo g++
g++ a.cpp -O3 -o a.exe && time ./a.exe
echo clang
clang a.cpp -O3 -o a.exe && time ./a.exe
echo golang
go tool compile -S main.go > main.s && time ./main

g++
result: 35160855261
real    0m4,386s
user    0m4,386s
sys     0m0,000s
clang
result: 35160855261
real    0m4,436s
user    0m4,435s
sys     0m0,000s
golang
35160855261

real    0m0,046s
user    0m0,046s
sys     0m0,000s

go оптимизирует код просто шикарно:

0x0014 00020 (main.go:8)	XORL	AX, AX
	0x0016 00022 (main.go:8)	XORL	CX, CX
	0x0018 00024 (main.go:11)	JMP	45
	0x001a 00026 (main.go:11)	INCQ	AX
	0x001d 00029 (main.go:12)	MOVQ	$35160855261, DX
	0x0027 00039 (main.go:12)	XORQ	CX, DX
	0x002a 00042 (main.go:12)	ADDQ	DX, CX
	0x002d 00045 (main.go:11)	CMPQ	AX, $1000000000
	0x0033 00051 (main.go:11)	JLT	26

а gcc делает тоже вроде ничего даже пытается оптимизировать но у него все равно не получилось

# %bb.0:
	movabsq	$-10000000000, %rax             # imm = 0xFFFFFFFDABF41C00
	movabsq	$35160855261, %rcx              # imm = 0x82FC012DD
	xorl	%esi, %esi
	.p2align	4, 0x90
.LBB0_1:                                # =>This Inner Loop Header: Depth=1
	movq	%rsi, %rdx
	xorq	%rcx, %rdx
	addq	%rsi, %rdx
	movq	%rdx, %rsi
	xorq	%rcx, %rsi
	addq	%rdx, %rsi
	movq	%rsi, %rdx
	xorq	%rcx, %rdx
	addq	%rsi, %rdx
	movq	%rdx, %rsi
	xorq	%rcx, %rsi
	addq	%rdx, %rsi
	movq	%rsi, %rdx
	xorq	%rcx, %rdx
	addq	%rsi, %rdx
	movq	%rdx, %rsi
	xorq	%rcx, %rsi
	addq	%rdx, %rsi
	movq	%rsi, %rdx
	xorq	%rcx, %rdx
	addq	%rsi, %rdx
	movq	%rdx, %rsi
	xorq	%rcx, %rsi
	addq	%rdx, %rsi
	addq	$8, %rax
	jne	.LBB0_1

[shurshur]

rPman, это было следующее, что я хотел предложить проверить - оптимизации :)

В своё время товарищи обнаружили, что рекурсивные фибоначчи на java работают быстрее, оказалось, что gcc при вызове каждой функции пушит в стек два регистра, а при завершении - достаёт обратно.

[Adamos]

А еще можно посмотреть вывод в С++ sizeof(long) и sizeof(long long) для вашего компилятора.

[Евгений Шатунов]

rPman, как бы long long c = 0; не является кодом C++. Типа по умолчанию в C++ нет.
Да и в целом, это код C, а не C++. Но собираешь ты его через g++, подтверждая лишний раз нестандартность подхода к стандарту C++ в GCC.
GCC очень во многих примерах кода сильно отстает от MSCL и clang. Я бы рекомендовал использовать clang для проверок в этом вопросе.

Так... я все-таки обратил внимание на то, что приведенный в вопросе код ровно такой же. Это значит, вопросы по поводу соблюдения стандарта стоит задавать автору. А я, в итоге, не на того человека сослался со своим комментарием.

Answer 1

[Roman K]

Да хотя бы потому что оптимизатор может выбросить цикл, посчитав его ненужным. Есть оптимизации, которые умеют цикл заменять прогрессией, а здесь цикл можно вовсе удалить, тк он не влияет ни на что

Answer 2

[Wataru]

Вы сами в комментариях привели дизассемблированный код. Go по какой-то причине оптимизирует код лучше - тупо выкидывает весь ваш цикл.

Чтобы этого не было, можно ксорить не с константой, а с индексом i, например.

Answer 3

[mayton2019]

Судя по скриншоту это windows. Если вы делаете бенчмарки под windows - то нужно правильно мерять время. Скорее всего вы меряли не время цикла а время запуска windows процесса + время цикла. Вместе с статическими конструкторами. И эти конструкторы в go оказались удачнее.

Короче вы не втом месте включали секундомер. А то так можно и доказать что PHP быстрее чем C++.

Comments

[kr_ilya]

Вот время цикла

[mayton2019]

kr_ilya, интересное наблюдение. Я проверю ваш эксперимент вечером на clang/gcc c разными настройками. Возможно golang действительно срезает углы на поворотах. Впрочем, если заменить ваш код на более полезный, я думаю такая разница будет нивелирована.

Answer 4

[kr_ilya]

С добавлением полезной нагрузки в цикл и флага оптимизации -O2 при компиляции на плюсах получились такие результаты
c++

#include <iostream>
#include <chrono>

int main(){
    auto start_time = std::chrono::steady_clock::now();
    long long c = 0;
    for(long long i = 0; i < 1000000000; i++){
        c+=c xor i;
    }

    auto end_time = std::chrono::steady_clock::now();
    auto elapsed_ns = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time);
    std::cout << elapsed_ns.count() << " ms\n";
    std::cout << c << std::endl;
    return 1;
}

go

package main

import (
	"fmt"
	"time"
)

func main(){
	var f int64 = 0
	var i int64 = 0
	start := time.Now()

	for i = 0; i < 1000000000; i++{
		f+=f ^ i
	}
	duration := time.Since(start)

	fmt.Println(duration)
	fmt.Println(f)
}

Всё дело в оптимизации

Comments

[mayton2019]

В каком нибудь гипотетическом ленивом ЯП из семейства функциональных подобные бенчмарки тоже давали бы 0 миллисекунд т.к компилятор посчитал бы тело цикла бесполезным и не влияющим на результат.