Method start

include/exec/static_thread_pool.hpp:1746–1781

        }

        void start() & noexcept
        {
          std::size_t size         = items_.size();
          std::size_t nthreads     = this->pool_.available_parallelism();
          bwos_params params       = this->pool_.params();
          std::size_t local_size   = params.blockSize * params.numBlocks;
          std::size_t chunk_size   = __umin({size / nthreads, local_size * nthreads});
          auto&       remote_queue = *this->pool_.get_remote_queue();
          auto        it           = std::ranges::begin(this->range_);
          std::size_t i0           = 0;
          while (i0 + chunk_size < size)
          {
            for (std::size_t i = i0; i < i0 + chunk_size; ++i)
            {
              items_[i].__construct_from(STDEXEC::connect,
                                         set_next(this->rcvr_, item_sender_t{this, it + i}),
                                         next_receiver_t{this});
              STDEXEC::start(items_[i].__get());
            }

            std::unique_lock lock{this->start_mutex_};
            this->pool_.bulk_enqueue(remote_queue, std::move(this->tasks_), this->tasks_size_);
            lock.unlock();
            i0 += chunk_size;
          }
          for (std::size_t i = i0; i < size; ++i)
          {
            items_[i].__construct_from(STDEXEC::connect,
                                       set_next(this->rcvr_, item_sender_t{this, it + i}),
                                       next_receiver_t{this});
            STDEXEC::start(items_[i].__get());
          }
          std::unique_lock lock{this->start_mutex_};
          this->has_started_ = true;
          this->pool_.bulk_enqueue(remote_queue, std::move(this->tasks_), this->tasks_size_);
        }
      };

      template <class Range>