C++ HPX_THROWS_IF函数代码示例

    threads::thread_priority get_thread_priority(thread_id_type id, error_code& ec)
    {
        hpx::applier::applier* app = hpx::applier::get_applier_ptr();
        if (NULL == app)
        {
            HPX_THROWS_IF(ec, invalid_status,
                "hpx::threads::get_thread_priority",
                "global applier object is not accessible");
            return threads::thread_priority_unknown;
        }

        if (&ec != &throws)
            ec = make_success_code();

        return app->get_thread_manager().get_priority(id);
    }

    std::size_t set_thread_data(thread_id_type id, std::size_t d, error_code& ec)
    {
        hpx::applier::applier* app = hpx::applier::get_applier_ptr();
        if (NULL == app)
        {
            HPX_THROWS_IF(ec, invalid_status,
                "hpx::threads::set_thread_data",
                "global applier object is not accessible");
            return 0;
        }

        if (&ec != &throws)
            ec = make_success_code();

        return app->get_thread_manager().set_thread_data(id, d, ec);
    }

    util::backtrace const* get_thread_backtrace(thread_id_type id, error_code& ec)
    {
        hpx::applier::applier* app = hpx::applier::get_applier_ptr();
        if (NULL == app)
        {
            HPX_THROWS_IF(ec, invalid_status,
                "hpx::threads::get_thread_backtrace",
                "global applier object is not accessible");
            return NULL;
        }

        if (&ec != &throws)
            ec = make_success_code();

        return app->get_thread_manager().get_backtrace(id);
    }

 void decode_compact_distribution(hwloc_topology& t,
     std::vector<mask_type>& affinities, error_code& ec)
 {
     std::size_t num_threads = affinities.size();
     for(std::size_t i = 0; i != num_threads; ++i)
     {
         if (any(affinities[i]))
         {
             HPX_THROWS_IF(ec, bad_parameter, "decode_compact_distribution",
                 boost::str(boost::format("affinity mask for thread %1% has "
                     "already been set") % i));
             return;
         }
         affinities[i] = t.init_thread_affinity_mask(i);
     }
 }

    threads::thread_state_ex_enum suspend(
        boost::posix_time::time_duration const& after_duration,
        char const* description, error_code& ec)
    {
        // handle interruption, if needed
        this_thread::interruption_point();

        // schedule a thread waking us up after_duration
        threads::thread_self& self = threads::get_self();
        threads::thread_id_type id = self.get_thread_id();

        threads::set_thread_state(id,
            after_duration, threads::pending, threads::wait_signaled,
            threads::thread_priority_critical, ec);
        if (ec) return threads::wait_unknown;

        // let the thread manager do other things while waiting
        threads::thread_state_ex_enum statex = threads::wait_unknown;
        {
            // verify that there are no more registered locks for this OS-thread
            util::verify_no_locks();

            // suspend the HPX-thread
            detail::reset_lco_description desc(id, description, ec);

#if HPX_THREAD_MAINTAIN_BACKTRACE_ON_SUSPENSION
            detail::reset_backtrace bt(id, ec);
#endif
            statex = self.yield(threads::suspended);
        }

        // handle interrupt and abort
        this_thread::interruption_point();
        if (statex == threads::wait_abort) {
            hpx::util::osstream strm;
            strm << "thread(" << id << ", "
                  << threads::get_thread_description(id)
                  << ") aborted (yield returned wait_abort)";
            HPX_THROWS_IF(ec, yield_aborted, description,
                hpx::util::osstream_get_string(strm));
        }

        if (&ec != &throws)
            ec = make_success_code();

        return statex;
    }

    threads::thread_id_type register_thread_plain(
        threads::thread_init_data& data, threads::thread_state_enum state,
        bool run_now, error_code& ec)
    {
        hpx::applier::applier* app = hpx::applier::get_applier_ptr();
        if (NULL == app)
        {
            HPX_THROWS_IF(ec, invalid_status,
                "hpx::applier::register_thread_plain",
                "global applier object is not accessible");
            return threads::invalid_thread_id;
        }

        threads::thread_id_type id = threads::invalid_thread_id;
        app->get_thread_manager().register_thread(data, id, state, run_now, ec);
        return id;
    }

    parcelset::endpoints_type request::get_endpoints(
        error_code& ec
        ) const
    { // {{{
        switch (data->which())
        {
            case request_data::subtype_locality_count:
                return data->get_data<request_data::subtype_locality_count, 0>(ec);

            default: {
                HPX_THROWS_IF(ec, bad_parameter,
                    "request::get_endpoints",
                    "invalid operation for request type");
                return parcelset::endpoints_type();
            }
        }
    } // }}}

    char const* set_thread_lco_description(thread_id_type const& id,
        char const* desc, error_code& ec)
    {
        hpx::applier::applier* app = hpx::applier::get_applier_ptr();
        if (NULL == app)
        {
            HPX_THROWS_IF(ec, invalid_status,
                "hpx::threads::set_thread_lco_description",
                "global applier object is not accessible");
            return NULL;
        }

        if (&ec != &throws)
            ec = make_success_code();

        return app->get_thread_manager().set_lco_description(id, desc);
    }

// Stop the executor identified with the given cookie
void resource_manager::stop_executor(std::size_t cookie, error_code& ec)
{
    std::lock_guard<mutex_type> l(mtx_);
    proxies_map_type::iterator it = proxies_.find(cookie);
    if (it == proxies_.end()) {
        HPX_THROWS_IF(ec, bad_parameter, "resource_manager::detach",
                      "the given cookie is not known to the resource manager");
        return;
    }

    // inform executor to give up virtual cores
    proxy_data& p = (*it).second;
    for (coreids_type coreids : p.core_ids_)
    {
        p.proxy_->remove_processing_unit(coreids.second, ec);
    }
}

    /// The function \a suspend will return control to the thread manager
    /// (suspends the current thread). It sets the new state of this thread
    /// to the thread state passed as the parameter.
    ///
    /// If the suspension was aborted, this function will throw a
    /// \a yield_aborted exception.
    threads::thread_state_ex_enum suspend(threads::thread_state_enum state,
        char const* description, error_code& ec)
    {
        // handle interruption, if needed
        this_thread::interruption_point();

        // let the thread manager do other things while waiting
        threads::thread_self& self = threads::get_self();
        threads::thread_state_ex_enum statex = threads::wait_unknown;
        {
            // verify that there are no more registered locks for this OS-thread
#if HPX_HAVE_VERIFY_LOCKS
            util::verify_no_locks();
#endif
#if HPX_THREAD_MAINTAIN_DESCRIPTION
            threads::thread_id_type id = self.get_thread_id();
            detail::reset_lco_description desc(id, description, ec);
#endif
#if HPX_THREAD_MAINTAIN_BACKTRACE_ON_SUSPENSION
            detail::reset_backtrace bt(id, ec);
#endif

            // suspend the HPX-thread
            statex = self.yield(state);
        }

        // handle interruption, if needed
        this_thread::interruption_point();

        // handle interrupt and abort
        if (statex == threads::wait_abort) {
            threads::thread_id_type id = self.get_thread_id();
            hpx::util::osstream strm;
            strm << "thread(" << id << ", "
                  << threads::get_thread_description(id)
                  << ") aborted (yield returned wait_abort)";
            HPX_THROWS_IF(ec, yield_aborted, description,
                hpx::util::osstream_get_string(strm));
        }

        if (&ec != &throws)
            ec = make_success_code();

        return statex;
    }

    void hwloc_topology::set_thread_affinity_mask(
        mask_type mask
      , error_code& ec
        ) const
    { // {{{
        hwloc_cpuset_t cpuset = hwloc_bitmap_alloc();

        for (std::size_t i = 0; i < sizeof(std::size_t) * CHAR_BIT; ++i)
        {
            if (mask & (static_cast<std::size_t>(1) << i))
            {
                hwloc_bitmap_set(cpuset, static_cast<unsigned int>(i));
            }
        }

        {
            scoped_lock lk(topo_mtx);
            if (hwloc_set_cpubind(topo, cpuset,
                  HWLOC_CPUBIND_STRICT | HWLOC_CPUBIND_THREAD))
            {
                // Strict binding not supported or failed, try weak binding.
                if (hwloc_set_cpubind(topo, cpuset, HWLOC_CPUBIND_THREAD))
                {
                    hwloc_bitmap_free(cpuset);

                    HPX_THROWS_IF(ec, kernel_error
                      , "hpx::threads::hwloc_topology::set_thread_affinity_mask"
                      , boost::str(boost::format(
                            "failed to set thread %x affinity mask")
                            % mask));

                    if (ec)
                        return;
                }
            }
        }
#if defined(__linux) || defined(linux) || defined(__linux__) || defined(__FreeBSD__)
        sleep(0);   // Allow the OS to pick up the change.
#endif

        hwloc_bitmap_free(cpuset);

        if (&ec != &throws)
            ec = make_success_code();
    } // }}}

    void set_thread_affinity_mask(
        boost::thread& thrd
      , mask_type mask
      , error_code& ec = throws
        ) const
    { // {{{
        if (!SetThreadAffinityMask(thrd.native_handle(), DWORD_PTR(mask)))
        {
            HPX_THROWS_IF(ec, kernel_error
              , "hpx::threads::windows_topology::set_thread_affinity_mask"
              , boost::str(boost::format(
                    "failed to set thread %1% affinity mask")
                    % mask));
        }

        else if (&ec != &throws)
            ec = make_success_code();
    } // }}}

    thread_state set_thread_state(thread_id_type id, thread_state_enum state,
        thread_state_ex_enum stateex, thread_priority priority, error_code& ec)
    {
        hpx::applier::applier* app = hpx::applier::get_applier_ptr();
        if (NULL == app)
        {
            HPX_THROWS_IF(ec, invalid_status,
                "hpx::threads::set_thread_state",
                "global applier object is not accessible");
            return thread_state(unknown);
        }

        if (&ec != &throws)
            ec = make_success_code();

        return app->get_thread_manager().set_state(id, state, stateex,
            priority, ec);
    }

    // Return the requested policy element
    std::size_t generic_thread_pool_executor::get_policy_element(
        threads::detail::executor_parameter p, error_code& ec) const
    {
        switch(p) {
        case threads::detail::min_concurrency:
        case threads::detail::max_concurrency:
        case threads::detail::current_concurrency:
            return hpx::get_os_thread_count();

        default:
            break;
        }

        HPX_THROWS_IF(ec, bad_parameter,
            "thread_pool_executor::get_policy_element",
            "requested value of invalid policy element");
        return std::size_t(-1);
    }

naming::gid_type get_next_id(
    std::size_t count
  , error_code& ec
    )
{
    if (get_runtime_ptr() == 0)
    {
        HPX_THROWS_IF(ec, invalid_status,
            "get_next_id", "the runtime system has not been started yet.");
        return naming::invalid_gid;
    }

    naming::resolver_client& agas_ = naming::get_agas_client();
    naming::gid_type lower_bound, upper_bound;
    agas_.get_id_range(count, lower_bound, upper_bound, ec);
    if (ec) return naming::invalid_gid;

    return lower_bound;
}