Function test_concurrent_parser_construction

Tests/Parser/main.cpp:156–235

}

int test_concurrent_parser_construction ()
{
    amrex::Print() << test_number++ << ". Testing concurrent Parser/IParser construction   ";

    constexpr int nthreads = 2;
    constexpr int niters = 64;
    std::vector<int> nfail(nthreads, 0);
    std::vector<std::thread> threads;
    threads.reserve(nthreads);

    for (int tid = 0; tid < nthreads; ++tid) {
        threads.emplace_back([tid, &nfail] ()
        {
            int local_nfail = 0;
            for (int iter = 0; iter < niters; ++iter) {
                try {
                    {
                        Parser parser("a*x + b");
                        auto const a = static_cast<double>(tid+1);
                        auto const b = 0.25*static_cast<double>(iter+1);
                        auto const x = static_cast<double>((iter % 7) - 3);
                        parser.setConstant("a", a);
                        parser.setConstant("b", b);
                        parser.registerVariables({"x"});
                        auto const exe = parser.compileHost<1>();
                        if (std::abs(exe(x) - (a*x + b)) > 1.e-12) {
                            ++local_nfail;
                        }
                    }
                    {
                        Parser parser("if(x > threshold, x*x + c, c-x)");
                        auto const threshold = static_cast<double>((tid % 3) - 1);
                        auto const c = 0.125*static_cast<double>(iter+1);
                        auto const x = static_cast<double>((iter % 5) - 2);
                        parser.setConstant("threshold", threshold);
                        parser.setConstant("c", c);
                        parser.registerVariables({"x"});
                        auto const exe = parser.compileHost<1>();
                        auto const expected = (x > threshold) ? x*x + c : c - x;
                        if (std::abs(exe(x) - expected) > 1.e-12) {
                            ++local_nfail;
                        }
                    }
                    {
                        IParser iparser("a*x + b");
                        auto const a = static_cast<long long>(tid) + 1;
                        auto const b = static_cast<long long>(iter) + 3;
                        auto const x = static_cast<long long>((iter % 9) - 4);
                        iparser.setConstant("a", a);
                        iparser.setConstant("b", b);
                        iparser.registerVariables({"x"});
                        auto const exe = iparser.compileHost<1>();
                        if (exe(x) != a*x + b) {
                            ++local_nfail;
                        }
                    }
                } catch (...) {
                    ++local_nfail;