00001
00002
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
00033 *p.core_as_change = *p.core;
00034
00035
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
00068 p.msg_buf.clear();
00069 msg_env->receive(parent ,
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
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);
00099 delete[] logname;
00100 } else {
00101 setvbuf(stdout, NULL, _IOLBF, 0);
00102 }
00103
00104
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
00111 p.msg_buf.clear();
00112 p.msg_env->receive(parent ,
00113 BCP_Msg_CoreDescription, p.msg_buf, -1);
00114 BCP_lp_process_core(p, p.msg_buf);
00115
00116
00117 p.msg_buf.clear();
00118 msg_env->receive(parent ,
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
00126
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;
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 }