Ignore:
Timestamp:
Jan 5, 2010 11:20:52 AM (10 years ago)
Author:
forrest
Message:

try and modularize threads

File:
1 edited

Legend:

Unmodified
Added
Removed
  • branches/sandbox/Cbc/src/CbcModel.cpp

    r1409 r1412  
    1212//#define CBC_DEBUG 1
    1313//#define CHECK_CUT_COUNTS
     14//#define CHECK_NODE
    1415//#define CHECK_NODE_FULL
    1516//#define NODE_LOG
     
    12061207                *feasible = false; // stop search
    12071208            }
     1209#if 0 // probably not needed def CBC_THREAD
     1210            if (master_) {
     1211                lockThread();
     1212                if (parallelMode() > 0) {
     1213                    while (master_->waitForThreadsInTree(0)) {
     1214                        lockThread();
     1215                        double dummyBest;
     1216                        tree_->cleanTree(this, -COIN_DBL_MAX, dummyBest) ;
     1217                        //unlockThread();
     1218                    }
     1219                }
     1220                master_->waitForThreadsInTree(2);
     1221                delete master_;
     1222                master_ = NULL;
     1223                masterThread_ = NULL;
     1224            }
     1225#endif
    12081226        }
    12091227    }
     
    33283346        if (tree_->empty()) {
    33293347#ifdef CBC_THREAD
    3330             if (parallelMode() > 0) {
     3348            if (parallelMode() > 0 && master_) {
    33313349                int anyLeft = master_->waitForThreadsInTree(0);
    3332                 if (!anyLeft)
     3350                if (!anyLeft) {
     3351                    master_->stopThreads(-1);
    33333352                    break;
     3353                }
    33343354            } else {
    33353355                break;
     
    35043524                        }
    35053525                        delete [] newSolution;
     3526#ifdef CBC_THREAD
     3527                        if (master_) {
     3528                            lockThread();
     3529                            if (parallelMode() > 0) {
     3530                                while (master_->waitForThreadsInTree(0)) {
     3531                                    lockThread();
     3532                                    double dummyBest;
     3533                                    tree_->cleanTree(this, -COIN_DBL_MAX, dummyBest) ;
     3534                                    //unlockThread();
     3535                                }
     3536                            } else {
     3537                                double dummyBest;
     3538                                tree_->cleanTree(this, -COIN_DBL_MAX, dummyBest) ;
     3539                            }
     3540                            master_->waitForThreadsInTree(2);
     3541                            delete master_;
     3542                            master_ = NULL;
     3543                            masterThread_ = NULL;
     3544                        }
     3545#endif
    35063546                        if (tree_->size()) {
    35073547                            double dummyBest;
     
    37313771#ifdef CBC_THREAD
    37323772        } else if (parallelMode() > 0) {
    3733             int anyLeft = master_->waitForThreadsInTree(1);
    3734             // may need to go round again
    3735             if (anyLeft)
    3736                 continue;
     3773            //lockThread();
     3774            //node = tree_->bestNode(cutoff) ;
     3775            // Possible one on tree worse than cutoff
     3776            if (true || !node || node->objectiveValue() > cutoff) {
     3777                assert (master_);
     3778                if (master_) {
     3779                    int anyLeft = master_->waitForThreadsInTree(1);
     3780                    // may need to go round again
     3781                    if (anyLeft) {
     3782                        continue;
     3783                    } else {
     3784                        master_->stopThreads(-1);
     3785                    }
     3786                }
     3787            }
     3788            //unlockThread();
    37373789        } else {
    37383790            // Deterministic parallel
     
    37933845    }
    37943846#ifdef CBC_THREAD
    3795     if (numberThreads_) {
     3847    if (master_) {
     3848        master_->stopThreads(-1);
    37963849        master_->waitForThreadsInTree(2);
    37973850        delete master_;
     
    53665419    delete eventHandler_ ;
    53675420    eventHandler_ = NULL ;
     5421#ifdef CBC_THREAD
     5422    // Get rid of all threaded stuff
     5423    delete master_;
     5424#endif
    53685425}
    53695426// Clears out as much as possible (except solver)
     
    74357492                    }
    74367493                }
     7494                unlockThread();
    74377495            }
    74387496            numberTries = 0 ;
     
    82208278    // Get rid of all threaded stuff
    82218279    if (master) {
    8222         master->stopThreads();
     8280        master->stopThreads(0);
    82238281        delete master;
    82248282    }
     
    1270712765                            continue;
    1270812766                        parameters[i-iChunk].solutionValue = heuristicValue;
     12767                        // Don't want a strategy object
     12768                        CbcStrategy * saveStrategy = strategy_;
     12769                        strategy_ = NULL;
    1270912770                        CbcModel * newModel = new CbcModel(*this);
     12771                        strategy_ = saveStrategy;
    1271012772                        assert (!newModel->continuousSolver_);
    1271112773                        if (continuousSolver_)
     
    1272512787                        newModel->numberHeuristics_ = 1;
    1272612788                    }
    12727                     CbcSimpleThread(nThisTime, 0, static_cast<int>(sizeof(argBundle)), parameters);
     12789                    void
     12790                    parallelHeuristics (int numberThreads,
     12791                                        int sizeOfData,
     12792                                        void * argBundle);
     12793                    parallelHeuristics(nThisTime,
     12794                                       static_cast<int>(sizeof(argBundle)),
     12795                                       parameters);
    1272812796                    double cutoff = heuristicValue;
    1272912797                    for (int i = 0; i < chunk; i++) {
     
    1308613154           node->nodeInfo()->numberBranchesLeft(),
    1308713155           node->nodeInfo()->numberPointingToThis()) ;
    13088     printf("\tdepth = %d, z =  %g, unsat = %d, var = %d.\n",
     13156    printf("\tdepth = %d, z =  %g, unsat = %d\n", //var = %d.\n",
    1308913157           node->depth(), node->objectiveValue(),
    13090            node->numberUnsatisfied(),
    13091            node->columnNumber()) ;
     13158           node->numberUnsatisfied());
     13159    //node->columnNumber()) ;
    1309213160#   endif
    1309313161
     
    1391013978        }
    1391113979        lockThread();
     13980        bool locked = true;
    1391213981        if (parallelMode() <= 0) {
    1391313982            if (numberUpdateItems_) {
     
    1398714056                    }
    1398814057                    unlockThread();
    13989 
     14058                    locked = false;
    1399014059                    double estValue = newNode->guessedObjectiveValue() ;
    1399114060                    int found = -1 ;
     
    1403414103                    delete [] newSolution ;
    1403514104                    newNode->setGuessedObjectiveValue(estValue) ;
    14036                     lockThread();
    1403714105                    if (parallelMode() >= 0) {
    1403814106                        if (!masterThread_) // only if serial
     
    1414714215            }
    1414814216        }
    14149         unlockThread();
     14217        if (locked)
     14218            unlockThread();
    1415014219    } else {
    1415114220        // add cuts found to be infeasible (on bound)!
Note: See TracChangeset for help on using the changeset viewer.