gauss_reduce()

void F4GB::gauss_reduce ( bool diagonalize )

private

Definition at line 612 of file f4.cpp.

{
  // For each row which is a non-pivot row:
  //  note that the row must be reducible, since the lead term corresponds to an
  //  spair cancellation
  //   actually: not true: generators will often not be reducible...
  //  also each such row must be non-zero, for the same reason
  int nrows = INTSIZE(mat->rows);
  int ncols = INTSIZE(mat->columns);
 
  int n_newpivots = -1;  // the number of new GB elements in this degree
  std::atomic<long> n_zero_reductions = 0;
 
  mtbb::tick_count t0;
  mtbb::tick_count t1;
  std::vector<int> spair_rows;
 
  if (hilbert)
    {
      n_newpivots = hilbert->nRemainingExpected();
      if (n_newpivots == 0)
        {
          std::cout << "Oh crap, our logic is wrong: should not get here if no new GB elements expected in this degree" << std::endl;
          return;
        }
    }
 
  for (int i = 0; i < nrows; ++i)
    {
      if (not is_pivot_row(i))
        spair_rows.push_back(i);
    }
 
  t0 = mtbb::tick_count::now();
 
#if defined(WITH_TBB)
 
  std::mutex cout_guard;
  using threadLocalDense_t = mtbb::enumerable_thread_specific<ElementArray>;
  // create a dense array for each thread
  threadLocalDense_t threadLocalDense([&]() { 
    return mVectorArithmetic->allocateElementArray(ncols);
  });
  
  if (M2_gbTrace >= 2) {
    // TODO: where to display this info
    std::cout << "Number of Threads Used: " << mNumThreads << std::endl; 
  }
  
  mScheduler.execute([&] {
    mtbb::parallel_for(mtbb::blocked_range<int>{0, INTSIZE(spair_rows)},
                       [&](const mtbb::blocked_range<int>& r)
                       {
                         // long actual_reductions = 0;
                         //  for (auto i = r.begin(); i != r.end(); ++i)
                         //    {
                         //      if (not is_pivot_row(i))
                         //        ++ actual_reductions;
                         //    }
 
                         //  cout_guard.lock();
                         //  std::cout << "#reductions to do: " << actual_reductions << std::endl;
                         //  cout_guard.unlock();
 
                         threadLocalDense_t::reference my_dense = threadLocalDense.local();
                         for (auto i = r.begin(); i != r.end(); ++i)
                         {
                               bool newNonzeroReduction = gauss_reduce_row(spair_rows[i], my_dense);
                         }
                       });
  });
  for (auto tlDense : threadLocalDense)
    mVectorArithmetic->deallocateElementArray(tlDense);
 
#else
 
  ElementArray my_dense { mVectorArithmetic->allocateElementArray(ncols) };
 
  for (int i = 0; i < INTSIZE(spair_rows); ++i)
    gauss_reduce_row(spair_rows[i], my_dense);
 
  mVectorArithmetic->deallocateElementArray(my_dense);
 
#endif
 
  t1 = mtbb::tick_count::now();
  mParallelGaussTime += (t1-t0).seconds();
 
  if (M2_gbTrace >= 2)
    std::cout << "About to do serial loop, n_newpivots = " << n_newpivots << std::endl;
  t0 = mtbb::tick_count::now();
  ElementArray gauss_row { mVectorArithmetic->allocateElementArray(ncols) };
  for (auto i = 0; i < spair_rows.size(); i++)
    {
      auto this_row = spair_rows[i];
      if ((not hilbert) or (n_newpivots > 0))
      {
         bool newNonzeroReduction = gauss_reduce_row(this_row, gauss_row);
         if (newNonzeroReduction)
         {
            row_elem &r = mat->rows[this_row];
            mVectorArithmetic->makeMonic(r.coeffs);
            mat->columns[r.comps[0]].head = this_row;
            if (hilbert) --n_newpivots;
         }
         else
            ++n_zero_reductions;
      } else if (hilbert)
        {
          // Inform code that we don't want a new GB element from this row.
          // The row will be deleted with clear_matrix.
          row_elem &r = mat->rows[this_row];
          r.len = 0;
        }
    }
  mVectorArithmetic->deallocateElementArray(gauss_row);
  t1 = mtbb::tick_count::now();
  mSerialGaussTime += (t1-t0).seconds();
 
  if (M2_gbTrace >= 3)
    fprintf(stderr, "-- #zeroreductions %ld\n", n_zero_reductions.load());
 
  t0 = mtbb::tick_count::now();
  if (diagonalize) tail_reduce();
  t1 = mtbb::tick_count::now();
  mTailReduceTime += (t1-t0).seconds();
}

References row_elem::coeffs, row_elem::comps, gauss_reduce_row(), hilbert, INTSIZE, is_pivot_row(), row_elem::len, M2_gbTrace, mat, mParallelGaussTime, mSerialGaussTime, mTailReduceTime, mVectorArithmetic, seconds(), and tail_reduce().

Referenced by do_spairs().