static void
initnodeobjvalinfo (CPXENVptr env, CPXLPptr lp, CUTINFOptr cutinfo)
{
cutinfo->nodeid = -1;
cutinfo->nodeobjval = 0.0;
cutinfo->objsen = CPXXgetobjsen (env, lp);
if ( cutinfo->objsen == CPX_MIN )
cutinfo->objsen = 1;
else
cutinfo->objsen = -1;
} /* END initnodeobjvalinfo */
int
main (int argc, char **argv)
{
CPXENVptr env = NULL;
CPXLPptr lp = NULL;
char errbuf[CPXMESSAGEBUFSIZE];
int status = 0;
char const *vmconfig = NULL;
char const *model = NULL;
double objval;
LOGINFO myloginfo;
#ifdef USE_MPI
MPI_Init (&argc, &argv);
#endif
if ( argc != 3 ) {
usage (argv[0]);
return -1;
}
vmconfig = argv[1];
model = argv[2];
/* Create a new CPLEX environment for each problem to solve.
*/
env = CPXXopenCPLEX (&status);
if ( env == NULL || status != 0 ) {
fprintf (stderr, "Failed to open CPLEX: %s\n",
CPXXgeterrorstring (NULL, status, errbuf));
goto TERMINATE;
}
/* Load a virtual machine configuration.
*/
status = CPXXreadcopyvmconfig (env, vmconfig);
if ( status != 0 ) {
fprintf (stderr, "Failed to load VMC %s: %s\n",
vmconfig, CPXXgeterrorstring (env, status, errbuf));
goto TERMINATE;
}
/* Create and input a problem.
*/
lp = CPXXcreateprob (env, &status, model);
if ( lp == NULL || status != 0 ) {
fprintf (stderr, "Failed to create problem: %s\n",
CPXXgeterrorstring (env, status, errbuf));
goto TERMINATE;
}
status = CPXXreadcopyprob (env, lp, model, NULL);
if ( status != 0 ) {
fprintf (stderr, "Failed to read problem %s: %s\n",
model, CPXXgeterrorstring (env, status, errbuf));
goto TERMINATE;
}
/* Turn off CPLEX logging.
*/
status = CPXXsetintparam (env, CPXPARAM_MIP_Display, 0);
if ( status ) goto TERMINATE;
/* Install an incumbent callback for logging.
*/
status = CPXXgettime (env, &myloginfo.timestart);
if ( status ) {
fprintf (stderr, "Failed to query time.\n");
goto TERMINATE;
}
status = CPXXgetdettime (env, &myloginfo.dettimestart);
if ( status ) {
fprintf (stderr, "Failed to query deterministic time.\n");
goto TERMINATE;
}
myloginfo.numcols = CPXXgetnumcols (env, lp);
myloginfo.lastincumbent = CPXXgetobjsen (env, lp) * 1e+35;
myloginfo.lastdettime = -10000.0;
status = CPXXsetinfocallbackfunc (env, logcallback, &myloginfo);
if ( status ) {
fprintf (stderr, "Failed to set logging callback function.\n");
goto TERMINATE;
}
/* Solve the problem using parallel distributed MIP.
*/
status = CPXXdistmipopt (env, lp);
if ( status != 0 ) {
fprintf (stderr, "Failed to optimize: %s\n",
CPXXgeterrorstring (env, status, errbuf));
goto TERMINATE;
}
/* Print some solution information.
*/
status = CPXXgetobjval (env, lp, &objval);
if ( status == CPXERR_NO_SOLN ) {
printf ("No solution available.\n");
}
else if ( status == 0 ) {
printf ("Solution value %f\n", objval);
}
else {
fprintf (stderr, "Error %d: %s\n", status,
CPXXgeterrorstring (env, status, errbuf));
}
printf ("Solution status %d\n", CPXXgetstat (env, lp));
TERMINATE:
CPXXfreeprob (env, &lp);
CPXXcloseCPLEX (&env);
#ifdef USE_MPI
CPXXfinalizeMPIworkers (-1, NULL, 0, NULL, 1);
MPI_Finalize ();
#endif
return status;
}
int
main(int argc, char **argv)
{
int status;
CPXENVptr *env;
CPXLPptr *lp;
char const *modelfile = NULL;
CPXASYNCptr *handle;
CPXENVGROUPptr group;
int i;
int jobs = 0;
int active;
int *finished;
char const **machine;
char cwd[MAX_PATH_LEN];
char usrfunc[MAX_PATH_LEN];
int frequency;
double absgap = 1e-6;
int bestidx;
CPXDIM c, cols;
double *x;
enum {
OUTPUT_SILENT, OUTPUT_PREFIXED, OUTPUT_LOG
} output = OUTPUT_SILENT;
#if defined(USE_MPI)
int numprocs, rank;
MPI_Init(&argc, &argv);
MPI_Comm_size (MPI_COMM_WORLD, &numprocs);
if ( numprocs < 3 ) {
fprintf (stderr, "Invalid number of processors (%d)\n", numprocs);
abort ();
}
MPI_Comm_rank (MPI_COMM_WORLD, &rank);
if ( rank != 0 ) {
fprintf (stderr, "Master must have rank 0!\n");
MPI_Finalize ();
abort ();
}
machine = malloc (sizeof (*machine) * numprocs);
if ( machine == NULL ) {
fprintf (stderr, "Out of memory!\n");
abort ();
}
for (i = 0; i < numprocs; ++i)
machine[i] = "mpimachine";
jobs = numprocs - 1;
#elif defined(USE_PROCESS)
char const *bin = "./cplex";
machine = malloc (sizeof (*machine) * argc);
if ( machine == NULL ) {
fprintf (stderr, "Out of memory!\n");
abort ();
}
#elif defined(USE_TCPIP)
machine = malloc (sizeof (*machine) * argc);
if ( machine == NULL ) {
fprintf (stderr, "Out of memory!\n");
abort ();
}
#else
# error "No transport type selected"
#endif
/* Parse the command line. */
for (i = 1; i < argc; ++i) {
if ( strncmp (argv[i], "-model=", 7) == 0 )
modelfile = argv[i] + 7;
#if defined(USE_MPI)
#elif defined(USE_PROCESS)
else if ( strncmp (argv[i], "-machine=", 9) == 0 )
machine[jobs++] = argv[i] + 9;
else if ( strncmp (argv[i], "-bin=", 5) == 0 )
bin = argv[i] + 5;
#elif defined(USE_TCPIP)
else if ( strncmp (argv[i], "-address=", 9) == 0 )
machine[jobs++] = argv[i];
#endif
else if ( strncmp (argv[i], "-absgap=", 8) == 0 )
absgap = strtod (argv[i] + 8, NULL);
else if ( strcmp (argv[i], "-output-prefixed") == 0 )
output = OUTPUT_PREFIXED;
else if ( strcmp (argv[i], "-output-log") == 0 )
output = OUTPUT_LOG;
}
/* Validate arguments.
*/
if ( modelfile == NULL ) {
fprintf (stderr, "No model file specified with -model=<modelfile>\n");
abort ();
}
if ( jobs < 1 ) {
fprintf (stderr, "Invalid job count %d\n", jobs);
abort ();
}
/* Allocate working arrays. */
if ( (env = malloc (sizeof (*env) * jobs)) == NULL ||
(handle = malloc (sizeof (*handle) * jobs)) == NULL ||
(lp = malloc (sizeof (*lp) * jobs)) == NULL ||
(finished = calloc (jobs, sizeof (*finished))) == NULL ||
(remotestats = calloc (jobs, sizeof (*remotestats))) == NULL )
{
fprintf (stderr, "Out of memory!\n");
abort ();
}
/* Find the place at which to find the shared object that implements
* the user function. On Windows the path to the current directory is
* likely to contain blanks, so better quote it.
*/
getcwd (cwd, sizeof (cwd));
usrfunc[0] = 0;
#ifdef _WIN32
strcat (usrfunc, "-libpath=\"");
strcat (usrfunc, cwd);
strcat (usrfunc, "\"");
#else
strcat (usrfunc, "-libpath=");
strcat (usrfunc, cwd);
#endif
/* Create a remote object instances. */
for (i = 0; i < jobs; ++i) {
/* These values define how we connect to the remote object. It is
* important to use a transport configuration that actually supports
* disconnect/reconnect. For the "processtransport" this means to use
* named pipes instead of anonymous pipes or stdio.
*/
char const *transport;
char const *args[16];
int nextarg = 0;
char *logpath = NULL;
#if defined(USE_MPI)
char rankbuf[256];
sprintf (rankbuf, "-remoterank=%d", i + 1);
transport = "mpitransport";
args[nextarg++] = rankbuf;
#elif defined(USE_PROCESS)
char logbuf[1024];
transport = "processtransport";
/* If the machine is not "localhost" then use ssh to connect to
* this machine. Otherwise just fork a process on the local
* machine.
*/
if ( machine[i] != NULL && strcmp (machine[i], "localhost") != 0 ) {
args[nextarg++] = "/usr/bin/ssh";
args[nextarg++] = machine[i];
}
args[nextarg++] = bin;
args[nextarg++] = "-worker=process";
if ( machine[i] != NULL )
args[nextarg++] = "-stdio";
else
args[nextarg++] = "-namedpipes=.";
args[nextarg++] = usrfunc;
args[nextarg++] = "-userfunction=parmipopt_userfunction=REGISTER_USERFUNCTION";
sprintf (logbuf, "-logfile=server%d.log", i);
if ( (args[nextarg] = logpath = strdup (logbuf)) != NULL )
++nextarg;
#elif defined(USE_TCPIP)
transport = "tcpiptransport";
args[nextarg++] = machine[i];
#endif
printf ("Creating env on %s\n", machine[i]);
env[i] = CPXXopenCPLEXremote(transport, nextarg, args, &status);
if ( status || env[i] == NULL ) {
fprintf (stderr, "CPXXopenCPLEXremote: %d\n", status);
abort ();
}
free (logpath);
/* Enable output */
switch (output) {
case OUTPUT_SILENT:
/* nothing */
break;
case OUTPUT_PREFIXED:
{
CPXCHANNELptr cres, cwar, cerr, clog;
if ( (status = CPXXgetchannels (env[i], &cres, &cwar, &cerr, &clog)) != 0 ) {
fprintf (stderr, "CPXXgetchannels: %d\n", status);
abort ();
}
if ( (status = CPXXaddfuncdest (env[i], cres, env[i], printer)) != 0 ||
(status = CPXXaddfuncdest (env[i], cwar, env[i], printer)) != 0 ||
(status = CPXXaddfuncdest (env[i], clog, env[i], printer)) != 0 )
{
fprintf (stderr, "CPXXaddfpdest: %d\n", status);
abort ();
}
}
break;
case OUTPUT_LOG:
{
if ( (status = CPXXsetintparam (env[i], CPXPARAM_ScreenOutput, CPX_ON)) != 0 ) {
fprintf (stderr, "CPXXgetchannels: %d\n", status);
abort ();
}
}
break;
}
/* Create empty problem object for this remote solver. */
printf ("Creating LP %d\n", i);
lp[i] = CPXXcreateprob(env[i], &status, "problem");
if ( status || lp[i] == NULL ) {
fprintf (stderr, "CPXXcreateprob: %d\n", status);
abort ();
}
/* Install and configure callbacks. */
remotestats[i].env = env[i];
remotestats[i].idx = i;
if ( (status = CPXXsetinfohandler (env[i], infohandler, &remotestats[i])) != 0 ) {
fprintf (stderr, "CPXXsetinfohandler: %d\n", status);
abort ();
}
if ( (status = changeObjdiff (env[i], 1e-5)) != 0 ) {
fprintf (stderr, "changeObjdiff: %d\n", status);
abort ();
}
if ( (status = installCallback (env[i])) != 0 ) {
fprintf (stderr, "installCallback: %d\n", status);
abort ();
}
/* Apply predefined perameter settings for this solver. */
applySettings (env[i], i);
}
/* Put all environments into one group so that we can use multicasts
* on operations that are the same for all solvers and/or imply lots
* of data exchange.
*/
status = CPXXcreateenvgroup (&group, jobs, env);
if ( status != 0 ) {
fprintf (stderr, "CPXXcreateenvgroup: %d\n", status);
abort ();
}
/* Read the model into all remote solver. */
status = CPXXreadcopyprob_multicast (group, modelfile, NULL);
if ( status != 0 ) {
fprintf (stderr, "CPXXreadcopyprob_multicast: %d\n", status);
abort ();
}
objsen = CPXXgetobjsen (env[0], lp[0]);
/* We set the thread count for each solver to 1 so that we do not
* run into problems if multiple solves are performed on the same
* machine.
*/
status = CPXXsetintparam_multicast (group, CPXPARAM_Threads, 1);
if ( status != 0 ) {
fprintf (stderr, "CPXXsetintparam_multicast: %d\n", status);
abort ();
}
/* Start an asynchronous solve on each remote solver. */
for (i = 0; i < jobs; ++i) {
printf ("Solving %d\n", i);
if ( (status = CPXXmipopt_async (env[i], lp[i], &handle[i])) != 0 ) {
fprintf (stderr, "CPXXmipopt_async: %d\n", status);
abort ();
}
}
/* All solves are started. Loop until the stopping criterion is met. */
active = jobs;
frequency = 10000; /* Print current bounds every two seconds. */
while (active > 0) {
int running = 0;
/* Check if we shold stop all solves.
* We stop them if the absolute mipgap is reached.
*/
if ( primal.valid && dual.valid &&
((objsen == CPX_MIN && dual.bound + absgap >= primal.bound) ||
(objsen == CPX_MAX && dual.bound - absgap <= primal.bound)) )
{
printf ("Stopping criterion reached. Stopping all pending solves.\n");
for (i = 0; i < jobs; ++i) {
if ( !finished[i] )
CPXXasynckill (handle[i]);
}
break;
}
if ( --frequency == 0 ) {
printf ("dual=%f, primal=%f\n", dual.bound, primal.bound);
frequency = 10000;
}
/* Loop over all solvers and test if they are still running. */
for (i = 0; i < jobs; ++i) {
if ( finished[i] )
continue;
CPXXasynctest (handle[i], &running);
if ( !running ) {
/* The job is finished. We have a solution, so kill all
* others. */
int j;
--active;
finished[i] = 1;
printf ("First job (%d) is finished, killing the rest\n", i);
for (j = 0; j < jobs; ++j) {
if ( j != i )
CPXXasynckill (handle[j]);
}
break;
}
}
millisleep (10);
}
/* All solves have finished. Join them. */
for (i = 0; i < jobs; ++i) {
double obj = -CPX_INFBOUND;
int stat;
status = CPXXmipopt_join (&handle[i]);
if ( status ) {
fprintf (stderr, "CPXXmipopt_join: %d\n", status);
abort ();
}
status = CPXXgetobjval (env[i], lp[i], &obj);
if ( status == CPXERR_NO_SOLN ) {
/* No feasible solution found (yet) on this machine.
* Just set objective function to a very big value
*/
obj = (objsen == CPX_MIN) ? CPX_INFBOUND : -CPX_INFBOUND;
}
else if ( status ) {
fprintf (stderr, "CPXXgetobjval: %d\n", status);
abort ();
}
stat = CPXXgetstat (env[i], lp[i]);
printf ("Job %d: %f, stat %d\n", i, obj, stat);
printf ("\t%f, %f, %f\n", remotestats[i].dettime,
remotestats[i].dual, remotestats[i].primal);
if ( (status = removeCallback (env[i])) != 0 ) {
fprintf (stderr, "removeCallback: %d\n", status);
abort ();
}
}
/* Fetch the x vector from the solver that produced the best
* primal bound. */
bestidx = primal.idx;
cols = CPXXgetnumcols (env[bestidx], lp[bestidx]);
if ( (x = malloc (cols * sizeof (*x))) == NULL ) {
fprintf (stderr, "Out of memory!\n");
abort ();
}
status = CPXXgetx (env[bestidx], lp[bestidx], x, 0, cols - 1);
if ( status ) {
fprintf (stderr, "CPXXgetx: %d\n", status);
abort ();
}
printf ("Optimal solution:\n");
for (c = 0; c < cols; ++c)
printf ("x[%5d]: %f\n", c, x[c]);
free (x);
CPXXfreeenvgroup (&group);
/* Close the CPLEX objects in _reverse_ order. */
for (i = jobs - 1; i >= 0; --i)
CPXXcloseCPLEX (&env[i]);
free (remotestats);
free (env);
free (lp);
free (handle);
free (finished);
free ((char **)machine);
#ifdef USE_MPI
MPI_Finalize ();
#endif
return 0;
}
int
main (int argc, char *argv[])
{
int uselogcallback = 0;
LOGINFO myloginfo;
int usetimelimcallback = 0;
TIMELIMINFO mytimeliminfo;
int useterminate = 0;
volatile int terminator;
CPXENVptr env = NULL;
CPXLPptr lp = NULL;
int solstat;
int status = 0;
/* Check the command line arguments */
if (( argc != 3 ) ||
( strchr ("lta", argv[2][0]) == NULL ) ) {
usage (argv[0]);
goto TERMINATE;
}
switch (argv[2][0]) {
case 'l':
uselogcallback = 1;
break;
case 't':
usetimelimcallback = 1;
break;
case 'a':
useterminate = 1;
break;
default:
break;
}
/* Initialize the CPLEX environment */
env = CPXXopenCPLEX (&status);
/* If an error occurs, the status value indicates the reason for
failure. A call to CPXXgeterrorstring will produce the text of
the error message. Note that CPXXopenCPLEX produces no output,
so the only way to see the cause of the error is to use
CPXXgeterrorstring. For other CPLEX routines, the errors will
be seen if the CPXPARAM_ScreenOutput indicator is set to CPX_ON. */
if ( env == NULL ) {
char errmsg[CPXMESSAGEBUFSIZE];
fprintf (stderr, "Could not open CPLEX environment.\n");
CPXXgeterrorstring (env, status, errmsg);
fprintf (stderr, "%s", errmsg);
goto TERMINATE;
}
/* Turn on output to the screen */
status = CPXXsetintparam (env, CPXPARAM_ScreenOutput, CPX_ON);
if ( status ) {
fprintf (stderr,
"Failure to turn on screen indicator, error %d.\n", status);
goto TERMINATE;
}
/* Create the problem, using the filename as the problem name */
lp = CPXXcreateprob (env, &status, argv[1]);
/* A returned pointer of NULL may mean that not enough memory
was available or there was some other problem. In the case of
failure, an error message will have been written to the error
channel from inside CPLEX. In this example, the setting of
the parameter CPXPARAM_ScreenOutput causes the error message to
appear on stdout. Note that most CPLEX routines return
an error code to indicate the reason for failure. */
if ( lp == NULL ) {
fprintf (stderr, "Failed to create LP.\n");
goto TERMINATE;
}
/* Now read the file, and copy the data into the created lp */
status = CPXXreadcopyprob (env, lp, argv[1], NULL);
if ( status ) {
fprintf (stderr, "Failed to read and copy the problem data.\n");
goto TERMINATE;
}
if ( usetimelimcallback ) {
double t;
status = CPXXgettime (env, &t);
if ( status ) {
fprintf (stderr, "Failed to initialize timer.\n");
goto TERMINATE;
}
mytimeliminfo.acceptablegap = 10.0;
mytimeliminfo.aborted = 0;
mytimeliminfo.timestart = t;
mytimeliminfo.timelim = 1.0;
status = CPXXsetinfocallbackfunc (env, timelimcallback, &mytimeliminfo);
if ( status ) {
fprintf (stderr, "Failed to set time limit callback function.\n");
goto TERMINATE;
}
}
else if ( uselogcallback ) {
/* Set overall node limit in case callback conditions are not met */
status = CPXXsetcntparam (env, CPXPARAM_MIP_Limits_Nodes, 5000);
if ( status ) goto TERMINATE;
status = CPXXgettime (env, &myloginfo.timestart);
if ( status ) {
fprintf (stderr, "Failed to query time.\n");
goto TERMINATE;
}
status = CPXXgetdettime (env, &myloginfo.dettimestart);
if ( status ) {
fprintf (stderr, "Failed to query deterministic time.\n");
goto TERMINATE;
}
myloginfo.numcols = CPXXgetnumcols (env, lp);
myloginfo.lastincumbent = CPXXgetobjsen (env, lp) * 1e+35;
myloginfo.lastlog = -10000;
status = CPXXsetinfocallbackfunc (env, logcallback, &myloginfo);
if ( status ) {
fprintf (stderr, "Failed to set logging callback function.\n");
goto TERMINATE;
}
/* Turn off CPLEX logging */
status = CPXXsetintparam (env, CPXPARAM_MIP_Display, 0);
if ( status ) goto TERMINATE;
}
else if ( useterminate) {
status = CPXXsetterminate (env, &terminator);
if ( status ) {
fprintf (stderr, "Failed to set terminator.\n");
goto TERMINATE;
}
/* Typically, you would pass the terminator variable to
another thread or pass it to an interrupt handler,
and monitor for some event to occur. When it does,
set terminator to a non-zero value.
To illustrate its use without creating a thread or
an interrupt handler, terminate immediately by setting
terminator before the solve.
*/
terminator = 1;
}
/* Optimize the problem and obtain solution. */
status = CPXXmipopt (env, lp);
if ( status ) {
fprintf (stderr, "Failed to optimize MIP.\n");
goto TERMINATE;
}
solstat = CPXXgetstat (env, lp);
printf ("Solution status %d.\n", solstat);
TERMINATE:
/* Free up the problem as allocated by CPXXcreateprob, if necessary */
if ( lp != NULL ) {
int xstatus = CPXXfreeprob (env, &lp);
if ( xstatus ) {
fprintf (stderr, "CPXXfreeprob failed, error code %d.\n", xstatus);
status = xstatus;
}
}
/* Free up the CPLEX environment, if necessary */
if ( env != NULL ) {
int xstatus = CPXXcloseCPLEX (&env);
/* Note that CPXXcloseCPLEX produces no output,
so the only way to see the cause of the error is to use
CPXXgeterrorstring. For other CPLEX routines, the errors will
be seen if the CPXPARAM_ScreenOutput indicator is set to CPX_ON. */
if ( status ) {
char errmsg[CPXMESSAGEBUFSIZE];
fprintf (stderr, "Could not close CPLEX environment.\n");
CPXXgeterrorstring (env, status, errmsg);
fprintf (stderr, "%s", errmsg);
status = xstatus;
}
}
return (status);
} /* END main */
