tfaot::BatchStrategy Class Reference

#include <Batching.h>

Public Member Functions
	BatchStrategy ()=default
const BatchRule &	getRule (size_t batchSize) const
bool	hasRule (size_t batchSize) const
void	setDefaultRule (size_t batchSize, const std::vector< size_t > &availableBatchSizes)
void	setRule (const BatchRule &rule)
void	setRule (const std::string &ruleString)
	~BatchStrategy ()=default

Private Attributes
std::map< size_t, BatchRule >	rules_

Detailed Description

Definition at line 59 of file Batching.h.

Constructor & Destructor Documentation

BatchStrategy()

tfaot::BatchStrategy::BatchStrategy ( )

explicitdefault

~BatchStrategy()

tfaot::BatchStrategy::~BatchStrategy ( )

default

Member Function Documentation

getRule()

const BatchRule & tfaot::BatchStrategy::getRule

(

size_t

batchSize

)

const

Definition at line 85 of file Batching.cc.

References HLT_FULL_cff::batchSize, Exception, ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, and rules_.

                                                                {
    const auto it = rules_.find(batchSize);
    if (it == rules_.end()) {
      throw cms::Exception("UnknownBatchSize") << "batchSize " << batchSize << " not known to batching strategy";
    }
    return it->second;
  }

hasRule()

bool tfaot::BatchStrategy::hasRule ( size_t  batchSize ) const

inline

Definition at line 74 of file Batching.h.

References HLT_FULL_cff::batchSize, and rules_.

{ return rules_.find(batchSize) != rules_.end(); }

setDefaultRule()

void tfaot::BatchStrategy::setDefaultRule	(	size_t	batchSize,
		const std::vector< size_t > &	availableBatchSizes
	)

Definition at line 101 of file Batching.cc.

References HLT_FULL_cff::batchSize, spr::find(), dqmiodumpmetadata::n, mergeAndRegister::rest, and setRule().

                                                                                                   {
    std::vector<size_t> sizes;
    size_t lastPadding = 0;

    // many implementations are possible here, but for simplicity assume the most simple one:
    // if there is an exact match, use it, and otherwise repeat the smallest available size
    // n times and potentially add padding
    if (std::find(availableBatchSizes.begin(), availableBatchSizes.end(), batchSize) != availableBatchSizes.end()) {
      sizes.push_back(batchSize);
    } else {
      size_t smallestBatchSize = *std::min_element(availableBatchSizes.begin(), availableBatchSizes.end());
      size_t rest = batchSize % smallestBatchSize;
      size_t n = (batchSize / smallestBatchSize) + (rest == 0 ? 0 : 1);
      lastPadding = rest == 0 ? 0 : (smallestBatchSize - rest);
      sizes.resize(n, smallestBatchSize);
    }

    // create and register the rule
    setRule(BatchRule(batchSize, sizes, lastPadding));
  }

setRule() [1/2]

void tfaot::BatchStrategy::setRule ( const BatchRule &  rule )

inline

Definition at line 68 of file Batching.h.

References tfaot::BatchRule::getBatchSize(), and rules_.

Referenced by tfaot::Model< W >::setBatchRule(), and setDefaultRule().

{ rules_.insert_or_assign(rule.getBatchSize(), rule); }

setRule() [2/2]

void tfaot::BatchStrategy::setRule ( const std::string &  ruleString )

inline

Definition at line 71 of file Batching.h.

References setRule().

Referenced by setRule().

{ this->setRule(BatchRule(ruleString)); }

Member Data Documentation

rules_

std::map<size_t, BatchRule> tfaot::BatchStrategy::rules_

private

Definition at line 83 of file Batching.h.

Referenced by getRule(), hasRule(), and setRule().