Rename parallelForEachN to just parallelFor

[thakis]

Summary

Patch created by running:

rg -l parallelForEachN | xargs sed -i '' -c 's/parallelForEachN/parallelFor/'

No behavior change.

[MaskRay]

LGTM.

lld/COFF/DebugTypes.cpp

tableSize =
       std::min(size_t(INT32_MAX) - TypeIndex::FirstNonSimpleIndex, tableSize);
   ghashState.table.init(static_cast<uint32_t>(tableSize));
 
   // Insert ghashes in parallel. During concurrent insertion, we cannot observe
   // the contents of the hash table cell, but we can remember the insertion
   // position. Because the table does not rehash, the position will not change
   // under insertion. After insertion is done, the value of the cell can be read
   // to retrieve the final PDB type index.
-  parallelForEachN(0, ctx.tpiSourceList.size(), [&](size_t tpiSrcIdx) {
+  parallelFor(0, ctx.tpiSourceList.size(), [&](size_t tpiSrcIdx) {
     TpiSource *source = ctx.tpiSourceList[tpiSrcIdx];
     source->indexMapStorage.resize(source->ghashes.size());
     for (uint32_t i = 0, e = source->ghashes.size(); i < e; i++) {
       if (source->shouldOmitFromPdb(i)) {
         source->indexMapStorage[i] = TypeIndex(SimpleTypeKind::NotTranslated);
         continue;
       }
       GloballyHashedType ghash = source->ghashes[i];

lld/COFF/ICF.cpp

void ICF::forEachClass(std::function<void(size_t, size_t)> fn) {
   // The sharding must be completed before any calls to Fn are made
   // so that Fn can modify the Chunks in its shard without causing data
   // races.
   const size_t numShards = 256;
   size_t step = chunks.size() / numShards;
   size_t boundaries[numShards + 1];
   boundaries[0] = 0;
   boundaries[numShards] = chunks.size();
-  parallelForEachN(1, numShards, [&](size_t i) {
+  parallelFor(1, numShards, [&](size_t i) {
     boundaries[i] = findBoundary((i - 1) * step, chunks.size());
   });
-  parallelForEachN(1, numShards + 1, [&](size_t i) {
+  parallelFor(1, numShards + 1, [&](size_t i) {
     if (boundaries[i - 1] < boundaries[i]) {
       forEachClassRange(boundaries[i - 1], boundaries[i], fn);
     }
   });
   ++cnt;
 }
 
 // Merge identical COMDAT sections.

lld/COFF/LLDMapFile.cpp

static SymbolMapTy getSectionSyms(ArrayRef<DefinedRegular *> syms) {
   }
   return ret;
 }
 
 // Construct a map from symbols to their stringified representations.
 static DenseMap<DefinedRegular *, std::string>
 getSymbolStrings(ArrayRef<DefinedRegular *> syms) {
   std::vector<std::string> str(syms.size());
-  parallelForEachN((size_t)0, syms.size(), [&](size_t i) {
+  parallelFor((size_t)0, syms.size(), [&](size_t i) {
     raw_string_ostream os(str[i]);
     writeHeader(os, syms[i]->getRVA(), 0, 0);
     os << indent16 << toString(*syms[i]);
   });
 
   DenseMap<DefinedRegular *, std::string> ret;
   for (size_t i = 0, e = syms.size(); i < e; ++i)
     ret[syms[i]] = std::move(str[i]);

lld/COFF/MapFile.cpp

static void getSymbols(const COFFLinkerContext &ctx,
   sortUniqueSymbols(syms);
   sortUniqueSymbols(staticSyms);
 }
 
 // Construct a map from symbols to their stringified representations.
 static DenseMap<Defined *, std::string>
 getSymbolStrings(const COFFLinkerContext &ctx, ArrayRef<Defined *> syms) {
   std::vector<std::string> str(syms.size());
-  parallelForEachN((size_t)0, syms.size(), [&](size_t i) {
+  parallelFor((size_t)0, syms.size(), [&](size_t i) {
     raw_string_ostream os(str[i]);
     Defined *sym = syms[i];
 
     uint16_t sectionIdx = 0;
     uint64_t address = 0;
     SmallString<128> fileDescr;
 
     if (auto *absSym = dyn_cast<DefinedAbsolute>(sym)) {

lld/ELF/ICF.cpp

void ICF<ELFT>::forEachClass(llvm::function_ref<void(size_t, size_t)> fn) {
   // so that Fn can modify the Chunks in its shard without causing data
   // races.
   const size_t numShards = 256;
   size_t step = sections.size() / numShards;
   size_t boundaries[numShards + 1];
   boundaries[0] = 0;
   boundaries[numShards] = sections.size();
 
-  parallelForEachN(1, numShards, [&](size_t i) {
+  parallelFor(1, numShards, [&](size_t i) {
     boundaries[i] = findBoundary((i - 1) * step, sections.size());
   });
 
-  parallelForEachN(1, numShards + 1, [&](size_t i) {
+  parallelFor(1, numShards + 1, [&](size_t i) {
     if (boundaries[i - 1] < boundaries[i])
       forEachClassRange(boundaries[i - 1], boundaries[i], fn);
   });
   ++cnt;
 }
 
 // Combine the hashes of the sections referenced by the given section into its
 // hash.

lld/ELF/MapFile.cpp

 }
 
 // Construct a map from symbols to their stringified representations.
 // Demangling symbols (which is what toString() does) is slow, so
 // we do that in batch using parallel-for.
 static DenseMap<Symbol *, std::string>
 getSymbolStrings(ArrayRef<Defined *> syms) {
   auto strs = std::make_unique<std::string[]>(syms.size());
-  parallelForEachN(0, syms.size(), [&](size_t i) {
+  parallelFor(0, syms.size(), [&](size_t i) {
     raw_string_ostream os(strs[i]);
     OutputSection *osec = syms[i]->getOutputSection();
     uint64_t vma = syms[i]->getVA();
     uint64_t lma = osec ? osec->getLMA() + vma - osec->getVA(0) : 0;
     writeHeader(os, vma, lma, syms[i]->getSize(), 1);
     os << indent16 << toString(*syms[i]);
   });
 

lld/ELF/OutputSections.cpp

#if LLVM_ENABLE_ZLIB
   auto shardsIn = split(makeArrayRef<uint8_t>(buf.get(), size), shardSize);
   const size_t numShards = shardsIn.size();
 
   // Compress shards and compute Alder-32 checksums. Use Z_SYNC_FLUSH for all
   // shards but the last to flush the output to a byte boundary to be
   // concatenated with the next shard.
   auto shardsOut = std::make_unique<SmallVector<uint8_t, 0>[]>(numShards);
   auto shardsAdler = std::make_unique<uint32_t[]>(numShards);
-  parallelForEachN(0, numShards, [&](size_t i) {
+  parallelFor(0, numShards, [&](size_t i) {
     shardsOut[i] = deflateShard(shardsIn[i], level,
                                 i != numShards - 1 ? Z_SYNC_FLUSH : Z_FINISH);
     shardsAdler[i] = adler32(1, shardsIn[i].data(), shardsIn[i].size());
   });
 
   // Update section size and combine Alder-32 checksums.
   uint32_t checksum = 1;       // Initial Adler-32 value
   compressed.uncompressedSize = size;
if (compressed.shards) {
     // Compute shard offsets.
     auto offsets = std::make_unique<size_t[]>(compressed.numShards);
     offsets[0] = 2; // zlib header
     for (size_t i = 1; i != compressed.numShards; ++i)
       offsets[i] = offsets[i - 1] + compressed.shards[i - 1].size();
 
     buf[0] = 0x78; // CMF
     buf[1] = 0x01; // FLG: best speed
-    parallelForEachN(0, compressed.numShards, [&](size_t i) {
+    parallelFor(0, compressed.numShards, [&](size_t i) {
       memcpy(buf + offsets[i], compressed.shards[i].data(),
              compressed.shards[i].size());
     });
 
     write32be(buf + (size - sizeof(*chdr) - 4), compressed.checksum);
     return;
   }
 
   // Write leading padding.
   SmallVector<InputSection *, 0> sections = getInputSections(*this);
   std::array<uint8_t, 4> filler = getFiller();
   bool nonZeroFiller = read32(filler.data()) != 0;
   if (nonZeroFiller)
     fill(buf, sections.empty() ? size : sections[0]->outSecOff, filler);
 
-  parallelForEachN(0, sections.size(), [&](size_t i) {
+  parallelFor(0, sections.size(), [&](size_t i) {
     InputSection *isec = sections[i];
     if (auto *s = dyn_cast<SyntheticSection>(isec))
       s->writeTo(buf + isec->outSecOff);
     else
       isec->writeTo<ELFT>(buf + isec->outSecOff);
 
     // Fill gaps between sections.
     if (nonZeroFiller) {
if (flags & SHF_EXECINSTR)
     return target->trapInstr;
   return {0, 0, 0, 0};
 }
 
 void OutputSection::checkDynRelAddends(const uint8_t *bufStart) {
   assert(config->writeAddends && config->checkDynamicRelocs);
   assert(type == SHT_REL || type == SHT_RELA);
   SmallVector<InputSection *, 0> sections = getInputSections(*this);
-  parallelForEachN(0, sections.size(), [&](size_t i) {
+  parallelFor(0, sections.size(), [&](size_t i) {
     // When linking with -r or --emit-relocs we might also call this function
     // for input .rel[a].<sec> sections which we simply pass through to the
     // output. We skip over those and only look at the synthetic relocation
     // sections created during linking.
     const auto *sec = dyn_cast<RelocationBaseSection>(sections[i]);
     if (!sec)
       return;
     for (const DynamicReloc &rel : sec->relocs) {

lld/ELF/SyntheticSections.cpp

static SmallVector<GdbIndexSection::GdbSymbol, 0> createSymbols(
   // A sharded map to uniquify symbols by name.
   auto map =
       std::make_unique<DenseMap<CachedHashStringRef, size_t>[]>(numShards);
   size_t shift = 32 - countTrailingZeros(numShards);
 
   // Instantiate GdbSymbols while uniqufying them by name.
   auto symbols = std::make_unique<SmallVector<GdbSymbol, 0>[]>(numShards);
 
-  parallelForEachN(0, concurrency, [&](size_t threadId) {
+  parallelFor(0, concurrency, [&](size_t threadId) {
     uint32_t i = 0;
     for (ArrayRef<NameAttrEntry> entries : nameAttrs) {
       for (const NameAttrEntry &ent : entries) {
         size_t shardId = ent.name.hash() >> shift;
         if ((shardId & (concurrency - 1)) != threadId)
           continue;
 
         uint32_t v = ent.cuIndexAndAttrs + cuIdxs[i];
if (auto *isec = dyn_cast<InputSection>(s))
       if (InputSectionBase *rel = isec->getRelocatedSection())
         return !rel->isLive();
     return !s->isLive();
   });
 
   SmallVector<GdbChunk, 0> chunks(files.size());
   SmallVector<SmallVector<NameAttrEntry, 0>, 0> nameAttrs(files.size());
 
-  parallelForEachN(0, files.size(), [&](size_t i) {
+  parallelFor(0, files.size(), [&](size_t i) {
     // To keep memory usage low, we don't want to keep cached DWARFContext, so
     // avoid getDwarf() here.
     ObjFile<ELFT> *file = cast<ObjFile<ELFT>>(files[i]);
     DWARFContext dwarf(std::make_unique<LLDDwarfObj<ELFT>>(file));
     auto &dobj = static_cast<const LLDDwarfObj<ELFT> &>(dwarf.getDWARFObj());
 
     // If the are multiple compile units .debug_info (very rare ld -r --unique),
     // this only picks the last one. Other address ranges are lost.
void MergeTailSection::finalizeContents() {
   // to a corresponding SectionPiece for easy access.
   for (MergeInputSection *sec : sections)
     for (size_t i = 0, e = sec->pieces.size(); i != e; ++i)
       if (sec->pieces[i].live)
         sec->pieces[i].outputOff = builder.getOffset(sec->getData(i));
 }
 
 void MergeNoTailSection::writeTo(uint8_t *buf) {
-  parallelForEachN(0, numShards,
-                   [&](size_t i) { shards[i].write(buf + shardOffsets[i]); });
+  parallelFor(0, numShards,
 }
 
 // This function is very hot (i.e. it can take several seconds to finish)
 // because sometimes the number of inputs is in an order of magnitude of
 // millions. So, we use multi-threading.
 //
 // For any strings S and T, we know S is not mergeable with T if S's hash
 // value is different from T's. If that's the case, we can safely put S and
 // T into different string builders without worrying about merge misses.
 // We do it in parallel.
 void MergeNoTailSection::finalizeContents() {
   // Initializes string table builders.
   for (size_t i = 0; i < numShards; ++i)
     shards.emplace_back(StringTableBuilder::RAW, alignment);
 
   // Concurrency level. Must be a power of 2 to avoid expensive modulo
   // operations in the following tight loop.
   size_t concurrency = PowerOf2Floor(
       std::min<size_t>(hardware_concurrency(parallel::strategy.ThreadsRequested)
                            .compute_thread_count(),
                        numShards));
 
   // Add section pieces to the builders.
-  parallelForEachN(0, concurrency, [&](size_t threadId) {
+  parallelFor(0, concurrency, [&](size_t threadId) {
     for (MergeInputSection *sec : sections) {
       for (size_t i = 0, e = sec->pieces.size(); i != e; ++i) {
         if (!sec->pieces[i].live)
           continue;
         size_t shardId = getShardId(sec->pieces[i].hash);
         if ((shardId & (concurrency - 1)) == threadId)
           sec->pieces[i].outputOff = shards[shardId].add(sec->getData(i));
       }

lld/ELF/Writer.cpp

 computeHash(llvm::MutableArrayRef<uint8_t> hashBuf,
             llvm::ArrayRef<uint8_t> data,
             std::function<void(uint8_t *dest, ArrayRef<uint8_t> arr)> hashFn) {
   std::vector<ArrayRef<uint8_t>> chunks = split(data, 1024 * 1024);
   const size_t hashesSize = chunks.size() * hashBuf.size();
   std::unique_ptr<uint8_t[]> hashes(new uint8_t[hashesSize]);
 
   // Compute hash values.
-  parallelForEachN(0, chunks.size(), [&](size_t i) {
+  parallelFor(0, chunks.size(), [&](size_t i) {
     hashFn(hashes.get() + i * hashBuf.size(), chunks[i]);
   });
 
   // Write to the final output buffer.
   hashFn(hashBuf.data(), makeArrayRef(hashes.get(), hashesSize));
 }
 
 template <class ELFT> void Writer<ELFT>::writeBuildId() {

lld/MachO/ICF.cpp

void ICF::forEachClass(llvm::function_ref<void(size_t, size_t)> func) {
   // Shard into non-overlapping intervals, and call FUNC in parallel.  The
   // sharding must be completed before any calls to FUNC are made so that FUNC
   // can modify the InputSection in its shard without causing data races.
   const size_t shards = 256;
   size_t step = icfInputs.size() / shards;
   size_t boundaries[shards + 1];
   boundaries[0] = 0;
   boundaries[shards] = icfInputs.size();
-  parallelForEachN(1, shards, [&](size_t i) {
+  parallelFor(1, shards, [&](size_t i) {
     boundaries[i] = findBoundary((i - 1) * step, icfInputs.size());
   });
-  parallelForEachN(1, shards + 1, [&](size_t i) {
+  parallelFor(1, shards + 1, [&](size_t i) {
     if (boundaries[i - 1] < boundaries[i]) {
       forEachClassRange(boundaries[i - 1], boundaries[i], func);
     }
   });
   ++icfPass;
 }
 
 void ICF::run() {

lld/MachO/MapFile.cpp

 }
 
 // Construct a map from symbols to their stringified representations.
 // Demangling symbols (which is what toString() does) is slow, so
 // we do that in batch using parallel-for.
 static DenseMap<Symbol *, std::string>
 getSymbolStrings(ArrayRef<Defined *> syms) {
   std::vector<std::string> str(syms.size());
-  parallelForEachN(0, syms.size(), [&](size_t i) {
+  parallelFor(0, syms.size(), [&](size_t i) {
     raw_string_ostream os(str[i]);
     Defined *sym = syms[i];
 
     switch (sym->isec->kind()) {
     case InputSection::CStringLiteralKind: {
       // Output "literal string: <string literal>"
       const auto *isec = cast<CStringInputSection>(sym->isec);
       const StringPiece &piece = isec->getStringPiece(sym->value);

lld/MachO/UnwindInfoSection.cpp

 }
 
 // We need to apply the relocations to the pre-link compact unwind section
 // before converting it to post-link form. There should only be absolute
 // relocations here: since we are not emitting the pre-link CU section, there
 // is no source address to make a relative location meaningful.
 void UnwindInfoSectionImpl::relocateCompactUnwind(
     std::vector<CompactUnwindEntry> &cuEntries) {
-  parallelForEachN(0, symbolsVec.size(), [&](size_t i) {
+  parallelFor(0, symbolsVec.size(), [&](size_t i) {
     CompactUnwindEntry &cu = cuEntries[i];
     const Defined *d = symbolsVec[i].second;
     cu.functionAddress = d->getVA();
     if (!d->unwindEntry)
       return;
 
     // If we have DWARF unwind info, create a CU entry that points to it.
     if (d->unwindEntry->getName() == section_names::ehFrame) {

lld/wasm/MapFile.cpp

 }
 
 // Construct a map from symbols to their stringified representations.
 // Demangling symbols (which is what toString() does) is slow, so
 // we do that in batch using parallel-for.
 static DenseMap<Symbol *, std::string>
 getSymbolStrings(ArrayRef<Symbol *> syms) {
   std::vector<std::string> str(syms.size());
-  parallelForEachN(0, syms.size(), [&](size_t i) {
+  parallelFor(0, syms.size(), [&](size_t i) {
     raw_string_ostream os(str[i]);
     auto *chunk = syms[i]->getChunk();
     if (chunk == nullptr)
       return;
     uint64_t fileOffset = chunk->outputSec != nullptr
                               ? chunk->outputSec->getOffset() + chunk->outSecOff
                               : 0;
     uint64_t vma = -1;

llvm/include/llvm/Support/Parallel.h

#if LLVM_ENABLE_THREADS
   if (parallel::strategy.ThreadsRequested != 1) {
     parallel::detail::parallel_sort(Start, End, Comp);
     return;
   }
 #endif
   llvm::sort(Start, End, Comp);
 }
 
-void parallelForEachN(size_t Begin, size_t End, function_ref<void(size_t)> Fn);
+void parallelFor(size_t Begin, size_t End, function_ref<void(size_t)> Fn);
 
 template <class IterTy, class FuncTy>
 void parallelForEach(IterTy Begin, IterTy End, FuncTy Fn) {
-  parallelForEachN(0, End - Begin, [&](size_t I) { Fn(Begin[I]); });
+  parallelFor(0, End - Begin, [&](size_t I) { Fn(Begin[I]); });
 }
 
 template <class IterTy, class ResultTy, class ReduceFuncTy,
           class TransformFuncTy>
 ResultTy parallelTransformReduce(IterTy Begin, IterTy End, ResultTy Init,
                                  ReduceFuncTy Reduce,
                                  TransformFuncTy Transform) {
 #if LLVM_ENABLE_THREADS

llvm/lib/DebugInfo/PDB/Native/GSIStreamBuilder.cpp

void GSIStreamBuilder::finalizeGlobalBuckets(uint32_t RecordZeroOffset) {
   }
 
   GSH->finalizeBuckets(RecordZeroOffset, Records);
 }
 
 void GSIHashStreamBuilder::finalizeBuckets(
     uint32_t RecordZeroOffset, MutableArrayRef<BulkPublic> Records) {
   // Hash every name in parallel.
-  parallelForEachN(0, Records.size(), [&](size_t I) {
+  parallelFor(0, Records.size(), [&](size_t I) {
     Records[I].setBucketIdx(hashStringV1(Records[I].Name) % IPHR_HASH);
   });
 
   // Count up the size of each bucket. Then, use an exclusive prefix sum to
   // calculate the bucket start offsets. This is C++17 std::exclusive_scan, but
   // we can't use it yet.
   uint32_t BucketStarts[IPHR_HASH] = {0};
   for (const BulkPublic &P : Records)
void GSIHashStreamBuilder::finalizeBuckets(
   }
 
   // Within the buckets, sort each bucket by memcmp of the symbol's name.  It's
   // important that we use the same sorting algorithm as is used by the
   // reference implementation to ensure that the search for a record within a
   // bucket can properly early-out when it detects the record won't be found.
   // The algorithm used here corresponds to the function
   // caseInsensitiveComparePchPchCchCch in the reference implementation.
-  parallelForEachN(0, IPHR_HASH, [&](size_t I) {
+  parallelFor(0, IPHR_HASH, [&](size_t I) {
     auto B = HashRecords.begin() + BucketStarts[I];
     auto E = HashRecords.begin() + BucketCursors[I];
     if (B == E)
       return;
     auto BucketCmp = [Records](const PSHashRecord &LHash,
                                const PSHashRecord &RHash) {
       const BulkPublic &L = Records[uint32_t(LHash.Off)];
       const BulkPublic &R = Records[uint32_t(RHash.Off)];

llvm/lib/Support/Parallel.cpp

void TaskGroup::spawn(std::function<void()> F) {
   }
 }
 
 } // namespace detail
 } // namespace parallel
 } // namespace llvm
 #endif // LLVM_ENABLE_THREADS
 
-void llvm::parallelForEachN(size_t Begin, size_t End,
-                            llvm::function_ref<void(size_t)> Fn) {
+void llvm::parallelFor(size_t Begin, size_t End,
   // If we have zero or one items, then do not incur the overhead of spinning up
   // a task group.  They are surprisingly expensive, and because they do not
   // support nested parallelism, a single entry task group can block parallel
   // execution underneath them.
 #if LLVM_ENABLE_THREADS
   auto NumItems = End - Begin;
   if (NumItems > 1 && parallel::strategy.ThreadsRequested != 1) {
     // Limit the number of tasks to MaxTasksPerGroup to limit job scheduling

llvm/unittests/Support/ParallelTest.cpp

 }
 
 TEST(Parallel, parallel_for) {
   // We need to test the case with a TaskSize > 1. We are white-box testing
   // here. The TaskSize is calculated as (End - Begin) / 1024 at the time of
   // writing.
   uint32_t range[2050];
   std::fill(range, range + 2050, 1);
-  parallelForEachN(0, 2049, [&range](size_t I) { ++range[I]; });
+  parallelFor(0, 2049, [&range](size_t I) { ++range[I]; });
 
   uint32_t expected[2049];
   std::fill(expected, expected + 2049, 2);
   ASSERT_TRUE(std::equal(range, range + 2049, expected));
   // Check that we don't write past the end of the requested range.
   ASSERT_EQ(range[2049], 1u);
 }
 

mlir/docs/Diagnostics.md

 A simple example is shown below:
 
 ```c++
 MLIRContext *context = ...;
 ParallelDiagnosticHandler handler(context);
 
 // Process a list of operations in parallel.
 std::vector<Operation *> opsToProcess = ...;
-llvm::parallelForEachN(0, opsToProcess.size(), [&](size_t i) {
+llvm::parallelFor(0, opsToProcess.size(), [&](size_t i) {
   // Notify the handler that we are processing the i'th operation.
   handler.setOrderIDForThread(i);
   auto *op = opsToProcess[i];
   ...
 
   // Notify the handler that we are finished processing diagnostics on this
   // thread.
   handler.eraseOrderIDForThread();
 });
 ```

mlir/include/mlir/IR/Threading.h

 }
 
 /// Invoke the given function on the elements between [begin, end)
 /// asynchronously. Diagnostics emitted during processing are ordered relative
 /// to the element's position within [begin, end). If the provided context does
 /// not have multi-threading enabled, this function always processes elements
 /// sequentially.
 template <typename FuncT>
-void parallelForEachN(MLIRContext *context, size_t begin, size_t end,
-                      FuncT &&func) {
+void parallelFor(MLIRContext *context, size_t begin, size_t end, FuncT &&func) {
   parallelForEach(context, llvm::seq(begin, end), std::forward<FuncT>(func));
 }
 
 } // namespace mlir
 
 #endif // MLIR_IR_THREADING_H