#include "Capi/au/cpuid/cpuid.h"
#include <stdio.h>

int main(void)
{
   int         core_num = 0;
   if (au_cpuid_is_amd(core_num)) {
      printf("AMD CPU detected...\n");
   } else {
      // Intel Apis are not exposed.
      printf("Unknown CPU detected...\n");
   }

   return 0;
}

#include "Au/Cpuid/X86Cpu.hh"
using namespace Au;
int main(void)
{
   X86Cpu cpu{ 0 };

   if (cpu.isAMD()) {
      std::cout << "AMD CPU detected..." << std::endl;
   } else if (cpu.isIntel()) {
      std::cout << "Intel CPU detected..." << std::endl;
   } else {
      std::cout << "Unknown CPU detected..." << std::endl;
   }

   return 0;
}

#include "Capi/au/threadpinning.h"

#include <pthread.h>
#include <sched.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>

#define NUM_THREADS 5

void* threadFunction(void* arg)
{
   int id = *((int*)arg);
   printf("Thread started with ID: %d\n", id);
   sleep(3);
   return NULL;
}

void checkThreadAffinity(pthread_t thread)
{
   cpu_set_t cpuset;
   CPU_ZERO(&cpuset);
   if (pthread_getaffinity_np(thread, sizeof(cpu_set_t), &cpuset) != 0) {
      printf("Error reading thread affinity on Linux\n");
   } else {
      printf("Affinity mask: %lu\n", cpuset.__bits[0]);
   }
}

int main()
{
   int       thread_ids[NUM_THREADS];
   pthread_t threads[NUM_THREADS];

   for (int i = 0; i < NUM_THREADS; ++i) {
      thread_ids[i] = i;
      if (pthread_create(&threads[i], NULL, threadFunction, &thread_ids[i])
            != 0) {
            printf("Error creating thread %d\n", i);
            return 1;
      }
   }

   // Pin threads to the processor group using different strategies
   // CORE, LOGICAL, SPREAD, CUSTOM
   printf(
      "Pinning threads to the processor group using different strategies\n");
   printf("CORE\n");
   au_pin_threads_core(threads, NUM_THREADS);
   for (int i = 0; i < NUM_THREADS; ++i) {
      checkThreadAffinity(threads[i]);
   }
   printf("LOGICAL\n");
   au_pin_threads_logical(threads, NUM_THREADS);
   for (int i = 0; i < NUM_THREADS; ++i) {
      checkThreadAffinity(threads[i]);
   }
   printf("SPREAD\n");
   au_pin_threads_spread(threads, NUM_THREADS);
   for (int i = 0; i < NUM_THREADS; ++i) {
      checkThreadAffinity(threads[i]);
   }
   printf("CUSTOM\n");
   int affinityVector[NUM_THREADS] = { 0, 1, 4, 6, 7 };
   au_pin_threads_custom(threads, NUM_THREADS, affinityVector, NUM_THREADS);
   for (int i = 0; i < NUM_THREADS; ++i) {
      checkThreadAffinity(threads[i]);
   }

   for (int i = 0; i < NUM_THREADS; ++i) {
      pthread_join(threads[i], NULL);
   }

   return 0;
}

#include "Au/ThreadPinning.hh"
#include <iostream>
#include <thread>
#include <vector>

#ifdef _WIN32
#include <windows.h>
#else
#include <pthread.h>
#include <sched.h>
#endif

using namespace Au;

// Function for the thread to execute
void printThreadId(int id)
{
   std::cout << "Thread started with ID: " << id << std::endl;
   std::this_thread::sleep_for(std::chrono::milliseconds(1));
}

void checkThreadAffinity(std::thread& thread)
{
#ifdef _WIN32
   // Get the native handle of the thread
   HANDLE handle = (HANDLE)thread.native_handle();

   // Get thread group affinity
   GROUP_AFFINITY groupAffinity;
   BOOL           result = GetThreadGroupAffinity(handle, &groupAffinity);
   if (!result) {
      std::cerr << "Error reading thread affinity for thread  on Windows"
                  << std::endl;
   } else {
      std::cout << "groupAffinity.mask" << groupAffinity.Mask << std::endl;
   }
#else
   // Get the native handle of the thread
   pthread_t handle = thread.native_handle();
   // Create a CPU set and get the current affinity
   cpu_set_t cpuset;
   CPU_ZERO(&cpuset);
   int result = pthread_getaffinity_np(handle, sizeof(cpu_set_t), &cpuset);
   if (result != 0) {
      std::cerr << "Error reading thread affinity for thread  on Linux"
                  << std::endl;
   } else {
      std::cout << " affinity mask: " << cpuset.__bits[0] << std::endl;
   }
#endif
}

int main()
{
   int                      n = 5; // Number of threads
   std::vector<std::thread> threads;

   // Create n threads
   for (int i = 0; i < n; ++i) {
      threads.push_back(std::thread(printThreadId, i));
   }

   ThreadPinning          tp;
   std::vector<pthread_t> threadList;
   for (int i = 0; i < n; i++) {
      threadList.push_back(threads[i].native_handle());
   }
   std::cout << "Pinning threads using custom pin strategy" << std::endl;
   // pin threads using the custom strategy.
   tp.pinThreads(threadList, { 0, 5, 2, 10, 4 });
   for (int i = 0; i < n; ++i) {
      checkThreadAffinity(threads[i]);
   }
   std::cout << "Pinning threads using spread pin strategy" << std::endl;
   // pin threads using the spread strategy
   tp.pinThreads(threadList, 0);
   // Verify thread affinity for each thread
   for (int i = 0; i < n; ++i) {
      checkThreadAffinity(threads[i]);
   }
   std::cout << "Pinning threads using core pin strategy" << std::endl;
   // pin threads using the core strategy
   tp.pinThreads(threadList, 1);
   // Verify thread affinity for each thread
   for (int i = 0; i < n; ++i) {
      checkThreadAffinity(threads[i]);
   }

   std::cout << "Pinning threads using logical pin strategy" << std::endl;
   // pin threads using the Logical strategy
   tp.pinThreads(threadList, 2);
   // Verify thread affinity for each thread
   for (int i = 0; i < n; ++i) {
      checkThreadAffinity(threads[i]);
   }
   // Join all threads
   for (auto& th : threads) {
      th.join();
   }

   return 0;
}