Compile instructions for Day 17 Part 2

Author: zeichensystem

aoclib/aocio.hpp

@@ -189,6 +189,28 @@ static inline std::optional<int64_t> parse_num_i64(const std::string& str, bool
  return n; 
 } 
 
+static inline std::optional<uint64_t> parse_num_u64(const std::string& str, bool strict = false)
+{
+ size_t num_read = 0; 
+ uint64_t n; 
+ try {
+ n = std::stoull(str, &num_read); 
+ } catch (const std::invalid_argument& err) {
+ return {};
+ } catch (const std::out_of_range& err) {
+ std::cerr << "parse_num_u64: the converted value would fall out of the range of uint64_t";
+ return {};
+ }
+ 
+ if (strict && num_read != str.size()) {
+ return {};
+ }
+ if (num_read == 0) {
+ return {};
+ }
+ return n; 
+} 
+
 static inline std::optional<int> parse_digit(char c)
 {
  int digit = static_cast<int>(c) - '0'; 
@@ -507,6 +529,15 @@ class RDParser
  }
  return num;
  }
+ template<>
+ std::optional<uint64_t> accept_int<uint64_t>()
+ {
+ const auto num = aocio::parse_num_u64(std::string{_current_token}, true); 
+ if (num.has_value()) {
+ next_token();
+ }
+ return num;
+ }
 
  template<class IntT> IntT require_int();
  template<>
@@ -533,6 +564,18 @@ class RDParser
  const std::string info = "on line " + std::to_string(line + 1) + " (col " + std::to_string(col - current_token().size()) + "):\n'" + offending_line + "'";
  throw std::runtime_error("Parser::require_int: Required int token does not match actual token\n'" + std::string{current_token()} + "'\n" + info);
  }
+ template<>
+ uint64_t require_int<uint64_t>()
+ {
+ const auto num = aocio::parse_num_u64(std::string{_current_token}, true); 
+ if (num.has_value()) {
+ next_token();
+ return num.value();
+ }
+ const std::string offending_line = line < lines.size() ? lines.at(line) : "";
+ const std::string info = "on line " + std::to_string(line + 1) + " (col " + std::to_string(col - current_token().size()) + "):\n'" + offending_line + "'";
+ throw std::runtime_error("Parser::require_int: Required int token does not match actual token\n'" + std::string{current_token()} + "'\n" + info);
+ }
 
  bool accept_newline() 
  {

aoclib/parallel.hpp

@@ -1,5 +1,7 @@
 #pragma once
 #include <thread>
+#include <future>
+#include <chrono>
 #include <iostream>
 #include <concepts>
 #include <utility>
@@ -142,4 +144,120 @@ T parallel_transform_reduce(int num_threads, ForwardIt first, ForwardIt last, T
 {
  return parallel_transform_reduce(first, last, init, reduce, transform, num_threads);
 }
-}
+
+// template<class ForwardIt, class WorkFn, class WorkFnResultOptional>
+// void parallel_search_first(ForwardIt begin, ForwardIt end, WorkFn work_fn, std::chrono::milliseconds busy_loop_sleep = 0)
+// {
+// std::promise<void> done_promise;
+// std::shared_future<void> done_future = done_promise.get_future(); 
+
+// const auto worker = [done_future](ForwardIt begin, ForwardIt end, std::promise<WorkFnResultOptional> result_promise) 
+// {
+// for (auto it = begin; it != end; ++it) {
+// if (done_future.wait_for(std::chrono::nanoseconds{0}) == std::future_status::ready) {
+// return;
+// }
+// WorkFnResultOptional result = work_fn(*begin);
+// if (result.has_value()) {
+// result_promise.set_value(result);
+// return;
+// }
+// }
+// result_promise.set_exception(WorkFnResultOptional{});
+// };
+
+// if (num_threads > num_elems) {
+// num_threads = num_elems;
+// }
+
+// const ptrdiff_t elems_per_thread = num_elems / num_threads;
+// ptrdiff_t remainder = num_elems % num_threads;
+// assert(elems_per_thread > 0 || remainder > 0);
+// assert((elems_per_thread * num_threads + remainder) == num_elems);
+ 
+// std::vector<std::thread> workers;
+// std::vector<std::future<WorkFnResultOptional>> worker_futures;
+// std::vector<std::future<WorkFnResultOptional>> worker_results;
+
+// for (auto start_it = first; start_it != last;) {
+// assert(std::ssize(workers) < num_threads);
+// ptrdiff_t increment = elems_per_thread;
+// if (remainder) {
+// ++increment;
+// --remainder;
+// }
+// assert(increment > 0);
+
+// const auto end_it = std::next(start_it, increment);
+
+// std::promise<WorkFnResultOptional> worker_promise; 
+// worker_futures.push_back(worker_promise.get_future());
+// assert(worker_futures.back().valid());
+// workers.push_back(std::thread(worker, start_it, end_it, std::move(worker_promise)));
+
+// start_it = end_it;
+// }
+// assert(std::ssize(workers) == num_threads);
+// assert(remainder == 0);
+// assert(worker_futures.size() == workers.size());
+
+// const auto is_first_result = [&worker_futures, &worker_results](size_t idx)
+// {
+// const auto& future = worker_futures.at(i);
+// bool is_first_res = true;
+// for (int j = 0; j < i; ++j) {
+// if (worker_futures.at(j).valid() || worker_results.at(j).has_value()) {
+// is_first_res = false;
+// break;
+// }
+// }
+// return is_first_res;
+// }
+
+// WorkFnResultOptional result = {};
+// for (;;) {
+// size_t not_found = 0;
+// for (size_t i = 0; i < worker_futures.size(); ++i) {
+// auto& wrk_future = worker_futures.at(i);
+// auto& wrk_result = worker_results.at(i);
+
+// const bool is_first_res = is_first_result(i);
+
+// const auto is_done = [is_first_res, &wrk_future, &result, &wrk_result, &not_found, &done_promise]() -> bool {
+// if (!wrk_results.has_value() || !is_first_res) {
+// ++not_found;
+// return false;
+// } else {
+// result = wrk_result;
+// done_promise.set_value(); // Signal to all workers we found a solution.
+// return true;
+// }
+// };
+
+// if (!future.valid() && is_done()) {
+// assert(result.has_value());
+// goto end;
+// } else if (future.valid() && future.wait_for(busy_loop_sleep) == std::future_status::ready) {
+// wrk_result = future.get();
+// assert(!future.valid());
+// if (is_done()) {
+// assert(result.has_value());
+// goto end;
+// }
+// }
+// }
+
+// if (not_found == worker_futures.size()) {
+// assert(!result.has_value());
+// goto end;
+// }
+// }
+
+// end:
+// for (auto& w: workers) {
+// w.join();
+// }
+// return result;
+// }
+
+}