Exemple #1
0
    Proxy( eq::Channel* ch )
        : _stream( 0 )
        , _eventHandler( 0 )
        , _channel( ch )
        , _sendFuture( make_ready_future( false ))
        , _running( false )
        , _texture( 0 )
    {
        const DrawableConfig& dc = _channel->getDrawableConfig();
        if( dc.colorBits != 8 )
        {
            LBWARN << "Can only stream 8-bit RGB(A) framebuffers to "
                   << "DisplayCluster, got " << dc.colorBits << " color bits"
                   << std::endl;
            return;
        }

        const std::string& dcHost = _channel->getView()->getDisplayCluster();
        _stream = new ::dc::Stream( _channel->getView()->getName(), dcHost );
        if( !_stream->isConnected( ))
        {
            LBWARN << "Could not connect to DisplayCluster host: " << dcHost
                   << std::endl;
            return;
        }

        _running = true;
        _sendFuture = make_ready_future( true );
    }
Exemple #2
0
        void unpin()
        {
            // make sure to always grab to AGAS lock first
            agas::mark_as_migrated(this->gid_,
                [this]() mutable -> std::pair<bool, hpx::future<void> >
                {
                    std::unique_lock<mutex_type> l(mtx_);
                    HPX_ASSERT(this->pin_count_ != 0);
                    if (this->pin_count_ != ~0x0u)
                    {
                        if (--this->pin_count_ == 0)
                        {
                            // trigger pending migration if this was the last
                            // unpin and a migration operation is pending
                            if (trigger_migration_.valid() && was_marked_for_migration_)
                            {
                                was_marked_for_migration_ = false;

                                l.unlock();
                                trigger_migration_.set_value();
                                return std::make_pair(true, make_ready_future());
                            }
                        }
                    }
                    return std::make_pair(false, make_ready_future());
                });
        }
Exemple #3
0
int main()
{
    auto a = make_ready_future(get_name()); // ok
    auto b = make_ready_future(get_name("Sir")); // ok
    
    
    std::future<std::string> c = make_ready_future(get_name("Sir")); // ok
    
    std::future<std::string> d = make_ready_future(get_name()); // error: return type mismatch from std::future<std::string&>
}
Exemple #4
0
    future<id_type> migrate_component(
        id_type const& to_migrate, naming::address const& addr,
        DistPolicy const& policy)
    {
        // 'migration' to same locality as before is a no-op
        if (policy.get_next_target() == hpx::find_here())
        {
            return make_ready_future(to_migrate);
        }

        if (!traits::component_supports_migration<Component>::call())
        {
            return hpx::make_exceptional_future<hpx::id_type>(
                HPX_GET_EXCEPTION(invalid_status,
                    "hpx::components::server::migrate_component",
                    "attempting to migrate an instance of a component which "
                    "does not support migration"));
        }

        // retrieve pointer to object (must be local)
        std::shared_ptr<Component> ptr =
            hpx::detail::get_ptr_for_migration<Component>(addr, to_migrate);

        // perform actual migration by sending data over to target locality
        return detail::migrate_component_postproc<Component>(
            ptr, to_migrate, policy);
    }
Exemple #5
0
 type operator()(future<T> const& x) const
 {
     if (auto&& state = x.get_state(use_private_interface))
         return state->template then<future<void>>(std::bind([](){}));
     else
         return make_ready_future();
 }
Exemple #6
0
        hpx::future<void> mark_as_migrated(hpx::id_type const& to_migrate)
        {
            // we need to first lock the AGAS migrated objects table, only then
            // access (lock) the object
            return agas::mark_as_migrated(to_migrate.get_gid(),
                [this]() mutable -> std::pair<bool, hpx::future<void> >
                {
                    std::unique_lock<mutex_type> l(mtx_);

                    // make sure that no migration is currently in flight
                    if (was_marked_for_migration_)
                    {
                        l.unlock();
                        return std::make_pair(false,
                            hpx::make_exceptional_future<void>(
                                HPX_GET_EXCEPTION(invalid_status,
                                    "migration_support::mark_as_migrated",
                                    "migration operation is already in flight")
                            ));
                    }

                    if (1 == pin_count_)
                    {
                        // all is well, migration can be triggered now
                        return std::make_pair(true, make_ready_future());
                    }

                    // delay migrate operation until pin count goes to zero
                    was_marked_for_migration_ = true;

                    l.unlock();
                    return std::make_pair(true, trigger_migration_.get_future());
                });
        }
    std::future<bool> send(core::const_frame frame) override
    {
        CASPAR_VERIFY(format_desc_.height * format_desc_.width * 4 == frame.image_data(0).size());

        graph_->set_value("tick-time", tick_timer_.elapsed() * format_desc_.fps * 0.5);
        tick_timer_.restart();

        caspar::timer frame_timer;

        {
            auto audio_buffer = core::audio_32_to_16(frame.audio_data());
            airsend::add_audio(air_send_.get(),
                               audio_buffer.data(),
                               static_cast<int>(audio_buffer.size()) / format_desc_.audio_channels);
        }

        {
            connected_ = airsend::add_frame_bgra(air_send_.get(), frame.image_data(0).begin());
        }

        graph_->set_text(print());
        graph_->set_value("frame-time", frame_timer.elapsed() * format_desc_.fps * 0.5);

        return make_ready_future(true);
    }
Exemple #8
0
    future<naming::id_type> trigger_migrate_to_storage_here(
        naming::id_type const& to_migrate,
        naming::id_type const& target_storage)
    {
        if (!Component::supports_migration())
        {
            HPX_THROW_EXCEPTION(invalid_status,
                "hpx::components::server::trigger_migrate_to_storage_here",
                "attempting to migrate an instance of a component which "
                "does not support migration");
            return make_ready_future(naming::invalid_id);
        }

        if (naming::get_locality_id_from_id(to_migrate) != get_locality_id())
        {
            HPX_THROW_EXCEPTION(invalid_status,
                "hpx::components::server::trigger_migrate_to_storage_here",
                "this function has to be executed on the locality responsible "
                "for managing the address of the given object");
            return make_ready_future(naming::invalid_id);
        }

        return agas::begin_migration(to_migrate, target_storage)
            .then(
                [to_migrate, target_storage](
                    future<std::pair<naming::id_type, naming::address> > && f)
                        -> future<naming::id_type>
                {
                    // rethrow errors
                    std::pair<naming::id_type, naming::address> r = f.get();

                    // perform actual object migration
                    typedef server::migrate_to_storage_here_action<Component>
                        action_type;
                    return async<action_type>(r.first, to_migrate, r.second,
                        target_storage);
                })
            .then(
                [to_migrate](future<naming::id_type> && f) -> naming::id_type
                {
                    agas::end_migration(to_migrate).get();
                    return f.get();
                });
    }
future<Credentials>
ContentModuleManager::RequestCredentialInput(const CredentialRequest &request)
{
    // nothing yet...
    // really want the std::make_immediate_future<>() function right now...
    std::promise<Credentials> promise;
    
    Credentials none;
    return make_ready_future(none);
}
    future<naming::id_type> migrate_component(
        naming::id_type const& to_migrate,
        naming::id_type const& target_locality)
    {
        // 'migration' to same locality as before is a no-op
        if (target_locality == hpx::find_here())
        {
            return make_ready_future(to_migrate);
        }
        if (!Component::supports_migration())
        {
            HPX_THROW_EXCEPTION(invalid_status,
                "hpx::components::server::migrate_component",
                "attempting to migrate an instance of a component which is "
                "does not support migration");
            return make_ready_future(naming::invalid_id);
        }

        return hpx::detail::get_ptr_for_migration<Component>(to_migrate)
            .then(util::bind(&detail::migrate_component_postproc<Component>,
                util::placeholders::_1, to_migrate, target_locality));
    }
    lcos::future<naming::id_type>
    runtime_support::create_performance_counter_async(naming::id_type targetgid,
        performance_counters::counter_info const& info)
    {
        if (!naming::is_locality(targetgid))
        {
            HPX_THROW_EXCEPTION(bad_parameter,
                "stubs::runtime_support::create_performance_counter_async",
                "The id passed as the first argument is not representing"
                    " a locality");
            return make_ready_future(naming::invalid_id);
        }

        typedef server::runtime_support::create_performance_counter_action
            action_type;
        return hpx::async<action_type>(targetgid, info);
    }
    lcos::future<std::vector<naming::id_type> >
    runtime_support::bulk_create_components_async(
        naming::id_type const& gid, components::component_type type,
        std::size_t count)
    {
        if (!naming::is_locality(gid))
        {
            HPX_THROW_EXCEPTION(bad_parameter,
                "stubs::runtime_support::bulk_create_components_async",
                "The id passed as the first argument is not representing"
                    " a locality");
            return make_ready_future(std::vector<naming::id_type>());
        }

        // Create a future, execute the required action,
        // we simply return the initialized future, the caller needs
        // to call get() on the return value to obtain the result
        typedef server::runtime_support::bulk_create_components_action action_type;
        return hpx::async<action_type>(gid, type, count);
    }
    lcos::future<naming::id_type>
    runtime_support::create_memory_block_async(
        naming::id_type const& id, std::size_t count,
        hpx::actions::manage_object_action<T, Config> const& act)
    {
        if (!naming::is_locality(id))
        {
            HPX_THROW_EXCEPTION(bad_parameter,
                "stubs::runtime_support::create_memory_block_async",
                "The id passed as the first argument is not representing"
                    " a locality");
            return make_ready_future(naming::invalid_id);
        }

        // Create a future, execute the required action,
        // we simply return the initialized future, the caller needs
        // to call get() on the return value to obtain the result
        typedef server::runtime_support::create_memory_block_action
            action_type;
        return hpx::async<action_type>(id, count, act);
    }
Exemple #14
0
    future<naming::id_type> migrate_to_storage_here(
        naming::id_type const& to_migrate,
        naming::address const& addr,
        naming::id_type const& target_storage)
    {
        if (!Component::supports_migration())
        {
            HPX_THROW_EXCEPTION(invalid_status,
                "hpx::components::server::migrate_to_storage_here",
                "attempting to migrate an instance of a component which "
                "does not support migration");
            return make_ready_future(naming::invalid_id);
        }

        // retrieve pointer to object (must be local)
        boost::shared_ptr<Component> ptr =
            hpx::detail::get_ptr_for_migration<Component>(addr, to_migrate);

        // perform actual migration by sending data over to target locality
        return detail::migrate_to_storage_here_postproc<Component>(
            ptr, to_migrate, target_storage);
    }
Exemple #15
0
future<void> when_all_ready(ForwardIterator first, ForwardIterator last)
{
    auto const diff = std::distance(first, last);
    if (diff <= 0)
        return make_ready_future();
    
    typedef typename std::iterator_traits<ForwardIterator>::difference_type diff_t;
    
    auto counter = std::make_shared<std::atomic<diff_t>>(diff);
    auto prm = std::make_shared<promise<void>>();
    auto dec = std::bind([=](){ if (counter->fetch_sub(1) == 1) prm->set_value(); }); // bind to ignore all arguments
    
    std::for_each(first, last,
                  [=](typename std::iterator_traits<ForwardIterator>::reference f) mutable
    {
        if (!f.valid())
            dec();
        else
            f.get_state(detail::use_private_interface)->continue_with(dec);
    });
    
    return prm->get_future();
}