start_computation()

void SchreyerFrame::start_computation

(

StopConditions &

stop

)

Definition at line 262 of file res-schreyer-frame.cpp.

{
  // This is the computation of the non-minimal maps themselves
  decltype(timer()) timeA, timeB;
  //  if (level(0).size() == 0)
  //    mState = Done;;
  computeFrame();
  if (M2_gbTrace >= 1)
    {
      std::cout << "computation status after computing frame: " << std::endl;
      mComputationStatus.output();
    }
 
  int top_slanted_degree = mHiSlantedDegree;
  if (stop.stop_after_degree and mHiSlantedDegree > stop.degree_limit->array[0])
    top_slanted_degree = stop.degree_limit->array[0];
 
#if defined(WITH_TBB)
  // build the dependency graph
  if (mParallelizeByDegree)
  {
     //std::cout << "In dep graph" << std::endl;
     mScheduler.execute([&] {
        makeDependencyGraph(mDepGraph,
                            mMaxLength+1,
                            top_slanted_degree - mLoSlantedDegree + 1,
                            false);
        mDepGraph.startComputation();
        mDepGraph.waitForCompletion();
     });
     //std::cout << "Out dep graph" << std::endl;
   }
  else
    computeSyzygies(top_slanted_degree, mMaxLength);
#else
  computeSyzygies(top_slanted_degree, mMaxLength);
#endif
 
  if (M2_gbTrace >= 1)
    {
      showMemoryUsage();
      std::cout << "total time for make matrix: " << timeMakeMatrix
                << std::endl;
      std::cout << "total time for sort matrix: " << timeSortMatrix
                << std::endl;
      std::cout << "total time for reorder matrix: " << timeReorderMatrix
                << std::endl;
      std::cout << "total time for gauss matrix: " << timeGaussMatrix
                << std::endl;
      std::cout << "total time for clear matrix: " << timeClearMatrix
                << std::endl;
      std::cout << "total time for reset hash table: " << timeResetHashTable
                << std::endl;
      std::cout << "total time for computing ranks: " << timeComputeRanks
                << std::endl;
      std::cout << "total time for computing sparse ranks: " << timeComputeSparseRanks
                << std::endl;
    }
 
  return;
#if 0  
  if (M2_gbTrace >= 1)
    {
      std::cout << "computation status after computing syzygies: " << std::endl;
      mComputationStatus.output();
    }
  timeA = timer();
  computeRanks(mHiSlantedDegree, mMaxLength);
  timeB = timer();
  timeComputeRanks += seconds(timeB-timeA);
  if (M2_gbTrace >= 1)
    {
      std::cout << "computation status after computing ranks: " << std::endl;
      mComputationStatus.output();
    }
 
 
  // This next part needs to be computed after the frame, as otherwise mHiSlantedDegree isn't yet set.
  int top_slanted_degree = 0;
 
  top_slanted_degree = mHiSlantedDegree;
  if (stop.stop_after_degree and mHiSlantedDegree > stop.degree_limit->array[0])
    top_slanted_degree = stop.degree_limit->array[0];
 
  while (true)
    {
      switch (mState) {
      case Initializing:
        break;
      case Frame:
        std::cerr << "ERROR: should not get to this point anymore..." << std::endl;
        if (M2_gbTrace >= 1)
          std::cout << "maxsize = " << mFrame.mLevels.size() << " and mCurrentLevel = " << mCurrentLevel << std::endl;
        if (mCurrentLevel >= mFrame.mLevels.size() or computeNextLevel() == 0)
          {
            //show(6);
            mState = Matrices;
            mCurrentLevel = 2;
            getBounds(mLoSlantedDegree, mHiSlantedDegree, mMaxLength);
            mSlantedDegree = mLoSlantedDegree;
            setBettiDisplays();
            if (M2_gbTrace >= 1)
              {
                std::cout << "non-minimal betti: " << std::endl;
                mBettiNonminimal.output();
              }
            //for (int i=0; i<mMinimalizeTODO.size(); i++)
            //  {
            //     auto a = mMinimalizeTODO[i];
            //     std::cout << "(" << a.first << "," << a.second << ") ";
            //  }
            // std::cout << std::endl;
          }
        break;
      case Matrices:
        if (M2_gbTrace >= 1)
          std::cout << "start_computation: entering matrices(" << mSlantedDegree << ", " << mCurrentLevel << ")" << std::endl;
        if (stop.always_stop) return;
        
        if (mCurrentLevel > mMaxLength)
          {
            mCurrentLevel = 2;
            mSlantedDegree++;
            if (mSlantedDegree > top_slanted_degree)
              {
                if (M2_gbTrace >= 1)
                  showMemoryUsage();
#if 0                
                debugCheckOrderAll();
#endif
                timeA = timer();
                for (auto it=mMinimalizeTODO.cbegin(); it != mMinimalizeTODO.cend(); ++it)
                  {
                    int rk = rank(it->first, it->second);
                    mBettiMinimal.entry(it->first, it->second) -= rk;
                    mBettiMinimal.entry(it->first+1, it->second-1) -= rk;
                  }
                timeB = timer();
                timeComputeRanks += seconds(timeB-timeA);
                mState = Done;
                if (M2_gbTrace >= 1)
                  mBettiMinimal.output();
                 break;
              }
            //            if (stop.stop_after_degree and mSlantedDegree > stop.degree_limit->array[0])
            //              return;
          }
        if (M2_gbTrace >= 2)
          {
            std::cout << "construct(" << mSlantedDegree << ", " << mCurrentLevel << ")..." << std::endl;
          }
        mComputer->construct(mCurrentLevel, mSlantedDegree+mCurrentLevel);
        if (M2_gbTrace >= 2)
            std::cout << "done" << std::endl;
        mCurrentLevel++;
        break;
      case Done:
        if (M2_gbTrace >= 1)
          {
            std::cout << "total time for make matrix: " << timeMakeMatrix << std::endl;
            std::cout << "total time for sort matrix: " << timeSortMatrix << std::endl;
            std::cout << "total time for reorder matrix: " << timeReorderMatrix << std::endl;
            std::cout << "total time for gauss matrix: " << timeGaussMatrix << std::endl;
            std::cout << "total time for clear matrix: " << timeClearMatrix << std::endl;
            std::cout << "total time for reset hash table: " << timeResetHashTable << std::endl; 
            std::cout << "total time for computing ranks: " << timeComputeRanks << std::endl;
          }
        return;
      default:
        break;
      }
    }
#endif
}

References StopConditions::always_stop, computeFrame(), computeNextLevel(), computeRanks(), computeSyzygies(), debugCheckOrderAll(), StopConditions::degree_limit, Done, getBounds(), Initializing, M2_gbTrace, makeDependencyGraph(), Matrices, mBettiMinimal, mBettiNonminimal, mComputationStatus, mComputer, mCurrentLevel, mFrame, mHiSlantedDegree, mLoSlantedDegree, mMaxLength, mMinimalizeTODO, mParallelizeByDegree, mSlantedDegree, mState, rank(), seconds(), setBettiDisplays(), showMemoryUsage(), StopConditions::stop_after_degree, timeClearMatrix, timeComputeRanks, timeComputeSparseRanks, timeGaussMatrix, timeMakeMatrix, timer(), timeReorderMatrix, timeResetHashTable, and timeSortMatrix.