folly::gen::detail::PMap< Predicate >::Generator< Value, Source, Input, Output > Class Template Reference

#include <ParallelMap-inl.h>

Inheritance diagram for folly::gen::detail::PMap< Predicate >::Generator< Value, Source, Input, Output >:

Classes
class	ExecutionPipeline

Public Member Functions
	Generator (Source source, const Predicate &pred, size_t nThreads)
template<class Body >
void	foreach (Body &&body) const
template<class Handler >
bool	apply (Handler &&handler) const
Public Member Functions inherited from folly::gen::GenImpl< Output, Generator< Value, Source, Input, Output > >
bool	apply (Handler &&handler) const
void	foreach (Body &&body) const
Public Member Functions inherited from folly::gen::FBounded< Self >
const Self &	self () const
Self &	self ()

Static Public Attributes
static constexpr bool	infinite = Source::infinite
Static Public Attributes inherited from folly::gen::GenImpl< Output, Generator< Value, Source, Input, Output > >
static constexpr bool	infinite

Private Attributes
Source	source_
Predicate	pred_
const size_t	nThreads_

Additional Inherited Members
Public Types inherited from folly::gen::GenImpl< Output, Generator< Value, Source, Input, Output > >
typedef Output	ValueType
typedef std::decay< Output >::type	StorageType
Protected Member Functions inherited from folly::gen::GenImpl< Output, Generator< Value, Source, Input, Output > >
	GenImpl ()=default
	GenImpl (GenImpl &&)=default
	GenImpl (const GenImpl &)=default
GenImpl &	operator= (GenImpl &&)=default
GenImpl &	operator= (const GenImpl &)=default

Detailed Description

template<class Predicate>
template<class Value, class Source, class Input = typename std::decay<Value>::type, class Output = typename std::decay<invoke_result_t<Predicate, Value>>::type>
class folly::gen::detail::PMap< Predicate >::Generator< Value, Source, Input, Output >

Definition at line 63 of file ParallelMap-inl.h.

Constructor & Destructor Documentation

template<class Predicate >

template<class Value , class Source , class Input = typename std::decay<Value>::type, class Output = typename std::decay<invoke_result_t<Predicate, Value>>::type>

folly::gen::detail::PMap< Predicate >::Generator< Value, Source, Input, Output >::Generator ( Source  source, const Predicate &  pred, size_t  nThreads  )

inline

Definition at line 151 of file ParallelMap-inl.h.

        : source_(std::move(source)),
          pred_(pred),
          nThreads_(nThreads ? nThreads : sysconf(_SC_NPROCESSORS_ONLN)) {}

Member Function Documentation

template<class Predicate >

template<class Value , class Source , class Input = typename std::decay<Value>::type, class Output = typename std::decay<invoke_result_t<Predicate, Value>>::type>

template<class Handler >

bool folly::gen::detail::PMap< Predicate >::Generator< Value, Source, Input, Output >::apply ( Handler &&  handler ) const

inline

Definition at line 194 of file ParallelMap-inl.h.

References folly::gen::detail::PMap< Predicate >::Generator< Value, Source, Input, Output >::ExecutionPipeline::blockingRead(), folly::gen::detail::PMap< Predicate >::Generator< Value, Source, Input, Output >::ExecutionPipeline::blockingWrite(), handler(), folly::gen::move, folly::gen::detail::PMap< Predicate >::Generator< Value, Source, Input, Output >::ExecutionPipeline::read(), folly::gen::detail::PMap< Predicate >::Generator< Value, Source, Input, Output >::ExecutionPipeline::stop(), folly::value(), testing::Value(), and folly::gen::detail::PMap< Predicate >::Generator< Value, Source, Input, Output >::ExecutionPipeline::write().

                                        {
      ExecutionPipeline pipeline(pred_, nThreads_);

      size_t wrote = 0;
      size_t read = 0;
      bool more = true;
      source_.apply([&](Value value) {
        if (pipeline.write(std::forward<Value>(value))) {
          // input queue not yet full, saturate it before we process
          // anything downstream
          ++wrote;
          return true;
        }

        // input queue full; drain ready items from the queue
        Output out;
        while (pipeline.read(out)) {
          ++read;
          if (!handler(std::move(out))) {
            more = false;
            return false;
          }
        }

        // write the value we were going to write before we made room.
        pipeline.blockingWrite(std::forward<Value>(value));
        ++wrote;
        return true;
      });

      pipeline.stop();

      // flush the output queue
      while (read < wrote) {
        Output out;
        pipeline.blockingRead(out);
        ++read;
        if (more) {
          more = more && handler(std::move(out));
        }
      }
      return more;
    }

template<class Predicate >

template<class Value , class Source , class Input = typename std::decay<Value>::type, class Output = typename std::decay<invoke_result_t<Predicate, Value>>::type>

template<class Body >

void folly::gen::detail::PMap< Predicate >::Generator< Value, Source, Input, Output >::foreach ( Body &&  body ) const

inline

Definition at line 157 of file ParallelMap-inl.h.

References folly::gen::detail::PMap< Predicate >::Generator< Value, Source, Input, Output >::ExecutionPipeline::blockingRead(), folly::gen::detail::PMap< Predicate >::Generator< Value, Source, Input, Output >::ExecutionPipeline::blockingWrite(), folly::gen::move, folly::gen::detail::PMap< Predicate >::Generator< Value, Source, Input, Output >::ExecutionPipeline::read(), folly::gen::detail::PMap< Predicate >::Generator< Value, Source, Input, Output >::ExecutionPipeline::stop(), folly::value(), testing::Value(), and folly::gen::detail::PMap< Predicate >::Generator< Value, Source, Input, Output >::ExecutionPipeline::write().

                                    {
      ExecutionPipeline pipeline(pred_, nThreads_);

      size_t wrote = 0;
      size_t read = 0;
      source_.foreach([&](Value value) {
        if (pipeline.write(std::forward<Value>(value))) {
          // input queue not yet full, saturate it before we process
          // anything downstream
          ++wrote;
          return;
        }

        // input queue full; drain ready items from the queue
        Output out;
        while (pipeline.read(out)) {
          ++read;
          body(std::move(out));
        }

        // write the value we were going to write before we made room.
        pipeline.blockingWrite(std::forward<Value>(value));
        ++wrote;
      });

      pipeline.stop();

      // flush the output queue
      while (read < wrote) {
        Output out;
        pipeline.blockingRead(out);
        ++read;
        body(std::move(out));
      }
    }

Member Data Documentation

template<class Predicate >

template<class Value , class Source , class Input = typename std::decay<Value>::type, class Output = typename std::decay<invoke_result_t<Predicate, Value>>::type>

constexpr bool folly::gen::detail::PMap< Predicate >::Generator< Value, Source, Input, Output >::infinite = Source::infinite

static

Definition at line 238 of file ParallelMap-inl.h.

template<class Predicate >

template<class Value , class Source , class Input = typename std::decay<Value>::type, class Output = typename std::decay<invoke_result_t<Predicate, Value>>::type>

const size_t folly::gen::detail::PMap< Predicate >::Generator< Value, Source, Input, Output >::nThreads_

private

Definition at line 67 of file ParallelMap-inl.h.

Referenced by folly::gen::detail::PMap< Predicate >::compose().

template<class Predicate >

template<class Value , class Source , class Input = typename std::decay<Value>::type, class Output = typename std::decay<invoke_result_t<Predicate, Value>>::type>

Predicate folly::gen::detail::PMap< Predicate >::Generator< Value, Source, Input, Output >::pred_

private

Definition at line 66 of file ParallelMap-inl.h.

template<class Predicate >

template<class Value , class Source , class Input = typename std::decay<Value>::type, class Output = typename std::decay<invoke_result_t<Predicate, Value>>::type>

Source folly::gen::detail::PMap< Predicate >::Generator< Value, Source, Input, Output >::source_

private

Definition at line 65 of file ParallelMap-inl.h.

---

The documentation for this class was generated from the following file:

• proxygen/folly/folly/gen/ParallelMap-inl.h