#include <tbb/pipeline.h>
// Deprecated:
// #include <tbb/task_scheduler_init.h>
#include <tbb/task_arena.h>

// Define your pipeline body
class MyPipeline {
public:
    void operator() (tbb::flow_control& fc) const {
        // Your pipeline logic here
        // ...
        // Inform the pipeline that there is no more data
        fc.stop();
    }
};

int main() {
    // Deprecated: tbb::task_scheduler_init init(1);
    tbb::task_arena arena(4); // 4 threads
    // Do some tasks:
    tbb::parallel_pipeline(/* max_number_of_live_tokens */ 4, MyPipeline); // FIXME: 似乎需要放入 arena 的 execute 函数中

    return 0;
}

#include <tbb/tbb.h>
#include <vector>
#include <iostream>

// 模拟 parallel_for 的内部实现
void my_parallel_for(const tbb::blocked_range<size_t>& range, const std::function<void(const tbb::blocked_range<size_t>&)>& body) {
    if (range.is_divisible()) {
        // 分割范围
        tbb::blocked_range<size_t> left(range.begin(), range.begin() + (range.end() - range.begin()) / 2);
        tbb::blocked_range<size_t> right(left.end(), range.end());

        // 递归调用
        tbb::parallel_invoke(
            [&] { my_parallel_for(left, body); },
            [&] { my_parallel_for(right, body); }
        );
    } else {
        // 处理当前范围
        body(range);
    }
}

int main() {
    std::vector<int> data(100);
    for (int i = 0; i < 100; ++i) {
        data[i] = i;
    }

    // 使用自定义的 parallel_for 进行并行处理
    my_parallel_for(tbb::blocked_range<size_t>(0, data.size()), [&](const tbb::blocked_range<size_t>& r) {
        for (size_t i = r.begin(); i != r.end(); ++i) {
            data[i] *= 2; // 示例操作：将每个元素乘以2
        }
    });

    // 输出结果
    for (const auto& val : data) {
        std::cout << val << " ";
    }
    std::cout << std::endl;

    return 0;
}

#include <tbb/tbb.h>

#include <iostream>
#include <mutex>
#include <thread>
#include <vector>
using namespace std;
using namespace tbb;

static std::atomic<int> total_blocks(0);  // Atomic counter to track the number of tasks processed
static std::atomic<int> total_blocks2(0);  // Atomic counter to track the number of tasks processed

// Function to process each data element
void process_data(int i, std::mutex& mtx) {
    // std::this_thread::sleep_for(std::chrono::milliseconds(1));  // Simulate some processing time
    for (int i = 0; i < 100; ++i)
        ;
}

int main(int argc, char* argv[]) {
    if (argc < 3) {
        std::cerr << "Usage: " << argv[0] << " <number_of_elements>"
                  << "<grain_size>" << std::endl;
        return 1;
    }

    int num_elements = std::stoi(argv[1]);
    int grain_size = std::stoi(argv[2]);

    std::mutex mtx;
    std::vector<int> data(num_elements);
    for (int i = 0; i < num_elements; ++i) {
        data[i] = i;
    }

    // {
    //     std::lock_guard<std::mutex> lock(mtx);
    //     std::cout << "Main thread ID: " << std::this_thread::get_id() << std::endl;
    // }

    tbb::concurrent_unordered_map<std::thread::id, tbb::concurrent_vector<int>> thread_task_counts;  // To store task counts for each thread
    tbb::concurrent_unordered_map<std::thread::id, tbb::concurrent_vector<int>> thread_task_counts2;  // To store task counts for each thread

    tbb::parallel_for(0, static_cast<int>((data.size() + grain_size - 1) / grain_size), [&](int i) {
        total_blocks++;
        int cnt = 0;  // Thread-local variable to avoid data
        for (int j = i * grain_size; j < std::min(static_cast<int>(data.size()), (i + 1) * grain_size); ++j) {
            process_data(i, mtx);
            ++cnt;
        }
        thread_task_counts[std::this_thread::get_id()].push_back(cnt);
    });

    tbb::parallel_for(blocked_range<int>(0u, data.size(), grain_size), [&](const blocked_range<int>& r) {
        total_blocks2++;
        int cnt = 0;  // Thread-local variable to avoid data
        for (int i = r.begin(); i < r.end(); ++i) {
            process_data(i, mtx);
            ++cnt;
        }
        thread_task_counts2[std::this_thread::get_id()].push_back(cnt);
    });

    std::cout << "Total blocks processed: " << total_blocks.load() << std::endl;
    for (const auto& pair : thread_task_counts) {
        std::cout << "Thread " << pair.first << " processed: ";
        for (const auto& task_count : pair.second)
            std::cout << task_count << ", ";
        std::cout << std::endl;
    }

    std::cout << "Total blocks2 processed: " << total_blocks2.load() << std::endl;
    for (const auto& pair : thread_task_counts2) {
        std::cout << "Thread " << pair.first << " processed: ";
        for (const auto& task_count : pair.second)
            std::cout << task_count << ", ";
        std::cout << std::endl;
    }

    return 0;
}

#include <iostream>
#include <vector>
#include <thread>
#include <functional>
#include <condition_variable>
#include <queue>

class TaskScheduler {
public:
    TaskScheduler(size_t numThreads);
    ~TaskScheduler();
    void enqueue(std::function<void()> task);
    void wait();

private:
    std::vector<std::thread> workers;
    std::queue<std::function<void()>> tasks;
    std::mutex queueMutex;
    std::condition_variable condition;
    std::condition_variable finished;
    bool stop;
    size_t activeTasks;

    void workerThread();
    void executeTask();
};

TaskScheduler::TaskScheduler(size_t numThreads) : stop(false), activeTasks(0) {
    for (size_t i = 0; i < numThreads; ++i) {
        workers.emplace_back(&TaskScheduler::workerThread, this);
    }
}

TaskScheduler::~TaskScheduler() {
    {
        std::unique_lock<std::mutex> lock(queueMutex);
        stop = true;
    }
    condition.notify_all();
    for (std::thread &worker : workers) {
        worker.join();
    }
}

void TaskScheduler::enqueue(std::function<void()> task) {
    {
        std::unique_lock<std::mutex> lock(queueMutex);
        tasks.push(std::move(task));
    }
    condition.notify_one();
}

void TaskScheduler::wait() {
    std::unique_lock<std::mutex> lock(queueMutex);
    while (!tasks.empty() || activeTasks > 0) {
        // 如果还有任务，执行一个任务，避免当前线程被阻塞
        if (!tasks.empty()) {
            executeTask();
        } else {
            finished.wait(lock);
        }
    }
}

void TaskScheduler::workerThread() {
    while (true) {
        std::function<void()> task;
        {
            std::unique_lock<std::mutex> lock(queueMutex);
            condition.wait(lock, [this] { return stop || !tasks.empty(); });
            if (stop && tasks.empty()) return;
            task = std::move(tasks.front());
            tasks.pop();
            ++activeTasks;
        }
        task();
        {
            std::unique_lock<std::mutex> lock(queueMutex);
            --activeTasks;
            if (tasks.empty() && activeTasks == 0) {
                finished.notify_all();
            }
        }
    }
}

void TaskScheduler::executeTask() {
    std::function<void()> task;
    {
        std::unique_lock<std::mutex> lock(queueMutex);
        if (tasks.empty()) return;
        task = std::move(tasks.front());
        tasks.pop();
        ++activeTasks;
    }
    task();
    {
        std::unique_lock<std::mutex> lock(queueMutex);
        --activeTasks;
        if (tasks.empty() && activeTasks == 0) {
            finished.notify_all();
        }
    }
}

void parallel_for(int start, int end, std::function<void(int)> func) {
    static TaskScheduler scheduler(std::thread::hardware_concurrency());
    for (int i = start; i < end; ++i) {
        scheduler.enqueue([i, &func] { func(i); });
    }
    scheduler.wait();
}

int main() {
    const int N1 = 100;
    const int N2 = 100;

    // The first parallel loop.
    parallel_for(0, N1, [&](int i) {
        // The second parallel loop.
        parallel_for(0, N2, [&](int j) {
            // Some work
        });
        // 线程发出 parallel_for 之后，需要等待内部所有 parallel loop 的任务完成
        // 在此期间允许继续拿取外部的 parallel loop 的任务执行
    });

    return 0;
}

#include <tbb/tbb.h>
#include <unistd.h>

#include <iostream>
#include <mutex>
#include <thread>
#include <vector>

using namespace std;

std::mutex mtx;

void task_group_function() {
    tbb::task_group tg;
    int max_concurrency = tbb::this_task_arena::max_concurrency();
    {
        std::lock_guard<std::mutex> lock(mtx);
        cout << "Task group max concurrency: " << max_concurrency << endl;
    }
    for (int i = 0; i < 16; ++i) {
        tg.run([i] {
            {
                std::lock_guard<std::mutex> lock(mtx);
                std::cout << "Task group thread " << std::this_thread::get_id() << " is running." << std::endl;
            }
            sleep(1);
        });
    }
    tg.wait();
}

void task_arena_function() {
    tbb::task_arena arena(4);
    int max_concurrency = arena.max_concurrency();
    {
        std::lock_guard<std::mutex> lock(mtx);
        cout << "Task arena max concurrency: " << max_concurrency << endl;
    }
    arena.execute([max_concurrency] {
        tbb::parallel_for(0, 16, [](int i) {
            {
                std::lock_guard<std::mutex> lock(mtx);
                std::cout << "Task arena thread " << std::this_thread::get_id() << " is running." << std::endl;
            }
            sleep(2);
        });
    });
}

int main() {
    // 获取默认task_arena的最大并发线程数
    int arena_max_concurrency = tbb::this_task_arena::max_concurrency();
    std::cout << "Default task_arena max concurrency: " << arena_max_concurrency << std::endl;

    // 创建两个线程
    std::thread tg_thread(task_group_function);
    std::thread ta_thread(task_arena_function);

    // 等待两个线程完成
    tg_thread.join();
    ta_thread.join();

    return 0;
}

// The first parallel loop.
oneapi::tbb::parallel_for( 0, N1, []( int i ) {
    // The second parallel loop.
    oneapi::tbb::parallel_for( 0, N2, []( int j ) { /* Some work */ } );
} );

oneapi::tbb::enumerable_thread_specific<int> ets;
oneapi::tbb::parallel_for( 0, N1, [&ets]( int i ) {
    // Set a thread specific value
    ets.local() = i;
    oneapi::tbb::parallel_for( 0, N2, []( int j ) { /* Some work */ } );
    // While executing the above parallel_for, the thread might have run iterations
    // of the outer parallel_for, and so might have changed the thread specific value.
    assert( ets.local()==i ); // The assertion may fail!
} );

oneapi::tbb::enumerable_thread_specific<int> ets;
oneapi::tbb::task_arena nested;
oneapi::tbb::parallel_for( 0, N1, [&]( int i ) {
    // Set a thread specific value
    ets.local() = i;
    nested.execute( []{
        // Run the inner parallel_for in a separate arena to prevent the thread
        // from taking tasks of the outer parallel_for.
        oneapi::tbb::parallel_for( 0, N2, []( int j ) { /* Some work */ } );
    } );
    assert( ets.local()==i ); // Valid assertion
} );

#include "oneapi/tbb/task_arena.h"
#include "oneapi/tbb/parallel_for.h"
#include "oneapi/tbb/enumerable_thread_specific.h"
#include <cassert>


int main() {
    const int N1 = 1000, N2 = 1000;
    oneapi::tbb::enumerable_thread_specific<int> ets;
    oneapi::tbb::parallel_for( 0, N1, [&ets]( int i ) {
        // Set a thread specific value
        ets.local() = i;
        // Run the second parallel loop in an isolated region to prevent the current thread
        // from taking tasks related to the outer parallel loop.
        oneapi::tbb::this_task_arena::isolate( []{
            oneapi::tbb::parallel_for( 0, N2, []( int j ) { /* Some work */ } );
        } );
        assert( ets.local()==i ); // Valid assertion
    } );
    return 0;
}

#include <tbb/tbb.h>
#include <iostream>

void taskA() {
    std::cout << "Task A executed by thread " << tbb::this_task_arena::current_thread_index() << std::endl;
    tbb::parallel_invoke(
         {
            std::cout << "Subtask A1 executed by thread " << tbb::this_task_arena::current_thread_index() << std::endl;
        },
         {
            std::cout << "Subtask A2 executed by thread " << tbb::this_task_arena::current_thread_index() << std::endl;
        }
    );
}

void taskB() {
    std::cout << "Task B executed by thread " << tbb::this_task_arena::current_thread_index() << std::endl;
    tbb::parallel_invoke(
         {
            std::cout << "Subtask B1 executed by thread " << tbb::this_task_arena::current_thread_index() << std::endl;
        },
         {
            std::cout << "Subtask B2 executed by thread " << tbb::this_task_arena::current_thread_index() << std::endl;
        }
    );
}

int main() {
    tbb::task_arena arena;
    arena.execute([&] {
        tbb::this_task_arena::isolate([&] {
            tbb::parallel_invoke(taskA, taskB);
        });
    });
    return 0;
}

#include <sys/times.h>

clock_t times(struct tms *buf);

char ** backtrace_symbols (void *const *buffer, int size) 

void *malloc( size_t size );
void free( void *ptr );

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

int main() {
    char** strings = (char**)malloc(3 * sizeof(char*) + 3 * 50); // assuming a maximum 50 characters per sentence
    char* block = (char*)(strings + 3);
    char* s1 = strcpy(block, "The first sentence"); block += strlen(s1) + 1;
    char* s2 = strcpy(block, "The second sentence"); block += strlen(s2) + 1;
    char* s3 = strcpy(block, "The third sentence");
    strings[0] = s1;
    strings[1] = s2;
    strings[2] = s3;
    for(int i = 0; i < 3; ++i) {
        printf("%s\n", strings[i]);
    }
    free(strings); // deallocate all memory at once

    return 0;
}

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

int main() {
    char** strings = (char**)malloc(3 * sizeof(char*) + 3 * 50);
    char* block = (char*)(strings + 3);
    for(int i = 0; i < 3; ++i) {
        strings[i] = block + i * 50; // Assuming a maximum of 50 characters per sentence
    }
    strcpy(strings[0], "The first sentence");
    strcpy(strings[1], "The second sentence");
    strcpy(strings[2], "The third sentence");

    for(int i = 0; i < 3; ++i) {
        printf("%s\n", strings[i]);
    }

    free(strings); // deallocate all memory at once

    return 0;
}