为何小规模场景下Go代码运行速度优于C代码？

据我观察，以下两段程序逻辑完全一致，但在数组规模小于30000的场景下，Go版本的运行速度明显更快。

测试数据 #

Time taken for size 1000 in Go: 35.417µs
Time taken for size 1000 in C:  74.000000us

环境信息 #

• 架构：Darwin, arm64

C代码编译命令 #

clang -O2 -march=native -mtune=native -g main.c

Go代码实现 #

package main

import (
   "fmt"
   "math/rand"
   "time"
)

func ArraySplice(array []int, index int) []int {
   return append(array[:index], array[index+1:]...)
}

func main() {
   s := 1000;
   array := make([]int, s)

   for i := 0; i < s; i++ {
      array[i] = rand.Intn(s)
   }

   start := time.Now()
   for len(array) > 0 {
      array = ArraySplice(array, array[len(array)/2] % len(array))
   }
   end := time.Now()
   fmt.Printf("Time taken for size %d: %v\n", s, end.Sub(start))
}

C代码实现 #

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

static inline size_t Array_Splice(int* array, size_t size, size_t index) {
   if (index >= size)
      return size;
   for (size_t i = index; i < size - 1; i++) {
      array[i] = array[i + 1];
   }
   return size - 1;
}

int main(void)
{
   const size_t size = 1000;
   size_t array_size = size;
   int* array = malloc(array_size * sizeof(int));
   if (array == NULL) {
      return 1;
   }

   for (size_t i = 0; i < size; i++) {
      array[i] = rand() % size;
   }

   const clock_t start = clock();
   while (array_size > 0) {
      array_size = Array_Splice(array, array_size, array[array_size/2] % array_size);
   }
   const clock_t end = clock();
   const double time_taken = (double)(end - start) / (CLOCKS_PER_SEC / 1000000.0f);
   printf("Time taken for size %lu: %fus\n", size, time_taken);

   free(array);
   return 0;
}

补充说明 #

• 尝试过反汇编两段代码，但Go的汇编代码难以阅读。
• 计时方式不存在问题，运行时间随数组规模线性增长。
• 数组规模较大时C代码会显著领先，推测是Go的GC调用增加所致。

内容的提问来源于stack exchange，提问作者Bogdan Ionescu