C++ util::runtime_configuration类代码示例

    runtime_impl<SchedulingPolicy, NotificationPolicy>::runtime_impl(
            util::runtime_configuration const& rtcfg,
            runtime_mode locality_mode, std::size_t num_threads,
            init_scheduler_type const& init,
            threads::policies::init_affinity_data const& init_affinity)
      : runtime(rtcfg, init_affinity),
        mode_(locality_mode), result_(0), num_threads_(num_threads),
        main_pool_(1,
            boost::bind(&runtime_impl::init_tss, This(), "main-thread", ::_1, ::_2, false),
            boost::bind(&runtime_impl::deinit_tss, This()), "main_pool"),
        io_pool_(rtcfg.get_thread_pool_size("io_pool"),
            boost::bind(&runtime_impl::init_tss, This(), "io-thread", ::_1, ::_2, true),
            boost::bind(&runtime_impl::deinit_tss, This()), "io_pool"),
        timer_pool_(rtcfg.get_thread_pool_size("timer_pool"),
            boost::bind(&runtime_impl::init_tss, This(), "timer-thread", ::_1, ::_2, true),
            boost::bind(&runtime_impl::deinit_tss, This()), "timer_pool"),
        parcel_port_(parcelset::parcelport::create_bootstrap(ini_,
            boost::bind(&runtime_impl::init_tss, This(), "parcel-thread", ::_1, ::_2, true),
            boost::bind(&runtime_impl::deinit_tss, This()))),
        scheduler_(init),
        notifier_(
            boost::bind(&runtime_impl::init_tss, This(), "worker-thread", ::_1, ::_2, false),
            boost::bind(&runtime_impl::deinit_tss, This()),
            boost::bind(&runtime_impl::report_error, This(), _1, _2)),
        thread_manager_(new hpx::threads::threadmanager_impl<
            SchedulingPolicy, NotificationPolicy>(
                timer_pool_, scheduler_, notifier_, num_threads)),
        agas_client_(*parcel_port_, ini_, mode_),
        parcel_handler_(agas_client_, thread_manager_.get(),
            new parcelset::policies::global_parcelhandler_queue),
        init_logging_(ini_, mode_ == runtime_mode_console, agas_client_),
        applier_(parcel_handler_, *thread_manager_,
            boost::uint64_t(runtime_support_.get()), boost::uint64_t(memory_.get())),
        action_manager_(applier_)
    {
        components::server::get_error_dispatcher().register_error_sink(
            &runtime_impl::default_errorsink, default_error_sink_);

        // in AGAS v2, the runtime pointer (accessible through get_runtime
        // and get_runtime_ptr) is already initialized at this point.
        applier_.init_tss();

#if defined(HPX_HAVE_SECURITY)
        // once all has been initialized, finalize security data for bootstrap
        this->init_security();
#endif
        // now, launch AGAS and register all nodes, launch all other components
        agas_client_.initialize(*parcel_port_);
        parcel_handler_.initialize(parcel_port_);

#if defined(HPX_HAVE_SECURITY)
        // enable parcel capability checking
        applier_.enable_verify_capabilities();
#endif

        // copy over all startup functions registered so far
        BOOST_FOREACH(HPX_STD_FUNCTION<void()> const& f, global_pre_startup_functions)
        {
            add_pre_startup_function(f);
        }

 parcelset::locality connection_handler::agas_locality(
     util::runtime_configuration const & ini) const
 {
     // load all components as described in the configuration information
     if (ini.has_section("hpx.agas")) {
         util::section const* sec = ini.get_section("hpx.agas");
         if (nullptr != sec) {
             return
                 parcelset::locality(
                     locality(
                         sec->get_entry("address", HPX_INITIAL_IP_ADDRESS)
                       , hpx::util::get_entry_as<boost::uint16_t>(
                             *sec, "port", HPX_INITIAL_IP_PORT)
                     )
                 );
         }
     }
     return
         parcelset::locality(
             locality(
                 HPX_INITIAL_IP_ADDRESS
               , HPX_INITIAL_IP_PORT
             )
         );
 }

    parcelport::parcelport(util::runtime_configuration const& ini,
            locality const & here, std::string const& type)
      : applier_(nullptr),
        here_(here),
        max_inbound_message_size_(ini.get_max_inbound_message_size()),
        max_outbound_message_size_(ini.get_max_outbound_message_size()),
        allow_array_optimizations_(true),
        allow_zero_copy_optimizations_(true),
        enable_security_(false),
        async_serialization_(false),
        priority_(hpx::util::get_entry_as<int>(ini,
            "hpx.parcel." + type + ".priority", "0")),
        type_(type)
    {
        std::string key("hpx.parcel.");
        key += type;

        if (hpx::util::get_entry_as<int>(
                ini, key + ".array_optimization", "1") == 0)
        {
            allow_array_optimizations_ = false;
            allow_zero_copy_optimizations_ = false;
        }
        else
        {
            if (hpx::util::get_entry_as<int>(
                    ini, key + ".zero_copy_optimization", "1") == 0)
            {
                allow_zero_copy_optimizations_ = false;
            }
        }

        if (hpx::util::get_entry_as<int>(
                ini, key + ".enable_security", "0") != 0)
        {
            enable_security_ = true;
        }

        if (hpx::util::get_entry_as<int>(
                ini, key + ".async_serialization", "0") != 0)
        {
            async_serialization_ = true;
        }
    }

    runtime_impl<SchedulingPolicy, NotificationPolicy>::runtime_impl(
            util::runtime_configuration const& rtcfg,
            runtime_mode locality_mode, init_scheduler_type const& init)
      : runtime(agas_client_, rtcfg),
        mode_(locality_mode), result_(0),
        main_pool_(1,
            boost::bind(&runtime_impl::init_tss, This(), "main-thread", ::_1),
            boost::bind(&runtime_impl::deinit_tss, This()), "main_pool"),
        io_pool_(rtcfg.get_thread_pool_size("io_pool"),
            boost::bind(&runtime_impl::init_tss, This(), "io-thread", ::_1),
            boost::bind(&runtime_impl::deinit_tss, This()), "io_pool"),
        parcel_pool_(rtcfg.get_thread_pool_size("parcel_pool"),
            boost::bind(&runtime_impl::init_tss, This(), "parcel-thread", ::_1),
            boost::bind(&runtime_impl::deinit_tss, This()), "parcel_pool"),
        timer_pool_(rtcfg.get_thread_pool_size("timer_pool"),
            boost::bind(&runtime_impl::init_tss, This(), "timer-thread", ::_1),
            boost::bind(&runtime_impl::deinit_tss, This()), "timer_pool"),
        parcel_port_(parcel_pool_, ini_.get_parcelport_address(),
            ini_.get_max_connections(), ini_.get_max_connections_per_loc()),
        scheduler_(init),
        notifier_(boost::bind(&runtime_impl::init_tss, This(), "worker-thread", ::_1),
            boost::bind(&runtime_impl::deinit_tss, This()),
            boost::bind(&runtime_impl::report_error, This(), _1, _2)),
        thread_manager_(new hpx::threads::threadmanager_impl<
            SchedulingPolicy, NotificationPolicy>(timer_pool_, scheduler_, notifier_)),
        agas_client_(parcel_port_, ini_, mode_),
        parcel_handler_(agas_client_, parcel_port_, thread_manager_.get(),
            new parcelset::policies::global_parcelhandler_queue),
        init_logging_(ini_, mode_ == runtime_mode_console, agas_client_),
        applier_(parcel_handler_, *thread_manager_,
            boost::uint64_t(&runtime_support_), boost::uint64_t(&memory_)),
        action_manager_(applier_),
        runtime_support_(ini_, parcel_handler_.get_locality(), agas_client_, applier_)
    {
        components::server::get_error_dispatcher().register_error_sink(
            &runtime_impl::default_errorsink, default_error_sink_);

        // copy over all startup functions registered so far
        BOOST_FOREACH(HPX_STD_FUNCTION<void()> const& f, global_pre_startup_functions)
        {
            add_pre_startup_function(f);
        }

    boost::shared_ptr<parcelport> parcelport::create_bootstrap(
        util::runtime_configuration const& cfg,
        HPX_STD_FUNCTION<void(std::size_t, char const*)> const& on_start_thread,
        HPX_STD_FUNCTION<void()> const& on_stop_thread)
    {
        std::string pptype = cfg.get_entry("hpx.parcel.bootstrap", "tcp");

        int type = get_connection_type_from_name(pptype);
        if (type == connection_unknown)
            type = connection_tcp;

        return create(type, cfg, on_start_thread, on_stop_thread);
    }

    boost::shared_ptr<parcelport> parcelport::create(connection_type type,
        util::runtime_configuration const& cfg,
        HPX_STD_FUNCTION<void(std::size_t, char const*)> const& on_start_thread,
        HPX_STD_FUNCTION<void()> const& on_stop_thread)
    {
        switch(type) {
        case connection_tcpip:
            return boost::make_shared<parcelset::tcp::parcelport>(
                cfg, on_start_thread, on_stop_thread);

        case connection_shmem:
            {
#if defined(HPX_HAVE_PARCELPORT_SHMEM)
                // Create shmem based parcelport only if allowed by the 
                // configuration info.
                std::string enable_shmem = 
                    cfg.get_entry("hpx.parcel.shmem.enable", "0");

                if (boost::lexical_cast<int>(enable_shmem)) 
                {
                    return boost::make_shared<parcelset::shmem::parcelport>(
                        cfg, on_start_thread, on_stop_thread);
                }
#endif
                HPX_THROW_EXCEPTION(bad_parameter, "parcelport::create",
                    "unsupported connection type 'connection_shmem'");
            }
            break;

        case connection_portals4:
            HPX_THROW_EXCEPTION(bad_parameter, "parcelport::create",
                "unsupported connection type 'connection_portals4'");
            break;

        default:
            HPX_THROW_EXCEPTION(bad_parameter, "parcelport::create",
                "unknown connection type");
            break;
        }

        return boost::shared_ptr<parcelport>();
    }

        bool detect_mpi_environment(util::runtime_configuration const& cfg,
            char const* default_env)
        {
#if defined(__bgq__)
            // If running on BG/Q, we can safely assume to always run in an
            // MPI environment
            return true;
#else
            std::string mpi_environment_strings = cfg.get_entry(
                "hpx.parcel.mpi.env", default_env);

            typedef
                boost::tokenizer<boost::char_separator<char> >
                tokenizer;
            boost::char_separator<char> sep(";,: ");
            tokenizer tokens(mpi_environment_strings, sep);
            for(tokenizer::iterator it = tokens.begin(); it != tokens.end(); ++it)
            {
                char *env = std::getenv(it->c_str());
                if(env) return true;
            }
            return false;
#endif
        }

    parcelport::parcelport(util::runtime_configuration const& ini,
            std::string const& type)
      : parcels_(),
        here_(ini.get_parcelport_address()),
        max_message_size_(ini.get_max_message_size()),
        allow_array_optimizations_(true),
        allow_zero_copy_optimizations_(true),
        enable_security_(false),
        async_serialization_(false)
    {
        std::string key("hpx.parcel.");
        key += type;

        std::string array_optimization =
            ini.get_entry(key + ".array_optimization", "1");

        if (boost::lexical_cast<int>(array_optimization) == 0) {
            allow_array_optimizations_ = false;
            allow_zero_copy_optimizations_ = false;
        }
        else {
            std::string zero_copy_optimization =
                ini.get_entry(key + ".zero_copy_optimization", "1");
            if (boost::lexical_cast<int>(zero_copy_optimization) == 0)
                allow_zero_copy_optimizations_ = false;
        }

        std::string enable_security =
            ini.get_entry(key + ".enable_security", "0");
        if(boost::lexical_cast<int>(enable_security) != 0)
        {
            enable_security_ = true;
        }

        std::string async_serialization =
            ini.get_entry(key + ".async_serialization", "0");
        if(boost::lexical_cast<int>(async_serialization) != 0)
        {
            async_serialization_ = true;
        }
    }

    boost::shared_ptr<parcelport> parcelport::create(int type,
        util::runtime_configuration const& cfg,
        HPX_STD_FUNCTION<void(std::size_t, char const*)> const& on_start_thread,
        HPX_STD_FUNCTION<void()> const& on_stop_thread)
    {
        switch(type) {
        case connection_tcp:
            {
#if defined(HPX_HAVE_PARCELPORT_TCP)
                std::string enable_tcp =
                    cfg.get_entry("hpx.parcel.tcp.enable", "1");

                if (boost::lexical_cast<int>(enable_tcp))
                {
                    return boost::make_shared<policies::tcp::connection_handler>(
                        cfg, on_start_thread, on_stop_thread);
                }
#endif

                HPX_THROW_EXCEPTION(bad_parameter, "parcelport::create",
                    "unsupported connection type 'connection_tcp'");
            }

        case connection_ipc:
            {
#if defined(HPX_HAVE_PARCELPORT_IPC)
                // Create ipc based parcelport only if allowed by the
                // configuration info.
                std::string enable_ipc =
                    cfg.get_entry("hpx.parcel.ipc.enable", "0");

                if (boost::lexical_cast<int>(enable_ipc))
                {
                    return boost::make_shared<policies::ipc::connection_handler>(
                        cfg, on_start_thread, on_stop_thread);
                }
#endif
                HPX_THROW_EXCEPTION(bad_parameter, "parcelport::create",
                    "unsupported connection type 'connection_ipc'");
            }
            break;

        case connection_ibverbs:
#if defined(HPX_HAVE_PARCELPORT_IBVERBS)
            {
                // Create ibverbs based parcelport only if allowed by the
                // configuration info.
                std::string enable_ibverbs =
                    cfg.get_entry("hpx.parcel.ibverbs.enable", "0");

                if (boost::lexical_cast<int>(enable_ibverbs))
                {
                    return boost::make_shared<policies::ibverbs::connection_handler>(
                        cfg, on_start_thread, on_stop_thread);
                }
            }
#endif
            HPX_THROW_EXCEPTION(bad_parameter, "parcelport::create",
                "unsupported connection type 'connection_ibverbs'");
            break;

        case connection_portals4:
            HPX_THROW_EXCEPTION(bad_parameter, "parcelport::create",
                "unsupported connection type 'connection_portals4'");
            break;

        case connection_mpi:
#if defined(HPX_HAVE_PARCELPORT_MPI)
            {
                // Create MPI based parcelport only if allowed by the
                // configuration info.
                std::string enable_mpi =
                    cfg.get_entry("hpx.parcel.mpi.enable", "0");

                if (boost::lexical_cast<int>(enable_mpi))
                {
                    return boost::make_shared<policies::mpi::connection_handler>(
                        cfg, on_start_thread, on_stop_thread);
                }
            }
#endif

            HPX_THROW_EXCEPTION(bad_parameter, "parcelport::create",
                "unsupported connection type 'connection_mpi'");
            break;

        default:
            HPX_THROW_EXCEPTION(bad_parameter, "parcelport::create",
                "unknown connection type");
            break;
        }

        return boost::shared_ptr<parcelport>();
    }