thread_test.cpp

Go to the documentation of this file.

#ifdef BUILD_UNITTEST
 
#include "warning_push.h"
#include <gtest/gtest.h>
#include "warning_pop.h"
 
#include <chrono>
#include <stdio.h> 
 
#include "runtime.h"
#include "analysis.h"
#include "jit.h"
 
using namespace newlang;
 
 
#include <iostream>
#include <thread>
#include <atomic>
 
TEST(Thread, Atomic) {
 
    unsigned long long not_atomic = 0;
 
    std::thread t1([&not_atomic]() {
        for (auto i = 0; i < 1'000'000; ++i) {
            ++not_atomic;
        }
    });
 
    std::thread t2([&not_atomic]() {
        for (auto i = 0; i < 1'000'000; ++i) {
            ++not_atomic;
        }
    });
 
    t1.join();
    t2.join();
 
    EXPECT_NE(not_atomic, 2'000'000);
 
 
    std::atomic<unsigned long long> g_count{ 0};
 
    std::thread at1([&g_count]() {
        for (auto i = 0; i < 1'000'000; ++i) {
            g_count.fetch_add(1);
        }
    });
 
    std::thread at2([&g_count]() {
        for (auto i = 0; i < 1'000'000; ++i) {
            g_count.fetch_add(1);
        }
    });
 
    at1.join();
    at2.join();
 
    EXPECT_EQ(g_count, 2'000'000);
}
 
// parallel_sum.cpp
// https://helloacm.com/how-to-async-and-await-in-c11/
#include <iostream>
#include <vector>
#include <future>
 
// for use of std::accumulate
#if _MSC_VER 
#include <numeric>  // in Visual Studio
#else
#include <algorithm>  // g++ -std=c++14 -pthread parallel_sum.cpp
#endif
 
using namespace std;
 
//std::atomic<unsigned long long> async_count{0};
//
//
//template <typename TYPE>
//int parallel_sum(TYPE beg, TYPE end) {
//    // block size
//    auto len = end - beg;
//    if (len < 5000) {
//        async_count.fetch_add(1);
//        // if block is small enough, it is faster to just sum them up.
//        return std::accumulate(beg, end, 0);
//    }
//    // (beg + end) / 2 may overflow
//    auto mid = beg + len / 2;
//    // sum the left part asynchronously 
//    auto handle_left = std::async(launch::async, parallel_sum<TYPE>, beg, mid);
//    // sum the right part asynchronously 
//    auto handle_right = std::async(launch::async, parallel_sum<TYPE>, mid, end);
//    // put them together
//    return handle_left.get() + handle_right.get();
//}
//
//TEST(Thread, Async) {
//
//    vector<int> v(100000000, 1);
//    std::cout << "Sum: " << parallel_sum(v.begin(), v.end()) << "  async_count:" << async_count << std::endl;
 
 
 
 
#include <thread>
#include <chrono>
#include <vector>
#include <future>
#include <iostream>
 
__thread volatile int you_shall_not_optimize_this;
 
void work() {
    // This is the simplest way I can think of to prevent the compiler and
    // operating system from doing naughty things
    you_shall_not_optimize_this = 42;
}
 
[[gnu::noinline]]
std::chrono::nanoseconds benchmark_threads(size_t count) {
    std::vector<std::optional < std::thread>> threads;
    threads.resize(count);
 
    auto before = std::chrono::high_resolution_clock::now();
 
    for (size_t i = 0; i < count; ++i)
        threads[i] = std::thread{work};
 
    for (size_t i = 0; i < count; ++i)
        threads[i]->join();
 
    threads.clear();
 
    auto after = std::chrono::high_resolution_clock::now();
 
    return after - before;
}
 
[[gnu::noinline]]
std::chrono::nanoseconds benchmark_async(size_t count, std::launch policy) {
    std::vector<std::optional<std::future<void>>> results;
    results.resize(count);
 
    auto before = std::chrono::high_resolution_clock::now();
 
    for (size_t i = 0; i < count; ++i)
        results[i] = std::async(policy, work);
 
    for (size_t i = 0; i < count; ++i)
        results[i]->wait();
 
    results.clear();
 
    auto after = std::chrono::high_resolution_clock::now();
 
    return after - before;
}
 
 
void stat_out(std::chrono::nanoseconds duration) {
    std::cout << "Completed in " << duration.count() << "ns (" << std::chrono::duration_cast<std::chrono::milliseconds>(duration).count() << "ms)\n";
}
 
TEST(Thread, Async) {
 
    
    /*
     * launch::async – если передан этот флаг, то поведение async будет следующим: 
     * будет создан объект класса thread, с функцией и её аргументами в качестве аргументов нового потока. 
     * Т.е. async инкапсулирует  создание потока, получение future и предоставляет однострочную запись для выполнения 
     * такого кода(скорее всего реализация будет использовать packaged_task, 
     * вместо простой передачи функции в поток, “под капотом”, но я не уверен)
     * 
     * launch::deferred – если передан этот флаг, то имя функции async становится несколько не логичным. 
     * Т.к. никакого асинхронного вызова не произойдёт. Вместо исполнения функции в новом потоке, 
     * она, вместе с аргументами, будет сохранена в future(еще одна особенность future), 
     * чтобы быть вызванными позже. Это позже наступит тогда, когда кто-либо вызовет 
     * метод get(или wait, но не wait_for!) на future, которое вернул async. 
     * При этот вызываемый объект выполнится в потоке, который вызывал get! 
     * Это поведение есть ни что иное, как отложенный вызов процедуры.
     */
    
    const int count_iteration = 10000;
 
    std::cout << "Running benchmark iterations " << count_iteration << '\n';
    std::cout << "threads:  ";
    stat_out(benchmark_threads(count_iteration));
    std::cout << "async:    ";
    stat_out(benchmark_async(count_iteration, std::launch::async));
    std::cout << "deferred: ";
    stat_out(benchmark_async(count_iteration, std::launch::deferred));
 
 
    //    const auto processor_count = std::thread::hardware_concurrency();
    //
    //    unsigned long long not_atomic = 0;
    //
    //    std::thread t1([&not_atomic]() {
    //        for (auto i = 0; i < 1'000'000; ++i) {
    //            usleep(1);
    //            ++not_atomic;
    //        }
    //    });
    //
    //    std::thread t2([&not_atomic]() {
    //        for (auto i = 0; i < 1'000'000; ++i) {
    //            usleep(1);
    //            ++not_atomic;
    //        }
    //    });
    //
    //    t1.join();
    //    t2.join();
    //
    //    EXPECT_NE(not_atomic, 2'000'000);
    //
    //
    //    std::atomic<unsigned long long> g_count{ 0};
    //
    //    std::thread at1([&g_count]() {
    //        for (auto i = 0; i < 1'000'000; ++i) {
    //            usleep(1);
    //            g_count.fetch_add(1);
    //        }
    //    });
    //
    //    std::thread at2([&g_count]() {
    //        for (auto i = 0; i < 1'000'000; ++i) {
    //            usleep(1);
    //            g_count.fetch_add(1);
    //        }
    //    });
    //
    //    at1.join();
    //    at2.join();
    //
    //    EXPECT_EQ(g_count, 2'000'000);
}
// * Тест производительности на базе исходников из статьи
// * https://towardsdatascience.com/how-fast-is-c-compared-to-python-978f18f474c7
// */
//extern "C" char convert(char c);
//
//TEST(Example, SpeedCPP) {
//
//    LOG_INFO("Start speed test C++");
//
//    std::chrono::steady_clock::time_point begin = std::chrono::steady_clock::now();
//
//    std::string opt = "ACGT";
//    std::string s = "";
//    std::string s_last = "";
//    int len_str = 13;
//    bool change_next;
//
//    for (int i = 0; i < len_str; i++) {
//        s += opt[0];
//    }
//
//    for (int i = 0; i < len_str; i++) {
//        s_last += opt.back();
//    }
//
//    int pos = 0;
//    int counter = 1;
//    while (s != s_last) {
//        counter++;
//        // You can uncomment the next line to see all k-mers.
//        //std::cout << s << std::endl;
//        change_next = true;
//        for (int i = 0; i < len_str; i++) {
//            if (change_next) {
//                if (s[i] == opt.back()) {
//                    s[i] = convert(s[i]);
//                    change_next = true;
//                } else {
//                    s[i] = convert(s[i]);
//                    i = len_str; // break;
//                }
//            }
//        }
//    }
//
//    // You can uncomment the next line to see all k-mers.
//    // cout << s << endl;
//    std::chrono::steady_clock::time_point end = std::chrono::steady_clock::now();
//    int sec = (int) std::chrono::duration_cast<std::chrono::seconds>(end - begin).count();
//    int ms = (int) std::chrono::duration_cast<std::chrono::microseconds>(end - begin).count() % 1000000;
//    LOG_INFO("Float of generated k-mers: %d  at %d.%d sec", counter, sec, ms);
//
//}
//
//TEST(Example, DISABLED_SpeedNewLang) {
//
//    JIT * jit = JIT::ReCreate();
//    ASSERT_TRUE(jit);
//
//    setvbuf(stdin, nullptr, _IONBF, 0);
//    setvbuf(stdout, nullptr, _IONBF, 0);
//    setvbuf(stderr, nullptr, _IONBF, 0);
//
//
//    ObjPtr test;
//
//    ObjPtr str = jit->Run("str := 'ABCDEF\\n';", nullptr);
//    ASSERT_TRUE(str);
//    ASSERT_STREQ("ABCDEF\n", str->GetValueAsString().c_str());
//
//    test = jit->Run("str := 'ABCDEF\\n'; print('%s', str)");
//    ASSERT_TRUE(test);
//    ASSERT_STREQ("7", test->GetValueAsString().c_str());
//
//    test = jit->Run("str[2] = 32; str", nullptr);
//    ASSERT_TRUE(test);
//    ASSERT_STREQ("AB DEF\n", test->GetValueAsString().c_str());
//
//    test = jit->Run("str[0]", nullptr);
//    ASSERT_TRUE(test);
//    ASSERT_STREQ("A", test->GetValueAsString().c_str());
//
//    test = jit->Run("str[1]", nullptr);
//    ASSERT_TRUE(test);
//    ASSERT_STREQ("B", test->GetValueAsString().c_str());
//
//    test = jit->Run("str[2]", nullptr);
//    ASSERT_TRUE(test);
//    ASSERT_STREQ(" ", test->GetValueAsString().c_str());
//
//    //    LLVMAddSymbol("convert", (void *) &convert);
//    ObjPtr test_convert = jit->Run("test_convert(sym:Int8):Int8 := %convert ...");
//    ASSERT_TRUE(test_convert);
//
//    //    [c == 'A'] --> 'C',
//    //    [c == 'C'] --> 'G',
//    //    [c == 'G'] --> 'T',
//    //    [c == 'T'] --> 'A',
//    //    [_] --> ' ';    
//
//    test = jit->Run("test_convert(65)", nullptr);
//    ASSERT_TRUE(test);
//    ASSERT_STREQ("67", test->GetValueAsString().c_str());
//    test = jit->Run("test_convert(67)", nullptr);
//    ASSERT_TRUE(test);
//    ASSERT_STREQ("71", test->GetValueAsString().c_str());
//
//    test = jit->Run("test_convert(71)", nullptr);
//    ASSERT_TRUE(test);
//    ASSERT_STREQ("84", test->GetValueAsString().c_str());
//
//    test = jit->Run("test_convert(84)", nullptr);
//    ASSERT_TRUE(test);
//    ASSERT_STREQ("65", test->GetValueAsString().c_str());
//
//    ASSERT_NO_THROW(test = jit->Run("str"));
//    ASSERT_TRUE(test);
//    ASSERT_STREQ("AB DEF\n", test->GetValueAsString().c_str());
//
//    ASSERT_NO_THROW(test = jit->Run("str[0]"));
//    ASSERT_TRUE(test);
//    ASSERT_STREQ("A", test->GetValueAsString().c_str());
//
//    ASSERT_NO_THROW(test = jit->Run(":Int8('A')"));
//    ASSERT_TRUE(test);
//    ASSERT_STREQ("65", test->GetValueAsString().c_str());
//
//    //    ASSERT_NO_THROW(test = jit->Run("test_convert('A')"));
//    //    ASSERT_TRUE(test);
//    //    ASSERT_STREQ("C", test->GetValueAsString().c_str());
//
//    ASSERT_NO_THROW(test = jit->Run("test_convert(:Int8(str[0]))"));
//    ASSERT_TRUE(test);
//    ASSERT_STREQ("67", test->GetValueAsString().c_str());
//
//    ASSERT_NO_THROW(test = jit->Run("str[0] = test_convert(:Int8(str[0])); str"));
//    ASSERT_TRUE(test);
//    ASSERT_STREQ("CB DEF\n", test->GetValueAsString().c_str());
//
//    Logger::LogLevelType save = Logger::Instance()->SetLogLevel(LOG_LEVEL_INFO);
//    std::chrono::steady_clock::time_point begin = std::chrono::steady_clock::now();
//    ObjPtr result = jit->RunFile("../examples/speed_test.src");
//    std::chrono::steady_clock::time_point end = std::chrono::steady_clock::now();
//    Logger::Instance()->SetLogLevel(save);
//
//
//
//    ASSERT_TRUE(result);
//    ASSERT_TRUE(result->is_string_type()) << result->toString();
//    ASSERT_STREQ("OK", result->GetValueAsString().c_str());
//
//
//    int sec = (int) std::chrono::duration_cast<std::chrono::seconds>(end - begin).count();
//    int ms = (int) std::chrono::duration_cast<std::chrono::microseconds>(end - begin).count() % 1000000;
//    LOG_INFO("Test speed complete at %d.%d sec", sec, ms);
//
//    /*
//     * 
//     * Start speed test C++
//     * Float of generated k-mers: 67108864  at 2.502049 sec
//     * 
//     * Start
//     * Float of generated k-mers: 67108864
//     * real   0m33,794s     
//     * 
//     * Start speed test NewLang
//     * Float of generated k-mers: 67108864
//     * Test complete at  ????????????????????
//     * 
//     * Своя функция convert 
//     * 5 символов - 1.3 сек (с вывоводм строк) 0.491895 sec - без вывода строк
//     * 6 символов - 14.789793 sec (с вывоводм строк) 1.898168 sec - без вывода строк
//     * 7 символов без вывода строк - 7.671152 sec
//     * 8 символов без вывода строк - 30.412468 sec
//     * 
//     * Импорт С++ функции convert 
//     * 5 символов - 1.23 сек (с вывоводм строк) 0.53 sec - без вывода строк
//     * 6 символов - 13.538338 sec (с вывоводм строк) 2.30900 sec - без вывода строк
//     * 7 символов без вывода строк - 8.43029 sec
//     * 8 символов без вывода строк - 32.154832 sec
//     * 
//     * После переделки способа хранения скаляров в нативном виде, а не в тензорах
//     * Своя функция convert 
//     * 5 символов - 1.255214 сек (с вывоводм строк) 0.306725 sec - без вывода строк
//     * 6 символов - 15.995722 sec (с вывоводм строк) 1.253190 sec - без вывода строк
//     * 7 символов без вывода строк - 5.12946 sec
//     * 8 символов без вывода строк - 19.653851 sec
//     * 
//     * Импорт С++ функции convert 
//     * 5 символов -  1.195008 sec (с вывоводм строк)  0.351575 sec - без вывода строк
//     * 6 символов -  13.666785 sec (с вывоводм строк) 1.428339 sec - без вывода строк
//     * 7 символов без вывода строк - 5.628200 sec
//     * 8 символов без вывода строк - 22.258760 sec
//     * 
//     * Start speed test NewLang
//     * From AAAAAAAAAA to TTTTTTTTTT
//     * Float of generated k-mers: 1048576
//     * Test complete at 320.401650 sec (более 5 минут)
//     * 
//     * Никакой оптимизации не проводилось. 
//     * Программа не преобразуется в промежуточный byte-code, а интерпретируется какждый раз при выполнении.
//     * LLVM код вызова нативных функий генерируется каждый раз,  не при создании функции.
//     * Возможности для оптимиации производительности чрезвычайно общширны ;-)
//     */
//}
//
//
//
//TEST(Example, Hello) {
//
//    JIT *jit = JIT::ReCreate();
//    ASSERT_TRUE(jit);
//
//    ObjPtr prn;
//    ASSERT_NO_THROW(prn = jit->Run("prn(format:FmtChar, ...):Int32 := %printf ..."));
//    ASSERT_TRUE(prn);
//
//    ObjPtr res = (*prn)("Привет, мир!\n");
//    ASSERT_TRUE(res);
//    ASSERT_TRUE(res->is_integer()) << res->toString();
//    ASSERT_STREQ("22", res->GetValueAsString().c_str());
//
//    //    ObjPtr func = jit->Run("func(arg) := {$arg}");
//    //    ASSERT_TRUE(func);
//    //
//    //    res = (*func)("TEST");
//    //    ASSERT_TRUE(res);
//    //    ASSERT_TRUE(res->is_string_char_type()) << res->toString();
//    //    ASSERT_STREQ("TEST", res->GetValueAsString().c_str());
//    //    hello(str) := { 
//    //      printf := :Pointer('printf(format:FmtChar, ...):Int32');  # Импорт стандартной C функции
//    //      printf('%s\n', $str);  # Вызов C функции с проверкой типов аргументов по строке формата
//    //    };
//    //    hello('Привет, мир!'); # Вызвать функцию    
//
//
//    setvbuf(stdin, nullptr, _IONBF, 0);
//    setvbuf(stdout, nullptr, _IONBF, 0);
//    setvbuf(stderr, nullptr, _IONBF, 0);
//
//
//    Logger::LogLevelType save = Logger::Instance()->SetLogLevel(LOG_LEVEL_INFO);
//    std::chrono::steady_clock::time_point begin = std::chrono::steady_clock::now();
//    ObjPtr result = jit->RunFile("../examples/hello.src");
//    std::chrono::steady_clock::time_point end = std::chrono::steady_clock::now();
//    Logger::Instance()->SetLogLevel(save);
//
//
//    ASSERT_TRUE(result);
//    ASSERT_TRUE(result->is_integral()) << result->toString();
//    ASSERT_STREQ("14", result->GetValueAsString().c_str());
//
//
//    //    save = Logger::Instance()->SetLogLevel(LOG_LEVEL_INFO);
//    //    begin = std::chrono::steady_clock::now();
//    //    ASSERT_NO_THROW(result = jit->Run("\\\\‍('../examples/hello.src')"));
//    //    end = std::chrono::steady_clock::now();
//    //    Logger::Instance()->SetLogLevel(save);
//    //
//    //
//    //    ASSERT_TRUE(result);
//    //    ASSERT_TRUE(result->is_integral()) << result->toString();
//    //    ASSERT_STREQ("14", result->GetValueAsString().c_str());
//}
//
//TEST(Example, Exec) {
//    JIT * jit = JIT::ReCreate({"--nlc-no-eval-enable"});
//    ASSERT_TRUE(jit);
//
//    ASSERT_FALSE(jit->m_eval_enable);
//    ASSERT_ANY_THROW(jit->Run("`ls`"));
//    jit->m_eval_enable = true;
//
//    ObjPtr exec;
//    ASSERT_NO_THROW(exec = jit->Run("`ls`"));
//    ASSERT_TRUE(exec);
//    ASSERT_TRUE(exec->is_string_char_type()) << exec->toString();
//    ASSERT_TRUE(exec->GetValueAsString().find("nlc-unittest\n") != std::string::npos) << exec->GetValueAsString();
//}
//
//TEST(Example, Fibonacci) {
//
//    JIT *jit = JIT::ReCreate();
//    ASSERT_TRUE(jit);
//
//
//    ObjPtr temp;
//    ASSERT_NO_THROW(temp = jit->Run("dict ::= (1+2, 5, 9,);\n"));
//    ASSERT_STREQ("(3, 5, 9,)", temp->toString().c_str()) << temp->toString();
//
//    ASSERT_NO_THROW(temp = jit->Run("dict[0]"));
//    ASSERT_STREQ("3", temp->toString().c_str()) << temp->toString();
//
//    ASSERT_NO_THROW(temp = jit->Run("dict[1]"));
//    ASSERT_STREQ("5", temp->toString().c_str()) << temp->toString();
//
//    ASSERT_NO_THROW(temp = jit->Run("dict[1+1]"));
//    ASSERT_STREQ("9", temp->toString().c_str()) << temp->toString();
//
//    ASSERT_NO_THROW(temp = jit->Run("( dict[1], dict[2], )"));
//    ASSERT_STREQ("(5, 9,)", temp->toString().c_str()) << temp->toString();
//
//
//    ASSERT_NO_THROW(temp = jit->Run("( dict[0]+dict[1], dict[2], )"));
//    ASSERT_STREQ("(8, 9,)", temp->toString().c_str()) << temp->toString();
//
//    ASSERT_NO_THROW(temp = jit->Run("{+ var := 1; {  var := 2;  ++ var ++; }  +}"));
//    ASSERT_STREQ("2", temp->toString().c_str()) << temp->toString();
//
//    ASSERT_NO_THROW(temp = jit->Run("{* varth := 1; {  varth := 2;  @throw varth; }  *}"));
//    ASSERT_STREQ("2", temp->toString().c_str()) << temp->toString();
//
//    ASSERT_NO_THROW(temp = jit->Run("var2 := 22; {  var2 := 33;  };  var2"));
//    ASSERT_STREQ("22", temp->toString().c_str()) << temp->toString();
//
//    ObjPtr fib;
//    ASSERT_NO_THROW(fib = jit->Run("fib_test(n) := {\n"
//            "   @if(n < 3){ \n"
//            "       @return (1\\1, 1\\1,);\n"
//            "   };\n"
//            "   p := fib_test(n-1);\n"
//            "   @return (p[0] + p[1], p[0],);\n"
//            "};\n"));
//    ASSERT_TRUE(fib);
//    // return и throw - без скобок как оператор
//    // запятые в аргументах макросов ?????????????????
//
//    std::cout << "\n1:\n\n";
//    ASSERT_NO_THROW(temp = jit->Run("fib_test(1)"));
//    ASSERT_TRUE(temp);
//    ASSERT_STREQ("(1\\1, 1\\1,)", temp->toString().c_str()) << temp->toString();
//
//    std::cout << "\n2:\n\n";
//    ASSERT_NO_THROW(temp = jit->Run("fib_test(2)"));
//    ASSERT_TRUE(temp);
//    ASSERT_STREQ("(1\\1, 1\\1,)", temp->toString().c_str()) << temp->toString();
//
//    std::cout << "\n3:\n\n";
//    ASSERT_NO_THROW(temp = jit->Run("fib_test(3)"));
//    ASSERT_TRUE(temp);
//    ASSERT_STREQ("(2\\1, 1\\1,)", temp->toString().c_str()) << temp->toString();
//
//    ASSERT_NO_THROW(temp = jit->Run("fib_test(4)"));
//    ASSERT_TRUE(temp);
//    ASSERT_STREQ("(3\\1, 2\\1,)", temp->toString().c_str()) << temp->toString();
//
//    ASSERT_NO_THROW(temp = jit->Run("fib_test(5)"));
//    ASSERT_TRUE(temp);
//    ASSERT_STREQ("(5\\1, 3\\1,)", temp->toString().c_str()) << temp->toString();
//
//    ASSERT_NO_THROW(temp = jit->Run("fib_test(6)"));
//    ASSERT_TRUE(temp);
//    ASSERT_STREQ("(8\\1, 5\\1,)", temp->toString().c_str()) << temp->toString();
//
//    //    ASSERT_NO_THROW(temp = jit->Run("fib_test(100)"));
//    //    ASSERT_TRUE(temp);
//    //    ASSERT_STREQ("(354224848179261915075\\1, 218922995834555169026\\1,)", temp->toString().c_str()) << temp->toString();
//    //
//    //    ASSERT_NO_THROW(temp = jit->Run("fib_test(250)"));
//    //    ASSERT_TRUE(temp);
//    //    ASSERT_STREQ("(7896325826131730509282738943634332893686268675876375\\1, 4880197746793002076754294951020699004973287771475874\\1,)", temp->toString().c_str()) << temp->toString();
//
//
//
//    ObjPtr calc;
//    ASSERT_NO_THROW(calc = jit->Run(""
//            "'{1}'(123456); \n"
//            ));
//    ASSERT_TRUE(calc);
//    ASSERT_STREQ("'123456'", calc->toString().c_str()) << calc->toString();
//
//
//    ObjPtr time;
//    ASSERT_NO_THROW(time = jit->Run(""
//            "@timeit( fib_test(5) ); \n"
//            ));
//    ASSERT_TRUE(time);
//    ASSERT_TRUE(time->toString().find("'Exec time 'fib_test(5)':") == 0) << time->toString();
//
//
//
//    ObjPtr fib_calc;
//    ASSERT_NO_THROW(fib_calc = jit->Run("fib_calc(n) := {\n"
//            "  res := fib_test(n);\n"
//            "  $value := '{1}'( res[1] );\n"
//            "  print('%d: %d\\n%s\\n', $n, len($value), $value);\n"
//            "};\n"));
//    ASSERT_TRUE(fib_calc);
//
//    ASSERT_NO_THROW(fib_calc = jit->Run("fib_calc(5)")) << fib_calc->m_sequence->toString();
//    ASSERT_TRUE(fib_calc);
//
//
//
//
//    setvbuf(stdin, nullptr, _IONBF, 0);
//    setvbuf(stdout, nullptr, _IONBF, 0);
//    setvbuf(stderr, nullptr, _IONBF, 0);
//
//
//    Logger::LogLevelType save = Logger::Instance()->SetLogLevel(LOG_LEVEL_INFO);
//    std::chrono::steady_clock::time_point begin = std::chrono::steady_clock::now();
//    ObjPtr result = jit->RunFile("../examples/fibonacci.src");
//    std::chrono::steady_clock::time_point end = std::chrono::steady_clock::now();
//    Logger::Instance()->SetLogLevel(save);
//
//    ASSERT_TRUE(result);
//    ASSERT_TRUE(result->is_string_type()) << result->toString();
//    ASSERT_TRUE(result->toString().find("'Exec time 'calc(") == 0) << result->toString();
//
//}
//
//
//TEST(Example, Thread_With) {
//
//    JIT *jit = JIT::ReCreate();
//    ASSERT_TRUE(jit);
//
//    //    ObjPtr prn;
//    //    ASSERT_NO_THROW(prn = jit->Run("prn(format:FmtChar, ...):Int32 := %printf ..."));
//    //    ASSERT_TRUE(prn);
//    //
//    //    ObjPtr res = (*prn)("Привет, мир!\n");
//    //    ASSERT_TRUE(res);
//    //    ASSERT_TRUE(res->is_integer()) << res->toString();
//    //    ASSERT_STREQ("22", res->GetValueAsString().c_str());
//    //
//    //    //    ObjPtr func = jit->Run("func(arg) := {$arg}");
//    //    //    ASSERT_TRUE(func);
//    //    //
//    //    //    res = (*func)("TEST");
//    //    //    ASSERT_TRUE(res);
//    //    //    ASSERT_TRUE(res->is_string_char_type()) << res->toString();
//    //    //    ASSERT_STREQ("TEST", res->GetValueAsString().c_str());
//    //    //    hello(str) := { 
//    //    //      printf := :Pointer('printf(format:FmtChar, ...):Int32');  # Импорт стандартной C функции
//    //    //      printf('%s\n', $str);  # Вызов C функции с проверкой типов аргументов по строке формата
//    //    //    };
//    //    //    hello('Привет, мир!'); # Вызвать функцию    
//    //
//    //
//    //    setvbuf(stdin, nullptr, _IONBF, 0);
//    //    setvbuf(stdout, nullptr, _IONBF, 0);
//    //    setvbuf(stderr, nullptr, _IONBF, 0);
//    //
//    //
//    //    Logger::LogLevelType save = Logger::Instance()->SetLogLevel(LOG_LEVEL_INFO);
//    //    std::chrono::steady_clock::time_point begin = std::chrono::steady_clock::now();
//    //    ObjPtr result = jit->RunFile("../examples/hello.src");
//    //    std::chrono::steady_clock::time_point end = std::chrono::steady_clock::now();
//    //    Logger::Instance()->SetLogLevel(save);
//    //
//    //
//    //    ASSERT_TRUE(result);
//    //    ASSERT_TRUE(result->is_integral()) << result->toString();
//    //    ASSERT_STREQ("14", result->GetValueAsString().c_str());
//    //
//    //
//    //    //    save = Logger::Instance()->SetLogLevel(LOG_LEVEL_INFO);
//    //    //    begin = std::chrono::steady_clock::now();
//    //    //    ASSERT_NO_THROW(result = jit->Run("\\\\‍('../examples/hello.src')"));
//    //    //    end = std::chrono::steady_clock::now();
//    //    //    Logger::Instance()->SetLogLevel(save);
//    //    //
//    //    //
//    //    //    ASSERT_TRUE(result);
//    //    //    ASSERT_TRUE(result->is_integral()) << result->toString();
//    //    //    ASSERT_STREQ("14", result->GetValueAsString().c_str());
//}
//
//TEST(Example, FileIO) {
//
//    JIT *jit = JIT::ReCreate();
//    ASSERT_TRUE(jit);
//
//    //    ObjPtr prn;
//    //    ASSERT_NO_THROW(prn = jit->Run("prn(format:FmtChar, ...):Int32 := %printf ..."));
//    //    ASSERT_TRUE(prn);
//    //
//    //    ObjPtr res = (*prn)("Привет, мир!\n");
//    //    ASSERT_TRUE(res);
//    //    ASSERT_TRUE(res->is_integer()) << res->toString();
//    //    ASSERT_STREQ("22", res->GetValueAsString().c_str());
//    //
//    //    //    ObjPtr func = jit->Run("func(arg) := {$arg}");
//    //    //    ASSERT_TRUE(func);
//    //    //
//    //    //    res = (*func)("TEST");
//    //    //    ASSERT_TRUE(res);
//    //    //    ASSERT_TRUE(res->is_string_char_type()) << res->toString();
//    //    //    ASSERT_STREQ("TEST", res->GetValueAsString().c_str());
//    //    //    hello(str) := { 
//    //    //      printf := :Pointer('printf(format:FmtChar, ...):Int32');  # Импорт стандартной C функции
//    //    //      printf('%s\n', $str);  # Вызов C функции с проверкой типов аргументов по строке формата
//    //    //    };
//    //    //    hello('Привет, мир!'); # Вызвать функцию    
//    //
//    //
//    //    setvbuf(stdin, nullptr, _IONBF, 0);
//    //    setvbuf(stdout, nullptr, _IONBF, 0);
//    //    setvbuf(stderr, nullptr, _IONBF, 0);
//    //
//    //
//    //    Logger::LogLevelType save = Logger::Instance()->SetLogLevel(LOG_LEVEL_INFO);
//    //    std::chrono::steady_clock::time_point begin = std::chrono::steady_clock::now();
//    //    ObjPtr result = jit->RunFile("../examples/hello.src");
//    //    std::chrono::steady_clock::time_point end = std::chrono::steady_clock::now();
//    //    Logger::Instance()->SetLogLevel(save);
//    //
//    //
//    //    ASSERT_TRUE(result);
//    //    ASSERT_TRUE(result->is_integral()) << result->toString();
//    //    ASSERT_STREQ("14", result->GetValueAsString().c_str());
//    //
//    //
//    //    //    save = Logger::Instance()->SetLogLevel(LOG_LEVEL_INFO);
//    //    //    begin = std::chrono::steady_clock::now();
//    //    //    ASSERT_NO_THROW(result = jit->Run("\\\\‍('../examples/hello.src')"));
//    //    //    end = std::chrono::steady_clock::now();
//    //    //    Logger::Instance()->SetLogLevel(save);
//    //    //
//    //    //
//    //    //    ASSERT_TRUE(result);
//    //    //    ASSERT_TRUE(result->is_integral()) << result->toString();
//    //    //    ASSERT_STREQ("14", result->GetValueAsString().c_str());
//}
//
//TEST(Example, MatchCase) {
//
//    JIT *jit = JIT::ReCreate();
//    ASSERT_TRUE(jit);
//
//    //    ObjPtr prn;
//    //    ASSERT_NO_THROW(prn = jit->Run("prn(format:FmtChar, ...):Int32 := %printf ..."));
//    //    ASSERT_TRUE(prn);
//    //
//    //    ObjPtr res = (*prn)("Привет, мир!\n");
//    //    ASSERT_TRUE(res);
//    //    ASSERT_TRUE(res->is_integer()) << res->toString();
//    //    ASSERT_STREQ("22", res->GetValueAsString().c_str());
//    //
//    //    //    ObjPtr func = jit->Run("func(arg) := {$arg}");
//    //    //    ASSERT_TRUE(func);
//    //    //
//    //    //    res = (*func)("TEST");
//    //    //    ASSERT_TRUE(res);
//    //    //    ASSERT_TRUE(res->is_string_char_type()) << res->toString();
//    //    //    ASSERT_STREQ("TEST", res->GetValueAsString().c_str());
//    //    //    hello(str) := { 
//    //    //      printf := :Pointer('printf(format:FmtChar, ...):Int32');  # Импорт стандартной C функции
//    //    //      printf('%s\n', $str);  # Вызов C функции с проверкой типов аргументов по строке формата
//    //    //    };
//    //    //    hello('Привет, мир!'); # Вызвать функцию    
//    //
//    //
//    //    setvbuf(stdin, nullptr, _IONBF, 0);
//    //    setvbuf(stdout, nullptr, _IONBF, 0);
//    //    setvbuf(stderr, nullptr, _IONBF, 0);
//    //
//    //
//    //    Logger::LogLevelType save = Logger::Instance()->SetLogLevel(LOG_LEVEL_INFO);
//    //    std::chrono::steady_clock::time_point begin = std::chrono::steady_clock::now();
//    //    ObjPtr result = jit->RunFile("../examples/hello.src");
//    //    std::chrono::steady_clock::time_point end = std::chrono::steady_clock::now();
//    //    Logger::Instance()->SetLogLevel(save);
//    //
//    //
//    //    ASSERT_TRUE(result);
//    //    ASSERT_TRUE(result->is_integral()) << result->toString();
//    //    ASSERT_STREQ("14", result->GetValueAsString().c_str());
//    //
//    //
//    //    //    save = Logger::Instance()->SetLogLevel(LOG_LEVEL_INFO);
//    //    //    begin = std::chrono::steady_clock::now();
//    //    //    ASSERT_NO_THROW(result = jit->Run("\\\\‍('../examples/hello.src')"));
//    //    //    end = std::chrono::steady_clock::now();
//    //    //    Logger::Instance()->SetLogLevel(save);
//    //    //
//    //    //
//    //    //    ASSERT_TRUE(result);
//    //    //    ASSERT_TRUE(result->is_integral()) << result->toString();
//    //    //    ASSERT_STREQ("14", result->GetValueAsString().c_str());
//}
 
#endif // UNITTEST