type_concsolver.h

Go to the documentation of this file.

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/*                                                                           */
/*                  This file is part of the program and library             */
/*         SCIP --- Solving Constraint Integer Programs                      */
/*                                                                           */
/*  Copyright (c) 2002-2026 Zuse Institute Berlin (ZIB)                      */
/*                                                                           */
/*  Licensed under the Apache License, Version 2.0 (the "License");          */
/*  you may not use this file except in compliance with the License.         */
/*  You may obtain a copy of the License at                                  */
/*                                                                           */
/*      http://www.apache.org/licenses/LICENSE-2.0                           */
/*                                                                           */
/*  Unless required by applicable law or agreed to in writing, software      */
/*  distributed under the License is distributed on an "AS IS" BASIS,        */
/*  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. */
/*  See the License for the specific language governing permissions and      */
/*  limitations under the License.                                           */
/*                                                                           */
/*  You should have received a copy of the Apache-2.0 license                */
/*  along with SCIP; see the file LICENSE. If not visit scipopt.org.         */
/*                                                                           */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
/**@file   type_concsolver.h
 * @ingroup TYPEDEFINITIONS
 * @brief  type definitions for concurrent solvers
 * @author Leona Gottwald
 * @author Marc Pfetsch
 *
 * This file defines the interface for concurrent solvers.
 *
 */
 
/*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
 
#ifndef __SCIP_TYPE_CONCSOLVER_H__
#define __SCIP_TYPE_CONCSOLVER_H__
 
#include "scip/def.h"
#include "scip/type_scip.h"
#include "scip/type_stat.h"
#include "scip/type_lp.h"
#include "scip/type_syncstore.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef struct SCIP_ConcSolverType SCIP_CONCSOLVERTYPE;          /**< the struct defining a concurrent solver class */
typedef struct SCIP_ConcSolverTypeData SCIP_CONCSOLVERTYPEDATA;  /**< concurrent solver class user data */
typedef struct SCIP_ConcSolver SCIP_CONCSOLVER;                  /**< struct for an instance of a concurrent solver */
typedef struct SCIP_ConcSolverData SCIP_CONCSOLVERDATA;          /**< concurrent solver user data */
 
/** creates a concurrent solver instance
 *
 *  input:
 *  - scip            : SCIP main data structure
 *  - concsolvertype  : type of concurrent solver an instance should be created for
 *  - concsolver      : pointer to return concurrent solver instance
 *
 *  returns SCIP_OKAY if everything worked, otherwise, a suitable error code
 */
#define SCIP_DECL_CONCSOLVERCREATEINST(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONCSOLVERTYPE* concsolvertype, SCIP_CONCSOLVER* concsolver)
 
/** destroys a concurrent solver instance
 *
 *  input:
 *  - scip            : SCIP main data structure
 *  - concsolver      : concurrent solver instance to destroy
 *
 *  returns SCIP_OKAY if everything worked, otherwise, a suitable error code
 */
#define SCIP_DECL_CONCSOLVERDESTROYINST(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONCSOLVER* concsolver)
 
/** frees data of a concurrent solver type
 *
 *  input:
 *  - data            : concurrent solver type data to free
 *
 *  returns SCIP_OKAY if everything worked, otherwise, a suitable error code
 */
#define SCIP_DECL_CONCSOLVERTYPEFREEDATA(x) void x (SCIP_CONCSOLVERTYPEDATA** data)
 
/** initialize random seeds of a concurrent solver
 *
 *  input:
 *  - concsolver      : concurrent solver data structure
 *  - seed            : seed for initializing the solver's internal random seeds
 *
 *  returns SCIP_OKAY if everything worked, otherwise, a suitable error code
 */
#define SCIP_DECL_CONCSOLVERINITSEEDS(x) SCIP_RETCODE x (SCIP_CONCSOLVER* concsolver, unsigned int seed)
 
/** synchronization method of concurrent solver for writing data
 *
 *  Syncronizes with other solvers. The concurrent solver should pass new solutions
 *  and bounds to the syncstore. For the solutions, no more than maxcandsols of the best solutions
 *  should be considered for sharing. Additionally a maximum if maxsharedsols should be
 *  passed to the syncstore.
 *
 *  input:
 *  - concsolver      : concurrent solver data structure
 *  - syncstore       : pointer to the SCIP synchronization store
 *  - syncdata        : synchronization data
 *  - maxcandsols     : maximal number of best solutions that should be considered for sharing
 *  - maxsharedsols   : maximum number of solutions that should be shared
 *  - nsolsshared     : pointer to return the number of solutions shared
 *
 *  returns SCIP_OKAY if everything worked, otherwise, a suitable error code
 */
#define SCIP_DECL_CONCSOLVERSYNCWRITE(x) SCIP_RETCODE x (SCIP_CONCSOLVER* concsolver, SCIP_SYNCSTORE* syncstore, SCIP_SYNCDATA* syncdata, int maxcandsols, int maxsharedsols, int* nsolsshared)
 
/** synchronization method of concurrent solver for reading data
 *
 *  The concurrent solver should read the solutions and bounds stored in the
 *  given synchronization data.
 *
 *  input:
 *  - concsolver      : concurrent solver data structure
 *  - syncstore       : pointer to the SCIP synchronization store
 *  - syncdata        : synchronization data
 *  - nsolsrecvd      : pointer to return the number of received solutions
 *  - ntighterbnds    : pointer to return the number of tighter bounds
 *  - ntighterintbnds : pointer to return the number of tighter integer bounds
 *
 *  returns SCIP_OKAY if everything worked, otherwise, a suitable error code
 */
#define SCIP_DECL_CONCSOLVERSYNCREAD(x) SCIP_RETCODE x (SCIP_CONCSOLVER* concsolver, SCIP_SYNCSTORE* syncstore, SCIP_SYNCDATA* syncdata, int* nsolsrecvd, int* ntighterbnds, int* ntighterintbnds)
 
/** execution method of concurrent solver
 *
 *  start solving of the problem given during initialization
 *
 *  input:
 *  - concsolver      : concurrent solver data structure
 *  - solvingtime     : pointer to return the used solving time
 *  - nlpiterations   : pointer to return the used number of LP iterations
 *  - nnodes          : pointer to return the used number of branch-and-bound nodes
 *
 *  returns SCIP_OKAY if everything worked, otherwise, a suitable error code
 */
#define SCIP_DECL_CONCSOLVEREXEC(x) SCIP_RETCODE x (SCIP_CONCSOLVER* concsolver, SCIP_Real* solvingtime, SCIP_Longint* nlpiterations, SCIP_Longint* nnodes)
 
/** stop the solving as soon as possible
 *
 *  input:
 *  - concsolver      : concurrent solver data structure
 *
 *  returns SCIP_OKAY if everything worked, otherwise, a suitable error code
 */
#define SCIP_DECL_CONCSOLVERSTOP(x) SCIP_RETCODE x (SCIP_CONCSOLVER* concsolver)
 
/** extract the solving data from the concurrent solver
 *
 *  The concurrent solver should get the data and store it into the SCIP datastructure, so that this SCIP instance has
 *  the optimal solution and reports the correct status and statistics.
 *
 *  input:
 *  - concsolver      : concurrent solver data structure
 *  - scip            : SCIP datastructure
 *
 *  returns SCIP_OKAY if everything worked, otherwise, a suitable error code
 */
#define SCIP_DECL_CONCSOLVERCOPYSOLVINGDATA(x) SCIP_RETCODE x (SCIP_CONCSOLVER* concsolver, SCIP* scip)
 
#ifdef __cplusplus
}
#endif
 
#endif