Может ли C# догнать C?

Вы правы, SIMD-оптимизации не были учтены, и это сильно портит сравнение. Однако Span<T>.Fill() я бы, все же, сравнил с memcpy. Хотелось посмотреть на то, как оптимизируются банальные вещи, без специфического тюнинга кода под задачу.

Может ли C# догнать C?

Справедливости ради, компилятор указан в начале статьи

Может ли C# догнать C?

Вроде бы, нет тут SIMD

Код асемблера:

	.file	"test.c"
	.text
	.section	.rodata.str1.8,"aMS",@progbits,1
	.align 8
.LC0:
	.string	"memsize=%zxh sizeof(size_t)=%zx cache_line=%lu\n"
	.section	.rodata.str1.1,"aMS",@progbits,1
.LC1:
	.string	"unable to allocate memory\n"
.LC2:
	.string	"iter=%d seq time=%lu\n"
	.section	.text.startup,"ax",@progbits
	.p2align 4
	.globl	main
	.type	main, @function
main:
.LFB51:
	.cfi_startproc
	endbr64
	pushq	%r15
	.cfi_def_cfa_offset 16
	.cfi_offset 15, -16
	movl	$190, %edi
	pushq	%r14
	.cfi_def_cfa_offset 24
	.cfi_offset 14, -24
	pushq	%r13
	.cfi_def_cfa_offset 32
	.cfi_offset 13, -32
	pushq	%r12
	.cfi_def_cfa_offset 40
	.cfi_offset 12, -40
	pushq	%rbp
	.cfi_def_cfa_offset 48
	.cfi_offset 6, -48
	pushq	%rbx
	.cfi_def_cfa_offset 56
	.cfi_offset 3, -56
	subq	$24, %rsp
	.cfi_def_cfa_offset 80
	call	sysconf@PLT
	movl	$8, %ecx
	movl	$1073741824, %edx
	leaq	.LC0(%rip), %rsi
	movq	%rax, %r8
	movq	%rax, %rbx
	movl	$2, %edi
	xorl	%eax, %eax
	call	__printf_chk@PLT
	leaq	1073741824(%rbx), %rdi
	call	malloc@PLT
	movq	%rax, 8(%rsp)
	testq	%rax, %rax
	je	.L14
	xorl	%edx, %edx
	movq	%rbx, %r14
	xorl	%r12d, %r12d
	movabsq	$2361183241434822607, %r15
	divq	%rbx
	movq	8(%rsp), %rax
	subq	%rdx, %r14
	addq	%rax, %r14
	leaq	1073741824(%r14), %rbp
	.p2align 4,,10
	.p2align 3
.L6:
	call	clock@PLT
	movq	%rax, %r13
	testq	%rbx, %rbx
	je	.L4
	movq	%r14, %rcx
	.p2align 4,,10
	.p2align 3
.L5:
	movq	%rcx, %rdi
	movq	%rbx, %rdx
	movl	$1, %esi
	call	memset@PLT
	movq	%rax, %rcx
	addq	%rbx, %rcx
	cmpq	%rbp, %rcx
	jb	.L5
.L4:
	call	clock@PLT
	movl	$2, %edi
	subq	%r13, %rax
	movq	%rax, %rsi
	imulq	%r15
	xorl	%eax, %eax
	sarq	$63, %rsi
	sarq	$7, %rdx
	subq	%rsi, %rdx
	leaq	.LC2(%rip), %rsi
	movq	%rdx, %rcx
	movl	%r12d, %edx
	addl	$1, %r12d
	call	__printf_chk@PLT
	cmpl	$10, %r12d
	jne	.L6
	movq	8(%rsp), %rdi
	call	free@PLT
	xorl	%eax, %eax
.L1:
	addq	$24, %rsp
	.cfi_remember_state
	.cfi_def_cfa_offset 56
	popq	%rbx
	.cfi_def_cfa_offset 48
	popq	%rbp
	.cfi_def_cfa_offset 40
	popq	%r12
	.cfi_def_cfa_offset 32
	popq	%r13
	.cfi_def_cfa_offset 24
	popq	%r14
	.cfi_def_cfa_offset 16
	popq	%r15
	.cfi_def_cfa_offset 8
	ret
.L14:
	.cfi_restore_state
	movq	stderr(%rip), %rcx
	movl	$26, %edx
	movl	$1, %esi
	leaq	.LC1(%rip), %rdi
	call	fwrite@PLT
	orl	$-1, %eax
	jmp	.L1
	.cfi_endproc
.LFE51:
	.size	main, .-main
	.ident	"GCC: (Ubuntu 13.2.0-23ubuntu4) 13.2.0"
	.section	.note.GNU-stack,"",@progbits
	.section	.note.gnu.property,"a"
	.align 8
	.long	1f - 0f
	.long	4f - 1f
	.long	5
0:
	.string	"GNU"
1:
	.align 8
	.long	0xc0000002
	.long	3f - 2f
2:
	.long	0x3
3:
	.align 8
4:

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

Может ли C# догнать C?

Речь идет о C, а не о C++. Проверьте вышеприведенный код с этим языком

Может ли C# догнать C?

В другом потоке, например

Может ли C# догнать C?

В замерах выделение памяти не участвует, gc на время выполнения не повлияет, так как он соберет большой объект только при выделении памяти, когда память выделенная для кучи закончится. Соберет он его вместе с поколением 2. Именно для того, чтобы сборка мусора не произошла в неудобный момент, выделений памяти вынесено за пределы измеряемого блока кода. Пробовал с ручной сборкой LOH, результаты не отличались. Оставил так для простоты кода.