How can this Go code be faster than the C version

The following programs are, as far as I can tell, identical. However, for small sizes (<30000), the go version is considerably faster.

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

Architecture:
Darwin, arm64

The C code was compiled with the following command:

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;
}

I have attempted to disassemble the code for both, but Go's assembly is quite hard to read.
The error is not in the timekeeping method, as the time to complete scales linearly with the array size.
Of note is that for larger arrays, C starts to pull ahead significantly, presumably due to increased GC calls.

I'm not familiar with go and its random number function(s) in particular.

But, I doubt that go's math/rand function rand.Intn will produce the same numbers as libc's rand function.

Ordinarily, the data wouldn't matter but we're using the random values as an index into the array to get the size/length of the array we're modifying.

That is, (e.g.) in the go program, we might use index 50 and the C program might use index 137.

Therefore, these index/size numbers must be the same for both programs. To verify this, we can print them out before using them. The outputs must match.

So, your go program and your C program are not equivalent tests.

We could spend a lot of time trying to find a [standard] C function that is equivalent to go's. But, an easier way is to write our own common/compatible function.

For the testing purposes here, the quality of the random function isn't much of an issue. A simple/reliable random function can be an LCG (linear congruential generator). See: https://en.wikipedia.org/wiki/Linear_congruential_generator

We can create our own version(s) of this in the code as it's just a one-liner (e.g.):

seed = (seed * 1103515245) + 12345;

I've modified your program to [optionally] use a simple LCG instead of libc's rand.

You'll need to modify your go program equivalently.

Here is the modified program:

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
unsigned int seed = 1;
int opt_r;
int opt_p;
int
myrand(void)
{
int val;
// use LCG algorithm
if (opt_r) {
seed = (seed * 1103515245) + 12345;
val = seed;
}
else
val = rand_r(&seed);
return val;
}
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(int argc,char **argv)
{
--argc;
++argv;
for (;  argc > 0;  --argc, ++argv) {
char *cp = *argv;
if (*cp != '-')
break;
cp += 2;
switch (cp[-1]) {
case 'r':
opt_r = ! opt_r;
break;
case 'p':
opt_p = ! opt_p;
break;
}
}
size_t size = 1000;
if (--argc > 0)
size = strtol(*argv++,NULL,10);
printf("size=%zu\n",size);
if (--argc > 0)
seed = strtol(*argv++,NULL,10);
printf("seed=%u\n",seed);
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] = myrand() % size;
if (opt_p)
printf("array[%zu]=%d\n",i,array[i]);
}
const clock_t start = clock();
while (array_size > 0) {
size_t array_index = array[array_size / 2] % array_size;
if (opt_p)
printf("array_index=%zu\n",array_index);
array_size = Array_Splice(array, array_size, array_index);
}
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;
}

Invoke with -p to print values (i.e. the timing will be meaningless).

Invoke with -r to use the LCG algorithm. Properly implemented [in go], the numbers will match with this option.

After that, the two programs will be making a meaningful timing comparison.