EXIT: Not enough memory #717

wladimirpetrov · 2023-10-19T18:58:12Z

wladimirpetrov
Oct 19, 2023

Hello one more time! Sorry for the long question!
I've written the code that optimizes the following task:
We have 2 values x1 and x2 that are both 0 <= x1 <= 10, 0 <= x2 <= 10. Their sum is x1+x2 <=20. I need to maximize the product between x1 and x2.

here is my code:

#include "Ipopt/src/Interfaces/IpIpoptApplication.hpp"
#include "Ipopt/src/Interfaces/IpTNLP.hpp"
#include <iostream>


using namespace Ipopt;

class DerivedOptimizationProblem : public TNLP {
public:
    // Constructor
    DerivedOptimizationProblem() {}

    // Define problem dimensions
    virtual bool get_nlp_info(Index& n, Index& m, Index& nnz_jac_g, Index& nnz_h_lag, IndexStyleEnum& index_style) {
        // Number of variables
        n = 2;

        // Number of constraints
        m = 1;

        // Number of non-zero elements in the Jacobian of the constraints
        nnz_jac_g = 2;

        // Number of non-zero elements in the Hessian of the Lagrangian (0 if not available)
        nnz_h_lag = 0;

        // Use C-style indexing
        index_style = TNLP::C_STYLE;
        return true;
    }

    // Define bounds for variables and constraints
    virtual bool get_bounds_info(Index n, Number* x_l, Number* x_u, Index m, Number* g_l, Number* g_u) {
        // Variable bounds
        x_l[0] = 0.0; // x1 lower bound
        x_u[0] = 10.0; // x1 upper bound
        x_l[1] = 0.0; // x2 lower bound
        x_u[1] = 10.0; // x2 upper bound

        // Constraint bounds
        g_l[0] = 0; // Lower bound for the constraint
        g_u[0] = 20; // Upper bound for the constraint
        return true;
        
    }

    // Define initial guess for the variables
    virtual bool get_starting_point(Index n, bool init_x, Number* x, bool init_z, Number* z_L, Number* z_U, Index m, bool init_lambda, Number* lambda) {
        // Initialize the variables
        x[0] = 5.0; // Initial guess for x1
        x[1] = 5.0; // Initial guess for x2
        return true;
    }

    // Define the objective function
    virtual bool eval_f(Index n, const Number* x, bool new_x, Number& obj_value) {
        // Objective: maximize the product of x1 and x2
        obj_value = -x[0] * x[1]; // Negative sign bc of maximization
        std::cout << "obj_value = " << obj_value << std::endl << std::flush;
        return true;
    }

    // Define the constraints
    virtual bool eval_g(Index n, const Number* x, bool new_x, Index m, Number* g) {
        // Constraint: x1 + x2 <= 20
        g[0] = x[0] + x[1];
        //std::cout << "g[0] = " << g[0] << std::endl << std::flush;
        return true;
    }

    // Define the Jacobian of the constraints
    virtual bool eval_jac_g(Index n, const Number* x, bool new_x, Index m, Index nele_jac, Index* iRow, Index* jCol, Number* values) {
        if (values == NULL) {
            // Non zero elements for Jacobian
            iRow[0] = 0; // Row index for the constraint
            jCol[0] = 0; // Column index for x1
            iRow[1] = 0; // Row index for the constraint
            jCol[1] = 1; // Column index for x2
        } else {
            // Calculate the values of the Jacobian matrix
            values[0] = 1.0; // Deriv of the constraint wrt x1
            values[1] = 1.0; // Deriv of the constraint wrt x2
        }
        return true;
    }

    // Define the gradient of the objective function
    virtual bool eval_grad_f(Index n, const Number* x, bool new_x, Number* grad_f) {
        // Implement the gradient evaluation
        grad_f[0] = -x[1]; // Partial derivative wrt to x1
        grad_f[1] = -x[0]; // Partial derivative wrt to x2
        return true;
    }

    // Implement the missing finalize_solution function
    virtual void finalize_solution(
        Ipopt::SolverReturn status,
        Ipopt::Index n,
        const Number* x, 
        const Number* z_L, 
        const Number* z_U,
        Ipopt::Index m, 
        const Number* g, 
        const Number* lambda, 
        Ipopt::Number obj_value,
        const IpoptData* ip_data, 
        Ipopt::IpoptCalculatedQuantities* ip_cq) {
        
        // Printing the successful variables and 
        std::cout << "x1 = " << x[0] << std::endl;
        std::cout << "x2 = " << x[1] << std::endl;
        std::cout << "Objective function value: " << obj_value << std::endl;
            
    }
};

int main() {
    SmartPtr<TNLP> problem = new DerivedOptimizationProblem();
    SmartPtr<IpoptApplication> app = IpoptApplicationFactory();

    // Adjust the maximum number of iterations
    app->Options()->SetIntegerValue("max_iter", 3000); 
    // Adjust the convergence tolerance
    app->Options()->SetNumericValue("tol", 1e-6); 
    // Set Hessian approximation method
    app->Options()->SetStringValue("hessian_approximation", "limited-memory");

    app->RethrowNonIpoptException(true);
    ApplicationReturnStatus status = app->Initialize();
    if (status != Solve_Succeeded) {
        std::cout << "IPOPT initialization failed!" << std::endl;
        return -1;
    }

    status = app->OptimizeTNLP(problem);

    /*
    if (status == Solve_Succeeded || status == Solved_To_Acceptable_Level) {
        // Number of variables
        Index n;
        // Number of constraints
        Index m;

        problem->get_nlp_info(n, m, nullptr, nullptr, index_style);

        // allocating memory for the vectors
        Number* x_l = new Number[n];
        Number* x_u = new Number[n];
        Number* x = new Number[n];
        Number* g_l = new Number[m];
        Number* g_u = new Number[m];
        Number* g = new Number[m];

        // Get the bounds and solution vectors
        problem->get_bounds_info(n, x_l, x_u, m, g_l, g_u);
        problem->get_x(n, x);
        problem->get_g(n, m, g);

        // Print the sizes
        std::cout << "Size of x_l: " << n << std::endl;
        std::cout << "Size of x_u: " << n << std::endl;
        std::cout << "Size of x: " << n << std::endl;
        std::cout << "Size of g_l: " << m << std::endl;
        std::cout << "Size of g_u: " << m << std::endl;
        std::cout << "Size of g: " << m << std::endl;

        // Clean up allocated memory
        delete[] x_l;
        delete[] x_u;
        delete[] x;
        delete[] g_l;
        delete[] g_u;
        delete[] g; 
        }
        */
    //if (status == Solve_Succeeded || status == Solved_To_Acceptable_Level) {
    //    Number obj_value;
    //    Number x[2];
    //    problem->eval_f(2, x, true, obj_value);

    //    std::cout << "Optimal solution:" << std::endl;
    //    std::cout << "x1: " << x[0] << std::endl;
    //    std::cout << "x2: " << x[1] << std::endl;
    //    std::cout << "Maximized Objective Value: " << obj_value << std::endl; // Restore the objective value to its positive form
    //} else {
    //    std::cout << "IPOPT optimization failed with status " << status << std::endl;
    //}

    return 0;
}

Then I tried to correct the code so that I would be able to optimize without coding the Jacobian and Gradient. As a matter of fact I made the eval_jac_g and eval_grad_f empty and enable finite-difference gradient and Jacobian approximation, here is my code:

#include "Ipopt/src/Interfaces/IpIpoptApplication.hpp"
#include "Ipopt/src/Interfaces/IpTNLP.hpp"
#include <iostream>

using namespace Ipopt;

class DerivedOptimizationProblem : public TNLP {
public:
   // Constructor
   DerivedOptimizationProblem() {}

   // Define problem dimensions
   virtual bool get_nlp_info(Index& n, Index& m, Index& nnz_jac_g, Index& nnz_h_lag, IndexStyleEnum& index_style) {
       // Number of variables
       n = 2;

       // Number of constraints
       m = 1;

       // Number of non-zero elements in the Jacobian of the constraints
       nnz_jac_g = -1;

       // Number of non-zero elements in the Hessian of the Lagrangian (0 if not available)
       nnz_h_lag = -1;

       // Use C-style indexing
       index_style = TNLP::C_STYLE;
       return true;
   }

   // Define bounds for variables and constraints
   virtual bool get_bounds_info(Index n, Number* x_l, Number* x_u, Index m, Number* g_l, Number* g_u) {
       // Variable bounds
       x_l[0] = 0.0; // x1 lower bound
       x_u[0] = 10.0; // x1 upper bound
       x_l[1] = 0.0; // x2 lower bound
       x_u[1] = 10.0; // x2 upper bound

       // Constraint bounds
       g_l[0] = 0; // Lower bound for the constraint
       g_u[0] = 20; // Upper bound for the constraint
       return true;
   }

   // Define initial guess for the variables
   virtual bool get_starting_point(Index n, bool init_x, Number* x, bool init_z, Number* z_L, Number* z_U, Index m, bool init_lambda, Number* lambda) {
       // Initialize the variables
       x[0] = 5.0; // Initial guess for x1
       x[1] = 5.0; // Initial guess for x2
       return true;
   }

   // Define the objective function
   virtual bool eval_f(Index n, const Number* x, bool new_x, Number& obj_value) {
       // Objective: maximize the product of x1 and x2
       obj_value = -x[0] * x[1]; // Negative sign because of maximization
       //std::cout << "obj_value = " << obj_value << std::endl << std::flush;
       return true;
   }

   // Define the constraints
   virtual bool eval_g(Index n, const Number* x, bool new_x, Index m, Number* g) {
       // Constraint: x1 + x2 <= 20
       g[0] = x[0] + x[1];
       return true;
   }

   virtual bool eval_jac_g(Index n, const Number* x, bool new_x, Index m, Index nele_jac, Index* iRow, Index* jCol, Number* values) {
       return true;
   }

   virtual bool eval_grad_f(Index n, const Number* x, bool new_x, Number* grad_f) {
       return true;
   }


   // Implement the missing finalize_solution function
   virtual void finalize_solution(
       Ipopt::SolverReturn status,
       Ipopt::Index n,
       const Number* x, 
       const Number* z_L, 
       const Number* z_U,
       Ipopt::Index m, 
       const Number* g, 
       const Number* lambda, 
       Ipopt::Number obj_value,
       const IpoptData* ip_data, 
       Ipopt::IpoptCalculatedQuantities* ip_cq) {
       
       // Printing the successful variables and 
       std::cout << "x1 = " << x[0] << std::endl;
       std::cout << "x2 = " << x[1] << std::endl;
       std::cout << "Objective function value: " << obj_value << std::endl;
   }
};

int main() {
   SmartPtr<TNLP> problem = new DerivedOptimizationProblem();
   SmartPtr<IpoptApplication> app = IpoptApplicationFactory();

   // Adjust the maximum number of iterations
   app->Options()->SetIntegerValue("max_iter", 50); 
   // Adjust the convergence tolerance
   app->Options()->SetNumericValue("tol", 1e-20); 
   // Set Hessian approximation method
   app->Options()->SetStringValue("hessian_approximation", "limited-memory");
   
   // Enable finite-difference gradient and Jacobian approximation
   app->Options()->SetStringValue("derivative_test", "second-order");
   app->Options()->SetStringValue("jacobian_approximation", "finite-difference-values");

   app->RethrowNonIpoptException(true);
   ApplicationReturnStatus status = app->Initialize();
   if (status != Solve_Succeeded) {
       std::cout << "IPOPT initialization failed!" << std::endl;
       return -1;
   }

   status = app->OptimizeTNLP(problem);

   return 0;
}

However it's giving an error "EXIT: Not enough memory":

when I run Valgrind:

 ==461942== Memcheck, a memory error detector
==461942== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al.
==461942== Using Valgrind-3.15.0 and LibVEX; rerun with -h for copyright info
==461942== Command: ./simple_example_no_jacob_no_hess
==461942== 

******************************************************************************
This program contains Ipopt, a library for large-scale nonlinear optimization.
 Ipopt is released as open source code under the Eclipse Public License (EPL).
         For more information visit https://github.com/coin-or/Ipopt
******************************************************************************

This is Ipopt version 3.14.13, running with linear solver MUMPS 5.6.0.


EXIT: Not enough memory.
==461942== 
==461942== HEAP SUMMARY:
==461942==     in use at exit: 40 bytes in 3 blocks
==461942==   total heap usage: 3,706 allocs, 3,703 frees, 446,207 bytes allocated
==461942== 
==461942== 8 bytes in 1 blocks are definitely lost in loss record 1 of 3
==461942==    at 0x483C583: operator new[](unsigned long) (in /usr/lib/x86_64-linux-gnu/valgrind/vgpreload_memcheck-amd64-linux.so)
==461942==    by 0x4A502BC: Ipopt::TNLPAdapter::CheckDerivatives(Ipopt::TNLPAdapter::DerivativeTestEnum, int) (in /local/vol00/home/vpetrov/dev/optimization/ipopt/Ipopt/src/.libs/libipopt.so.3.14.13)
==461942==    by 0x4A5413F: Ipopt::TNLPAdapter::GetSpaces(Ipopt::SmartPtr<Ipopt::VectorSpace const>&, Ipopt::SmartPtr<Ipopt::VectorSpace const>&, Ipopt::SmartPtr<Ipopt::VectorSpace const>&, Ipopt::SmartPtr<Ipopt::VectorSpace const>&, Ipopt::SmartPtr<Ipopt::MatrixSpace const>&, Ipopt::SmartPtr<Ipopt::VectorSpace const>&, Ipopt::SmartPtr<Ipopt::MatrixSpace const>&, Ipopt::SmartPtr<Ipopt::VectorSpace const>&, Ipopt::SmartPtr<Ipopt::MatrixSpace const>&, Ipopt::SmartPtr<Ipopt::VectorSpace const>&, Ipopt::SmartPtr<Ipopt::MatrixSpace const>&, Ipopt::SmartPtr<Ipopt::MatrixSpace const>&, Ipopt::SmartPtr<Ipopt::MatrixSpace const>&, Ipopt::SmartPtr<Ipopt::SymMatrixSpace const>&) (in /local/vol00/home/vpetrov/dev/optimization/ipopt/Ipopt/src/.libs/libipopt.so.3.14.13)
==461942==    by 0x49D14AE: Ipopt::OrigIpoptNLP::InitializeStructures(Ipopt::SmartPtr<Ipopt::Vector>&, bool, Ipopt::SmartPtr<Ipopt::Vector>&, bool, Ipopt::SmartPtr<Ipopt::Vector>&, bool, Ipopt::SmartPtr<Ipopt::Vector>&, bool, Ipopt::SmartPtr<Ipopt::Vector>&, bool, Ipopt::SmartPtr<Ipopt::Vector>&, Ipopt::SmartPtr<Ipopt::Vector>&) (in /local/vol00/home/vpetrov/dev/optimization/ipopt/Ipopt/src/.libs/libipopt.so.3.14.13)
==461942==    by 0x49A5DAA: Ipopt::IpoptData::InitializeDataStructures(Ipopt::IpoptNLP&, bool, bool, bool, bool, bool) (in /local/vol00/home/vpetrov/dev/optimization/ipopt/Ipopt/src/.libs/libipopt.so.3.14.13)
==461942==    by 0x495C9E7: Ipopt::DefaultIterateInitializer::SetInitialIterates() (in /local/vol00/home/vpetrov/dev/optimization/ipopt/Ipopt/src/.libs/libipopt.so.3.14.13)
==461942==    by 0x4975387: Ipopt::IpoptAlgorithm::InitializeIterates() (in /local/vol00/home/vpetrov/dev/optimization/ipopt/Ipopt/src/.libs/libipopt.so.3.14.13)
==461942==    by 0x4975522: Ipopt::IpoptAlgorithm::Optimize(bool) (in /local/vol00/home/vpetrov/dev/optimization/ipopt/Ipopt/src/.libs/libipopt.so.3.14.13)
==461942==    by 0x4A396BB: Ipopt::IpoptApplication::call_optimize() (in /local/vol00/home/vpetrov/dev/optimization/ipopt/Ipopt/src/.libs/libipopt.so.3.14.13)
==461942==    by 0x4A3BA07: Ipopt::IpoptApplication::OptimizeNLP(Ipopt::SmartPtr<Ipopt::NLP> const&, Ipopt::SmartPtr<Ipopt::AlgorithmBuilder>&) (in /local/vol00/home/vpetrov/dev/optimization/ipopt/Ipopt/src/.libs/libipopt.so.3.14.13)
==461942==    by 0x4A352CC: Ipopt::IpoptApplication::OptimizeNLP(Ipopt::SmartPtr<Ipopt::NLP> const&) (in /local/vol00/home/vpetrov/dev/optimization/ipopt/Ipopt/src/.libs/libipopt.so.3.14.13)
==461942==    by 0x4A373BD: Ipopt::IpoptApplication::OptimizeTNLP(Ipopt::SmartPtr<Ipopt::TNLP> const&) (in /local/vol00/home/vpetrov/dev/optimization/ipopt/Ipopt/src/.libs/libipopt.so.3.14.13)
==461942== 
==461942== 16 bytes in 1 blocks are definitely lost in loss record 2 of 3
==461942==    at 0x483C583: operator new[](unsigned long) (in /usr/lib/x86_64-linux-gnu/valgrind/vgpreload_memcheck-amd64-linux.so)
==461942==    by 0x4A4F9B7: Ipopt::TNLPAdapter::CheckDerivatives(Ipopt::TNLPAdapter::DerivativeTestEnum, int) (in /local/vol00/home/vpetrov/dev/optimization/ipopt/Ipopt/src/.libs/libipopt.so.3.14.13)
==461942==    by 0x4A5413F: Ipopt::TNLPAdapter::GetSpaces(Ipopt::SmartPtr<Ipopt::VectorSpace const>&, Ipopt::SmartPtr<Ipopt::VectorSpace const>&, Ipopt::SmartPtr<Ipopt::VectorSpace const>&, Ipopt::SmartPtr<Ipopt::VectorSpace const>&, Ipopt::SmartPtr<Ipopt::MatrixSpace const>&, Ipopt::SmartPtr<Ipopt::VectorSpace const>&, Ipopt::SmartPtr<Ipopt::MatrixSpace const>&, Ipopt::SmartPtr<Ipopt::VectorSpace const>&, Ipopt::SmartPtr<Ipopt::MatrixSpace const>&, Ipopt::SmartPtr<Ipopt::VectorSpace const>&, Ipopt::SmartPtr<Ipopt::MatrixSpace const>&, Ipopt::SmartPtr<Ipopt::MatrixSpace const>&, Ipopt::SmartPtr<Ipopt::MatrixSpace const>&, Ipopt::SmartPtr<Ipopt::SymMatrixSpace const>&) (in /local/vol00/home/vpetrov/dev/optimization/ipopt/Ipopt/src/.libs/libipopt.so.3.14.13)
==461942==    by 0x49D14AE: Ipopt::OrigIpoptNLP::InitializeStructures(Ipopt::SmartPtr<Ipopt::Vector>&, bool, Ipopt::SmartPtr<Ipopt::Vector>&, bool, Ipopt::SmartPtr<Ipopt::Vector>&, bool, Ipopt::SmartPtr<Ipopt::Vector>&, bool, Ipopt::SmartPtr<Ipopt::Vector>&, bool, Ipopt::SmartPtr<Ipopt::Vector>&, Ipopt::SmartPtr<Ipopt::Vector>&) (in /local/vol00/home/vpetrov/dev/optimization/ipopt/Ipopt/src/.libs/libipopt.so.3.14.13)
==461942==    by 0x49A5DAA: Ipopt::IpoptData::InitializeDataStructures(Ipopt::IpoptNLP&, bool, bool, bool, bool, bool) (in /local/vol00/home/vpetrov/dev/optimization/ipopt/Ipopt/src/.libs/libipopt.so.3.14.13)
==461942==    by 0x495C9E7: Ipopt::DefaultIterateInitializer::SetInitialIterates() (in /local/vol00/home/vpetrov/dev/optimization/ipopt/Ipopt/src/.libs/libipopt.so.3.14.13)
==461942==    by 0x4975387: Ipopt::IpoptAlgorithm::InitializeIterates() (in /local/vol00/home/vpetrov/dev/optimization/ipopt/Ipopt/src/.libs/libipopt.so.3.14.13)
==461942==    by 0x4975522: Ipopt::IpoptAlgorithm::Optimize(bool) (in /local/vol00/home/vpetrov/dev/optimization/ipopt/Ipopt/src/.libs/libipopt.so.3.14.13)
==461942==    by 0x4A396BB: Ipopt::IpoptApplication::call_optimize() (in /local/vol00/home/vpetrov/dev/optimization/ipopt/Ipopt/src/.libs/libipopt.so.3.14.13)
==461942==    by 0x4A3BA07: Ipopt::IpoptApplication::OptimizeNLP(Ipopt::SmartPtr<Ipopt::NLP> const&, Ipopt::SmartPtr<Ipopt::AlgorithmBuilder>&) (in /local/vol00/home/vpetrov/dev/optimization/ipopt/Ipopt/src/.libs/libipopt.so.3.14.13)
==461942==    by 0x4A352CC: Ipopt::IpoptApplication::OptimizeNLP(Ipopt::SmartPtr<Ipopt::NLP> const&) (in /local/vol00/home/vpetrov/dev/optimization/ipopt/Ipopt/src/.libs/libipopt.so.3.14.13)
==461942==    by 0x4A373BD: Ipopt::IpoptApplication::OptimizeTNLP(Ipopt::SmartPtr<Ipopt::TNLP> const&) (in /local/vol00/home/vpetrov/dev/optimization/ipopt/Ipopt/src/.libs/libipopt.so.3.14.13)
==461942== 
==461942== 16 bytes in 1 blocks are definitely lost in loss record 3 of 3
==461942==    at 0x483C583: operator new[](unsigned long) (in /usr/lib/x86_64-linux-gnu/valgrind/vgpreload_memcheck-amd64-linux.so)
==461942==    by 0x4A4FEB9: Ipopt::TNLPAdapter::CheckDerivatives(Ipopt::TNLPAdapter::DerivativeTestEnum, int) (in /local/vol00/home/vpetrov/dev/optimization/ipopt/Ipopt/src/.libs/libipopt.so.3.14.13)
==461942==    by 0x4A5413F: Ipopt::TNLPAdapter::GetSpaces(Ipopt::SmartPtr<Ipopt::VectorSpace const>&, Ipopt::SmartPtr<Ipopt::VectorSpace const>&, Ipopt::SmartPtr<Ipopt::VectorSpace const>&, Ipopt::SmartPtr<Ipopt::VectorSpace const>&, Ipopt::SmartPtr<Ipopt::MatrixSpace const>&, Ipopt::SmartPtr<Ipopt::VectorSpace const>&, Ipopt::SmartPtr<Ipopt::MatrixSpace const>&, Ipopt::SmartPtr<Ipopt::VectorSpace const>&, Ipopt::SmartPtr<Ipopt::MatrixSpace const>&, Ipopt::SmartPtr<Ipopt::VectorSpace const>&, Ipopt::SmartPtr<Ipopt::MatrixSpace const>&, Ipopt::SmartPtr<Ipopt::MatrixSpace const>&, Ipopt::SmartPtr<Ipopt::MatrixSpace const>&, Ipopt::SmartPtr<Ipopt::SymMatrixSpace const>&) (in /local/vol00/home/vpetrov/dev/optimization/ipopt/Ipopt/src/.libs/libipopt.so.3.14.13)
==461942==    by 0x49D14AE: Ipopt::OrigIpoptNLP::InitializeStructures(Ipopt::SmartPtr<Ipopt::Vector>&, bool, Ipopt::SmartPtr<Ipopt::Vector>&, bool, Ipopt::SmartPtr<Ipopt::Vector>&, bool, Ipopt::SmartPtr<Ipopt::Vector>&, bool, Ipopt::SmartPtr<Ipopt::Vector>&, bool, Ipopt::SmartPtr<Ipopt::Vector>&, Ipopt::SmartPtr<Ipopt::Vector>&) (in /local/vol00/home/vpetrov/dev/optimization/ipopt/Ipopt/src/.libs/libipopt.so.3.14.13)
==461942==    by 0x49A5DAA: Ipopt::IpoptData::InitializeDataStructures(Ipopt::IpoptNLP&, bool, bool, bool, bool, bool) (in /local/vol00/home/vpetrov/dev/optimization/ipopt/Ipopt/src/.libs/libipopt.so.3.14.13)
==461942==    by 0x495C9E7: Ipopt::DefaultIterateInitializer::SetInitialIterates() (in /local/vol00/home/vpetrov/dev/optimization/ipopt/Ipopt/src/.libs/libipopt.so.3.14.13)
==461942==    by 0x4975387: Ipopt::IpoptAlgorithm::InitializeIterates() (in /local/vol00/home/vpetrov/dev/optimization/ipopt/Ipopt/src/.libs/libipopt.so.3.14.13)
==461942==    by 0x4975522: Ipopt::IpoptAlgorithm::Optimize(bool) (in /local/vol00/home/vpetrov/dev/optimization/ipopt/Ipopt/src/.libs/libipopt.so.3.14.13)
==461942==    by 0x4A396BB: Ipopt::IpoptApplication::call_optimize() (in /local/vol00/home/vpetrov/dev/optimization/ipopt/Ipopt/src/.libs/libipopt.so.3.14.13)
==461942==    by 0x4A3BA07: Ipopt::IpoptApplication::OptimizeNLP(Ipopt::SmartPtr<Ipopt::NLP> const&, Ipopt::SmartPtr<Ipopt::AlgorithmBuilder>&) (in /local/vol00/home/vpetrov/dev/optimization/ipopt/Ipopt/src/.libs/libipopt.so.3.14.13)
==461942==    by 0x4A352CC: Ipopt::IpoptApplication::OptimizeNLP(Ipopt::SmartPtr<Ipopt::NLP> const&) (in /local/vol00/home/vpetrov/dev/optimization/ipopt/Ipopt/src/.libs/libipopt.so.3.14.13)
==461942==    by 0x4A373BD: Ipopt::IpoptApplication::OptimizeTNLP(Ipopt::SmartPtr<Ipopt::TNLP> const&) (in /local/vol00/home/vpetrov/dev/optimization/ipopt/Ipopt/src/.libs/libipopt.so.3.14.13)
==461942== 
==461942== LEAK SUMMARY:
==461942==    definitely lost: 40 bytes in 3 blocks
==461942==    indirectly lost: 0 bytes in 0 blocks
==461942==      possibly lost: 0 bytes in 0 blocks
==461942==    still reachable: 0 bytes in 0 blocks
==461942==         suppressed: 0 bytes in 0 blocks
==461942== 
==461942== For lists of detected and suppressed errors, rerun with: -s
==461942== ERROR SUMMARY: 3 errors from 3 contexts (suppressed: 0 from 0)

what can be the issue? is something wrong with the code? Many thanks!

Answered by svigerske

Oct 20, 2023

It's probably nnz_jac_g = -1; that leads to this. Finite difference first-derivative approximation isn't much used, because, well, it usually shouldn't be used. It gives very bad performance. So somewhere it may still try to allocate a vector with length nnz_jac_g and allocating a negative number of bytes produces an error (or it tries to alloc something like INT_MAX-1, for which there is indeed not enough memory).

You can try with nnz_jac_g=0 and nnz_h_lag=0. I don't remember whether the Jacobian approx still needed the sparsity pattern of the Jacobian, though. Do yourself a favor and provide at least first derivatives.

View full answer

wladimirpetrov · 2023-10-19T21:34:19Z

wladimirpetrov
Oct 19, 2023
Author

I found out that I might be encountering the issue due to the "linear solver". I started playing with options of the solver, but didn't succeed:

    app->Options()->SetNumericValue("ma27_pivtol", 1e-8); // 1e-8 
    app->Options()->SetNumericValue("ma27_pivtolmax", 0.0001); // 0.0001
    app->Options()->SetNumericValue("ma27_liw_init_factor", 5.0); // 5.0
    app->Options()->SetNumericValue("ma27_la_init_factor", 5.0); // 5.0
    app->Options()->SetNumericValue("ma27_meminc_factor", 5.0); // 5.0

the characteristics of the PC are the following:

1 reply

wladimirpetrov Oct 19, 2023
Author

I corrected the code, I got rid of the line:

app->Options()->SetStringValue("derivative_test", "second-order");
here is the code:

#include "Ipopt/src/Interfaces/IpIpoptApplication.hpp"
#include "Ipopt/src/Interfaces/IpTNLP.hpp"
#include <iostream>

using namespace Ipopt;

class DerivedOptimizationProblem : public TNLP {
public:
    // Constructor
    DerivedOptimizationProblem() {}

    // Define problem dimensions
    virtual bool get_nlp_info(Index& n, Index& m, Index& nnz_jac_g, Index& nnz_h_lag, IndexStyleEnum& index_style) {
        // Number of variables
        n = 2;

        // Number of constraints
        m = 1;

        // Number of non-zero elements in the Jacobian of the constraints
        nnz_jac_g = -1;

        // Number of non-zero elements in the Hessian of the Lagrangian (0 if not available)
        nnz_h_lag = -1;

        // Use C-style indexing
        index_style = TNLP::C_STYLE;
        return true;
    }

    // Define bounds for variables and constraints
    virtual bool get_bounds_info(Index n, Number* x_l, Number* x_u, Index m, Number* g_l, Number* g_u) {
        // Variable bounds
        x_l[0] = 0.0; // x1 lower bound
        x_u[0] = 10.0; // x1 upper bound
        x_l[1] = 0.0; // x2 lower bound
        x_u[1] = 10.0; // x2 upper bound

        // Constraint bounds
        g_l[0] = 0; // Lower bound for the constraint
        g_u[0] = 20; // Upper bound for the constraint
        return true;
    }

    // Define initial guess for the variables
    virtual bool get_starting_point(Index n, bool init_x, Number* x, bool init_z, Number* z_L, Number* z_U, Index m, bool init_lambda, Number* lambda) {
        // Initialize the variables
        x[0] = 5.0; // Initial guess for x1
        x[1] = 5.0; // Initial guess for x2
        return true;
    }

    // Define the objective function
    virtual bool eval_f(Index n, const Number* x, bool new_x, Number& obj_value) {
        // Objective: maximize the product of x1 and x2
        obj_value = -x[0] * x[1]; // Negative sign because of maximization
        //std::cout << "obj_value = " << obj_value << std::endl << std::flush;
        return true;
    }

    // Define the constraints
    virtual bool eval_g(Index n, const Number* x, bool new_x, Index m, Number* g) {
        // Constraint: x1 + x2 <= 20
        g[0] = x[0] + x[1];
        return true;
    }

    virtual bool eval_jac_g(Index n, const Number* x, bool new_x, Index m, Index nele_jac, Index* iRow, Index* jCol, Number* values) {
        return true;
    }

    virtual bool eval_grad_f(Index n, const Number* x, bool new_x, Number* grad_f) {
        return true;
    }


    // Implement the missing finalize_solution function
    virtual void finalize_solution(
        Ipopt::SolverReturn status,
        Ipopt::Index n,
        const Number* x, 
        const Number* z_L, 
        const Number* z_U,
        Ipopt::Index m, 
        const Number* g, 
        const Number* lambda, 
        Ipopt::Number obj_value,
        const IpoptData* ip_data, 
        Ipopt::IpoptCalculatedQuantities* ip_cq) {
        
        // Printing the successful variables and 
        std::cout << "x1 = " << x[0] << std::endl;
        std::cout << "x2 = " << x[1] << std::endl;
        std::cout << "Objective function value: " << obj_value << std::endl;
    }
};

int main() {
    SmartPtr<TNLP> problem = new DerivedOptimizationProblem();
    SmartPtr<IpoptApplication> app = IpoptApplicationFactory();
    
    // Set linear solver options
    app->Options()->SetNumericValue("ma27_pivtol", 1e-8);//0.99 // 1e-8 // between 0 and 1
    app->Options()->SetNumericValue("ma27_pivtolmax", 0.0001);//0.99 // 0.0001 // between 0 and 
    app->Options()->SetNumericValue("ma27_liw_init_factor", 5.0); // 5.0 has to be 
    app->Options()->SetNumericValue("ma27_la_init_factor", 5.0); // 5.0
    app->Options()->SetNumericValue("ma27_meminc_factor", 5.0); // 5.0


    // Changing the linear sovler

    app->Options()->SetIntegerValue("max_iter", 1000); 
    app->Options()->SetNumericValue("tol", 1e-6); 
    app->Options()->SetStringValue("hessian_approximation", "limited-memory");
    app->Options()->SetStringValue("mu_strategy", "adaptive");
    app->Options()->SetStringValue("jacobian_approximation", "finite-difference-values");
    app->Options()->SetStringValue("gradient_approximation", "finite-difference-values");
    app->RethrowNonIpoptException(true);

    ApplicationReturnStatus status = app->Initialize();
    if (status != Solve_Succeeded) {
        std::cout << "IPOPT initialization failed!" << std::endl;
        return -1;
    }

    status = app->OptimizeTNLP(problem);

    return 0;
}

The valgrind doesn't give the error anymore:

vpetrov@lnx-me002:/local/vol00/home/vpetrov/dev/optimization/ipopt$ valgrind --leak-check=full ./simple_example_no_jacob_no_hess 
==466938== Memcheck, a memory error detector
==466938== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al.
==466938== Using Valgrind-3.15.0 and LibVEX; rerun with -h for copyright info
==466938== Command: ./simple_example_no_jacob_no_hess
==466938== 

******************************************************************************
This program contains Ipopt, a library for large-scale nonlinear optimization.
 Ipopt is released as open source code under the Eclipse Public License (EPL).
         For more information visit https://github.com/coin-or/Ipopt
******************************************************************************

This is Ipopt version 3.14.13, running with linear solver MUMPS 5.6.0.


EXIT: Not enough memory.
==466938== 
==466938== HEAP SUMMARY:
==466938==     in use at exit: 0 bytes in 0 blocks
==466938==   total heap usage: 3,733 allocs, 3,733 frees, 447,820 bytes allocated
==466938== 
==466938== All heap blocks were freed -- no leaks are possible
==466938== 
==466938== For lists of detected and suppressed errors, rerun with: -s
==466938== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)

But nevertheless when I run the code i get the same error :
EXIT: Not enough memory.

svigerske · 2023-10-20T06:41:10Z

svigerske
Oct 20, 2023
Maintainer

It's probably nnz_jac_g = -1; that leads to this. Finite difference first-derivative approximation isn't much used, because, well, it usually shouldn't be used. It gives very bad performance. So somewhere it may still try to allocate a vector with length nnz_jac_g and allocating a negative number of bytes produces an error (or it tries to alloc something like INT_MAX-1, for which there is indeed not enough memory).

You can try with nnz_jac_g=0 and nnz_h_lag=0. I don't remember whether the Jacobian approx still needed the sparsity pattern of the Jacobian, though. Do yourself a favor and provide at least first derivatives.

1 reply

wladimirpetrov Oct 20, 2023
Author

Thank you for response!
I changed the following lines, it worked:

nnz_jac_g = 0;
nnz_h_lag = 0;

Commented out the line:

//app->Options()->SetStringValue("jacobian_approximation", "finite-difference-values");
    // Compute Gradient automatically

left the line unchanged:

app->Options()->SetStringValue("gradient_approximation", "finite-difference-values");

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

EXIT: Not enough memory #717

{{title}}

Replies: 2 comments 2 replies

{{title}}

{{editor}}'s edit

{{editor}}'s edit

{{title}}

{{title}}

{{title}}

{{editor}}'s edit

{{editor}}'s edit

Select a reply

EXIT: Not enough memory #717

wladimirpetrov Oct 19, 2023

Replies: 2 comments · 2 replies

wladimirpetrov Oct 19, 2023 Author

wladimirpetrov Oct 19, 2023 Author

svigerske Oct 20, 2023 Maintainer

wladimirpetrov Oct 20, 2023 Author

wladimirpetrov
Oct 19, 2023

Replies: 2 comments 2 replies

wladimirpetrov
Oct 19, 2023
Author

wladimirpetrov Oct 19, 2023
Author

svigerske
Oct 20, 2023
Maintainer

wladimirpetrov Oct 20, 2023
Author