/home/coin/SVN-release/OS-2.1.0/Bcp/src/LP/BCP_lp_main.cpp

Go to the documentation of this file.
00001 // Copyright (C) 2000, International Business Machines
00002 // Corporation and others.  All Rights Reserved.
00003 #include <cfloat>
00004 #include <cerrno>
00005 #ifdef _MSC_VER
00006 #include <process.h>
00007 #endif 
00008 
00009 #include "CoinTime.hpp"
00010 
00011 #include "BcpConfig.h"
00012 #include "BCP_os.hpp"
00013 
00014 #include "BCP_USER.hpp"
00015 #include "BCP_buffer.hpp"
00016 #include "BCP_problem_core.hpp"
00017 #include "BCP_lp_node.hpp"
00018 #include "BCP_lp.hpp"
00019 #include "BCP_main_fun.hpp"
00020 #include "BCP_lp_functions.hpp"
00021 #include "BCP_lp_user.hpp"
00022 
00023 #include "BCP_message.hpp"
00024 
00025 //#############################################################################
00026 
00027 void
00028 BCP_lp_process_core(BCP_lp_prob& p, BCP_buffer& buf)
00029 {
00030    p.core->unpack(buf);
00031 
00032    // create the core_as_change from core
00033    *p.core_as_change = *p.core;
00034 
00035    // create the core part of p.node
00036    const BCP_vec<BCP_var_core*>& bvars = p.core->vars;
00037    const int bvarnum = bvars.size();
00038    p.node->vars.reserve(std::max<int>(1000, 3 * bvarnum));
00039    if (bvarnum > 0) {
00040       BCP_vec<BCP_var*>& vars = p.node->vars;
00041       for (int i = 0; i < bvarnum; ++i) {
00042          vars.unchecked_push_back(new BCP_var_core(*bvars[i]));
00043       }
00044    }
00045 
00046    const BCP_vec<BCP_cut_core*>& bcuts = p.core->cuts;
00047    const int bcutnum = bcuts.size();
00048    p.node->cuts.reserve(std::max<int>(1000, 3 * bcutnum));
00049    if (bcutnum > 0) {
00050       BCP_vec<BCP_cut*>& cuts = p.node->cuts;
00051       for (int i = 0; i < bcutnum; ++i) {
00052          cuts.unchecked_push_back(new BCP_cut_core(*bcuts[i]));
00053       }
00054    }
00055 }
00056 
00057 //#############################################################################
00058 
00059 BCP_process_t BCP_lp_main(BCP_message_environment* msg_env,
00060                           USER_initialize* user_init,
00061                           int my_id, int parent, double ub)
00062 {
00063    BCP_lp_prob p(my_id, parent);
00064    p.upper_bound = ub;
00065    p.msg_env = msg_env;
00066 
00067    // wait for the message with the parameters and unpack it
00068    p.msg_buf.clear();
00069    msg_env->receive(parent /*tree_manager*/,
00070                     BCP_Msg_ProcessParameters, p.msg_buf, -1);
00071    p.par.unpack(p.msg_buf);
00072    double wallclockInit;
00073    p.msg_buf.unpack(wallclockInit);
00074    p.msg_buf.unpack(p.start_time);
00075    CoinWallclockTime(wallclockInit);
00076 
00077    // Let us be nice
00078    setpriority(PRIO_PROCESS, 0, p.par.entry(BCP_lp_par::NiceLevel));
00079 
00080    FILE* logfile = 0;
00081 
00082    const BCP_string& log = p.par.entry(BCP_lp_par::LogFileName);
00083    if (! (p.par.entry(BCP_lp_par::LogFileName) == "")) {
00084       int len = log.length();
00085       char *logname = new char[len + 300];
00086       memcpy(logname, log.c_str(), len);
00087       memcpy(logname + len, "-lp-", 4);
00088       len += 4;
00089       gethostname(logname + len, 255);
00090       len = strlen(logname);
00091       logname[len++] = '-';
00092       sprintf(logname + len, "%i", static_cast<int>(GETPID));
00093       logfile = freopen(logname, "a", stdout);
00094       if (logfile == 0) {
00095          fprintf(stderr, "Error while redirecting stdout: %i\n", errno);
00096          throw BCP_fatal_error("");
00097       }
00098       setvbuf(logfile, NULL, _IOLBF, 0); // make it line buffered
00099       delete[] logname;
00100    } else {
00101       setvbuf(stdout, NULL, _IOLBF, 0); // make it line buffered
00102    }
00103 
00104    // now create the user universe
00105    p.user = user_init->lp_init(p);
00106    p.user->setLpProblemPointer(&p);
00107    p.packer = user_init->packer_init(p.user);
00108    p.packer->user_class = p.user;
00109 
00110    // wait for the core description and process it
00111    p.msg_buf.clear();
00112    p.msg_env->receive(parent /*tree_manager*/,
00113                       BCP_Msg_CoreDescription, p.msg_buf, -1);
00114    BCP_lp_process_core(p, p.msg_buf);
00115 
00116    // wait for the user info
00117    p.msg_buf.clear();
00118    msg_env->receive(parent /*tree_manager*/,
00119                     BCP_Msg_InitialUserInfo, p.msg_buf, -1);
00120    p.user->unpack_module_data(p.msg_buf);
00121 
00122    p.master_lp = p.user->initialize_solver_interface();
00123    p.user->initialize_int_and_sos_list(p.intAndSosObjects);
00124 
00125    // ok, we're all geared up to process search tree nodes
00126    // wait for messages and process them...
00127    BCP_message_tag msgtag;
00128    BCP_process_t ptype = BCP_ProcessType_EndProcess;
00129    while (true) {
00130       p.msg_buf.clear();
00131       msg_env->receive(BCP_AnyProcess,
00132                        BCP_Msg_AnyMessage, p.msg_buf, -1);
00133       msgtag = p.msg_buf.msgtag();
00134       if (msgtag == BCP_Msg_ProcessType) {
00135           p.msg_buf.unpack(ptype);
00136           break;
00137       }
00138       p.no_more_cuts_cnt = -1; // not waiting for cuts
00139       p.process_message();
00140       if (msgtag == BCP_Msg_FinishedBCP)
00141          break;
00142    }
00143 
00144    if (logfile)
00145       fclose(logfile);
00146 
00147    return ptype;
00148 }

Generated on Tue Mar 30 03:04:32 2010 by  doxygen 1.4.7