Perl 停滞不前的日子：揭示 C 的隐藏力量

#!/home/chrisarg/perl5/perlbrew/perls/current/bin/perl
use v5.38;
use inline (
    c         => 'data',
    cc        => 'g++',
    ld        => 'g++',
    inc       => q{},      # replace q{} with anything else you need
    ccflagsex => q{},      # replace q{} with anything else you need
    lddlflags => join(
        q{ },
        $config::config{lddlflags},
        q{ },              # replace q{ } with anything else you need
    ),
    libs => join(
        q{ },
        $config::config{libs},
        q{ },              # replace q{ } with anything else you need
    ),
    myextlib => ''
);

use benchmark qw(cmpthese);
use getopt::long;
my ($buffer_size, $init_value, $iterations);
getoptions(
    'buffer_size=i' => \$buffer_size,
    'init_value=s'  => \$init_value,
    'iterations=i'  => \$iterations,
) or die "usage: $0 --buffer_size <size> --init_value <value> --iterations <count>\n";
my $init_value_byte = ord($init_value);
my %code_snippets   = (
    'string' => sub {
        $init_value x ( $buffer_size - 1 );
    },
    'pack' => sub {
        pack "c*", ( ($init_value_byte) x $buffer_size );
    },
    'c' => sub {
        allocate_and_initialize_array( $buffer_size, $init_value_byte );
    },
);

cmpthese( $iterations, \%code_snippets );

__data__

__c__

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

sv* allocate_and_initialize_array(size_t length, short initial_value) {
    // allocate memory for the array
    char* array = (char*)malloc(length * sizeof(char));
    char initial_value_byte = (char)initial_value;
    if (array == null) {
        fprintf(stderr, "memory allocation failed\n");
        exit(1);
    }

    // initialize each element with the initial_value
    memset(array, initial_value_byte, length);
    return newsvuv(ptr2uv(array));
}

./time_mem_alloc.pl -buffer_size=1000000 -init_value=a -iterations=20000

          rate   pack      c string
pack     322/s     --   -92%   -99%
c       4008/s  1144%     --   -92%
string 50000/s 15417%  1147%     --

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

char* allocate_and_initialize_array(size_t length, char initial_value) {
    // allocate memory for the array
    char* array = (char*)malloc(length * sizeof(char));
    if (array == null) {
        fprintf(stderr, "memory allocation failed\n");
        exit(1);
    }

    // initialize each element with the initial_value
    memset(array, initial_value, length);

    return array;
}

double time_allocation_and_initialization(size_t length, char initial_value) {
    clock_t start, end;
    double cpu_time_used;

    start = clock();
    char* array = allocate_and_initialize_array(length, initial_value);
    end = clock();

    cpu_time_used = ((double) (end - start)) / clocks_per_sec;
    /* this rudimentary loop prevents the compiler from optimizing out the 
     * allocation/initialization with the de-allocation
    */
    for(size_t i = 1; i < length; i++) {
       array[i]++;
       if(i % 100000 == 0) {
           printf("array[%zu] = %c\n", i, array[i]);
       }
    }
    free(array); // free the allocated memory

    return cpu_time_used;
}

int main(int argc, char *argv[]) {
    if (argc != 3) {
        fprintf(stderr, "usage: %s <length> <initial_value>\n", argv[0]);
        return 1;
    }

    size_t length = strtoull(argv[1], null, 10);
    char initial_value = argv[2][0];

    double time_taken = time_allocation_and_initialization(length, initial_value);
    printf("time taken to allocate and initialize array: %f seconds\n", time_taken);
    printf("initializes per second: %f\n", 1/time_taken);

    return 0;
}

/*
compilation command:
gcc -o2 -o time_array_allocation time_array_allocation.c -std=c99

example invocation:
./time_array_allocation 10000000 a
*/

Time taken to allocate and initialize array: 0.000203 seconds
Initializes per second: 4926.108374