Changeset 2370 for trunk


Ignore:
Timestamp:
Mar 31, 2018 12:45:28 PM (16 months ago)
Author:
forrest
Message:

changes for rays

Location:
trunk/Cbc/src
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/Cbc/src/CbcModel.cpp

    r2365 r2370  
    8585/* Various functions local to CbcModel.cpp */
    8686
     87typedef struct {
     88  double useCutoff;
     89  CbcModel * model;
     90  int switches;
     91} rootBundle;
    8792static void * doRootCbcThread(void * voidInfo);
    8893
     
    23692374    delete continuousSolver_;
    23702375    continuousSolver_ = solver_->clone() ;
     2376#ifdef CONFLICT_CUTS
     2377    if ((moreSpecialOptions_&4194304)!=0) {
     2378#ifdef COIN_HAS_CLP
     2379      OsiClpSolverInterface * clpSolver
     2380        = dynamic_cast<OsiClpSolverInterface *> (solver_);
     2381      if (clpSolver) {
     2382        int specialOptions=clpSolver->getModelPtr()->specialOptions();
     2383        // 2097152 switches on rays in crunch
     2384        if (!parentModel_)
     2385          clpSolver->getModelPtr()->setSpecialOptions(specialOptions|32|2097152);
     2386        else
     2387          clpSolver->getModelPtr()->setSpecialOptions(specialOptions&~(32|2097152));
     2388      }
     2389    }
     2390#endif
     2391#endif
    23712392#ifdef COIN_HAS_NTY
    23722393    // maybe allow on fix and restart later
     
    26362657#ifdef CBC_THREAD
    26372658      numberRootThreads = (multipleRootTries_/100)%100;
    2638       if (!numberRootThreads)
    2639         numberRootThreads=numberModels;
     2659      if (!numberRootThreads) {
     2660        if (numberThreads_<2)
     2661          numberRootThreads=numberModels;
     2662        else
     2663          numberRootThreads=CoinMin(numberThreads_,numberModels);
     2664      }
    26402665#endif
    26412666      int otherOptions = (multipleRootTries_/10000)%100;
     
    26652690        rootModels[i]->randomNumberGenerator()->setSeed(newSeed+50000000*i);
    26662691        rootModels[i]->setMultipleRootTries(0);
     2692#ifdef COIN_HAS_NTY
     2693        rootModels[i]->zapSymmetry();
     2694        rootModels[i]->moreSpecialOptions2_ &= ~(128|256); // off nauty
     2695#endif
    26672696        // use seed
    26682697        rootModels[i]->setSpecialOptions(specialOptions_ |(4194304|8388608));
     
    27292758      }
    27302759      delete basis;
     2760      char general[200];
     2761      /*
     2762        1 - bit set - first come first served
     2763        2 - bit set - pass on cutoffs (not deterministic if 1 set)
     2764       */
     2765#define MULTIPLE_TYPE 3
     2766#if MULTIPLE_TYPE == 1 || MULTIPLE_TYPE == 3
     2767#define FIRST_COME
     2768#endif
     2769#if MULTIPLE_TYPE == 2 || MULTIPLE_TYPE == 3
     2770#define SET_CUTOFF
     2771#endif
     2772#ifndef MAX_HEURISTIC_TIMES
     2773#define MAX_HEURISTIC_TIMES 16
     2774#endif
     2775#ifdef SET_CUTOFF
     2776      double bestCutoff = getCutoff();
     2777#endif
    27312778#ifdef CBC_THREAD
    27322779      if (numberRootThreads==1) {
    27332780#endif
    27342781        for (int iModel=0;iModel<numberModels;iModel++) {
    2735           doRootCbcThread(rootModels[iModel]);
     2782          rootBundle bundle;
     2783          bundle.useCutoff=COIN_DBL_MAX;
     2784          bundle.model=rootModels[iModel];
     2785          bundle.switches=0;
     2786#ifdef SET_CUTOFF
     2787          bundle.useCutoff=bestCutoff;
     2788          rootModels[iModel]->setCutoff(bestCutoff);
     2789#endif
     2790          doRootCbcThread(&bundle);
     2791          sprintf(general,"Ending multiple root solver %d out of %d",
     2792                  iModel+1,numberModels);
     2793          messageHandler()->message(CBC_GENERAL,messages())
     2794            << general << CoinMessageEol ;
     2795#ifdef SET_CUTOFF
     2796          if (rootModels[iModel]->getCutoff()<bestCutoff)
     2797            bestCutoff = rootModels[iModel]->getCutoff();
     2798#endif
    27362799          // see if solved at root node
    27372800          if (rootModels[iModel]->getMaximumNodes()) {
     
    27422805#ifdef CBC_THREAD
    27432806      } else {
     2807        // redone so can use numberThreads_ threads more efficiently
     2808        // but then if changing cutoff - not deterministic
     2809        // BUT changing cutoff has a bug (what bug - debug)
    27442810        Coin_pthread_t * threadId = new Coin_pthread_t [numberRootThreads];
    2745         for (int kModel=0;kModel<numberModels;kModel+=numberRootThreads) {
    2746           bool finished=false;
    2747           for (int iModel=kModel;iModel<CoinMin(numberModels,kModel+numberRootThreads);iModel++) {
    2748             pthread_create(&(threadId[iModel-kModel].thr), NULL,
    2749                            doRootCbcThread,
    2750                            rootModels[iModel]);
     2811        rootBundle * bundle = new rootBundle [numberRootThreads];
     2812        int numberDone=0;
     2813        int kModel=numberRootThreads;
     2814        for (int iModel=0;iModel<kModel;iModel++) {
     2815          threadId[iModel].status=1000+iModel;
     2816          bundle[iModel].useCutoff=COIN_DBL_MAX;
     2817          if (numberDone>=MAX_HEURISTIC_TIMES) {
     2818#ifdef SET_CUTOFF
     2819            bundle[iModel].useCutoff=bestCutoff;
     2820            rootModels[iModel]->setCutoff(bestCutoff);
     2821#endif
     2822            for (int i=0;i<rootModels[iModel]->numberHeuristics_;i++)
     2823              delete rootModels[iModel]->heuristic_[i];
     2824            delete [] rootModels[iModel]->heuristic_;
     2825            rootModels[iModel]->heuristic_=NULL;
     2826            numberHeuristics_=0;
    27512827          }
    2752           // wait
    2753           for (int iModel=kModel;iModel<CoinMin(numberModels,kModel+numberRootThreads);iModel++) {
    2754             pthread_join(threadId[iModel-kModel].thr, NULL);
     2828          bundle[iModel].model=rootModels[iModel];
     2829          bundle[iModel].switches=0;
     2830          pthread_create(&(threadId[iModel].thr), NULL,
     2831                         doRootCbcThread,
     2832                         bundle+iModel);
     2833        }
     2834        bool finished=false;
     2835        while (numberDone<numberModels) {
     2836#ifdef FIRST_COME
     2837          usleep(100000);
     2838#else
     2839          for (int iModel=0;iModel<numberRootThreads;iModel++) {
     2840            pthread_join(threadId[iModel].thr, NULL);
     2841#ifdef SET_CUTOFF
     2842            int jModel = static_cast<int>(threadId[iModel].status-1000);
     2843            if (rootModels[jModel]->getCutoff()<bestCutoff)
     2844              bestCutoff = rootModels[jModel]->getCutoff();
     2845#endif
    27552846          }
    2756           // see if solved at root node
    2757           for (int iModel=kModel;iModel<CoinMin(numberModels,kModel+numberRootThreads);iModel++) {
    2758             if (rootModels[iModel]->getMaximumNodes())
    2759               finished=true;
    2760           }
    2761           if (finished) {
    2762             feasible=false;
    2763             break;
     2847#endif
     2848          for (int iModel=0;iModel<numberRootThreads;iModel++) {
     2849            if (threadId[iModel].status>0) {
     2850              int jModel = static_cast<int>(threadId[iModel].status-1000);
     2851              if (rootModels[jModel]->secondaryStatus()==123456789) {
     2852#ifdef FIRST_COME
     2853                pthread_join(threadId[iModel].thr, NULL);
     2854#ifdef SET_CUTOFF
     2855                if (rootModels[jModel]->getCutoff()<bestCutoff)
     2856                  bestCutoff = rootModels[jModel]->getCutoff();
     2857#endif
     2858#endif
     2859                sprintf(general,"Ending multiple root solver %d (%d) out of %d",
     2860                        numberDone+1,jModel+1,numberModels);
     2861                messageHandler()->message(CBC_GENERAL,messages())
     2862                  << general << CoinMessageEol ;
     2863                if (rootModels[jModel]->getMaximumNodes()) {
     2864                  finished=true;
     2865                  numberDone += numberModels-kModel;
     2866                  kModel=numberModels;
     2867                }
     2868                numberDone++;
     2869                if (kModel<numberModels) {
     2870                  bundle[iModel].useCutoff=COIN_DBL_MAX;
     2871                  bundle[iModel].model=rootModels[kModel];
     2872                  bundle[iModel].switches=0;
     2873#ifdef SET_CUTOFF
     2874                  bundle[iModel].useCutoff=bestCutoff;
     2875#endif
     2876                  if (numberDone>=MAX_HEURISTIC_TIMES) {
     2877                    for (int i=0;i<rootModels[kModel]->numberHeuristics_;i++)
     2878                      delete rootModels[kModel]->heuristic_[i];
     2879                    delete [] rootModels[kModel]->heuristic_;
     2880                    rootModels[kModel]->heuristic_=NULL;
     2881                    rootModels[kModel]->numberHeuristics_=0;
     2882                  }
     2883                  threadId[iModel].status=1000+kModel;
     2884                  pthread_create(&(threadId[iModel].thr), NULL,
     2885                                 doRootCbcThread,
     2886                                 bundle+iModel);
     2887                  kModel++;
     2888                } else {
     2889                  threadId[iModel].status=-1;
     2890                }
     2891              }
     2892            }
    27642893          }
    27652894        }
     2895        // see if solved at root node
     2896        if (finished)
     2897          feasible=false;
    27662898        delete [] threadId;
     2899        delete [] bundle;
    27672900      }
    27682901#endif
     
    27782911        }
    27792912      }
    2780       char general[100];
    27812913      rootTimeCpu=CoinCpuTime()-rootTimeCpu;
    27822914      if (numberRootThreads==1)
     
    45454677#ifdef CONFLICT_CUTS
    45464678                // temporary
    4547                 if ((moreSpecialOptions_&4194304)!=0)
    4548                   tryNewSearch=false;
     4679                //if ((moreSpecialOptions_&4194304)!=0)
     4680                //tryNewSearch=false;
    45494681#endif
    45504682                if (tryNewSearch) {
     
    78878019
    78888020    numberOldActiveCuts_ = numberRowsAtStart - numberRowsAtContinuous_ ;
     8021#ifndef NDEBUG
     8022    {
     8023      int n=0;
     8024      for (int i=0;i<currentNumberCuts_;i++) {
     8025        if (addedCuts_[i])
     8026          n++;
     8027      }
     8028      assert (n==numberOldActiveCuts_);
     8029    }
     8030#endif
    78898031    numberNewCuts_ = cuts.sizeRowCuts();
    78908032    int lastNumberCuts = numberNewCuts_ ;
     
    1462714769#endif
    1462814770        clpSolver->resolve();
     14771#ifdef CHECK_RAY
     14772        static int nSolves=0;
     14773        static int nInfSolves=0;
     14774        static int nRays=0;
     14775        nSolves++;
     14776        if (!parentModel_&&clpSolver->getModelPtr()->problemStatus()==1
     14777            &&(clpSolver->getModelPtr()->specialOptions()&32)!=0) {
     14778          nInfSolves++;
     14779          if(clpSolver->getModelPtr()->infeasibilityRay())
     14780            nRays++;
     14781        }
     14782        if ((nSolves%1000)==0)
     14783          printf("ZZ %d solves, %d infeasible %d rays\n",
     14784                 nSolves,nInfSolves,nRays);
     14785#endif
    1462914786#ifdef CHECK_KNOWN_SOLUTION
    1463014787        if ((specialOptions_&1) != 0&&onOptimalPath) {
     
    1656216719                        incrementExtra(info->numberNodesExplored_,
    1656316720                                       info->numberIterations_);
    16564                         if (feasible) {
     16721                        if (feasible&&false) { // can mess up cuts
    1656516722                          double objValue=simplex->objectiveValue();
    1656616723                          feasible = solveWithCuts(cuts, 1, node);
     
    1914919306static void * doRootCbcThread(void * voidInfo)
    1915019307{
    19151     CbcModel * model = reinterpret_cast<CbcModel *> (voidInfo);
     19308    rootBundle * bundle = reinterpret_cast<rootBundle *>(voidInfo);
     19309    CbcModel * model = bundle->model;
     19310    if (bundle->useCutoff<model->getCutoff())
     19311      model->setCutoff(bundle->useCutoff);
    1915219312#ifdef COIN_HAS_CLP
    1915319313    OsiClpSolverInterface * clpSolver
  • trunk/Cbc/src/unitTestClp.cpp

    r2266 r2370  
    9999    return false;
    100100}
    101 
    102101//#############################################################################
    103102/*
     
    265264    PUSH_MPS("swath", 884, 6805, 497.603, 334.4968581, 7, false);
    266265    PUSH_MPS("vpm1", 234, 378, 20, 15.4167, 0, false);
     266    PUSH_MPS("vpm2", 234, 378, 13.75, 9.8892645972, 0, false);
    267267#endif
    268     PUSH_MPS("vpm2", 234, 378, 13.75, 9.8892645972, 0, false);
    269268  }
    270269#undef PUSH_MPS
     
    593592#ifdef CONFLICT_CUTS
    594593    {
    595       model->setCutoffAsConstraint(true);
     594      model->setCutoffAsConstraint(true); // very slow on bell5 ??
    596595      int moreOptions=model->moreSpecialOptions();
    597596      model->setMoreSpecialOptions(moreOptions|4194304);
Note: See TracChangeset for help on using the changeset viewer.