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. More...
void	execute ()
	Execute method. More...
MooseUtils::SharedPool< Ray >::PtrType	acquireParallelData (const THREAD_ID tid, Args &&... args)
	Acquire a parallel data object from the pool. More...
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. More...
const ReceiveBuffer< Ray, ParallelStudy< std::shared_ptr< Ray >, Ray > > &	receiveBuffer () const
	Gets the receive buffer. More...
const MooseUtils::Buffer< std::shared_ptr< Ray > > &	workBuffer () const
	Gets the work buffer. More...
unsigned long long int	sendBufferPoolCreated () const
	Gets the total number of send buffer pools created. More...
unsigned long long int	parallelDataSent () const
	Gets the total number of parallel data objects sent from this processor. More...
unsigned long long int	buffersSent () const
	Gets the total number of buffers sent from this processor. More...
unsigned long long int	poolParallelDataCreated () const
	Gets the total number of parallel data created in all of the threaded pools. More...
unsigned long long int	localWorkStarted () const
	Gets the total amount of work started from this processor. More...
unsigned long long int	localWorkExecuted () const
	Gets the total amount of work executed on this processor. More...
unsigned long long int	totalWorkCompleted () const
	Gets the total amount of work completeed across all processors. More...
unsigned long long int	localChunksExecuted () const
	Gets the total number of chunks of work executed on this processor. More...
bool	currentlyExecuting () const
	Whether or not this object is currently in execute(). More...
bool	currentlyPreExecuting () const
	Whether or not this object is between preExecute() and execute(). More...
unsigned int	maxBufferSize () const
	Gets the max buffer size. More...
unsigned int	chunkSize () const
	Gets the chunk size. More...
unsigned int	clicksPerCommunication () const
	Gets the number of iterations to wait before communicating. More...
unsigned int	clicksPerRootCommunication () const
	Gets the number of iterations to wait before communicating with root. More...
unsigned int	clicksPerReceive () const
	Gets the number of iterations to wait before checking for new parallel data. More...
ParallelStudyMethod	method () const
	Gets the method. More...
void	reserveBuffer (const std::size_t size)
	Reserve size entries in the work buffer. More...
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. More...
const RayTracingStudy &	rayTracingStudy () const
void	moveWorkToBuffer (std::shared_ptr< Ray > &work, const THREAD_ID tid)
	Adds work to the buffer to be executed. More...
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. More...
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. More...
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. More...
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. More...
virtual bool	alternateSmartEndingCriteriaMet ()
	Insertion point for derived classes to provide an alternate ending criteria for SMART execution. More...
virtual void	postExecuteChunk (const work_iterator, const work_iterator)
	Insertion point for acting on work that was just executed. More...
virtual void	preReceiveAndExecute ()
	Insertion point called just after trying to receive work and just before beginning work on the work buffer. More...
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. More...
bool	buffersAreEmpty () const
	Whether or not ALL of the buffers are empty: Working buffer, threaded buffers, receive buffer, and send buffers. More...
void	moveContinuingWorkToBuffer (std::shared_ptr< Ray > &Work)
	Moves work that is considered continuing for the purposes of the execution algorithm into the buffer. More...
void	moveContinuingWorkToBuffer (const work_iterator begin, const work_iterator end)

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

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 1202 of file ParallelStudy.h.

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

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 1209 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 1178 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;
}

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 419 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 988 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");
}

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);
}

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 ( 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 1128 of file ParallelStudy.h.

Referenced by postReceiveParallelData().

{
  if (_currently_executing_work)
    moveWorkError(MoveWorkError::CONTINUING_DURING_EXECUTING_WORK);

  _work_buffer->move(work);
}

moveContinuingWorkToBuffer() [2/2]

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

protectedinherited

Definition at line 1138 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);
}

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 576 of file ParallelStudy.h.

Referenced by postExecuteChunk().

{
  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());
}

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 1022 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 ( 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 1070 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() [2/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 1089 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() [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 1120 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 1166 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 1190 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.

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 964 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; }

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 618 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 1154 of file ParallelStudy.h.

{
  unsigned long long int total = 0;

  for (const auto & buffer : _send_buffers)
    total += buffer.second->bufferPoolCreated();

  return total;
}

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 436 of file ParallelStudy.h.

Referenced by RayTracingStudy::validParams().

{
  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

_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.

_method

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

protectedinherited

The study method.

Definition at line 267 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.

_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.

Referenced by executeWork(), and postExecuteChunk().

_ray_tracing_study

RayTracingStudy& ParallelRayStudy::_ray_tracing_study

protected

The RayTracingStudy.

Definition at line 44 of file ParallelRayStudy.h.

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

_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().

---

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

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