parallelBuildF4Matrix()

void NCF4::parallelBuildF4Matrix ( const std::deque< Overlap > & overlapsToProcess )

private

Definition at line 510 of file NCF4.cpp.

{
  matrixReset();
 
  mColumnMonomials.rehash(pow(2, ceil(log2(mPreviousColumnMonomials.size()))));
 
  for (auto o : overlapsToProcess)
    {
      auto stillValid = std::get<3>(o);
      if (stillValid) preRowsFromOverlap(o);
    }
 
  struct ThreadData {
    RowsVector rowsVector;
    MemoryBlock* memoryBlock;
  };
 
  mtbb::enumerable_thread_specific<ThreadData> threadData([&](){  
      mtbb::queuing_mutex::scoped_lock myColumnLock(mColumnMutex);
      ThreadData data;
      data.memoryBlock = new MemoryBlock;
      mMemoryBlocks.push_back(data.memoryBlock);
      return data;
    });
 
  // can't do this loop as a range-based for loop since we are adding to it
  // during the for loop
  // process each element in mReducersTodo
 
  mtbb::parallel_for_each(mReducersTodo.begin(), mReducersTodo.end(),
      [&](const PreRow& prerow, PreRowFeeder& feeder)
      {
        auto& data = threadData.local();
        processPreRow(prerow,
                      data.rowsVector,
                      *data.memoryBlock,
                      &feeder);
      });
 
  // combine the thread local rows into mRows
  for (const auto& data : threadData)
  {
    mRows.reserve(mRows.size() + data.rowsVector.size());
    std::move(data.rowsVector.begin(),
              data.rowsVector.end(),
              std::back_inserter(mRows));
  }
 
  // WARNING: The feeder doesn't actually add things to mReducersTodo
  //          so in this algorithm there is now a disconnect between the
  //          sizes of mReducersTodo and mRows.
 
  int numReducersAtFirst = mReducersTodo.size();
  
  // this can be a parallel_for
  for (auto over : mOverlapsTodo)
    processPreRow(over,mOverlaps);  // this often adds new elements to mReducersTodo
 
  // this must (eventually) be a parallel_for_each
  // can't do this loop as a range-based for loop since we are adding
  // to mReducersTodo during the for loop
  for (int i=numReducersAtFirst ; i < mReducersTodo.size(); ++i)
    processPreRow(mReducersTodo[i],mRows); // this often adds new elements to mReducersTodo
 
  // Now we move the overlaps into mRows, and set mFirstOverlap.
  mFirstOverlap = mRows.size();
  for (int i=0; i < mOverlapsTodo.size(); ++i)
    {
      mRows.emplace_back(mOverlaps[i]);
      mReducersTodo.emplace_back(mOverlapsTodo[i]);
    }
}

References matrixReset(), mColumnMonomials, mColumnMutex, mFirstOverlap, mMemoryBlocks, mOverlaps, mOverlapsTodo, mPreviousColumnMonomials, mReducersTodo, mRows, preRowsFromOverlap(), and processPreRow().