int
UtilTransactions::verifyOrderedIndex(Ndb* pNdb,
const NdbDictionary::Index* pIndex,
int parallelism,
bool transactional){
int retryAttempt = 0;
const int retryMax = 100;
int check;
NdbScanOperation *pOp;
NdbIndexScanOperation * iop = 0;
NDBT_ResultRow scanRow(tab);
NDBT_ResultRow pkRow(tab);
NDBT_ResultRow indexRow(tab);
const char * indexName = pIndex->getName();
int res;
parallelism = 1;
while (true){
if (retryAttempt >= retryMax){
g_info << "ERROR: has retried this operation " << retryAttempt
<< " times, failing!" << endl;
return NDBT_FAILED;
}
pTrans = pNdb->startTransaction();
if (pTrans == NULL) {
const NdbError err = pNdb->getNdbError();
if (err.status == NdbError::TemporaryError){
ERR(err);
NdbSleep_MilliSleep(50);
retryAttempt++;
continue;
}
ERR(err);
return NDBT_FAILED;
}
pOp = pTrans->getNdbScanOperation(tab.getName());
if (pOp == NULL) {
ERR(pTrans->getNdbError());
closeTransaction(pNdb);
return NDBT_FAILED;
}
if( pOp->readTuples(NdbScanOperation::LM_Read, 0, parallelism) ) {
ERR(pTrans->getNdbError());
closeTransaction(pNdb);
return NDBT_FAILED;
}
check = pOp->interpret_exit_ok();
if( check == -1 ) {
ERR(pTrans->getNdbError());
closeTransaction(pNdb);
return NDBT_FAILED;
}
if(get_values(pOp, scanRow))
{
abort();
}
check = pTrans->execute(NoCommit, AbortOnError);
if( check == -1 ) {
const NdbError err = pTrans->getNdbError();
if (err.status == NdbError::TemporaryError){
ERR(err);
closeTransaction(pNdb);
NdbSleep_MilliSleep(50);
retryAttempt++;
continue;
}
ERR(err);
closeTransaction(pNdb);
return NDBT_FAILED;
}
int eof;
int rows = 0;
while(check == 0 && (eof = pOp->nextResult()) == 0){
rows++;
bool null_found= false;
for(int a = 0; a<(int)pIndex->getNoOfColumns(); a++){
const NdbDictionary::Column * col = pIndex->getColumn(a);
if (scanRow.attributeStore(col->getName())->isNULL())
{
null_found= true;
break;
}
}
// Do pk lookup
NdbOperation * pk = pTrans->getNdbOperation(tab.getName());
if(!pk || pk->readTuple())
goto error;
if(equal(&tab, pk, scanRow) || get_values(pk, pkRow))
goto error;
if(!null_found)
{
if(!iop && (iop= pTrans->getNdbIndexScanOperation(indexName,
tab.getName())))
{
if(iop->readTuples(NdbScanOperation::LM_CommittedRead,
parallelism))
goto error;
iop->interpret_exit_ok();
if(get_values(iop, indexRow))
goto error;
}
else if(!iop || iop->reset_bounds())
{
goto error;
}
if(equal(pIndex, iop, scanRow))
goto error;
}
check = pTrans->execute(NoCommit, AbortOnError);
if(check)
goto error;
if(scanRow.c_str() != pkRow.c_str()){
g_err << "Error when comapring records" << endl;
g_err << " scanRow: \n" << scanRow.c_str().c_str() << endl;
g_err << " pkRow: \n" << pkRow.c_str().c_str() << endl;
closeTransaction(pNdb);
return NDBT_FAILED;
}
if(!null_found)
{
if((res= iop->nextResult()) != 0){
g_err << "Failed to find row using index: " << res << endl;
ERR(pTrans->getNdbError());
closeTransaction(pNdb);
return NDBT_FAILED;
}
if(scanRow.c_str() != indexRow.c_str()){
g_err << "Error when comapring records" << endl;
g_err << " scanRow: \n" << scanRow.c_str().c_str() << endl;
g_err << " indexRow: \n" << indexRow.c_str().c_str() << endl;
closeTransaction(pNdb);
return NDBT_FAILED;
}
if(iop->nextResult() == 0){
g_err << "Found extra row!!" << endl;
g_err << " indexRow: \n" << indexRow.c_str().c_str() << endl;
closeTransaction(pNdb);
return NDBT_FAILED;
}
}
}
if (eof == -1 || check == -1) {
error:
const NdbError err = pTrans->getNdbError();
if (err.status == NdbError::TemporaryError){
ERR(err);
iop = 0;
closeTransaction(pNdb);
NdbSleep_MilliSleep(50);
retryAttempt++;
rows--;
continue;
}
ERR(err);
closeTransaction(pNdb);
return NDBT_FAILED;
}
closeTransaction(pNdb);
return NDBT_OK;
}
return NDBT_FAILED;
}
int
UtilTransactions::readRowFromTableAndIndex(Ndb* pNdb,
NdbConnection* scanTrans,
const NdbDictionary::Index* pIndex,
NDBT_ResultRow& row ){
NdbDictionary::Index::Type indexType= pIndex->getType();
int retryAttempt = 0;
const int retryMax = 100;
int check, a;
NdbConnection *pTrans1=NULL;
NdbOperation *pOp;
int return_code= NDBT_FAILED;
// Allocate place to store the result
NDBT_ResultRow tabRow(tab);
NDBT_ResultRow indexRow(tab);
const char * indexName = pIndex->getName();
while (true){
if(retryAttempt)
ndbout_c("retryAttempt %d", retryAttempt);
if (retryAttempt >= retryMax){
g_info << "ERROR: has retried this operation " << retryAttempt
<< " times, failing!" << endl;
goto close_all;
}
pTrans1 = pNdb->hupp(scanTrans); //startTransaction();
if (pTrans1 == NULL) {
const NdbError err = pNdb->getNdbError();
if (err.status == NdbError::TemporaryError){
ERR(err);
NdbSleep_MilliSleep(50);
retryAttempt++;
continue;
}
if(err.code == 0){
return_code = NDBT_OK;
goto close_all;
}
ERR(err);
goto close_all;
}
/**
* Read the record from TABLE
*/
pOp = pTrans1->getNdbOperation(tab.getName());
if (pOp == NULL) {
ERR(pTrans1->getNdbError());
goto close_all;
}
check = pOp->readTuple();
if( check == -1 ) {
ERR(pTrans1->getNdbError());
goto close_all;
}
// Define primary keys
#if VERBOSE
printf("PK: ");
#endif
for(a = 0; a<tab.getNoOfColumns(); a++){
const NdbDictionary::Column* attr = tab.getColumn(a);
if (attr->getPrimaryKey() == true){
if (pOp->equal(attr->getName(), row.attributeStore(a)->aRef()) != 0){
ERR(pTrans1->getNdbError());
goto close_all;
}
#if VERBOSE
printf("%s = %d: ", attr->getName(), row.attributeStore(a)->aRef());
#endif
}
}
#if VERBOSE
printf("\n");
#endif
// Read all attributes
#if VERBOSE
printf("Reading %u attributes: ", tab.getNoOfColumns());
#endif
for(a = 0; a<tab.getNoOfColumns(); a++){
if((tabRow.attributeStore(a) =
pOp->getValue(tab.getColumn(a)->getName())) == 0) {
ERR(pTrans1->getNdbError());
goto close_all;
}
#if VERBOSE
printf("%s ", tab.getColumn(a)->getName());
#endif
}
#if VERBOSE
printf("\n");
#endif
/**
* Read the record from INDEX_TABLE
*/
NdbIndexOperation* pIndexOp= NULL;
NdbIndexScanOperation *pScanOp= NULL;
NdbOperation *pIOp= 0;
bool null_found= false;
for(a = 0; a<(int)pIndex->getNoOfColumns(); a++){
const NdbDictionary::Column * col = pIndex->getColumn(a);
if (row.attributeStore(col->getName())->isNULL())
{
null_found= true;
break;
}
}
const char * tabName= tab.getName();
if(!null_found)
{
if (indexType == NdbDictionary::Index::UniqueHashIndex) {
pIOp= pIndexOp= pTrans1->getNdbIndexOperation(indexName, tabName);
} else {
pIOp= pScanOp= pTrans1->getNdbIndexScanOperation(indexName, tabName);
}
if (pIOp == NULL) {
ERR(pTrans1->getNdbError());
goto close_all;
}
{
bool not_ok;
if (pIndexOp) {
not_ok = pIndexOp->readTuple() == -1;
} else {
not_ok = pScanOp->readTuples();
}
if( not_ok ) {
ERR(pTrans1->getNdbError());
goto close_all;
}
}
// Define primary keys for index
#if VERBOSE
printf("SI: ");
#endif
for(a = 0; a<(int)pIndex->getNoOfColumns(); a++){
const NdbDictionary::Column * col = pIndex->getColumn(a);
int r;
if ( !row.attributeStore(col->getName())->isNULL() ) {
if(pIOp->equal(col->getName(),
row.attributeStore(col->getName())->aRef()) != 0){
ERR(pTrans1->getNdbError());
goto close_all;
}
}
#if VERBOSE
printf("%s = %d: ", col->getName(), row.attributeStore(a)->aRef());
#endif
}
#if VERBOSE
printf("\n");
#endif
// Read all attributes
#if VERBOSE
printf("Reading %u attributes: ", tab.getNoOfColumns());
#endif
for(a = 0; a<tab.getNoOfColumns(); a++){
void* pCheck;
pCheck= indexRow.attributeStore(a)=
pIOp->getValue(tab.getColumn(a)->getName());
if(pCheck == NULL) {
ERR(pTrans1->getNdbError());
goto close_all;
}
#if VERBOSE
printf("%s ", tab.getColumn(a)->getName());
#endif
}
}
#if VERBOSE
printf("\n");
#endif
scanTrans->refresh();
check = pTrans1->execute(Commit, AbortOnError);
if( check == -1 ) {
const NdbError err = pTrans1->getNdbError();
if (err.status == NdbError::TemporaryError){
ERR(err);
pNdb->closeTransaction(pTrans1);
NdbSleep_MilliSleep(50);
retryAttempt++;
continue;
}
ndbout << "Error when comparing records - normal op" << endl;
ERR(err);
ndbout << "row: " << row.c_str().c_str() << endl;
goto close_all;
}
/**
* Compare the two rows
*/
if(!null_found){
if (pScanOp) {
if (pScanOp->nextResult() != 0){
const NdbError err = pTrans1->getNdbError();
ERR(err);
ndbout << "Error when comparing records - index op next_result missing" << endl;
ndbout << "row: " << row.c_str().c_str() << endl;
goto close_all;
}
}
if (!(tabRow.c_str() == indexRow.c_str())){
ndbout << "Error when comapring records" << endl;
ndbout << " tabRow: \n" << tabRow.c_str().c_str() << endl;
ndbout << " indexRow: \n" << indexRow.c_str().c_str() << endl;
goto close_all;
}
if (pScanOp) {
if (pScanOp->nextResult() == 0){
ndbout << "Error when comparing records - index op next_result to many" << endl;
ndbout << "row: " << row.c_str().c_str() << endl;
goto close_all;
}
}
}
return_code= NDBT_OK;
goto close_all;
}
close_all:
if (pTrans1)
pNdb->closeTransaction(pTrans1);
return return_code;
}
int
MilpRounding::solution(double &solutionValue, double *betterSolution)
{
if(model_->getCurrentPassNumber() > 1) return 0;
if (model_->currentDepth() > 2 && (model_->getNodeCount()%howOften_)!=0)
return 0;
int returnCode = 0; // 0 means it didn't find a feasible solution
OsiTMINLPInterface * nlp = NULL;
if(setup_->getAlgorithm() == B_BB)
nlp = dynamic_cast<OsiTMINLPInterface *>(model_->solver()->clone());
else
nlp = dynamic_cast<OsiTMINLPInterface *>(setup_->nonlinearSolver()->clone());
TMINLP2TNLP* minlp = nlp->problem();
// set tolerances
double integerTolerance = model_->getDblParam(CbcModel::CbcIntegerTolerance);
//double primalTolerance = 1.0e-6;
int n;
int m;
int nnz_jac_g;
int nnz_h_lag;
Ipopt::TNLP::IndexStyleEnum index_style;
minlp->get_nlp_info(n, m, nnz_jac_g,
nnz_h_lag, index_style);
const Bonmin::TMINLP::VariableType* variableType = minlp->var_types();
const double* x_sol = minlp->x_sol();
const double* g_l = minlp->g_l();
const double* g_u = minlp->g_u();
const double * colsol = model_->solver()->getColSolution();
// Get information about the linear and nonlinear part of the instance
TMINLP* tminlp = nlp->model();
vector<Ipopt::TNLP::LinearityType> c_lin(m);
tminlp->get_constraints_linearity(m, c_lin());
vector<int> c_idx(m);
int n_lin = 0;
for (int i=0;i<m;i++) {
if (c_lin[i]==Ipopt::TNLP::LINEAR)
c_idx[i] = n_lin++;
else
c_idx[i] = -1;
}
// Get the structure of the jacobian
vector<int> indexRow(nnz_jac_g);
vector<int> indexCol(nnz_jac_g);
minlp->eval_jac_g(n, x_sol, false,
m, nnz_jac_g,
indexRow(), indexCol(), 0);
// get the jacobian values
vector<double> jac_g(nnz_jac_g);
minlp->eval_jac_g(n, x_sol, false,
m, nnz_jac_g,
NULL, NULL, jac_g());
// Sort the matrix to column ordered
vector<int> sortedIndex(nnz_jac_g);
CoinIotaN(sortedIndex(), nnz_jac_g, 0);
MatComp c;
c.iRow = indexRow();
c.jCol = indexCol();
std::sort(sortedIndex.begin(), sortedIndex.end(), c);
vector<int> row (nnz_jac_g);
vector<double> value (nnz_jac_g);
vector<int> columnStart(n,0);
vector<int> columnLength(n,0);
int indexCorrection = (index_style == Ipopt::TNLP::C_STYLE) ? 0 : 1;
int iniCol = -1;
int nnz = 0;
for(int i=0; i<nnz_jac_g; i++) {
int thisIndexCol = indexCol[sortedIndex[i]]-indexCorrection;
int thisIndexRow = c_idx[indexRow[sortedIndex[i]] - indexCorrection];
if(thisIndexCol != iniCol) {
iniCol = thisIndexCol;
columnStart[thisIndexCol] = nnz;
columnLength[thisIndexCol] = 0;
}
if(thisIndexRow == -1) continue;
columnLength[thisIndexCol]++;
row[nnz] = thisIndexRow;
value[nnz] = jac_g[i];
nnz++;
}
// Build the row lower and upper bounds
vector<double> newRowLower(n_lin);
vector<double> newRowUpper(n_lin);
for(int i = 0 ; i < m ; i++){
if(c_idx[i] == -1) continue;
newRowLower[c_idx[i]] = g_l[i];
newRowUpper[c_idx[i]] = g_u[i];
}
// Get solution array for heuristic solution
vector<double> newSolution(n);
std::copy(x_sol, x_sol + n, newSolution.begin());
// Define the constraint matrix for MILP
CoinPackedMatrix matrix(true,n_lin,n, nnz, value(), row(), columnStart(), columnLength());
// create objective function and columns lower and upper bounds for MILP
// and create columns for matrix in MILP
//double alpha = 0;
double beta = 1;
vector<double> objective(n);
vector<int> idxIntegers;
idxIntegers.reserve(n);
for(int i = 0 ; i < n ; i++){
if(variableType[i] != Bonmin::TMINLP::CONTINUOUS){
idxIntegers.push_back(i);
objective[i] = beta*(1 - 2*colsol[i]);
}
}
#if 0
// Get dual multipliers and build gradient of the lagrangean
const double * duals = nlp->getRowPrice() + 2 *n;
vector<double> grad(n, 0);
vector<int> indices(n, 0);
tminlp->eval_grad_f(n, x_sol, false, grad());
for(int i = 0 ; i < m ; i++){
if(c_lin[i] == Ipopt::TNLP::LINEAR) continue;
int nnz;
tminlp->eval_grad_gi(n, x_sol, false, i, nnz, indices(), NULL);
tminlp->eval_grad_gi(n, x_sol, false, i, nnz, NULL, grad());
for(int k = 0 ; k < nnz ; k++){
objective[indices[k]] += alpha *duals[i] * grad[k];
}
}
for(int i = 0 ; i < n ; i++){
if(variableType[i] != Bonmin::TMINLP::CONTINUOUS)
objective[i] += alpha * grad[i];
//if(fabs(objective[i]) < 1e-4) objective[i] = 0;
else objective[i] = 0;
}
std::copy(objective.begin(), objective.end(), std::ostream_iterator<double>(std::cout, " "));
std::cout<<std::endl;
#endif
// load the problem to OSI
OsiSolverInterface *si = mip_->solver();
assert(si != NULL);
CoinMessageHandler * handler = model_->messageHandler()->clone();
si->passInMessageHandler(handler);
si->messageHandler()->setLogLevel(1);
si->loadProblem(matrix, model_->solver()->getColLower(), model_->solver()->getColUpper(), objective(),
newRowLower(), newRowUpper());
si->setInteger(idxIntegers(), static_cast<int>(idxIntegers.size()));
si->applyCuts(noGoods);
bool hasFractionnal = true;
while(hasFractionnal){
mip_->optimize(DBL_MAX, 0, 60);
hasFractionnal = false;
#if 0
bool feasible = false;
if(mip_->getLastSolution()) {
const double* solution = mip_->getLastSolution();
std::copy(solution, solution + n, newSolution.begin());
feasible = true;
}
if(feasible) {
// fix the integer variables and solve the NLP
// also add no good cut
CoinPackedVector v;
double lb = 1;
for (int iColumn=0;iColumn<n;iColumn++) {
if (variableType[iColumn] != Bonmin::TMINLP::CONTINUOUS) {
double value=newSolution[iColumn];
if (fabs(floor(value+0.5)-value)>integerTolerance) {
#ifdef DEBUG_BON_HEURISTIC_DIVE_MIP
cout<<"It should be infeasible because: "<<endl;
cout<<"variable "<<iColumn<<" is not integer"<<endl;
#endif
feasible = false;
break;
}
else {
value=floor(newSolution[iColumn]+0.5);
if(value > 0.5){
v.insert(iColumn, -1);
lb -= value;
}
minlp->SetVariableUpperBound(iColumn, value);
minlp->SetVariableLowerBound(iColumn, value);
}
}
}
}
#endif
}
bool feasible = false;
if(mip_->getLastSolution()) {
const double* solution = mip_->getLastSolution();
std::copy(solution, solution + n, newSolution.begin());
feasible = true;
delete handler;
}
if(feasible) {
// fix the integer variables and solve the NLP
// also add no good cut
CoinPackedVector v;
double lb = 1;
for (int iColumn=0;iColumn<n;iColumn++) {
if (variableType[iColumn] != Bonmin::TMINLP::CONTINUOUS) {
double value=newSolution[iColumn];
if (fabs(floor(value+0.5)-value)>integerTolerance) {
feasible = false;
break;
}
else {
value=floor(newSolution[iColumn]+0.5);
if(value > 0.5){
v.insert(iColumn, -1);
lb -= value;
}
minlp->SetVariableUpperBound(iColumn, value);
minlp->SetVariableLowerBound(iColumn, value);
}
}
}
OsiRowCut c;
c.setRow(v);
c.setLb(lb);
c.setUb(DBL_MAX);
noGoods.insert(c);
if(feasible) {
nlp->initialSolve();
if(minlp->optimization_status() != Ipopt::SUCCESS) {
feasible = false;
}
std::copy(x_sol,x_sol+n, newSolution.begin());
}
}
if(feasible) {
double newSolutionValue;
minlp->eval_f(n, newSolution(), true, newSolutionValue);
if(newSolutionValue < solutionValue) {
std::copy(newSolution.begin(), newSolution.end(), betterSolution);
solutionValue = newSolutionValue;
returnCode = 1;
}
}
delete nlp;
#ifdef DEBUG_BON_HEURISTIC_DIVE_MIP
std::cout<<"DiveMIP returnCode = "<<returnCode<<std::endl;
#endif
return returnCode;
}
