benchmark

#!/bin/bash

mkdir -p /tmp/rando
cd /tmp/rando

echo 'BEGIN{
    tgt_len=20;
    for (i=48; i<=122; i++) {
        char = sprintf("%c", i)
        if ( char ~ /[[:alnum:]]/ ) {
            chars[++numChars] = char
        }
    }
}

{
    split($0, ec, "")
    for (c in ec) if (!(c in chars)) {printf "Not in alnum: %s\n", c; exit}
    if (length($0)!=20) {printf "%s: length %s\n", $0, length($0); exit}
    if (seen[$0]++) {printf "%s: duplicate key\n", $0; exit}
}
END{
    printf "Lines: %s\n", NR
    cnt=3; for (e in seen) {print e; if (cnt--==0) break  }
}
' > test.awk

echo '
function fill_buf() {
    buf_=""
    buf_idx=1
    min=48
    max=123
    arg=1024
    cmd="od -A n -t u1 -N " arg " /dev/urandom"  # this is POSIX
    #             ^  ^                unsigned character
    #                   ^  ^          count of i*4 bytes
    while((cmd | getline line)>0) {
        split(line, la)
        for (e in la) {
        if (la[e]<min || la[e]>max) continue
        c=sprintf("%c", la[e])
        if (c~/[[:alnum:]]/) buf_=buf_ c
        }
    }
    close(cmd)
}

function rand_string(i) {
    if (length(buf_)-buf_idx<i) {fill_buf()}
    rtr=substr(buf_, buf_idx, i)
    buf_idx+=i
    return rtr
}

BEGIN {for(i=1;i<=1000;i++) print rand_string(20) }' >awk_od


echo '
function fill_buf(w,         cmd, line, arg) {
    # buf and buf_idx purposely global

    split("", buf)
    buf_idx=1
    arg=int(w+w*0.2)
    cmd="base64 -w " arg " -i /dev/urandom | head -n 10000"
    while((cmd | getline line)>0) {
        gsub(/[^[:alnum:][:space:]]/, "", line)
        if (length(line)<w) continue
        buf[buf_idx++]=substr(line, 1, w)
    }
    close(cmd)
    buf_idx=1
}

function rand_string(w) {
    # Note: if you use length(buf) PRIOR to it being used as an array --
    # it is marked forever as a scalar
    if (buf_idx==0 || length(buf)-buf_idx==-1) fill_buf(w)
    return buf[buf_idx++]
}

BEGIN {
for(i=1;i<=10000;i++) print rand_string(20)
}' >awk_base


echo '
function rand_string(n,         s,i) {
    for ( i=1; i<=n; i++ ) {
        s = s chars[int(1+rand()*numChars)]
    }
    return s
}
BEGIN{
    srand(r)      # Use srand ONCE only
    for (i=48; i<=122; i++) {
        char = sprintf("%c", i)
        if ( char ~ /[[:alnum:]]/ ) {
            chars[++numChars] = char
        }
    }

    for (i=1; i<=10000; i++) {print rand_string(20)}
}' >awk_edmorton

echo '
function rand_string(i) {
    s=""
    min=48
    max=123
    #srand(res)
    while (length(s)<i) {
        c=sprintf("%c", int(min+rand()*(max-min+1)))
        if (c~/[[:alnum:]]/) s=s c
    }
    return s
}
BEGIN{
    srand(r)
    for (i=1; i<=10000; i++) {print rand_string(20)}
}' >awk_abd1

echo '
function fill_buf(low, high,          i, char) {
    for(i=low; i<=high; i++) {
        char = sprintf("%c", i)
        if ( char ~ /[[:alnum:]]/ ) {
            chars[++numChars] = char
        }
    }
}
function rand_string(n,         s,i) {
    if (numChars=="") fill_buf(48,123)
    for ( i=1; i<=n; i++ ) {
        s = s chars[int(1+rand()*numChars)]
    }
    return s
}
BEGIN{
    srand(r)      # Use srand ONCE only
    for (i=1; i<=10000; i++) {print rand_string(20)}
}' >awk_abd2


echo '
def rand_string(len, min=48, max=123, pat=/[[:alnum:]]/)
    # @tgt ||= means only run the first time this function is called
    @tgt ||= (min..max).map(&:chr).grep(pat)
    (1..len).map{ @tgt.sample }.join
end

10_000.times{puts rand_string(20)}' >ruby1_abd

echo 'use 5.20.0;
my @alpha = ("a".."z", "A".."Z", "0".."9");
for (1..10000) {
    my @ou;
    push(@ou, @alpha[rand @alpha]) for (1..20);
    say @ou;
}' >perl_abd

cat << "EOF" >routines.sh
#!/bin/bash

case "$1" in

    ruby1)
        echo "ruby1_abd"
        ruby ruby1_abd
    ;;

    ruby2)
        echo "ruby2_abd"
        ruby ruby2_abd
    ;;


    perl)
        echo "perl"
        perl -f perl_abd
    ;;

    awk1)
        echo "awk Ed Morton"
        awk -v r=$RANDOM -f awk_edmorton
    ;;

    awk2)
        echo "awk abd original"
        awk -f awk_abd1
    ;;

    awk3)
        echo "awk abd ed like"
        awk -f awk_abd2
    ;;

    gawk1)
        gawk -v r=$RANDOM -f awk_edmorton
    ;;

    gawk2)
        gawk -v r=$RANDOM -f awk_abd2
    ;;

    gawk3)
        awk -v r=$RANDOM -f awk_base
    ;;

    awk4)
        echo "awk abd ed like"
        awk -f awk_base
    ;;


esac
EOF

chmod +x routines.sh

cat << "EOF" >tst.pl
#!/usr/bin/perl

use strict;
use warnings;

use Benchmark qw(:all) ;
use Benchmark ":hireswallclock";

cmpthese(50, {
    "ruby abd" => sub { `./routines.sh ruby1` },
    "perl abd" => sub { `./routines.sh perl` },
    "awk EdM" => sub { `./routines.sh awk1` },
    "awk abd 1" => sub { `./routines.sh awk2` },
    "awk abd 2" => sub { `./routines.sh awk3` },
    "gawk EdM" => sub { `./routines.sh gawk1` },
    "gawk abd base64" => sub { `./routines.sh gawk1` },
    "awk abd base64" => sub { `./routines.sh gawk1` },
    "gawk abd 2" => sub { `./routines.sh gawk2` },
    });
EOF

perl tst.pl