hybridBitonicSortUtils Namespace Reference

Functions
unsigned int	bitonicMergeLatencyRef (unsigned int nIn)
unsigned int	bitonicSortLatencyRef (unsigned int nIn, unsigned int nOut)
template<typename T >
void	clear (T &t)
template<typename T >
void	compAndSwap (T a[], int i, int j, bool dir)
unsigned int	hybridBitonicSortLatencyRef (unsigned int nIn, unsigned int nOut)
unsigned int	PowerOf2LessThan (unsigned int n)

Function Documentation

bitonicMergeLatencyRef()

unsigned int hybridBitonicSortUtils::bitonicMergeLatencyRef ( unsigned int  nIn )

inline

Definition at line 36 of file bitonic_hybrid_sort_ref.h.

References SiStripPI::max, l1ctLayer1_cff::nIn, and PowerOf2LessThan().

Referenced by bitonicSortLatencyRef(), and hybridBitonicSortLatencyRef().

                                                               {
    if (nIn <= 1)
      return 0;
    return 1 +
           std::max(bitonicMergeLatencyRef(PowerOf2LessThan(nIn)), bitonicMergeLatencyRef(nIn - PowerOf2LessThan(nIn)));
  }

bitonicSortLatencyRef()

unsigned int hybridBitonicSortUtils::bitonicSortLatencyRef ( unsigned int  nIn, unsigned int  nOut  )

inline

Definition at line 43 of file bitonic_hybrid_sort_ref.h.

References bitonicMergeLatencyRef(), SiStripPI::max, SiStripPI::min, l1ctLayer1_cff::nIn, and l1ctLayer1_cff::nOut.

                                                                                 {
    if (nIn <= 1)
      return 0;
    unsigned int sort1Size = nIn / 2, sort2Size = nIn - sort1Size;
    unsigned int sort1Latency = bitonicSortLatencyRef(sort1Size, nOut);
    unsigned int sort2Latency = bitonicSortLatencyRef(sort2Size, nOut);
    unsigned int mergeLatency = bitonicMergeLatencyRef(std::min(sort1Size, nOut) + std::min(sort2Size, nOut));
    return std::max(sort1Latency, sort2Latency) + mergeLatency;
  }

clear()

template<typename T >

void hybridBitonicSortUtils::clear

(

T &

t

)

Definition at line 71 of file bitonic_hybrid_sort_ref.h.

References submitPVValidationJobs::t.

Referenced by folded_hybrid_bitonic_sort_and_crop_ref().

                   {
    t.clear();
  }

compAndSwap()

template<typename T >

void hybridBitonicSortUtils::compAndSwap	(	T	a[],
		int	i,
		int	j,
		bool	dir
	)

Definition at line 26 of file bitonic_hybrid_sort_ref.h.

References a, DeadROC_duringRun::dir, mps_fire::i, dqmiolumiharvest::j, and std::swap().

Referenced by hybridBitonicMergeRef(), and hybridBitonicSortRef().

                                                  {
    if (dir) {
      if (a[j] < a[i])
        std::swap(a[i], a[j]);
    } else {
      if (a[i] < a[j])
        std::swap(a[i], a[j]);
    }
  }

hybridBitonicSortLatencyRef()

unsigned int hybridBitonicSortUtils::hybridBitonicSortLatencyRef ( unsigned int  nIn, unsigned int  nOut  )

inline

Definition at line 53 of file bitonic_hybrid_sort_ref.h.

References bitonicMergeLatencyRef(), SiStripPI::max, SiStripPI::min, l1ctLayer1_cff::nIn, and l1ctLayer1_cff::nOut.

                                                                                       {
    if (nIn <= 1)
      return 0;
    if (nIn == 5 || nIn == 6)
      return 3;
    if (nIn == 12)
      return 8;
    if (nIn == 13)
      return 9;
    unsigned int sort1Size = nIn / 2, sort2Size = nIn - sort1Size;
    unsigned int sort1Latency = hybridBitonicSortLatencyRef(sort1Size, nOut);
    unsigned int sort2Latency = hybridBitonicSortLatencyRef(sort2Size, nOut);
    unsigned int mergeLatency = bitonicMergeLatencyRef(std::min(sort1Size, nOut) + std::min(sort2Size, nOut));
    return std::max(sort1Latency, sort2Latency) + mergeLatency;
  }

PowerOf2LessThan()

unsigned int hybridBitonicSortUtils::PowerOf2LessThan ( unsigned int  n )

inline

Definition at line 8 of file bitonic_hybrid_sort_ref.h.

References cms::cuda::assert(), mps_fire::i, and dqmiodumpmetadata::n.

Referenced by bitonicMergeLatencyRef(), and hybridBitonicMergeRef().

                                                       {
    unsigned int i = 1;
    unsigned int prev = 1;
    if (n <= 1)
      return n;
    while (i < n) {
      i <<= 1;
      if (i < n) {
        prev = i;
      } else {
        return prev;
      }
    }
    // shouldn't happen
    assert(false);
  }