Int RSR_InputSgsToRulesAndOutputSgs_OMP()

in sparseconvnet/SCN/Metadata/RandomizedStrideRules.h [127:173]

• 44 lines of code
• 8 McCabe index (conditional complexity)

Int RSR_InputSgsToRulesAndOutputSgs_OMP(SparseGrids<dimension> &input_SGs,
                                        SparseGrids<dimension> &output_SGs,
                                        RuleBook &rules, long *size,
                                        long *stride, long *input_spatialSize,
                                        long *output_spatialSize,
                                        std::default_random_engine re) {
  auto t = RSRRegions(input_spatialSize, output_spatialSize, dimension, size,
                      stride, re);
  rules.clear();
  rules.resize(volume<dimension>(size));
  output_SGs.clear();
  Int batchSize = input_SGs.size();
  output_SGs.resize(batchSize);
  std::vector<RuleBook> rbs(batchSize);
  {
    Int i;
#pragma omp parallel for private(i)
    for (i = 0; i < batchSize; i++)
      RSR_InputSgToRulesAndOutputSg<dimension>(input_SGs[i], output_SGs[i],
                                               rbs[i], t, size, stride);
  }
  Int output_nActive = 0;
  for (Int i = 0; i < batchSize; i++) {
    // Parallel assignment:
    // output_nActive     <-  output_nActive+output_SGs[i].ctr
    // output_SGs[i].ctr  <-  output_nActive
    Int tmp = output_nActive;
    output_nActive += output_SGs[i].ctr;
    output_SGs[i].ctr = tmp;
  }
  {
    Int i;
#pragma omp parallel for private(i)
    for (i = 0; i < (Int)rules.size(); i++) {
      auto &R = rules[i];
      for (Int j = 0; j < batchSize; j++) {
        auto &r = rbs[j][i];
        auto offset = output_SGs[j].ctr;
        for (Int k = 0; k < (Int)r.size();) {
          R.push_back(r[k++]);
          R.push_back(r[k++] + offset);
        }
      }
    }
  }
  return output_nActive;
}