Метапрог-прототип, версия 6 + будильник на Метапроге

#define NUM_SEARCHES UINT64_C(1000)
/* ... */
    size_t count = 0;
#pragma omp parallel for reduction(+ : count)
    for (size_t iter = 0; iter < NUM_SEARCHES; iter++) {

extern crate rand;
extern crate rayon;
use rand::Rng;
use rand::distributions::Alphanumeric;
use rayon::prelude::*;
use std::time::Instant;
use regex::Regex;
use regex;

fn main() {
    for _ in 0..10 {
        let timer = Instant::now();
        let vec: Vec<String> = (0..100_000)
            .into_par_iter()
            .map_init(
                || rand::thread_rng(),
                |rng, _| rng.sample_iter(&Alphanumeric).take(100).collect()
            ).collect();

        let overall_count: u32 =
            (0..1000)
                .into_par_iter()
                .fold(|| 0u32, |acc,  _| {
                    let needle: String = rand::thread_rng()
                        .sample_iter(&Alphanumeric)
                        .take(20)
                        .collect();
                    let needle_regex = Regex::new(&regex::escape(&needle)).unwrap();
                    if (&vec).iter().any(|s100 | {
                        needle_regex.find(&s100).is_some()
                    }) {
                        acc + 1
                    }
                    else {
                        acc
                    }
                })
                .sum();

        println!("Found {} instances of in {:.2} secs", overall_count,
                 timer.elapsed().as_secs_f64());
    }
}

open System;
open System.Diagnostics;

[<EntryPoint>]
let main argv =
    let random = Random()
    
    let randomStr = 
        let chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
        let charsLen = chars.Length
        
        fun len -> 
            let randomChars = [|for _ in 0..len-1 -> chars.[random.Next(charsLen)]|]
            new string(randomChars)
    
    let randomString100(_) = randomStr(100)
    
    let randomString20() = randomStr(20)
    
    for _ in 1..10 do
        let stopWatch = Stopwatch.StartNew()
        let listString100 = Array.init 100000 randomString100
        let  matches = 
            [|1..1000|]
            |> Array.Parallel.map (fun _ -> 
                let s20 = randomString20()
                listString100 
                    |> Array.exists (fun s100 -> s100.Contains(s20))
                    |> fun exists -> if exists then 1 else 0)
            |> Array.sum

        printfn "%d strings matches, time = %f" 
            matches stopWatch.Elapsed.TotalMilliseconds
    0 // return an integer exit code