Originally posted by: prashanw

I have a large MIP problem. The number variables, constraints are 

num_variables for original problem :       1,999,292
num_constraints for original problem :  17,694,849

I also warm start my MIP with an initial solution. I tried running with parallel=[deterministic, opportunistic] and the optimizer seems to select whatever number of threads that are available.

But when I optimize I see that the optimization doesn't move further than the provided solution. Since I have set a 2 hour time limit the solving finishes after 2 hours and exits with the same solution. How can I get it to search more??  should I turn on/off the presolve, aggregator or any other thing.

I run the MIP on a cluster. So I can get 50-300GB memory. Thus memory is not a constraint. In fact I monitor the amount of memory the problem takes and it takes about 25 GB. I have a large number of cores (50 cores) I am not exactly sure whether uses all 50. It says its using 32 threads but I suspect that cplex saying that it uses 32 thread is not equal to running on 32 cores.

The log is given below. Any help is greatly appreciated!

1 of 1 MIP starts provided solutions.
MIP start 'm1' defined initial solution with objective 337000.0015.
MIP emphasis: balance optimality and feasibility.
MIP search method: dynamic search.
Parallel mode: deterministic, using up to 32 threads.
Root relaxation solution time = 6812.46 sec. (1486055.81 ticks)

        Nodes                                         Cuts/
   Node  Left     Objective  IInf  Best Integer    Best Bound    ItCnt     Gap

*     0+    0                       337000.0015        0.0000   131711  100.00%
      0     0  -1.00000e+37     0   337000.0015        0.0000   131711  100.00%

Root node processing (before b&c):
  Real time             = 6823.97 sec. (1490629.74 ticks)
Parallel b&c, 32 threads:
  Real time             =    0.00 sec. (0.00 ticks)
  Sync time (average)   =    0.00 sec.
  Wait time (average)   =    0.00 sec.
                          ------------
Total (root+branch&cut) = 6823.97 sec. (1490629.74 ticks)
cumulative_objective []
cb.incobjval []
cb.bestobjval []

stop minimization iteration:  1 , type:  non_alternating , time elapsed:  7233.88
Solution value  =  337000.001503

I tried playing around with the MIP paramters too. The current state thats giving me results (for a smaller data set is below). The saller dataset is 200 poaints. The larger one(which gets stuck) is 500points.

def set_MIP_run_parameters(my_prob):
    time_limit,tl=True,5*60*60  
    emphasis,emp=True,0
    max_num_sol,sol=False,1
    max_search_nodes,n=False,3
    aggregator_flag,agg=False,0
    #tolerances
    tolerane_flag,tolerance_value=True,0
    Integrality,i_value=True,0
    numerical_precision,numerical_precision_value=True,1    
    #presolve
    presolve_ignore,presolve_value=True,0
    #warm start related
    advance_start,advance_start_value=False,1
    repair_tries,repair_tries_value=True,10
    #conflicts
    conflict_display,conflict_value=False,2
    #parallel
    parallel_mode,parallel_mode_value=True,9
    #display
    display_interval,display_interval_value=True,1
    
   
    
    
    parameter_str=''
    
    if time_limit==True:
        my_prob.parameters.timelimit.set(tl)
        parameter_str+='time_limit= '+str(tl)+'s | '
    if emphasis==True:
        my_prob.parameters.emphasis.mip.set(emp)
        parameter_str+='emphasis= '+str(emp)+' | ' 
    if max_num_sol==True:
        my_prob.parameters.mip.limits.solutions.set(sol)
        parameter_str+='max_num_sol= '+str(sol)+' | ' 
    if max_search_nodes==True:
        my_prob.parameters.mip.limits.nodes.set(n)
        parameter_str+='max_search_nodes= '+str(n)+' | '
    if aggregator_flag==True:   
        my_prob.parameters.preprocessing.aggregator.set(agg)
    if tolerane_flag==True:          
        my_prob.parameters.mip.tolerances.absmipgap.set(tolerance_value)
        my_prob.parameters.mip.tolerances.mipgap.set(tolerance_value)
    if Integrality==True:
        my_prob.parameters.mip.tolerances.integrality.set(i_value)
    if presolve_ignore==True:
        my_prob.parameters.preprocessing.presolve.set(presolve_value)
    if advance_start==True:
        my_prob.parameters.advance.set(advance_start_value) 
    if repair_tries==True:
        my_prob.parameters.mip.limits.repairtries.set(repair_tries_value) 
    if conflict_display==True:
        my_prob.parameters.conflict.display.set(conflict_value)        
    if numerical_precision==True:
        my_prob.parameters.emphasis.numerical.set(numerical_precision_value)  
    if parallel_mode==True:
        my_prob.parameters.parallel.set(-1) #  opportunistic parallel search mode
        #my_prob.parameters.threads.set(parallel_mode_value)  
    if display_interval==True:
        my_prob.parameters.mip.interval.set(display_interval_value)
     
    return parameter_str

Is this the same as this thread?

Originally posted by: prashanw

yes it is.Thanks!