Cleaning up pool and affinity test compatibility

    }

};

// this does nothing, it only serves to make the DCA tests pass

// HPX manages affinity without the help of DCA

static std::vector<int> affinity_;

// Returns a list of cores id for which the calling thread has affinity.

std::vector<int> get_affinity()

{

  cpu_set_t cpu_set_mask;

  auto status = sched_getaffinity(0, sizeof(cpu_set_t), &cpu_set_mask);

  if (status == -1) {

    throw(std::runtime_error("Unable to get thread affinity."));

  }

  auto cpu_count = CPU_COUNT(&cpu_set_mask);

  std::vector<int> cores;

  cores.reserve(cpu_count);

  for (auto i = 0; i < CPU_SETSIZE && cores.size() < cpu_count; ++i) {

      cores.push_back(i);

    // do nothing, hpx handles this internally

    return affinity_;

}

  return cores;

}

void set_affinity(const std::vector<int>& /*cores*/)

// Set a list of cores id for which the calling thread has affinity.

void set_affinity(const std::vector<int>& cores)

{

    // just do nothing, hpx handles this internally

    // do nothing, hpx handles this internally

    affinity_ = cores;

}

// Number of cores used by this process.

int get_core_count() { return hpx::get_num_worker_threads(); }

int get_core_count() {

    return std::thread::hardware_concurrency(); // hpx::get_num_worker_threads();

}

class ThreadPool {

public:

  // Creates a pool with n_threads.

  // Actually does nothing, HPX does not need to allocate threads

  ThreadPool(size_t n_threads = 1) : exec(500, 500) {

  ThreadPool(size_t n_threads = 0) : exec(500, 500) {

    pool_size = n_threads;

  }

  // Conclude all the pending work and destroy the threads spawned by this class.

  ~ThreadPool() {

      exec.wait_all();

      pool_size = 0;

  }

  void set_task_count_threshold(std::int64_t count)

    exec.wait_all();

  }

  // we don't do anything here

  // we don't do anything here, just update the size

  // so that DCA tests pass

  void enlarge(std::size_t n_threads) {

      std::cout << "HPX threadpool enlarge: " << n_threads << std::endl;

      pool_size = n_threads;

      pool_size = std::max(pool_size, n_threads);

  }

  // Call asynchronously the function f with arguments args. This method is thread safe.

  }

  // Returns the number of threads used by this class.

  // The DCA unit testing expects the size set to be returned

  // so we ignore the true thread pool size and return what DCA expects

  std::size_t size() const {

    std::cout << "HPX threadpool size" << std::endl;

    return pool_size;

    // return hpx::get_num_worker_threads();

    return pool_size; // hpx::get_num_worker_threads();

  }

  // Returns a static instance.

  }

  // this is just to make the DCA tests pass

  int pool_size;

  std::size_t pool_size;

  hpx::threads::executors::limiting_executor

    <hpx::threads::executors::default_executor> exec;