ParallelRayStudy Class Reference

#include <ParallelRayStudy.h>

Inheritance diagram for ParallelRayStudy:

Public Types
typedef MooseUtils::Buffer< std::shared_ptr< Ray > >::iterator	work_iterator
typedef MooseUtils::Buffer< std::shared_ptr< Ray > >::iterator	parallel_data_iterator

Public Member Functions
	ParallelRayStudy (RayTracingStudy &study, const std::vector< std::shared_ptr< TraceRay > > &threaded_trace_ray)
void	preExecute ()
	Pre-execute method that MUST be called before execute() and before adding work.
void	execute ()
	Execute method.
MooseUtils::SharedPool< Ray >::PtrType	acquireParallelData (const THREAD_ID tid, Args &&... args)
	Acquire a parallel data object from the pool.
void	moveParallelDataToBuffer (std::shared_ptr< Ray > &data, const processor_id_type dest_pid)
	Moves parallel data objects to the send buffer to be communicated to processor dest_pid.
const ReceiveBuffer< Ray, ParallelStudy< std::shared_ptr< Ray >, Ray > > &	receiveBuffer () const
	Gets the receive buffer.
const MooseUtils::Buffer< std::shared_ptr< Ray > > &	workBuffer () const
	Gets the work buffer.
unsigned long long int	sendBufferPoolCreated () const
	Gets the total number of send buffer pools created.
unsigned long long int	parallelDataSent () const
	Gets the total number of parallel data objects sent from this processor.
unsigned long long int	buffersSent () const
	Gets the total number of buffers sent from this processor.
unsigned long long int	poolParallelDataCreated () const
	Gets the total number of parallel data created in all of the threaded pools.
unsigned long long int	localWorkStarted () const
	Gets the total amount of work started from this processor.
unsigned long long int	localWorkExecuted () const
	Gets the total amount of work executed on this processor.
unsigned long long int	totalWorkCompleted () const
	Gets the total amount of work completeed across all processors.
unsigned long long int	localChunksExecuted () const
	Gets the total number of chunks of work executed on this processor.
bool	currentlyExecuting () const
	Whether or not this object is currently in execute().
bool	currentlyPreExecuting () const
	Whether or not this object is between preExecute() and execute().
unsigned int	maxBufferSize () const
	Gets the max buffer size.
unsigned int	chunkSize () const
	Gets the chunk size.
unsigned int	clicksPerCommunication () const
	Gets the number of iterations to wait before communicating.
unsigned int	clicksPerRootCommunication () const
	Gets the number of iterations to wait before communicating with root.
unsigned int	clicksPerReceive () const
	Gets the number of iterations to wait before checking for new parallel data.
ParallelStudyMethod	method () const
	Gets the method.
void	reserveBuffer (const std::size_t size)
	Reserve size entries in the work buffer.
const Parallel::Communicator &	comm () const
processor_id_type	n_processors () const
processor_id_type	processor_id () const
RayTracingStudy &	rayTracingStudy ()
	Get the RayTracingStudy associated with this ParallelRayStudy.
const RayTracingStudy &	rayTracingStudy () const
void	moveWorkToBuffer (std::shared_ptr< Ray > &work, const THREAD_ID tid)
	Adds work to the buffer to be executed.
void	moveWorkToBuffer (const work_iterator begin, const work_iterator end, const THREAD_ID tid)
void	moveWorkToBuffer (std::vector< std::shared_ptr< Ray > > &work, const THREAD_ID tid)

Static Public Member Functions
static InputParameters	validParams ()

Protected Types
enum	MoveWorkError
	Enum for providing useful errors during work addition in moveWorkError(). More...

Protected Member Functions
void	executeWork (const std::shared_ptr< Ray > &ray, const THREAD_ID tid) override
	Pure virtual to be overridden that executes a single object of work on a given thread.
void	moveWorkError (const MoveWorkError error, const std::shared_ptr< Ray > *ray) const override
void	postReceiveParallelData (const parallel_data_iterator begin, const parallel_data_iterator end) override
bool	workIsComplete (const std::shared_ptr< Ray > &ray) override
	Can be overridden to denote if a piece of work is not complete yet.
void	postExecuteChunk (const work_iterator begin, const work_iterator end) override
virtual std::unique_ptr< MooseUtils::Buffer< std::shared_ptr< Ray > > >	createWorkBuffer ()
	Creates the work buffer.
virtual void	moveWorkError (const MoveWorkError error, const std::shared_ptr< Ray > *work=nullptr) const
	Virtual that allows for the customization of error text for moving work into the buffer.
virtual bool	alternateSmartEndingCriteriaMet ()
	Insertion point for derived classes to provide an alternate ending criteria for SMART execution.
virtual void	postExecuteChunk (const work_iterator, const work_iterator)
	Insertion point for acting on work that was just executed.
virtual void	preReceiveAndExecute ()
	Insertion point called just after trying to receive work and just before beginning work on the work buffer.
virtual void	postReceiveParallelData (const parallel_data_iterator begin, const parallel_data_iterator end)=0
	Pure virtual for acting on parallel data that has JUST been received and filled into the buffer.
bool	buffersAreEmpty () const
	Whether or not ALL of the buffers are empty: Working buffer, threaded buffers, receive buffer, and send buffers.
void	moveContinuingWorkToBuffer (std::shared_ptr< Ray > &Work)
	Moves work that is considered continuing for the purposes of the execution algorithm into the buffer.
void	moveContinuingWorkToBuffer (const work_iterator begin, const work_iterator end)

Protected Attributes
RayTracingStudy &	_ray_tracing_study
	The RayTracingStudy.
const std::vector< std::shared_ptr< TraceRay > > &	_threaded_trace_ray
	The TraceRay objects that do the tracing for each thread.
const processor_id_type	_pid
	This rank.
const std::string	_name
	Name for this object for use in error handling.
const InputParameters &	_params
	The InputParameters.
const ParallelStudyMethod	_method
	The study method.
bool	_has_alternate_ending_criteria
	Whether or not this object has alternate ending criteria.
const Parallel::Communicator &	_communicator

Private Member Functions
void	flushSendBuffers ()
	Flushes all parallel data out of the send buffers.
void	smartExecute ()
	Execute work using SMART.
void	harmExecute ()
	Execute work using HARM.
void	bsExecute ()
	Execute work using BS.
bool	receiveAndExecute ()
	Receive packets of parallel data from other processors and executes work.
void	executeAndBuffer (const std::size_t chunk_size)
	Execute a chunk of work and buffer.
void	canMoveWorkCheck (const THREAD_ID tid)
	Internal check for if it is allowed to currently add work in moveWorkToBuffer().
void	postReceiveParallelDataInternal ()
	Internal method for acting on the parallel data that has just been received into the parallel buffer.

Private Attributes
const unsigned int	_min_buffer_size
	Minimum size of a SendBuffer.
const unsigned int	_max_buffer_size
	Number of objects to buffer before communication.
const Real	_buffer_growth_multiplier
	Multiplier for the buffer size for growing the buffer.
const Real	_buffer_shrink_multiplier
	Multiplier for the buffer size for shrinking the buffer.
const unsigned int	_chunk_size
	Number of objects to execute at once during communication.
const bool	_allow_new_work_during_execution
	Whether or not to allow the addition of new work to the buffer during execution.
const unsigned int	_clicks_per_communication
	Iterations to wait before communicating.
const unsigned int	_clicks_per_root_communication
	Iterations to wait before communicating with root.
const unsigned int	_clicks_per_receive
	Iterations to wait before checking for new objects.
Parallel::MessageTag	_parallel_data_buffer_tag
	MessageTag for sending parallel data.
std::vector< MooseUtils::SharedPool< Ray > >	_parallel_data_pools
	Pools for re-using destructed parallel data objects (one for each thread)
std::vector< std::vector< std::shared_ptr< Ray > > >	_temp_threaded_work
	Threaded temprorary storage for work added while we're using the _work_buffer (one for each thread)
const std::unique_ptr< MooseUtils::Buffer< std::shared_ptr< Ray > > >	_work_buffer
	Buffer for executing work.
const std::unique_ptr< ReceiveBuffer< Ray, ParallelStudy< std::shared_ptr< Ray >, Ray > > >	_receive_buffer
	The receive buffer.
std::unordered_map< processor_id_type, std::unique_ptr< SendBuffer< Ray, ParallelStudy< std::shared_ptr< Ray >, Ray > > > >	_send_buffers
	Send buffers for each processor.
unsigned long long int	_local_chunks_executed
	Number of chunks of work executed on this processor.
unsigned long long int	_local_work_completed
	Amount of work completed on this processor.
unsigned long long int	_local_work_started
	Amount of work started on this processor.
unsigned long long int	_local_work_executed
	Amount of work executed on this processor.
unsigned long long int	_total_work_started
	Amount of work started on all processors.
unsigned long long int	_total_work_completed
	Amount of work completed on all processors.
bool	_currently_executing
	Whether we are within execute()
bool	_currently_pre_executing
	Whether we are between preExecute() and execute()
bool	_currently_executing_work
	Whether or not we are currently within executeAndBuffer()

Detailed Description

Definition at line 21 of file ParallelRayStudy.h.

Member Typedef Documentation

parallel_data_iterator

typedef MooseUtils::Buffer<std::shared_ptr<Ray >>::iterator ParallelStudy< std::shared_ptr< Ray > , Ray >::parallel_data_iterator

inherited

Definition at line 34 of file ParallelStudy.h.

work_iterator

typedef MooseUtils::Buffer<std::shared_ptr< Ray > >::iterator ParallelStudy< std::shared_ptr< Ray > , Ray >::work_iterator

inherited

Definition at line 32 of file ParallelStudy.h.

Member Enumeration Documentation

MoveWorkError

enum ParallelStudy::MoveWorkError

protectedinherited

Enum for providing useful errors during work addition in moveWorkError().

Definition at line 182 of file ParallelStudy.h.

  {
    DURING_EXECUTION_DISABLED,
    PRE_EXECUTION_AND_EXECUTION_ONLY,
    PRE_EXECUTION_ONLY,
    PRE_EXECUTION_THREAD_0_ONLY,
    CONTINUING_DURING_EXECUTING_WORK
  };

Constructor & Destructor Documentation

ParallelRayStudy()

ParallelRayStudy::ParallelRayStudy	(	RayTracingStudy &	study,
		const std::vector< std::shared_ptr< TraceRay > > &	threaded_trace_ray
	)

Definition at line 16 of file ParallelRayStudy.C.

  : ParallelStudy<std::shared_ptr<Ray>, Ray>(
        ray_tracing_study.comm(), ray_tracing_study.parameters(), "ParallelRayStudy"),
    _ray_tracing_study(ray_tracing_study),
    _threaded_trace_ray(threaded_trace_ray)
{
}

Member Function Documentation

acquireParallelData()

MooseUtils::SharedPool< Ray >::PtrType ParallelStudy< std::shared_ptr< Ray > , Ray >::acquireParallelData ( const THREAD_ID  tid, Args &&...  args  )

inlineinherited

Acquire a parallel data object from the pool.

Definition at line 73 of file ParallelStudy.h.

  {
    return _parallel_data_pools[tid].acquire(std::forward<Args>(args)...);
  }

alternateSmartEndingCriteriaMet()

bool ParallelStudy< std::shared_ptr< Ray > , Ray >::alternateSmartEndingCriteriaMet ( )

protectedvirtualinherited

Insertion point for derived classes to provide an alternate ending criteria for SMART execution.

Only called when _has_alternate_ending_criteria == true.

Definition at line 212 of file ParallelStudy.h.

{
  mooseError(_name, ": Unimplemented alternateSmartEndingCriteriaMet()");
}

bsExecute()

void ParallelStudy< std::shared_ptr< Ray > , Ray >::bsExecute ( )

privateinherited

Execute work using BS.

Definition at line 288 of file ParallelStudy.h.

{
  if (_has_alternate_ending_criteria)
    mooseError("ParallelStudy: Alternate ending criteria not yet supported for BS");
  if (_allow_new_work_during_execution)
    mooseError(_name, ": The addition of new work during execution is not supported by BS");
  mooseAssert(_method == ParallelStudyMethod::BS, "Should be called with BS only");
 
  Parallel::Request work_completed_probe_status;
  Parallel::Request work_completed_request;
 
  // Temp for use in sending the current value in a nonblocking sum instead of an updated value
  unsigned long long int temp;
 
  // Get the amount of work that were started in the whole domain
  comm().sum(_local_work_started, _total_work_started, work_completed_probe_status);
 
  // Keep working until done
  while (true)
  {
    bool receiving = false;
    bool sending = false;
 
    Parallel::Request some_left_request;
    unsigned int some_left = 0;
    unsigned int all_some_left = 1;
 
    do
    {
      _receive_buffer->receive();
      postReceiveParallelDataInternal();
      flushSendBuffers();
 
      receiving = _receive_buffer->currentlyReceiving();
 
      sending = false;
      for (auto & send_buffer : _send_buffers)
        sending = sending || send_buffer.second->currentlySending() ||
                  send_buffer.second->currentlyBuffered();
 
      if (!receiving && !sending && some_left_request.test() && all_some_left)
      {
        some_left = receiving || sending;
        comm().sum(some_left, all_some_left, some_left_request);
      }
    } while (receiving || sending || !some_left_request.test() || all_some_left);
 
    executeAndBuffer(_work_buffer->size());
 
    comm().barrier();
 
    if (work_completed_probe_status.test() && work_completed_request.test())
    {
      if (_total_work_started == _total_work_completed)
        return;
 
      temp = _local_work_completed;
      comm().sum(temp, _total_work_completed, work_completed_request);
    }
  }
}

buffersAreEmpty()

bool ParallelStudy< std::shared_ptr< Ray > , Ray >::buffersAreEmpty ( ) const

protectedinherited

Whether or not ALL of the buffers are empty: Working buffer, threaded buffers, receive buffer, and send buffers.

Definition at line 258 of file ParallelStudy.h.

{
  if (!_work_buffer->empty())
    return false;
  for (const auto & threaded_buffer : _temp_threaded_work)
    if (!threaded_buffer.empty())
      return false;
  if (_receive_buffer->currentlyReceiving())
    return false;
  for (const auto & map_pair : _send_buffers)
    if (map_pair.second->currentlySending() || map_pair.second->currentlyBuffered())
      return false;
 
  return true;
}

buffersSent()

unsigned long long int ParallelStudy< std::shared_ptr< Ray > , Ray >::buffersSent ( ) const

inherited

Gets the total number of buffers sent from this processor.

Definition at line 109 of file ParallelStudy.h.

{
  unsigned long long int total_sent = 0;
 
  for (const auto & buffer : _send_buffers)
    total_sent += buffer.second->buffersSent();
 
  return total_sent;
}

canMoveWorkCheck()

void ParallelStudy< std::shared_ptr< Ray > , Ray >::canMoveWorkCheck ( const THREAD_ID  tid )

privateinherited

Internal check for if it is allowed to currently add work in moveWorkToBuffer().

Definition at line 303 of file ParallelStudy.h.

{
  if (_currently_executing)
  {
    if (!_allow_new_work_during_execution)
      moveWorkError(MoveWorkError::DURING_EXECUTION_DISABLED);
  }
  else if (!_currently_pre_executing)
  {
    if (_allow_new_work_during_execution)
      moveWorkError(MoveWorkError::PRE_EXECUTION_AND_EXECUTION_ONLY);
    else
      moveWorkError(MoveWorkError::PRE_EXECUTION_ONLY);
  }
  else if (tid != 0)
    moveWorkError(MoveWorkError::PRE_EXECUTION_THREAD_0_ONLY);
}

chunkSize()

unsigned int ParallelStudy< std::shared_ptr< Ray > , Ray >::chunkSize ( ) const

inlineinherited

Gets the chunk size.

Definition at line 148 of file ParallelStudy.h.

{ return _chunk_size; }

clicksPerCommunication()

unsigned int ParallelStudy< std::shared_ptr< Ray > , Ray >::clicksPerCommunication ( ) const

inlineinherited

Gets the number of iterations to wait before communicating.

Definition at line 153 of file ParallelStudy.h.

{ return _clicks_per_communication; }

clicksPerReceive()

unsigned int ParallelStudy< std::shared_ptr< Ray > , Ray >::clicksPerReceive ( ) const

inlineinherited

Gets the number of iterations to wait before checking for new parallel data.

Definition at line 161 of file ParallelStudy.h.

{ return _clicks_per_receive; }

clicksPerRootCommunication()

unsigned int ParallelStudy< std::shared_ptr< Ray > , Ray >::clicksPerRootCommunication ( ) const

inlineinherited

Gets the number of iterations to wait before communicating with root.

Definition at line 157 of file ParallelStudy.h.

{ return _clicks_per_root_communication; }

createWorkBuffer()

std::unique_ptr< MooseUtils::Buffer< std::shared_ptr< Ray > > > ParallelStudy< std::shared_ptr< Ray > , Ray >::createWorkBuffer ( )

protectedvirtualinherited

Creates the work buffer.

This is virtual so that derived classes can use their own specialized buffers

Definition at line 196 of file ParallelStudy.h.

{
  std::unique_ptr<MooseUtils::Buffer<WorkType>> buffer;
 
  const auto buffer_type = _params.get<MooseEnum>("work_buffer_type");
  if (buffer_type == "lifo")
    buffer = std::make_unique<MooseUtils::LIFOBuffer<WorkType>>();
  else if (buffer_type == "circular")
    buffer = std::make_unique<MooseUtils::CircularBuffer<WorkType>>();
  else
    mooseError("Unknown work buffer type");
 
  return buffer;
}

currentlyExecuting()

bool ParallelStudy< std::shared_ptr< Ray > , Ray >::currentlyExecuting ( ) const

inlineinherited

Whether or not this object is currently in execute().

Definition at line 135 of file ParallelStudy.h.

{ return _currently_executing; }

currentlyPreExecuting()

bool ParallelStudy< std::shared_ptr< Ray > , Ray >::currentlyPreExecuting ( ) const

inlineinherited

Whether or not this object is between preExecute() and execute().

Definition at line 139 of file ParallelStudy.h.

{ return _currently_pre_executing; }

execute()

void ParallelStudy< std::shared_ptr< Ray > , Ray >::execute ( )

inherited

Execute method.

Definition at line 49 of file ParallelStudy.h.

{
  if (!_currently_pre_executing)
    mooseError(_name, ": preExecute() was not called before execute()");
 
  _currently_pre_executing = false;
  _currently_executing = true;
 
  switch (_method)
  {
    case ParallelStudyMethod::SMART:
      smartExecute();
      break;
    case ParallelStudyMethod::HARM:
      harmExecute();
      break;
    case ParallelStudyMethod::BS:
      bsExecute();
      break;
    default:
      mooseError("Unknown ParallelStudyMethod");
  }
 
  _currently_executing = false;
 
  // Sanity checks on if we're really done
  comm().barrier();
 
  if (!buffersAreEmpty())
    mooseError(_name, ": Buffers are not empty after execution");
}

executeAndBuffer()

void ParallelStudy< std::shared_ptr< Ray > , Ray >::executeAndBuffer ( const std::size_t  chunk_size )

privateinherited

Execute a chunk of work and buffer.

Definition at line 298 of file ParallelStudy.h.

{
  _currently_executing_work = true;
 
  // If chunk_size > the number of objects left, this will properly grab all of them
  const auto begin = _work_buffer->beginChunk(chunk_size);
  const auto end = _work_buffer->endChunk(chunk_size);
 
  _local_chunks_executed++;
 
#ifdef LIBMESH_HAVE_OPENMP
#pragma omp parallel
#endif
  {
    const THREAD_ID tid =
#ifdef LIBMESH_HAVE_OPENMP
        omp_get_thread_num();
#else
        0;
#endif
 
#ifdef LIBMESH_HAVE_OPENMP
#pragma omp for schedule(dynamic, 20) nowait
#endif
    for (auto it = begin; it < end; ++it)
      executeWork(*it, tid);
  }
 
  // Increment the executed and completed counters
  _local_work_executed += std::distance(begin, end);
  for (auto it = begin; it != end; ++it)
    if (workIsComplete(*it))
      ++_local_work_completed;
 
  // Insertion point for derived classes to do something to the completed work
  // Example: Create ParallelData to spawn additional work on another processor
  postExecuteChunk(begin, end);
 
  // Remove the objects we just worked on from the buffer
  _work_buffer->eraseChunk(chunk_size);
 
  // If new work is allowed to be geneated during execution, it goes into _temp_threaded_work
  // during the threaded execution phase and then must be moved into the working buffer
  if (_allow_new_work_during_execution)
  {
    // Amount of work that needs to be moved into the main working buffer from
    // the temporary working buffer
    std::size_t threaded_work_size = 0;
    for (const auto & work_objects : _temp_threaded_work)
      threaded_work_size += work_objects.size();
 
    if (threaded_work_size)
    {
      // We don't ever want to decrease the capacity, so only set it if we need more entries
      if (_work_buffer->capacity() < _work_buffer->size() + threaded_work_size)
        _work_buffer->setCapacity(_work_buffer->size() + threaded_work_size);
 
      // Move the work into the buffer
      for (auto & threaded_work_vector : _temp_threaded_work)
      {
        for (auto & work : threaded_work_vector)
          _work_buffer->move(work);
        threaded_work_vector.clear();
      }
 
      // Variable that must be set when adding work so that the algorithm can keep count
      // of how much work still needs to be executed
      _local_work_started += threaded_work_size;
    }
  }
 
  if (_method == ParallelStudyMethod::HARM)
    flushSendBuffers();
 
  _currently_executing_work = false;
}

executeWork()

void ParallelRayStudy::executeWork ( const std::shared_ptr< Ray > &  work, const THREAD_ID  tid  )

overrideprotectedvirtual

Pure virtual to be overridden that executes a single object of work on a given thread.

Implements ParallelStudy< std::shared_ptr< Ray >, Ray >.

Definition at line 64 of file ParallelRayStudy.C.

{
  mooseAssert(ray->shouldContinue(), "Tracing Ray that should not continue");
 
  // If this is false, it means we have a Ray that is banked to go onto another processor
  if (ray->currentElem()->processor_id() == _pid)
    _threaded_trace_ray[tid]->trace(ray);
}

flushSendBuffers()

void ParallelStudy< std::shared_ptr< Ray > , Ray >::flushSendBuffers ( )

privateinherited

Flushes all parallel data out of the send buffers.

Definition at line 275 of file ParallelStudy.h.

{
  for (auto & send_buffer_iter : _send_buffers)
    send_buffer_iter.second->forceSend();
}

harmExecute()

void ParallelStudy< std::shared_ptr< Ray > , Ray >::harmExecute ( )

privateinherited

Execute work using HARM.

Definition at line 284 of file ParallelStudy.h.

{
  if (_has_alternate_ending_criteria)
    mooseError("ParallelStudy: Alternate ending criteria not yet supported for HARM");
  if (_allow_new_work_during_execution)
    mooseError(_name, ": The addition of new work during execution is not supported by HARM");
  mooseAssert(_method == ParallelStudyMethod::HARM, "Should be called with HARM only");
 
  // Request for the total amount of work started
  Parallel::Request work_started_request;
  // Requests for sending the amount of finished worked to every other processor
  std::vector<Parallel::Request> work_completed_requests(comm().size());
  // Whether or not the finished requests have been sent to each processor
  std::vector<bool> work_completed_requests_sent(comm().size(), false);
  // Values of work completed on this processor that are being sent to other processors
  std::vector<unsigned long long int> work_completed_requests_temps(comm().size(), 0);
  // Work completed by each processor
  std::vector<unsigned long long int> work_completed_per_proc(comm().size(), 0);
  // Tag for sending work finished
  const auto work_completed_requests_tag = comm().get_unique_tag();
 
  // Get the amount of work that was started in the whole domain
  comm().sum(_local_work_started, _total_work_started, work_started_request);
 
  // All work has been executed, so time to communicate
  flushSendBuffers();
 
  // HARM only does some communication based on times through the loop.
  // This counter will be used for that
  unsigned int communication_clicks = 0;
 
  Parallel::Status work_completed_probe_status;
  int work_completed_probe_flag;
 
  // Keep working until done
  while (true)
  {
    receiveAndExecute();
 
    flushSendBuffers();
 
    if (communication_clicks > comm().size())
    {
      // Receive messages about work being finished
      do
      {
        MPI_Iprobe(MPI_ANY_SOURCE,
                   work_completed_requests_tag.value(),
                   comm().get(),
                   &work_completed_probe_flag,
                   work_completed_probe_status.get());
 
        if (work_completed_probe_flag)
        {
          auto proc = work_completed_probe_status.source();
          comm().receive(proc, work_completed_per_proc[proc], work_completed_requests_tag);
        }
      } while (work_completed_probe_flag);
 
      _total_work_completed = std::accumulate(
          work_completed_per_proc.begin(), work_completed_per_proc.end(), _local_work_completed);
 
      // Reset
      communication_clicks = 0;
    }
 
    // Send messages about objects being finished
    for (processor_id_type pid = 0; pid < comm().size(); ++pid)
      if (pid != _pid &&
          (!work_completed_requests_sent[pid] || work_completed_requests[pid].test()) &&
          _local_work_completed > work_completed_requests_temps[pid])
      {
        work_completed_requests_temps[pid] = _local_work_completed;
        comm().send(pid,
                    work_completed_requests_temps[pid],
                    work_completed_requests[pid],
                    work_completed_requests_tag);
        work_completed_requests_sent[pid] = true;
      }
 
    // All procs agree on the amount of work started and we've finished all the work started
    if (work_started_request.test() && _total_work_started == _total_work_completed)
    {
      // Need to call the post wait work for all of the requests
      for (processor_id_type pid = 0; pid < comm().size(); ++pid)
        if (pid != _pid)
          work_completed_requests[pid].wait();
 
      return;
    }
 
    communication_clicks++;
  }
}

localChunksExecuted()

unsigned long long int ParallelStudy< std::shared_ptr< Ray > , Ray >::localChunksExecuted ( ) const

inlineinherited

Gets the total number of chunks of work executed on this processor.

Definition at line 130 of file ParallelStudy.h.

{ return _local_chunks_executed; }

localWorkExecuted()

unsigned long long int ParallelStudy< std::shared_ptr< Ray > , Ray >::localWorkExecuted ( ) const

inlineinherited

Gets the total amount of work executed on this processor.

Definition at line 122 of file ParallelStudy.h.

{ return _local_work_executed; }

localWorkStarted()

unsigned long long int ParallelStudy< std::shared_ptr< Ray > , Ray >::localWorkStarted ( ) const

inlineinherited

Gets the total amount of work started from this processor.

Definition at line 118 of file ParallelStudy.h.

{ return _local_work_started; }

maxBufferSize()

unsigned int ParallelStudy< std::shared_ptr< Ray > , Ray >::maxBufferSize ( ) const

inlineinherited

Gets the max buffer size.

Definition at line 144 of file ParallelStudy.h.

{ return _max_buffer_size; }

method()

ParallelStudyMethod ParallelStudy< std::shared_ptr< Ray > , Ray >::method ( ) const

inlineinherited

Gets the method.

Definition at line 166 of file ParallelStudy.h.

{ return _method; }

moveContinuingWorkToBuffer() [1/2]

void ParallelStudy< std::shared_ptr< Ray > , Ray >::moveContinuingWorkToBuffer ( const work_iterator  begin, const work_iterator  end  )

protectedinherited

Definition at line 251 of file ParallelStudy.h.

{
  if (_currently_executing_work)
    moveWorkError(MoveWorkError::CONTINUING_DURING_EXECUTING_WORK);
 
  const auto size = std::distance(begin, end);
  if (_work_buffer->capacity() < _work_buffer->size() + size)
    _work_buffer->setCapacity(_work_buffer->size() + size);
 
  for (auto it = begin; it != end; ++it)
    _work_buffer->move(*it);
}

moveContinuingWorkToBuffer() [2/2]

void ParallelStudy< std::shared_ptr< Ray > , Ray >::moveContinuingWorkToBuffer ( std::shared_ptr< Ray > &  Work )

protectedinherited

Moves work that is considered continuing for the purposes of the execution algorithm into the buffer.

Definition at line 250 of file ParallelStudy.h.

{
  if (_currently_executing_work)
    moveWorkError(MoveWorkError::CONTINUING_DURING_EXECUTING_WORK);
 
  _work_buffer->move(work);
}

moveParallelDataToBuffer()

void ParallelStudy< std::shared_ptr< Ray > , Ray >::moveParallelDataToBuffer ( std::shared_ptr< Ray > &  data, const processor_id_type  dest_pid  )

inherited

Moves parallel data objects to the send buffer to be communicated to processor dest_pid.

Definition at line 81 of file ParallelStudy.h.

{
  mooseAssert(comm().size() > dest_pid, "Invalid processor ID");
  mooseAssert(_pid != dest_pid, "Processor ID is self");
 
  if (!_currently_executing && !_currently_pre_executing)
    mooseError(_name, ": Cannot sendParallelData() when not executing");
 
  // Get the send buffer for the proc this object is going to
  auto find_pair = _send_buffers.find(dest_pid);
  // Need to create a send buffer for said processor
  if (find_pair == _send_buffers.end())
    _send_buffers
        .emplace(dest_pid,
                 std::make_unique<
                     SendBuffer<ParallelDataType, ParallelStudy<WorkType, ParallelDataType>>>(
                     comm(),
                     this,
                     dest_pid,
                     _method,
                     _min_buffer_size,
                     _max_buffer_size,
                     _buffer_growth_multiplier,
                     _buffer_shrink_multiplier,
                     _parallel_data_buffer_tag))
        .first->second->moveObject(data);
  // Send buffer exists for this processor
  else
    find_pair->second->moveObject(data);
}

moveWorkError() [1/2]

void ParallelRayStudy::moveWorkError ( const MoveWorkError  error, const std::shared_ptr< Ray > *  ray  ) const

overrideprotected

Definition at line 74 of file ParallelRayStudy.C.

{
  std::stringstream oss;
  oss << "In method " << _ray_tracing_study.type() << "::addRay(s)ToBuffer:\n";
 
  if (error == MoveWorkError::DURING_EXECUTION_DISABLED)
  {
    oss << "Rays are being added to the buffer during propagation.\n\n";
    oss << "This capability must be enabled by setting the parameter\n";
    oss << "'allow_new_work_during_execution' to true.";
  }
  else if (error == MoveWorkError::PRE_EXECUTION_AND_EXECUTION_ONLY)
    oss << "Rays can only be added to the buffer during generateRays() and tracing.";
  else if (error == MoveWorkError::PRE_EXECUTION_ONLY)
    oss << "Rays can only be added to the buffer during generateRays().";
  else if (error == MoveWorkError::PRE_EXECUTION_THREAD_0_ONLY)
    oss << "Rays can only be added on thread 0 during generateRays() (not thread safe)";
  else if (error == CONTINUING_DURING_EXECUTING_WORK)
    ParallelStudy<std::shared_ptr<Ray>, Ray>::moveWorkError(error, ray);
 
  if (ray)
    oss << "\n\n" << (*ray)->getInfo();
 
  mooseError(oss.str());
}

Referenced by moveWorkError().

moveWorkError() [2/2]

void ParallelStudy< std::shared_ptr< Ray > , Ray >::moveWorkError ( const MoveWorkError  error, const std::shared_ptr< Ray > *  work = nullptr  ) const

protectedvirtualinherited

Virtual that allows for the customization of error text for moving work into the buffer.

Definition at line 206 of file ParallelStudy.h.

{
  if (error == MoveWorkError::DURING_EXECUTION_DISABLED)
    mooseError(_name,
               ": The moving of new work into the buffer during work execution requires\n",
               "that the parameter 'allow_new_work_during_execution = true'");
  if (error == MoveWorkError::PRE_EXECUTION_AND_EXECUTION_ONLY)
    mooseError(
        _name,
        ": Can only move work into the buffer in the pre-execution and execution phase\n(between "
        "preExecute() and the end of execute()");
  if (error == MoveWorkError::PRE_EXECUTION_ONLY)
    mooseError(_name,
               ": Can only move work into the buffer in the pre-execution phase\n(between "
               "preExecute() and execute()");
  if (error == MoveWorkError::PRE_EXECUTION_THREAD_0_ONLY)
    mooseError(_name,
               ": Can only move work into the buffer in the pre-execution phase\n(between "
               "preExecute() and execute()) on thread 0");
  if (error == CONTINUING_DURING_EXECUTING_WORK)
    mooseError(_name, ": Cannot move continuing work into the buffer during executeAndBuffer()");
 
  mooseError("Unknown MoveWorkError");
}

moveWorkToBuffer() [1/3]

void ParallelStudy< std::shared_ptr< Ray > , Ray >::moveWorkToBuffer ( const work_iterator  begin, const work_iterator  end, const THREAD_ID  tid  )

inherited

Definition at line 64 of file ParallelStudy.h.

{
  // Error checks for moving work into the buffer at unallowed times
  canMoveWorkCheck(tid);
 
  // Get work size beforehand so we can resize
  const auto size = std::distance(begin, end);
 
  // Can move directly into the work buffer on thread 0 when we're not executing work
  if (!_currently_executing_work && tid == 0)
  {
    if (_work_buffer->capacity() < _work_buffer->size() + size)
      _work_buffer->setCapacity(_work_buffer->size() + size);
    _local_work_started += size;
  }
  else
    _temp_threaded_work[tid].reserve(_temp_threaded_work[tid].size() + size);
 
  // Move the objects
  if (!_currently_executing_work && tid == 0)
    for (auto it = begin; it != end; ++it)
      _work_buffer->move(*it);
  else
    for (auto it = begin; it != end; ++it)
      _temp_threaded_work[tid].emplace_back(std::move(*it));
}

moveWorkToBuffer() [2/3]

void ParallelStudy< std::shared_ptr< Ray > , Ray >::moveWorkToBuffer ( std::shared_ptr< Ray > &  work, const THREAD_ID  tid  )

inherited

Adds work to the buffer to be executed.

This will move the work into the buffer (with std::move), therefore the passed in work will be invalid after this call. For the purposes of the completion algorithm, this added work is considered NEW work.

During pre-execution (between preExecute() and execute()), this method can ONLY be called on thread 0.

During execute(), this method is thread safe and can be used to add work during execution.

Definition at line 63 of file ParallelStudy.h.

{
  // Error checks for moving work into the buffer at unallowed times
  canMoveWorkCheck(tid);
 
  // Can move directly into the work buffer on thread 0 when we're not executing work
  if (!_currently_executing_work && tid == 0)
  {
    ++_local_work_started; // must ALWAYS increment when adding new work to the working buffer
    _work_buffer->move(work);
  }
  // Objects added during execution go into a temporary threaded vector (is thread safe) to be
  // moved into the working buffer when possible
  else
    _temp_threaded_work[tid].emplace_back(std::move(work));
}

moveWorkToBuffer() [3/3]

void ParallelStudy< std::shared_ptr< Ray > , Ray >::moveWorkToBuffer ( std::vector< std::shared_ptr< Ray > > &  work, const THREAD_ID  tid  )

inherited

Definition at line 65 of file ParallelStudy.h.

{
  moveWorkToBuffer(work_vector.begin(), work_vector.end(), tid);
}

parallelDataSent()

unsigned long long int ParallelStudy< std::shared_ptr< Ray > , Ray >::parallelDataSent ( ) const

inherited

Gets the total number of parallel data objects sent from this processor.

Definition at line 105 of file ParallelStudy.h.

{
  unsigned long long int total_sent = 0;
 
  for (const auto & buffer : _send_buffers)
    total_sent += buffer.second->objectsSent();
 
  return total_sent;
}

poolParallelDataCreated()

unsigned long long int ParallelStudy< std::shared_ptr< Ray > , Ray >::poolParallelDataCreated ( ) const

inherited

Gets the total number of parallel data created in all of the threaded pools.

Definition at line 113 of file ParallelStudy.h.

{
  unsigned long long int num_created = 0;
 
  for (const auto & pool : _parallel_data_pools)
    num_created += pool.num_created();
 
  return num_created;
}

postExecuteChunk() [1/2]

void ParallelRayStudy::postExecuteChunk ( const work_iterator  begin, const work_iterator  end  )

overrideprotected

Definition at line 27 of file ParallelRayStudy.C.

{
  for (auto it = begin; it != end; ++it)
  {
    std::shared_ptr<Ray> & ray = *it;
 
    // The Ray is done tracing
    if (!ray->shouldContinue())
    {
      _ray_tracing_study.onCompleteRay(ray);
      continue;
    }
 
    // Going to another processor
    mooseAssert(ray->currentElem()->processor_id() != _pid,
                "Continuing Ray not going to another processor");
    moveParallelDataToBuffer(ray, ray->currentElem()->processor_id());
  }
}

postExecuteChunk() [2/2]

virtual void ParallelStudy< std::shared_ptr< Ray > , Ray >::postExecuteChunk ( const work_iterator  , const work_iterator    )

inlineprotectedvirtualinherited

Insertion point for acting on work that was just executed.

This is not called in threads.

Definition at line 219 of file ParallelStudy.h.

{}

postReceiveParallelData() [1/2]

void ParallelRayStudy::postReceiveParallelData ( const parallel_data_iterator  begin, const parallel_data_iterator  end  )

overrideprotected

Definition at line 55 of file ParallelRayStudy.C.

{
  // Move all of the parallel data (Rays that are continuing to be traced on this processor)
  // directly into the work buffer
  moveContinuingWorkToBuffer(begin, end);
}

postReceiveParallelData() [2/2]

virtual void ParallelStudy< std::shared_ptr< Ray > , Ray >::postReceiveParallelData ( const parallel_data_iterator  begin, const parallel_data_iterator  end  )

protectedpure virtualinherited

Pure virtual for acting on parallel data that has JUST been received and filled into the buffer.

The parallel data in the range passed here will have its use count reduced by one if it still exists after this call.

postReceiveParallelDataInternal()

void ParallelStudy< std::shared_ptr< Ray > , Ray >::postReceiveParallelDataInternal ( )

privateinherited

Internal method for acting on the parallel data that has just been received into the parallel buffer.

Definition at line 309 of file ParallelStudy.h.

{
  if (_receive_buffer->buffer().empty())
    return;
 
  // Let derived classes work on the data and then clear it after
  postReceiveParallelData(_receive_buffer->buffer().begin(), _receive_buffer->buffer().end());
  for (auto & data : _receive_buffer->buffer())
    if (data)
      data.reset();
 
  _receive_buffer->buffer().clear();
}

preExecute()

void ParallelStudy< std::shared_ptr< Ray > , Ray >::preExecute ( )

inherited

Pre-execute method that MUST be called before execute() and before adding work.

Definition at line 45 of file ParallelStudy.h.

{
  if (!buffersAreEmpty())
    mooseError(_name, ": Buffers are not empty in preExecute()");
 
  // Clear communication buffers
  for (auto & send_buffer_pair : _send_buffers)
    send_buffer_pair.second->clear();
  _send_buffers.clear();
  _receive_buffer->clear();
 
  // Clear counters
  _local_chunks_executed = 0;
  _local_work_completed = 0;
  _local_work_started = 0;
  _local_work_executed = 0;
  _total_work_started = 0;
  _total_work_completed = 0;
 
  _currently_pre_executing = true;
}

preReceiveAndExecute()

virtual void ParallelStudy< std::shared_ptr< Ray > , Ray >::preReceiveAndExecute ( )

inlineprotectedvirtualinherited

Insertion point called just after trying to receive work and just before beginning work on the work buffer.

Definition at line 225 of file ParallelStudy.h.

{}

rayTracingStudy() [1/2]

RayTracingStudy & ParallelRayStudy::rayTracingStudy ( )

inline

Get the RayTracingStudy associated with this ParallelRayStudy.

Definition at line 31 of file ParallelRayStudy.h.

{ return _ray_tracing_study; }

rayTracingStudy() [2/2]

const RayTracingStudy & ParallelRayStudy::rayTracingStudy ( ) const

inline

Definition at line 32 of file ParallelRayStudy.h.

{ return _ray_tracing_study; }

receiveAndExecute()

bool ParallelStudy< std::shared_ptr< Ray > , Ray >::receiveAndExecute ( )

privateinherited

Receive packets of parallel data from other processors and executes work.

Definition at line 293 of file ParallelStudy.h.

{
  bool executed_some = false;
 
  if (_receive_buffer->currentlyReceiving() && _method == ParallelStudyMethod::SMART)
    _receive_buffer->cleanupRequests();
  else
    _receive_buffer->receive();
 
  postReceiveParallelDataInternal();
 
  preReceiveAndExecute();
 
  while (!_work_buffer->empty())
  {
    executed_some = true;
 
    // Switch between tracing a chunk and buffering with SMART
    if (_method == ParallelStudyMethod::SMART)
    {
      // Look for extra work first so that these transfers can be finishing while we're executing
      // Start receives only if our work buffer is decently sized
      const bool start_receives_only = _work_buffer->size() > (2 * _chunk_size);
      _receive_buffer->receive(_work_buffer->size() > (2 * _chunk_size));
      if (!start_receives_only)
        postReceiveParallelDataInternal();
 
      // Execute some objects
      executeAndBuffer(_chunk_size);
    }
    // Execute all of them and then buffer with the other methods
    else
      executeAndBuffer(_work_buffer->size());
  }
 
  return executed_some;
}

receiveBuffer()

const ReceiveBuffer< Ray , ParallelStudy< std::shared_ptr< Ray > , Ray > > & ParallelStudy< std::shared_ptr< Ray > , Ray >::receiveBuffer ( ) const

inlineinherited

Gets the receive buffer.

Definition at line 88 of file ParallelStudy.h.

  {
    return *_receive_buffer;
  }

reserveBuffer()

void ParallelStudy< std::shared_ptr< Ray > , Ray >::reserveBuffer ( const std::size_t  size )

inherited

Reserve size entries in the work buffer.

This can only be used during the pre-execution phase (between preExecute() and execute()).

This is particularly useful when one wants to move many work objects into the buffer using moveWorkToBuffer() and wants to allocate the space ahead of time.

Definition at line 176 of file ParallelStudy.h.

{
  if (!_currently_pre_executing)
    mooseError(_name, ": Can only reserve in object buffer during pre-execution");
 
  // We don't ever want to decrease the capacity, so only set if we need more entries
  if (_work_buffer->capacity() < size)
    _work_buffer->setCapacity(size);
}

sendBufferPoolCreated()

unsigned long long int ParallelStudy< std::shared_ptr< Ray > , Ray >::sendBufferPoolCreated ( ) const

inherited

Gets the total number of send buffer pools created.

Definition at line 101 of file ParallelStudy.h.

{
  unsigned long long int total = 0;
 
  for (const auto & buffer : _send_buffers)
    total += buffer.second->bufferPoolCreated();
 
  return total;
}

smartExecute()

void ParallelStudy< std::shared_ptr< Ray > , Ray >::smartExecute ( )

privateinherited

Execute work using SMART.

Definition at line 280 of file ParallelStudy.h.

{
  mooseAssert(_method == ParallelStudyMethod::SMART, "Should be called with SMART only");
 
  // Request for the sum of the started work
  Parallel::Request started_request;
  // Request for the sum of the completed work
  Parallel::Request completed_request;
 
  // Temp for use in sending the current value in a nonblocking sum instead of an updated value
  unsigned long long int temp;
 
  // Whether or not to make the started request first, or after every finished request.
  // When allowing adding new work during the execution phase, the starting object counts could
  // change after right now, so we must update them after each finished request is complete.
  // When not allowing generation during propagation, we know the counts up front.
  const bool started_request_first = !_allow_new_work_during_execution;
 
  // Get the amount of work that was started in the whole domain, if applicable
  if (started_request_first)
    comm().sum(_local_work_started, _total_work_started, started_request);
 
  // Whether or not the started request has been made
  bool made_started_request = started_request_first;
  // Whether or not the completed request has been made
  bool made_completed_request = false;
 
  // Good time to get rid of whatever's currently in our SendBuffers
  flushSendBuffers();
 
  // Use these to try to delay some forced communication
  unsigned int non_executing_clicks = 0;
  unsigned int non_executing_root_clicks = 0;
  bool executed_some = true;
 
  // Keep executing work until it has all completed
  while (true)
  {
    executed_some = receiveAndExecute();
 
    if (executed_some)
    {
      non_executing_clicks = 0;
      non_executing_root_clicks = 0;
    }
    else
    {
      non_executing_clicks++;
      non_executing_root_clicks++;
    }
 
    if (non_executing_clicks >= _clicks_per_communication)
    {
      non_executing_clicks = 0;
 
      flushSendBuffers();
    }
 
    if (_has_alternate_ending_criteria)
    {
      if (buffersAreEmpty() && alternateSmartEndingCriteriaMet())
      {
        comm().barrier();
        return;
      }
    }
    else if (non_executing_root_clicks >= _clicks_per_root_communication)
    {
      non_executing_root_clicks = 0;
 
      // We need the starting work sum first but said request isn't complete yet
      if (started_request_first && !started_request.test())
        continue;
 
      // At this point, we need to make a request for the completed work sum
      if (!made_completed_request)
      {
        made_completed_request = true;
        temp = _local_work_completed;
        comm().sum(temp, _total_work_completed, completed_request);
        continue;
      }
 
      // We have the completed work sum
      if (completed_request.test())
      {
        // The starting work sum must be requested /after/ we have finishing counts and we
        // need to make the request for said sum
        if (!made_started_request)
        {
          made_started_request = true;
          temp = _local_work_started;
          comm().sum(temp, _total_work_started, started_request);
          continue;
        }
 
        // The starting work sum must be requested /after/ we have finishing sum and we
        // don't have the starting sum yet
        if (!started_request_first && !started_request.test())
          continue;
 
        // Started count is the same as the finished count - we're done!
        if (_total_work_started == _total_work_completed)
          return;
 
        // Next time around we should make a completed sum request
        made_completed_request = false;
        // If we need the starting work sum after the completed work sum, we need those now as well
        if (!started_request_first)
          made_started_request = false;
      }
    }
  }
}

totalWorkCompleted()

unsigned long long int ParallelStudy< std::shared_ptr< Ray > , Ray >::totalWorkCompleted ( ) const

inlineinherited

Gets the total amount of work completeed across all processors.

Definition at line 126 of file ParallelStudy.h.

{ return _total_work_completed; }

validParams()

InputParameters ParallelStudy< std::shared_ptr< Ray > , Ray >::validParams ( )

staticinherited

Definition at line 36 of file ParallelStudy.h.

{
  auto params = emptyInputParameters();
 
  params.addRangeCheckedParam<unsigned int>(
      "send_buffer_size", 100, "send_buffer_size > 0", "The size of the send buffer");
  params.addRangeCheckedParam<unsigned int>(
      "chunk_size",
      100,
      "chunk_size > 0",
      "The number of objects to process at one time during execution");
  params.addRangeCheckedParam<unsigned int>("clicks_per_communication",
                                            10,
                                            "clicks_per_communication >= 0",
                                            "Iterations to wait before communicating");
  params.addRangeCheckedParam<unsigned int>("clicks_per_root_communication",
                                            10,
                                            "clicks_per_root_communication > 0",
                                            "Iterations to wait before communicating with root");
  params.addRangeCheckedParam<unsigned int>("clicks_per_receive",
                                            1,
                                            "clicks_per_receive > 0",
                                            "Iterations to wait before checking for new objects");
 
  params.addParam<unsigned int>("min_buffer_size",
                                "The initial size of the SendBuffer and the floor for shrinking "
                                "it.  This defaults to send_buffer_size if not set (i.e. the "
                                "buffer won't change size)");
  params.addParam<Real>("buffer_growth_multiplier",
                        2.,
                        "How much to grow a SendBuffer by if the buffer completely fills and "
                        "dumps.  Will max at send_buffer_size");
  params.addRangeCheckedParam<Real>("buffer_shrink_multiplier",
                                    0.5,
                                    "0 < buffer_shrink_multiplier <= 1.0",
                                    "Multiplier (between 0 and 1) to apply to the current buffer "
                                    "size if it is force dumped.  Will stop at "
                                    "min_buffer_size.");
 
  params.addParam<bool>(
      "allow_new_work_during_execution",
      true,
      "Whether or not to allow the addition of new work to the work buffer during execution");
 
  MooseEnum methods("smart harm bs", "smart");
  params.addParam<MooseEnum>("method", methods, "The algorithm to use");
 
  MooseEnum work_buffers("lifo circular", "circular");
  params.addParam<MooseEnum>("work_buffer_type", work_buffers, "The work buffer type to use");
 
  params.addParamNamesToGroup(
      "send_buffer_size chunk_size clicks_per_communication clicks_per_root_communication "
      "clicks_per_receive min_buffer_size buffer_growth_multiplier buffer_shrink_multiplier method "
      "work_buffer_type allow_new_work_during_execution",
      "Advanced");
 
  return params;
}

workBuffer()

const MooseUtils::Buffer< std::shared_ptr< Ray > > & ParallelStudy< std::shared_ptr< Ray > , Ray >::workBuffer ( ) const

inlineinherited

Gets the work buffer.

Definition at line 96 of file ParallelStudy.h.

{ return *_work_buffer; }

workIsComplete()

bool ParallelRayStudy::workIsComplete ( const std::shared_ptr< Ray > &  )

overrideprotectedvirtual

Can be overridden to denote if a piece of work is not complete yet.

The complete terminology is used within the execution algorithms to determine if the study is complete.

Reimplemented from ParallelStudy< std::shared_ptr< Ray >, Ray >.

Definition at line 48 of file ParallelRayStudy.C.

{
  // "Work" (a Ray) is considered complete in the parallel algorithm when it is done tracing
  return !ray->shouldContinue();
}

Member Data Documentation

_allow_new_work_during_execution

const bool ParallelStudy< std::shared_ptr< Ray > , Ray >::_allow_new_work_during_execution

privateinherited

Whether or not to allow the addition of new work to the buffer during execution.

Definition at line 322 of file ParallelStudy.h.

_buffer_growth_multiplier

const Real ParallelStudy< std::shared_ptr< Ray > , Ray >::_buffer_growth_multiplier

privateinherited

Multiplier for the buffer size for growing the buffer.

Definition at line 316 of file ParallelStudy.h.

_buffer_shrink_multiplier

const Real ParallelStudy< std::shared_ptr< Ray > , Ray >::_buffer_shrink_multiplier

privateinherited

Multiplier for the buffer size for shrinking the buffer.

Definition at line 318 of file ParallelStudy.h.

_chunk_size

const unsigned int ParallelStudy< std::shared_ptr< Ray > , Ray >::_chunk_size

privateinherited

Number of objects to execute at once during communication.

Definition at line 320 of file ParallelStudy.h.

_clicks_per_communication

const unsigned int ParallelStudy< std::shared_ptr< Ray > , Ray >::_clicks_per_communication

privateinherited

Iterations to wait before communicating.

Definition at line 325 of file ParallelStudy.h.

_clicks_per_receive

const unsigned int ParallelStudy< std::shared_ptr< Ray > , Ray >::_clicks_per_receive

privateinherited

Iterations to wait before checking for new objects.

Definition at line 329 of file ParallelStudy.h.

_clicks_per_root_communication

const unsigned int ParallelStudy< std::shared_ptr< Ray > , Ray >::_clicks_per_root_communication

privateinherited

Iterations to wait before communicating with root.

Definition at line 327 of file ParallelStudy.h.

_currently_executing

bool ParallelStudy< std::shared_ptr< Ray > , Ray >::_currently_executing

privateinherited

Whether we are within execute()

Definition at line 362 of file ParallelStudy.h.

_currently_executing_work

bool ParallelStudy< std::shared_ptr< Ray > , Ray >::_currently_executing_work

privateinherited

Whether or not we are currently within executeAndBuffer()

Definition at line 366 of file ParallelStudy.h.

_currently_pre_executing

bool ParallelStudy< std::shared_ptr< Ray > , Ray >::_currently_pre_executing

privateinherited

Whether we are between preExecute() and execute()

Definition at line 364 of file ParallelStudy.h.

_has_alternate_ending_criteria

bool ParallelStudy< std::shared_ptr< Ray > , Ray >::_has_alternate_ending_criteria

protectedinherited

Whether or not this object has alternate ending criteria.

Definition at line 269 of file ParallelStudy.h.

_local_chunks_executed

unsigned long long int ParallelStudy< std::shared_ptr< Ray > , Ray >::_local_chunks_executed

privateinherited

Number of chunks of work executed on this processor.

Definition at line 349 of file ParallelStudy.h.

_local_work_completed

unsigned long long int ParallelStudy< std::shared_ptr< Ray > , Ray >::_local_work_completed

privateinherited

Amount of work completed on this processor.

Definition at line 351 of file ParallelStudy.h.

_local_work_executed

unsigned long long int ParallelStudy< std::shared_ptr< Ray > , Ray >::_local_work_executed

privateinherited

Amount of work executed on this processor.

Definition at line 355 of file ParallelStudy.h.

_local_work_started

unsigned long long int ParallelStudy< std::shared_ptr< Ray > , Ray >::_local_work_started

privateinherited

Amount of work started on this processor.

Definition at line 353 of file ParallelStudy.h.

_max_buffer_size

const unsigned int ParallelStudy< std::shared_ptr< Ray > , Ray >::_max_buffer_size

privateinherited

Number of objects to buffer before communication.

Definition at line 314 of file ParallelStudy.h.

_method

const ParallelStudyMethod ParallelStudy< std::shared_ptr< Ray > , Ray >::_method

protectedinherited

The study method.

Definition at line 267 of file ParallelStudy.h.

_min_buffer_size

const unsigned int ParallelStudy< std::shared_ptr< Ray > , Ray >::_min_buffer_size

privateinherited

Minimum size of a SendBuffer.

Definition at line 312 of file ParallelStudy.h.

_name

const std::string ParallelStudy< std::shared_ptr< Ray > , Ray >::_name

protectedinherited

Name for this object for use in error handling.

Definition at line 263 of file ParallelStudy.h.

_parallel_data_buffer_tag

Parallel::MessageTag ParallelStudy< std::shared_ptr< Ray > , Ray >::_parallel_data_buffer_tag

privateinherited

MessageTag for sending parallel data.

Definition at line 332 of file ParallelStudy.h.

_parallel_data_pools

std::vector<MooseUtils::SharedPool<Ray > > ParallelStudy< std::shared_ptr< Ray > , Ray >::_parallel_data_pools

privateinherited

Pools for re-using destructed parallel data objects (one for each thread)

Definition at line 334 of file ParallelStudy.h.

_params

const InputParameters& ParallelStudy< std::shared_ptr< Ray > , Ray >::_params

protectedinherited

The InputParameters.

Definition at line 265 of file ParallelStudy.h.

_pid

const processor_id_type ParallelStudy< std::shared_ptr< Ray > , Ray >::_pid

protectedinherited

This rank.

Definition at line 261 of file ParallelStudy.h.

_ray_tracing_study

RayTracingStudy& ParallelRayStudy::_ray_tracing_study

protected

The RayTracingStudy.

Definition at line 44 of file ParallelRayStudy.h.

Referenced by moveWorkError(), postExecuteChunk(), rayTracingStudy(), and rayTracingStudy().

_receive_buffer

const std::unique_ptr<ReceiveBuffer<Ray , ParallelStudy<std::shared_ptr< Ray > , Ray > > > ParallelStudy< std::shared_ptr< Ray > , Ray >::_receive_buffer

privateinherited

The receive buffer.

Definition at line 341 of file ParallelStudy.h.

_send_buffers

std::unordered_map< processor_id_type, std::unique_ptr<SendBuffer<Ray , ParallelStudy<std::shared_ptr< Ray > , Ray > > > > ParallelStudy< std::shared_ptr< Ray > , Ray >::_send_buffers

privateinherited

Send buffers for each processor.

Definition at line 346 of file ParallelStudy.h.

_temp_threaded_work

std::vector<std::vector<std::shared_ptr< Ray > > > ParallelStudy< std::shared_ptr< Ray > , Ray >::_temp_threaded_work

privateinherited

Threaded temprorary storage for work added while we're using the _work_buffer (one for each thread)

Definition at line 336 of file ParallelStudy.h.

_threaded_trace_ray

const std::vector<std::shared_ptr<TraceRay> >& ParallelRayStudy::_threaded_trace_ray

protected

The TraceRay objects that do the tracing for each thread.

Definition at line 46 of file ParallelRayStudy.h.

Referenced by executeWork().

_total_work_completed

unsigned long long int ParallelStudy< std::shared_ptr< Ray > , Ray >::_total_work_completed

privateinherited

Amount of work completed on all processors.

Definition at line 359 of file ParallelStudy.h.

_total_work_started

unsigned long long int ParallelStudy< std::shared_ptr< Ray > , Ray >::_total_work_started

privateinherited

Amount of work started on all processors.

Definition at line 357 of file ParallelStudy.h.

_work_buffer

const std::unique_ptr<MooseUtils::Buffer<std::shared_ptr< Ray > > > ParallelStudy< std::shared_ptr< Ray > , Ray >::_work_buffer

privateinherited

Buffer for executing work.

Definition at line 338 of file ParallelStudy.h.

---

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

• ray_tracing/include/raytracing/ParallelRayStudy.h
• ray_tracing/src/raytracing/ParallelRayStudy.C