packup-0.6/ 0000755 0001750 0001001 00000000000 11573000741 011745 5 ustar mikolas None packup-0.6/basic_clause.hh 0000644 0001750 0001001 00000014634 11573000740 014712 0 ustar mikolas None /******************************************************************************\
* This file is part of packup. *
* *
* packup is free software: you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* *
* packup is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with packup. If not, see . *
\******************************************************************************/
//jpms:bc
/*----------------------------------------------------------------------------*\
* File: basic_clause.hh
*
* Description: A basic clause is a vector of literals.
*
* Author: jpms
*
* Revision: $Id$.
*
* Copyright (c) 2009, Joao Marques-Silva
\*----------------------------------------------------------------------------*/
//jpms:ec
#ifndef _BASIC_CLAUSE_H
#define _BASIC_CLAUSE_H 1
#include "globals.hh"
//jpms:bc
/*----------------------------------------------------------------------------*\
* Basic types for class BasicClause.
\*----------------------------------------------------------------------------*/
//jpms:ec
typedef vector LitVector;
typedef vector::iterator Literator;
typedef vector::reverse_iterator RLiterator;
//jpms:bc
/*----------------------------------------------------------------------------*\
* Class: BasicClause
*
* Purpose: New organization of clauses, to be used in future tools
\*----------------------------------------------------------------------------*/
//jpms:ec
class BasicClause {
friend class ClauseRegistry;
friend class BasicClauseSet;
protected:
BasicClause(vector& lits) : clits(lits), weight(0), id(0), grp_id(0) {
assert(adjacent_find(lits.begin(),lits.end(),AbsLitGreater())==lits.end());
//sort_lits();
//N
DBG(cout << "Creating clause: [" << *this << "]" << endl;);
}
//BasicClause(int nlits, const long int lits[]) :
//clits(lits, lits+nlits), weight(0) {
//sort_lits();
////N
//DBG(cout << "Creating clause: " << *this << endl;);
//}
virtual ~BasicClause() { clits.clear(); }
public:
ULINT size() { return clits.size(); }
Literator begin() { return clits.begin(); }
Literator end() { return clits.end(); }
protected:
void add_lit(LINT lit) {
clits.push_back(lit); // Currently sorts; it is simpler to insert & shift
assert(clits.size() > 0);
if (abs(lit) < abs(clits[clits.size()-1])) {
sort_lits(); // alternatively:
/* => Seems to be less efficient
Literator pos2 = clits.end();
Literator pos1 = clits.end();
--pos1;
for (--pos1; abs(*pos1) > abs(lit); --pos1, --pos2) {
*pos2 = *pos1;
if (pos1 == clits.begin()) { break; }
}
*pos1 = lit;
*/
//update_internal_data((unsigned)lit);
}
}
void del_lit(LINT lit) {
for (Literator pos = clits.begin(); pos != clits.end(); ++pos) {
if (*pos == lit) { *pos = clits.back(); break; }
}
clits.pop_back(); // Currently sorts; it is simpler to insert & shift
//sort_lits(); // alternatively:
//update_internal_data((unsigned)lit); // hash XOR removes bits due to lit
}
vector& cl_lits() { return clits; }
//ULINT clhash() { return hashval; }
ULINT get_min_lit() { ULINT minid=abs(clits[0]); return minid; }
ULINT get_max_lit() { ULINT maxid=abs(clits[clits.size()-1]); return maxid; }
public: // Weight/group/id functions
void set_weight(XLINT nweight) { weight = nweight; }
XLINT get_weight() { return weight; }
void set_grp_id(ULINT grp) { grp_id = grp; } // ANTON: store it properly
ULINT get_grp_id() { return grp_id; } // ANTON: store it properly
void set_id(ULINT nid) { id = nid; }
ULINT get_id() { return id; }
public: // Comparison functions
friend bool operator > (BasicClause& ptr1, BasicClause& ptr2) {
return
(ptr1.size() > ptr2.size()) ||
(ptr1.size() == ptr2.size() && ptr1.get_id() > ptr2.get_id());
}
friend bool operator < (BasicClause& ptr1, BasicClause& ptr2) {
return
(ptr1.size() < ptr2.size()) ||
(ptr1.size() == ptr2.size() && ptr1.get_id() < ptr2.get_id());
}
public: // Output functions
void dump(ostream& outs=cout) {
// +ANTON added group ID
// outs << "[" << get_grp_id() << "] ";
// -ANTON
Literator lpos = clits.begin();
Literator lend = clits.end();
for (; lpos != lend; ++lpos) {
outs << *lpos << " ";
}
outs << "0";
//outs << endl;
}
friend ostream & operator << (ostream& outs, BasicClause& cl) {
cl.dump(outs);
return outs;
}
protected:
void sort_lits() {
//cout << "Lits A: ";
//copy(clits.begin(), clits.end(), ostream_iterator(cout, " "));
//cout << endl;
//if (!is_sorted(clits.begin(), clits.end(), AbsLitLess())) { }
sort(clits.begin(), clits.end(), AbsLitLess());
//cout << "Lits B: ";
//copy(clits.begin(), clits.end(), ostream_iterator(cout, " "));
//cout << endl;
}
ULINT compute_hash() { // Not being used: see below new hash functions
exit(0);
register ULINT hashv = 0;
for(vector::iterator pos = clits.begin(); pos != clits.end(); ++pos) {
hashv ^= (*pos>0) ? *pos : -*pos;
}
cout << "Hash value: " << hashv << endl; cout.flush();
return hashv;
}
//void update_internal_data(ULINT uval) { sort_lits(); hashval ^= uval; }
protected:
vector clits;
//ULINT hashval;
XLINT weight;
ULINT id;
ULINT grp_id; // ANTON: the actual group ID, rather than using id
};
#endif /* _BASIC_CLAUSE_H */
/*----------------------------------------------------------------------------*/
packup-0.6/basic_clset.hh 0000644 0001750 0001001 00000031070 11573000741 014542 0 ustar mikolas None /******************************************************************************\
* This file is part of packup. *
* *
* packup is free software: you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* *
* packup is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with packup. If not, see . *
\******************************************************************************/
//jpms:bc
/*----------------------------------------------------------------------------*\
* File: basic_clset.hh
*
* Description:
*
* Author: jpms
*
* Revision: $Id$.
*
* Copyright (c) 2009, Joao Marques-Silva
\*----------------------------------------------------------------------------*/
//jpms:ec
#ifndef _BASIC_CLSET_H
#define _BASIC_CLSET_H 1
#include
#include
#include // Location of STL hash extensions
#include // Location of STL hash extensions
using namespace std;
using namespace __gnu_cxx; // Required for STL hash extensions
#include "globals.hh"
#include "basic_clause.hh"
#include "cl_functors.hh"
#include "cl_types.hh"
#include "cl_registry.hh"
#define SM_CL_SZ 3
//jpms:bc
/*----------------------------------------------------------------------------*\
* Class: BasicClauseSet
*
* Purpose: Container for set of clauses.
\*----------------------------------------------------------------------------*/
//jpms:ec
class BasicClauseSet {
public:
BasicClauseSet() :
clreg(ClauseRegistry::instance()), clauses(), g2cv_map(), clvect() {
top_weight = LONG_MAX; def_clw = top_weight; def_cltype = CL_HARD;
num_hard_cls = num_soft_cls = num_other_cls = num_weighted_cls = 0;
soft_units = false;
}
virtual ~BasicClauseSet() {
/* Clear actual clauses ... */
clauses.clear();
g2cv_map.clear();
clvect.clear();
}
BasicClause* create_clause(LINT nlits, const LINT lits[]) {
BasicClause* ncl = clreg.create_clause(nlits, lits);
return insert_clause(ncl);
}
BasicClause* create_clause(vector& clits) {
BasicClause* ncl = clreg.create_clause(clits);
return insert_clause(ncl);
}
BasicClause* create_clause(vector& clits, LINT clid) {
BasicClause* ncl = clreg.create_clause(clits);
set_cl_id(ncl, clid);
return insert_clause(ncl);
}
BasicClause* create_unit_clause(LINT lit) {
assert(lit != 0);
LINT lits[] = { lit };
return create_clause(1, lits);
}
BasicClause* create_binary_clause(LINT lit1, LINT lit2) {
assert(lit1 != 0 && lit2 != 0);
LINT lits[] = { lit1, lit2 };
return create_clause(2, lits);
}
BasicClause* create_ternary_clause(LINT lit1, LINT lit2, LINT lit3) {
assert(lit1 != 0 && lit2 != 0 && lit3 != 0);
LINT lits[] = { lit1, lit2, lit3 };
return create_clause(3, lits);
}
BasicClause* insert_clause(BasicClause* ncl) {
// Clause is assumed to already exist; no need to set its type
HashedClauseSet::iterator cpos = clauses.find(ncl);
if (cpos == clauses.end()) {
clauses.insert(ncl);
clreg.incr_cl_refs(ncl);
set_def_cltype(ncl); // Clause is new; set type as default type
} DBG(else { cout << "Clause already exists: "<<*ncl<& clits) { return clreg.lookup_vect(clits); }
BasicClause* lookup(LINT num, const LINT ivect[]) {
return clreg.lookup_vect(num, ivect);
}
ULINT get_cl_min_lit(BasicClause* cl) { return cl->get_min_lit(); }
ULINT get_cl_max_lit(BasicClause* cl) { return cl->get_max_lit(); }
void set_num_vars(ULINT nvars) { }
ULINT get_num_vars() { return -1; }
void set_num_cls(ULINT ncls) { }
ULINT get_num_cls() { return size(); }
void set_top(XLINT topv) { assert(clauses.size() == 0); top_weight = topv; }
XLINT get_top() { return top_weight; }
void set_num_grp(XLINT ngrp) { top_weight = ngrp; }
XLINT get_num_grp() { return top_weight; }
vector& get_cl_lits(BasicClause* cl) { return cl->cl_lits(); }
void cl_lits(BasicClause* cl, IntVector lvect) {
Literator lpos = cl->begin(); Literator lend = cl->end();
for(; lpos != lend; ++lpos) { lvect.push_back(*lpos); }
}
// Preferably use incr_cl_weight
void set_cl_weight(BasicClause* cl, XLINT clweight = 1) {
// For repeated clauses, need to update existing weight
cl->set_weight((clweight >= top_weight) ? top_weight : clweight);
// Stats
if (clweight == top_weight) { ++num_hard_cls; }
else if (clweight == 1) { ++num_soft_cls; }
else { ++num_other_cls; }
++num_weighted_cls;
}
XLINT get_cl_weight(BasicClause* cl) { return cl->get_weight(); }
XLINT incr_cl_weight(BasicClause* cl, XLINT incr) {
// For repeated clauses, need to update existing weight
if (!is_cl_hard(cl)) {
XLINT nw = (cl->get_weight() + incr < top_weight) ?
(cl->get_weight() + incr) : top_weight;
cl->set_weight(nw);
} //else { assert(0); }
return cl->get_weight();
}
XLINT decr_cl_weight(BasicClause* cl, XLINT decr) {
// For repeated clauses, need to update existing weight
if (!is_cl_hard(cl)) { cl->set_weight(cl->get_weight() - decr); }
else { assert(0); }
return cl->get_weight();
}
void set_cl_id(BasicClause* cl, ULINT clid) { cl->set_id(clid); }
ULINT get_cl_id(BasicClause* cl) { return cl->get_id(); }
void set_cl_grp_id(BasicClause* cl, ULINT gid) { cl->set_grp_id(gid); }
ULINT get_cl__grp_id(BasicClause* cl) { return cl->get_grp_id(); }
void set_cl_group(BasicClause* cl, XLINT clgrp) {
cl->set_weight(clgrp);
vector* bcvect = NULL;
XLInt2ClVMap::iterator ipos = g2cv_map.find(clgrp);
if (ipos == g2cv_map.end()) {
bcvect = new vector();
g2cv_map.insert(make_pair(clgrp, bcvect));
}
else {
bcvect = ipos->second;
bcvect->push_back(cl);
}
}
XLINT get_cl_group(BasicClause* cl) {
return cl->get_weight();
}
void set_cl_hard(BasicClause* cl) { set_cl_weight(cl, top_weight); }
void set_cl_soft(BasicClause* cl) { set_cl_weight(cl, 1); }
bool is_cl_hard(BasicClause* cl) {
XLINT clw = get_cl_weight(cl);
return clw >= top_weight;
}
bool is_cl_soft(BasicClause* cl) {
XLINT clw = get_cl_weight(cl);
return clw < top_weight;
}
bool is_cl_unit(BasicClause* cl) { return cl->size() == 1; }
void set_def_cl_hard() { def_cltype = CL_HARD; }
void set_def_cl_soft() { def_cltype = CL_SOFT; }
void set_def_cl_weight(XLINT nclw) {
def_cltype = CL_WEIGHTED; def_clw = nclw; }
public: // Properties of clause set: hard & soft clauses
bool all_soft_unit() { return soft_units; }
void compute_properties() {
compute_hard_cl_properties(); compute_soft_cl_properties(); }
void compute_hard_cl_properties() { }
void compute_soft_cl_properties() {
DBG(LINT clcnt = size(); LINT scnt = 0;);
cset_iterator cpos = begin();
cset_iterator cend = end();
soft_units = true;
for(; cpos!=cend; ++cpos) {
BasicClause* cl = *cpos;
if (is_cl_soft(cl)) {
if (cl->size() != 1) { soft_units = false; break; }
DBG(scnt++; if (cl->size() != 1) { soft_units = false; });
}
}
DBG(cout << "Number of clauses: " << clcnt << endl;
cout << " Soft clauses: " << scnt << endl;
cout << "All soft clauses are unit.\n";);
}
public: // Access to clauses
cset_iterator begin() { return clauses.begin(); }
cset_iterator end() { return clauses.end(); }
cset_iterator find(BasicClause* cl) { return clauses.find(cl); }
ULINT size() { return clauses.size(); }
ClVectIterator svect_begin() {
// Resize vector of cl pointers
if (clvect.size() < clauses.size()) { clvect.resize(clauses.size()); }
// Fill in vector of cl pointers
ClSetIterator cpos = clauses.begin();
ClSetIterator cend = clauses.end();
ClVectIterator vpos = clvect.begin();
for (; cpos != cend; ++cpos, ++vpos) { *vpos = *cpos; }
// Sort cl pointers
sort(clvect.begin(), clvect.end(), PtrLess());
// Return iterator for sorted vector of cl pointers
return clvect.begin();
}
ClVectIterator svect_end() { return clvect.end(); }
public: // Clean up
inline void clear() {
clear_direct();
//clear_indirect();
}
// Simple clear, with a single pass, currently being tested (jpms@20100415)
inline void clear_direct() {
cset_iterator cpos = begin();
cset_iterator cend = end();
for(LINT i=0; cpos != cend; ++cpos, ++i) {
BasicClause* cl = *cpos;
if (clreg.decr_cl_refs(cl) == 0) { clreg.erase_clause(cl); }
}
clauses.clear();
}
// Safe version of clear, using vector
inline void clear_indirect() {
BasicClauseVector clvect; clvect.resize(size(), NULL);
cset_iterator cpos = begin();
cset_iterator cend = end();
for(LINT i=0; cpos != cend; ++cpos, ++i) { clvect[i] = *cpos; }
clauses.clear();
BasicClauseVector::iterator dpos = clvect.begin();
BasicClauseVector::iterator dend = clvect.end();
for(; dpos != dend; ++dpos) {
BasicClause* cl = *dpos;
if (clreg.decr_cl_refs(cl) == 0) { clreg.erase_clause(cl); }
}
clvect.clear();
}
public: // Stats
ULINT get_num_hard_cls() { return num_hard_cls; }
ULINT get_num_soft_cls() { return num_soft_cls; }
ULINT get_num_nonsofthard_cls() { return num_other_cls; }
ULINT get_num_weighted_cls() { return num_weighted_cls; }
public: // Output functions
void dump(ostream& outs=cout) {
DBG(LINT clcnt = 0);
cset_iterator cpos = clauses.begin();
cset_iterator cend = clauses.end();
for (; cpos != cend; ++cpos) {
outs << **cpos << " ";
outs << endl;
DBG(clcnt++;)
}
DBG(outs<<"Done... CLSET Size: "<. *
\******************************************************************************/
//jpms:bc
/*----------------------------------------------------------------------------*\
* File: basic_types.h
*
* Description: Basic types used by BOLT.
*
* Author: jpms
*
* Revision: $Id$.
*
* Copyright (c) 2009, Joao Marques-Silva
\*----------------------------------------------------------------------------*/
//jpms:ec
#ifndef _BASIC_TYPES_H
#define _BASIC_TYPES_H 1
/*----------------------------------------------------------------------------*\
* Values besides 0 and 1
\*----------------------------------------------------------------------------*/
#ifdef __LP64__
typedef unsigned long long int ULINT;
typedef long long int LINT;
#define MAXLINT LLONG_MAX;
#define MINLINT LLONG_MIN;
#define MAXULINT ULLONG_MAX;
#else
typedef unsigned long int ULINT;
typedef long int LINT;
#define MAXLINT LONG_MAX;
#define MINLINT LONG_MIN;
#define MAXULINT ULONG_MAX;
#endif
#ifdef GMPDEF
#include
typedef mpz_class XLINT;
#define ToLint(x) x.get_si()
#else
typedef LINT XLINT;
#define ToLint(x) (LINT)x
#endif
#endif /* _BASIC_TYPES_H */
/*----------------------------------------------------------------------------*/
packup-0.6/clause_utils.hh 0000644 0001750 0001001 00000004073 11573000741 014766 0 ustar mikolas None /******************************************************************************\
* This file is part of packup. *
* *
* packup is free software: you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* *
* packup is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with packup. If not, see . *
\******************************************************************************/
//jpms:bc
/*----------------------------------------------------------------------------*\
* File: clause_utils.hh
*
* Description: Utilities for the
*
* Author: jpms
*
* Revision: $Id$.
*
* Copyright (c) 2009, Joao Marques-Silva
\*----------------------------------------------------------------------------*/
//jpms:ec
#ifndef _CLAUSE_UTILS_H
#define _CLAUSE_UTILS_H 1
#include "basic_clause.hh"
/*----------------------------------------------------------------------------*\
* Classes to be used in the definition of hash sets and maps
\*----------------------------------------------------------------------------*/
#endif /* _CLAUSE_UTILS_H */
/*----------------------------------------------------------------------------*/
packup-0.6/cl_functors.hh 0000644 0001750 0001001 00000012472 11573000741 014615 0 ustar mikolas None /******************************************************************************\
* This file is part of packup. *
* *
* packup is free software: you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* *
* packup is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with packup. If not, see . *
\******************************************************************************/
//jpms:bc
/*----------------------------------------------------------------------------*\
* File: cl_functors.hh
*
* Description: Functors based on clauses.
*
* Author: jpms
*
* Revision: $Id$.
*
* Copyright (c) 2009, Joao Marques-Silva
\*----------------------------------------------------------------------------*/
//jpms:ec
#ifndef _CL_FUNCTORS_H
#define _CL_FUNCTORS_H 1
#include "basic_clause.hh"
//jpms:bc
/*----------------------------------------------------------------------------*\
* Functors based on class BasicClause
\*----------------------------------------------------------------------------*/
//jpms:ec
class ClauseHash {
public:
ULINT operator()(BasicClause* clref) const { // see below new hash functions
//return clref->clhash(); // -> Very slow; unable to undertand why
register ULINT hashv = 0;
for(Literator pos = clref->begin(); pos != clref->end(); ++pos) {
hashv ^= (*pos>0) ? *pos : -*pos;
} cout << "Hash value: " << hashv << endl; cout.flush();
return hashv;
}
};
class ClauseEqual {
public:
bool operator()(BasicClause* cl1, BasicClause* cl2) const {
if (cl1->size() != cl2->size()) { return false; }
Literator pos1 = cl1->begin(); // Vectors assumed to be sorted
Literator pos2 = cl2->begin();
for(; pos1 != cl1->end(); ++pos1, ++pos2) {
if (*pos1 != *pos2) { return false; }
}
return true;
}
};
class ClPtrHash {
public:
ULINT operator()(const BasicClause* ptr) const { return (ULINT)ptr; }
};
class ClPtrEqual {
public:
bool operator()(const BasicClause* ptr1, const BasicClause* ptr2) const {
return ptr1 == ptr2;
}
};
class ClSizeIDLess {
public:
bool operator()(BasicClause* ptr1, BasicClause* ptr2) const {
return
ptr1->size() < ptr2->size() ||
ptr1->size() == ptr2->size() && ptr1->get_id() < ptr2->get_id();
}
};
class ClSizeIDGreater {
public:
bool operator()(BasicClause* ptr1, BasicClause* ptr2) const {
return
ptr1->size() > ptr2->size() ||
ptr1->size() == ptr2->size() && ptr1->get_id() > ptr2->get_id();
}
};
class ClIDLess {
public:
bool operator()(BasicClause* ptr1, BasicClause* ptr2) const
{
return ptr1->get_id() < ptr2->get_id();
}
};
class ClIDGreater {
public:
bool operator()(BasicClause* ptr1, BasicClause* ptr2) const
{
return ptr1->get_id() > ptr2->get_id();
}
};
#define HPSHIFT 3
#define HNSHIFT 2
class LitVectHash {
public:
ULINT operator()(vector* lvect) const {
//cout << "VECT SIZE:" << lvect->size() <::iterator pos=lvect->begin(); pos!=lvect->end(); ++pos) {
// v3:
hashv = (hashv << HPSHIFT) ^ ((*pos>0) ? *pos : -*pos);
/*
// v5:
hashv = (hashv << HPSHIFT) ^ (*pos);
// v4:
hashv =
(*pos>0) ? ((hashv << HPSHIFT) ^ *pos) : ((hashv >> HNSHIFT) ^ -*pos);
// v3:
hashv = (hashv << HPSHIFT) ^ ((*pos>0) ? *pos : -*pos);
// v2:
hashv ^= ((*pos>0) ? *pos : -*pos);
// v1:
hashv *= fabs(*pos);
*/
} //cout << "Hash value: " << hashv << endl; cout.flush();
return hashv;
}
};
class LitVectEqual {
public:
bool operator()(vector* lv1, vector* lv2) const {
if (lv1->size() != lv2->size()) { return false; }
Literator pos1 = lv1->begin(); // Vectors assumed to be sorted
Literator pos2 = lv2->begin();
for(; pos1 != lv1->end(); ++pos1, ++pos2) { // vectors w/ the same size
if (*pos1 != *pos2) { return false; }
}
/* Not as efficient...
for(register int k=0; ksize(); ++k) { // vectors w/ the same size
if ((*lv1)[k] != (*lv2)[k]) { return false; }
} //cout<<((pos1==lv1->end()&&pos2==lv2->end())?"TRUE":"FALSE B")<. *
\******************************************************************************/
//jpms:bc
/*----------------------------------------------------------------------------*\
* File: cl_globals.hh
*
* Description: Complete definitions for clauses and clause sets.
*
* Author: jpms
*
* Revision: $Id$.
*
* Copyright (c) 2009, Joao Marques-Silva
\*----------------------------------------------------------------------------*/
//jpms:ec
#ifndef _CL_GLOBALS_H
#define _CL_GLOBALS_H 1
#include
#include
#include // Location of STL hash extensions
#include // Location of STL hash extensions
using namespace std;
using namespace __gnu_cxx; // Required for STL hash extensions
#include "globals.hh"
#include "basic_clause.hh"
#include "cl_functors.hh"
#include "cl_types.hh"
#include "cl_registry.hh"
#endif /* _CL_GLOBALS_H */
/*----------------------------------------------------------------------------*/
packup-0.6/cl_registry.cc 0000644 0001750 0001001 00000003530 11573000742 014604 0 ustar mikolas None /******************************************************************************\
* This file is part of packup. *
* *
* packup is free software: you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* *
* packup is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with packup. If not, see . *
\******************************************************************************/
//jpms:bc
/*----------------------------------------------------------------------------*\
* File: cl_registry.cc
*
* Description: Definition of static variables for the ClauseRegistry.
*
* Author: jpms
*
* Revision: $Id$.
*
* Copyright (c) 2009, Joao Marques-Silva
\*----------------------------------------------------------------------------*/
//jpms:ec
#include "cl_registry.hh"
ClauseRegistry ClauseRegistry::clreg_instance;
/*----------------------------------------------------------------------------*/
packup-0.6/cl_registry.hh 0000644 0001750 0001001 00000013660 11573000742 014623 0 ustar mikolas None /******************************************************************************\
* This file is part of packup. *
* *
* packup is free software: you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* *
* packup is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with packup. If not, see . *
\******************************************************************************/
//jpms:bc
/*----------------------------------------------------------------------------*\
* File: cl_registry.hh
*
* Description:
*
* Author: jpms
*
* Revision: $Id$.
*
* Copyright (c) 2009, Joao Marques-Silva
\*----------------------------------------------------------------------------*/
//jpms:ec
#ifndef _CL_REGISTRY_H
#define _CL_REGISTRY_H 1
#include
#include
#include // Location of STL hash extensions
#include // Location of STL hash extensions
#include // Location of STL hash extensions
using namespace std;
using namespace __gnu_cxx; // Required for STL hash extensions
#include "globals.hh"
#include "basic_clause.hh"
#include "cl_functors.hh"
#include "cl_types.hh"
//jpms:bc
/*----------------------------------------------------------------------------*\
* Class: ClauseRegistry
*
* Purpose: Unique registry for created clauses.
\*----------------------------------------------------------------------------*/
//jpms:ec
class ClauseRegistry {
friend class BasicClauseSet;
public:
static ClauseRegistry& instance() { return clreg_instance; }
protected:
ClauseRegistry() : v2p_map(), c2n_map() { }
virtual ~ClauseRegistry() {
/* Clear actual clauses ... */
v2p_map.clear();
c2n_map.clear();
}
BasicClause* create_clause(LINT nlits, const LINT lits[]) {
vector clits(lits, lits+nlits);
sort(clits.begin(), clits.end(), AbsLitLess());
remove_duplicates(clits);
BasicClause* ncl = lookup_vect(clits);
if (ncl != NULL) { return ncl; }
ncl = new BasicClause(clits);
register_clause(ncl);
return ncl;
}
BasicClause* create_clause(vector& clits) {
sort(clits.begin(), clits.end(), AbsLitLess());
remove_duplicates(clits);
BasicClause* ncl = lookup_vect(clits);
if (ncl != NULL) {
DBG(cout << "Clause exists: " << *ncl << endl;);
return ncl; }
ncl = new BasicClause(clits);
register_clause(ncl);
return ncl;
}
LINT num_cl_refs(BasicClause* cl) {
c2n_iterator cpos = c2n_map.find(cl);
assert(cpos != c2n_map.end());
return cpos->second;
}
LINT incr_cl_refs(BasicClause* cl) {
c2n_iterator cpos = c2n_map.find(cl);
assert(cpos != c2n_map.end());
return ++cpos->second;
}
LINT decr_cl_refs(BasicClause* cl) {
c2n_iterator cpos = c2n_map.find(cl);
assert(cpos != c2n_map.end());
return --cpos->second;
}
void register_clause(BasicClause* ncl) {
// Map from lit vect to cl
vector& lits = ncl->cl_lits();
assert(v2p_map.find(&lits) == v2p_map.end());
v2p_map.insert(make_pair(&lits, ncl));
// Map from cl to ref cnt
LINT nclref = 0;
c2n_map.insert(make_pair(ncl, nclref));
}
void add_literal(BasicClause* cl, LINT nlit) {
CHK(ULINT mapsz = v2p_map.size(););
vector& clits = cl->cl_lits();
v2p_map.erase(&clits);
cl->add_lit(nlit);
vector& nclits = cl->cl_lits();
v2p_map.insert(make_pair(&nclits, cl));
CHK(assert(mapsz == v2p_map.size()));
}
void erase_clause(BasicClause* cl) {
NDBG(cout << "Erasing clause: " << *cl << endl;);
vector& clits = cl->cl_lits();
assert(v2p_map.find(&clits) != v2p_map.end());
v2p_map.erase(&clits);
delete cl;
}
BasicClause* lookup_vect(vector& clits) {
assert(is_sorted(clits.begin(), clits.end(), AbsLitLess()));
iv2cl_iterator ippos = v2p_map.find(&clits);
return (ippos != v2p_map.end()) ? ippos->second : NULL;
}
BasicClause* lookup_vect(LINT num, const LINT ivect[]) {
vector clits(ivect, ivect+num);
iv2cl_iterator ippos = v2p_map.find(&clits);
return (ippos != v2p_map.end()) ? ippos->second : NULL;
}
protected:
// Remove duplicate literals
void remove_duplicates(vector& clits) {
DBG(PRINT_ELEMENTS(clits); cout << endl;);
unsigned int i = 1;
unsigned int j = 1;
for(; i j) { clits.resize(j); } // Final clause size
DBG(PRINT_ELEMENTS(clits, "Final cl: ", " ");)
}
protected:
IVec2ClMap v2p_map;
Clause2IntMap c2n_map;
static ClauseRegistry clreg_instance;
};
#endif /* _CL_REGISTRY_H */
/*----------------------------------------------------------------------------*/
packup-0.6/cl_types.hh 0000644 0001750 0001001 00000011066 11573000741 014114 0 ustar mikolas None /******************************************************************************\
* This file is part of packup. *
* *
* packup is free software: you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* *
* packup is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with packup. If not, see . *
\******************************************************************************/
//jpms:bc
/*----------------------------------------------------------------------------*\
* File: cl_types.hh
*
* Description: Types derived from clauses and clause sets.
*
* Author: jpms
*
* Revision: $Id$.
*
* Copyright (c) 2009, Joao Marques-Silva
\*----------------------------------------------------------------------------*/
//jpms:ec
#ifndef _CL_TYPES_H
#define _CL_TYPES_H 1
#include "basic_clause.hh"
#include "cl_functors.hh"
typedef enum ClTypes {
CL_HARD = 0x10,
CL_SOFT = 0x20,
CL_WEIGHTED = 0x30
} ClauseTypes;
//jpms:bc
/*----------------------------------------------------------------------------*\
* Type definitions.
\*----------------------------------------------------------------------------*/
//jpms:ec
class BasicClauseSet;
typedef BasicClause* BasicClausePtr;
typedef BasicClause** BasicClausePtrPtr;
//typedef hash_set HashedClauseSet;
typedef hash_set HashedClauseSet;
typedef HashedClauseSet::iterator ClSetIterator;
typedef HashedClauseSet::iterator cset_iterator;
typedef hash_map Clause2IntMap;
typedef hash_map IVec2ClMap;
typedef IVec2ClMap::iterator iv2cl_iterator;
typedef vector BasicClauseVector;
typedef BasicClauseVector::iterator ClVectIterator;
typedef slist BasicClauseSList;
typedef list BasicClauseList;
typedef vector BasicClauseSetVector;
typedef IntKeyMap*> Int2ClVectMap;
//typedef hash_map*,IntHash,IntEqual> Int2ClVectMap;
typedef hash_map*,ClPtrHash,ClPtrEqual> Cl2IntVMap;
typedef hash_map*,ClPtrHash,ClPtrEqual> Cl2ClVMap;
typedef hash_map Cl2IntMap;
typedef Cl2IntMap::iterator c2n_iterator;
typedef hash_map Int2ClMap;
//typedef hash_map*,IntHash,IntEqual> Int2IntVMap;
typedef hash_map Cl2ClMap;
typedef
vector ClauseSetVector;
typedef
hash_map Int2ClVMap;
typedef
hash_map XLInt2ClVMap;
typedef
hash_map*,ClPtrHash,ClPtrEqual> Cl2IntVMap;
typedef
hash_map*,ClPtrHash,ClPtrEqual> Cl2ClVMap;
typedef
hash_map Cl2IntMap;
typedef
hash_map Int2ClMap;
typedef
hash_map*,IntHash,IntEqual> Int2IntVMap;
//typedef
//hash_map Int2ClVMap;
typedef
vector VectCl2IntMap;
typedef
vector VectClSet;
typedef
vector VectHashedClauseSet;
//typedef
//vector*> IntVCl2IntMap;
//typedef hash_map,IntHash,IntEqual> Int2ClVMap;
//typedef
//hash_map Cl2ClPMap;
#endif /* _CL_TYPES_H */
/*----------------------------------------------------------------------------*/
packup-0.6/cl_utils.hh 0000644 0001750 0001001 00000012553 11573000741 014112 0 ustar mikolas None /******************************************************************************\
* This file is part of packup. *
* *
* packup is free software: you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* *
* packup is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with packup. If not, see . *
\******************************************************************************/
//jpms:bc
/*----------------------------------------------------------------------------*\
* File: cl_utils.hh
*
* Description: Clause set utilities.
*
* Author: jpms
*
* Copyright (c) 2010, Joao Marques-Silva
\*----------------------------------------------------------------------------*/
//jpms:ec
#ifndef _CL_UTILS_H
#define _CL_UTILS_H 1
//jpms:bc
/*----------------------------------------------------------------------------*\
* Namespace: ClSetUtils
*
* Purpose: Clause set utilities. Examples include intersection of two clsets.
\*----------------------------------------------------------------------------*/
//jpms:ec
namespace ClSetUtils {
// Template functions for performing intersection of two sets P and Q,
// such that Q is a subset of P
// Version 1: Direct deletion of elements from P
template
void intersect_clset(T& P, U& Q) {
CHK(int psz = P.size(); int qsz = Q.size(););
// Create temporary container
vector vect;
vect.resize(P.size()+Q.size(), NULL);
typename vector::iterator vpos = vect.begin();
// Fill container with contents of P and Q
I ppos = P.begin();
I pend = P.end();
for(; ppos != pend; ++ppos, ++vpos) {
assert(vpos != vect.end()); *vpos = *ppos;
}
typename U::iterator qpos = Q.begin();
typename U::iterator qend = Q.end();
for(; qpos != qend; ++qpos, ++vpos) {
assert(vpos != vect.end()); *vpos = *qpos;
}
// Sort contents of container
sort(vect.begin(), vect.end());
// Keep duplicates; remove everything else
typename vector::iterator vref = vect.begin();
typename vector::iterator vend = vect.end();
vpos = vect.begin(); ++vpos;
for(; vref != vend; vref++, vpos++) {
if (vpos == vend || *vref != *vpos) {
assert(P.find(*vref) != P.end());
P.rm_clause(*vref);
}
else { vref++; vpos++; }
}
CHK(cout << "Init P size: " << psz << endl;
cout << "Init Q size: " << qsz << endl;
cout << " Final P size: " << P.size() << endl);
assert((LINT)P.size() == qsz);
vect.clear();
}
// Version 2: with callback for removing elements
template
void intersect_clset(T& P, U& Q, E& robj, V rm_elem) {
CHK(int psz = P.size(); int qsz = Q.size(););
// Create temporary container
vector vect;
vect.resize(P.size()+Q.size(), NULL);
typename vector::iterator vpos = vect.begin();
// Fill container with contents of P and Q
I ppos = P.begin();
I pend = P.end();
for(; ppos != pend; ++ppos, ++vpos) {
assert(vpos != vect.end()); *vpos = *ppos;
}
typename U::iterator qpos = Q.begin();
typename U::iterator qend = Q.end();
for(; qpos != qend; ++qpos, ++vpos) {
assert(vpos != vect.end()); *vpos = *qpos;
}
// Sort contents of container
sort(vect.begin(), vect.end());
// Keep duplicates; remove everything else
typename vector::iterator vref = vect.begin();
typename vector::iterator vend = vect.end();
vpos = vect.begin(); ++vpos;
for(; vref != vend; vref++, vpos++) {
if (vpos == vend || *vref != *vpos) { (robj->*rm_elem)(*vref); }
else { vref++; vpos++; }
}
CHK(cout << "Init P size: " << psz << endl;
cout << "Init Q size: " << qsz << endl;
cout << " Final P size: " << P.size() << endl);
assert((LINT)P.size() == qsz);
vect.clear();
}
// Export clause set in WCNF format
template
void export_wcnf(C& cset, U nv, ostream& outs=cout)
{
ULINT topw = cset.get_top();
outs << "p wcnf " << nv << " " << cset.size() << " " << topw << endl;
ClSetIterator cpos = cset.begin();
ClSetIterator cend = cset.end();
for (; cpos != cend; ++cpos) {
if (cset.is_cl_soft(*cpos)) {
outs << "1 " << **cpos << endl;
}
else {
outs << topw << " " << **cpos << endl;
}
}
}
}
#endif /* _CL_UTILS_H */
/*----------------------------------------------------------------------------*/
packup-0.6/collections.cc 0000644 0001750 0001001 00000003656 11573000736 014610 0 ustar mikolas None /******************************************************************************\
* This file is part of packup. *
* *
* packup is free software: you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* *
* packup is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with packup. If not, see . *
\******************************************************************************/
/* Copyright (C) 2011, Mikolas Janota*/
#include "collections.hh"
void collection_printing::print(CONSTANT PackageVersionsList &pvl,ostream& out)
{
for (UINT i=0;i0) out << ", ";
pvl[i].print(out);
}
}
void collection_printing::print(CONSTANT PackageVersionList &pvl,ostream& out)
{
for (UINT i=0;i0) out << ", ";
out << pvl[i].to_string();
}
}
void collection_printing::print(CONSTANT PackageVersionsCNF &pvs_cnf, ostream& out)
{
for (UINT i=0;i0) out << " & ";
print(*(pvs_cnf[i]), out);
}
}
packup-0.6/collections.hh 0000644 0001750 0001001 00000006202 11573000736 014610 0 ustar mikolas None /******************************************************************************\
* This file is part of packup. *
* *
* packup is free software: you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* *
* packup is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with packup. If not, see . *
\******************************************************************************/
/*
* File: collections.hh
* Author: mikolas
*
* Created on September 19, 2010, 3:04 PM
* Copyright (C) 2011, Mikolas Janota
*/
#ifndef COLLECTIONS_HH
#define COLLECTIONS_HH
#include "common_types.hh"
#include "PackageVersions.hh"
#include "package_version.hh"
typedef unordered_map VariableToName;
typedef vector VersionsList;
typedef vector PackageVersionsList;
typedef vector PackageVersionsCNF;
typedef vector PackageVersionList;
typedef unordered_map< const char*,string,__gnu_cxx::hash, streq > Str2Str;
typedef unordered_map PackageVersionMap;
typedef unordered_map VariableToPackageVersion;
typedef vector VersionVector;
typedef vector LiteralVector;
typedef unordered_set VersionSet;
typedef unordered_set VariableSet;
typedef unordered_map PackageToVersions;
typedef unordered_map PackageToVersion;
typedef unordered_map FeaturesToPackages;
typedef unordered_map PackageToFeatureVersions;
typedef unordered_set PackageVersionSet;
typedef unordered_set PackageVersionsSet;
typedef unordered_map FeatureToVersions;
typedef unordered_set StringSet;
namespace collection_printing {
void print(CONSTANT PackageVersionsList& pvl,ostream& out);
void print(CONSTANT PackageVersionList& pvl, ostream& out);
void print(CONSTANT PackageVersionsCNF& pvs_cnf, ostream& out);
}
#endif /* COLLECTIONS_HH */
packup-0.6/common_types.cc 0000644 0001750 0001001 00000007132 11573000737 015000 0 ustar mikolas None /******************************************************************************\
* This file is part of packup. *
* *
* packup is free software: you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* *
* packup is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with packup. If not, see . *
\******************************************************************************/
/* Copyright (C) 2011, Mikolas Janota */
#include
#include
#include "common_types.hh"
using namespace version_operators;
bool version_operators::evaluate(Version version_1, Operator op, Version version_2) {
switch (op) {
case VERSIONS_NONE: return true;
case VERSIONS_EQUALS: return version_1 == version_2;
case VERSIONS_NOT_EQUALS: return version_1 != version_2;
case VERSIONS_GREATER_EQUALS: return version_1 >= version_2;
case VERSIONS_GREATER: return version_1 > version_2;
case VERSIONS_LESS_EQUALS: return version_1 <= version_2;
case VERSIONS_LESS: return version_1 < version_2;
}
assert(false);
return NULL;
}
const char* version_operators::to_string(Operator op) {
switch (op) {
case VERSIONS_NONE: return "";
case VERSIONS_EQUALS: return "=";
case VERSIONS_NOT_EQUALS: return "!=";
case VERSIONS_GREATER_EQUALS: return ">=";
case VERSIONS_GREATER: return ">";
case VERSIONS_LESS_EQUALS: return "<=";
case VERSIONS_LESS: return "<";
}
assert(false);
return NULL;
}
const string to_string(const Objective& o) {
return string(o.second ? "+" : "-") + to_string(o.first);
}
const char* to_string(OBJECTIVE_FUNCTION f) {
switch (f) {
case COUNT_NEW: return "new";
case COUNT_UNMET_RECOMMENDS: return "unmet_recommends";
case COUNT_REMOVED: return "removed";
case COUNT_NOT_UP_TO_DATE: return "notuptodate";
case COUNT_CHANGED: return "changed";
}
assert(false);
return NULL;
}
void print(const vector& ls, ostream& o) {
bool f = true;
FOR_EACH(vector::const_iterator, i, ls) {
if (!f) o << ',';
f = false;
o << to_string(*i);
}
}
const char* to_string(KeepValue value) {
switch (value) {
case KEEP_NONE: return "KEEP_NONE";
case KEEP_VERSION: return "KEEP_VERSION";
case KEEP_PACKAGE: return "KEEP_PACKAGE";
case KEEP_FEATURE: return "KEEP_FEATURE";
}
assert(false);
return NULL;
}
const char* to_string(Criterion value) {
switch (value) {
case NO_OPTIMIZATION: return "no_optimization";
case PARANOID: return "paranoid";
case TRENDY: return "trendy";
}
assert(false);
return NULL;
}
packup-0.6/common_types.hh 0000644 0001750 0001001 00000007373 11573000737 015021 0 ustar mikolas None /******************************************************************************\
* This file is part of packup. *
* *
* packup is free software: you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* *
* packup is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with packup. If not, see . *
\******************************************************************************/
/*
* File: common_types.hh
* Author: mikolas
*
* Created on August 23, 2010, 8:53 PM
* Copyright (C) 2011, Mikolas Janota
*/
#ifndef COMMON_TYPES_H
#define COMMON_TYPES_H
#include
#include
#include
#include "types.hh"
using __gnu_cxx::hash;
using __gnu_cxx::hash_map;
using __gnu_cxx::hash_set;
using std::string;
using std::vector;
using std::ostream;
#define CNF_OUT(c)
#define CONSTANT const
#define CONTAINS(s,e) ( ((s).find(e))!=(s).end() )
#define SAME_PACKAGE_NAME(n1,n2) (n1.data()==n2.data())
#define unordered_set hash_set
#define unordered_map hash_map
typedef unsigned int UINT;
typedef UINT Version;
typedef set< XLINT, greater > WeightSet;
#ifdef CONV_DBG
#define MAPPING
#undef NDEBUG
#define OUT(c) { c }
#define __PL (cerr << __FILE__ << ":" << __LINE__ << endl).flush();
#else
#define OUT(c)
#define __PL
#endif
#define FOR_EACH(iterator_type,index,iterated)\
for (iterator_type index = (iterated).begin(); index != (iterated).end();++index)
#define FOR_EACH_REV(iterator_type,index,iterated)\
for (iterator_type index = (iterated).rbegin(); index != (iterated).rend();++index)
enum Criterion
{
TRENDY,
PARANOID,
NO_OPTIMIZATION
};
enum OBJECTIVE_FUNCTION
{
COUNT_NEW,
COUNT_UNMET_RECOMMENDS,
COUNT_REMOVED,
COUNT_NOT_UP_TO_DATE,
COUNT_CHANGED
};
typedef pair Objective;
const string to_string(const Objective& o);
const char* to_string(OBJECTIVE_FUNCTION f);
void print(const vector& ls, ostream& o);
namespace version_operators {
enum Operator
{
VERSIONS_NONE,
VERSIONS_EQUALS,
VERSIONS_NOT_EQUALS,
VERSIONS_GREATER_EQUALS,
VERSIONS_GREATER,
VERSIONS_LESS_EQUALS,
VERSIONS_LESS
};
bool evaluate (Version version_1, Operator op, Version version_2);
const char* to_string (Operator op);
} /*end of namespace version_operators */
enum KeepValue
{
KEEP_NONE,
KEEP_VERSION,
KEEP_PACKAGE,
KEEP_FEATURE
};
typedef UINT Variable;
struct streq {
bool operator()(const char* s1, const char* s2) const
{return strcmp(s1, s2) == 0;}
};
namespace __gnu_cxx
{
template<>
struct hash
{
size_t operator()(const std::string& s) const
{
hash h;
return h(s.data());
}
};
} /*end of namespace __gnu_cxx */
const char* to_string (KeepValue value);
const char* to_string (Criterion value);
inline LINT neg(Variable v) { return -((LINT)v); }
#endif /* COMMON_TYPES_H */
packup-0.6/config.hh 0000644 0001750 0001001 00000005245 11573000737 013546 0 ustar mikolas None /******************************************************************************\
* This file is part of packup. *
* *
* packup is free software: you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* *
* packup is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with packup. If not, see . *
\******************************************************************************/
/*----------------------------------------------------------------------------*\
* Version: $Id: config.hh 73 2007-07-26 15:16:48Z jpms $
*
* Author: jpms
*
* Description: Defines used throughout
*
* Copyright (c) 2006, Joao Marques-Silva
\*----------------------------------------------------------------------------*/
#ifndef _CONFIG_HH_
#define _CONFIG_HH_ 1
/*----------------------------------------------------------------------------*\
* Data structure fine-tuning configuration
\*----------------------------------------------------------------------------*/
//#define NO_NOTOS_OPT 1 // **Uncomment** to use std map structures
#ifdef NO_NOTOS_OPT // Define if goal is *not* to optimize data structures
#define USE_RBTREE_MAPS 1 // Use std RBTree-based maps (instead of hash maps)
#define USE_RBTREE_SETS 1 // Use std RBTree-based sets (instead of hash sets)
#else
#undef USE_RBTREE_MAPS // Use (optimized and so preferred) hash maps
#undef USE_RBTREE_SETS // Use (optimized and so preferred) hash sets
#endif
#define PRINTOUT 1 // **Comment** to prevent printing of msgs to stdout
#define LOGGING 1 // **Comment** to prevent logging to file
//#define RBC_NOCOLLAPSE 1 // **Uncomment** to prevent node collapsing in RBCs
#endif /* _CONFIG_HH_ */
/*----------------------------------------------------------------------------*/
packup-0.6/ConverterMem.cc 0000644 0001750 0001001 00000007243 11573000733 014671 0 ustar mikolas None /******************************************************************************\
* This file is part of packup. *
* *
* packup is free software: you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* *
* packup is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with packup. If not, see . *
\******************************************************************************/
/*
* File: ConverterMem.cc
* Author: mikolas
*
* Created on September 25, 2010, 5:46 PM
* Copyright (C) 2011, Mikolas Janota
*/
#include "ConverterMem.hh"
ConverterMem::~ConverterMem() {}
#ifdef MAPPING
void ConverterMem::set_maping_file (const char* filen) {encoder.get_mapping().open(filen);}
#endif
void ConverterMem::solution_check(const char* file_name) {
sr.read(file_name);
encoder.cs = true;
encoder.stc=&(sr.installed_package_versions);
}
void ConverterMem::start_package() {
current_unit = new InstallableUnit();
current_unit->name=read_package_name;
// default values for a unit
current_unit->keep=KEEP_NONE;
current_unit->installed=false;
has_version = false;
}
void ConverterMem::close_package()
{
// current_unit->dump(cerr);
// cerr << endl;
encoder.add_unit(current_unit);
}
void ConverterMem::close_universe(){}
void ConverterMem::close_input () { solve(); }
void ConverterMem::package_provides()
{
PackageVersionList ¤t_provides=current_unit->provides;
current_provides.insert(current_provides.end(), read_feature_list.begin (), read_feature_list.end());
}
void ConverterMem::package_conflicts()
{
PackageVersionsList& current_conflicts = current_unit->conflicts;
current_conflicts.insert (current_conflicts.end(), read_package_versions_list.begin(), read_package_versions_list.end());
}
void ConverterMem::package_depends()
{
PackageVersionsCNF ¤t_depends = current_unit->depends_cnf;
current_depends.insert(current_depends.end(), read_CNF.begin(),read_CNF.end());
}
void ConverterMem::package_recommends()
{
PackageVersionsCNF ¤t_recommends = current_unit->recommends_cnf;
current_recommends.insert(current_recommends.end(), read_CNF.begin(),read_CNF.end());
}
void ConverterMem::package_keep() { current_unit->keep=read_keep_value; }
void ConverterMem::package_installed(bool installed_value)
{current_unit->installed=installed_value;}
void ConverterMem::end_processed_package_version ()
{
current_unit->version = read_version;
has_version = true;
}
void ConverterMem::request_install()
{
encoder.add_install(read_package_versions_list);
}
void ConverterMem::request_remove()
{
encoder.add_remove(read_package_versions_list);
}
void ConverterMem::upgrade()
{
encoder.add_upgrade(read_package_versions_list);
}
Encoder& ConverterMem::get_encoder() {
return encoder;
}
packup-0.6/ConverterMem.hh 0000644 0001750 0001001 00000006277 11573000733 014711 0 ustar mikolas None /******************************************************************************\
* This file is part of packup. *
* *
* packup is free software: you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* *
* packup is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with packup. If not, see . *
\******************************************************************************/
/*
* File: ConverterMem.hh
* Author: mikolas
*
* Created on September 25, 2010, 5:46 PM
* Copyright (C) 2011, Mikolas Janota
*/
#ifndef CONVERTERMEM_HH
#define CONVERTERMEM_HH
#include "parser.hh"
#include "InstallableUnit.hh"
#include "Encoder.hh"
#include "SolutionReader.hh"
class ConverterMem : public Parser {
public:
ConverterMem(SolverWrapper& solver,IDManager &id_manager)
: sr(package_names_set),encoder (solver, id_manager)
{}
virtual ~ConverterMem();
inline void set_criterion(Criterion optimization_criterion)
{encoder.set_criterion(optimization_criterion);}
inline void disable_solving () {encoder.disable_solving ();}
inline bool solve () {
encoder.encode();
return encoder.solution();
}
void solution_check(const char* file_name);
#ifdef MAPPING
void set_maping_file (const char* filen);
#endif
/** Processing of a new package started.*/
virtual void start_package();
/** Processing of a package stopped.*/
virtual void close_package();
/**The version of currently processed package was read.*/
virtual void end_processed_package_version();
/** The package universe has been fully read.*/
virtual void close_universe();
/**The whole input was read.*/
virtual void close_input ();
//Package stanza
virtual void package_provides();
virtual void package_conflicts(); // A list of conflicting versions was read.
virtual void package_depends();
virtual void package_recommends();
virtual void package_keep();
virtual void package_installed(bool installed_value);
//Request stanzas
virtual void request_install();
virtual void request_remove();
virtual void upgrade();
Encoder& get_encoder();
private:
bool has_version;
InstallableUnit *current_unit;
SolutionReader sr;
Encoder encoder;
};
#endif /* CONVERTERMEM_HH */
packup-0.6/cudf_msu.cc 0000644 0001750 0001001 00000020633 11573000736 014071 0 ustar mikolas None /******************************************************************************\
* This file is part of packup. *
* *
* packup is free software: you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* *
* packup is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with packup. If not, see . *
\******************************************************************************/
/* Copyright (C) 2011, Mikolas Janota */
#include
#include
#include
#include
#include "common_types.hh"
#include "Lexer.hh"
#include "ConverterMem.hh"
#include "SolutionReader.hh"
#include "SolverWrapperTypes.hh"
#include "Options.hh"
using std::ifstream;
static const char* dist_date = ""DISTDATE"";
static const char* changeset = ""CHANGESET"";
static const char* release = "0.6";
IDManager id_manager;
SolverType solver(id_manager);
ConverterMem parser(solver,id_manager);
extern int yyparse (void);
extern Lexer* lexer;
bool parse_lexicographic_specification (const char* specification,vector& lexicographic) {
std::stringstream ss(specification);
std::string item;
while(std::getline(ss, item, ',')) {
CONSTANT bool maximize(item[0]=='+');
CONSTANT string sfunction(item.substr(1));
OBJECTIVE_FUNCTION function;
if (sfunction.compare("new")==0) function = COUNT_NEW;
else if (sfunction.compare("unmet_recommends")==0) function = COUNT_UNMET_RECOMMENDS;
else if (sfunction.compare("removed")==0) function = COUNT_REMOVED;
else if (sfunction.compare("notuptodate")==0) function = COUNT_NOT_UP_TO_DATE;
else if (sfunction.compare("changed")==0) function = COUNT_CHANGED;
else { cerr << "unknown criterion " << sfunction << endl ; return false; }
lexicographic.push_back(Objective(function, maximize));
}
return true;
}
#ifndef EXTERNAL_SOLVER
static void SIG_handler(int signum) {
cerr << "# received external signal " << signum << "(" << (RUSAGE::read_cpu_time()) << ")" << endl;
parser.get_encoder().print_solution();
cerr << "Terminating ..." << endl;
exit(0);
}
#endif /* !EXTERNAL_SOLVER */
void print_usage(ostream &output) {
output << "USAGE " << endl;
output << "\t[OPTIONS] instance_file_name [output_file_name]" << endl;
output << "\t--help,-h \t print this message" << endl;
output << "\t-t \t\t trendy" << endl;
output << "\t-p \t\t paranoid" << endl;
output << "\t-u cs \t\t user criteria" << endl;
output << "\t--external-solver\t\t command for the external solver" << endl;
output << "\t\t\t\t\t default 'minisat+ -ansi -cs'"<< endl;
output << "\t--multiplication-string\t\t string between coefficients and variables when communicating to the solver"<< endl;
output << "\t\t\t\t\t default '*'"<< endl;
output << "\t--temporary-directory DIR\t where temporary files should be placed"<< endl;
output << "\t\t\t\t\t default '/tmp'"<< endl;
output << "\t--leave-temporary-files\t\t do not delete temporary files" << endl;
output << "\t--max-sat\t\t\t The external solver is a MaxSAT solver, only one call is made to the solver." << endl;
output << "NOTE" << endl;
output << "If the input file is '-', input is read from the standard input." << endl;
output << "If the output filename is omitted, output is produced to the standard output." << endl;
}
#define TIMETOL 1
void print_header() {
cout << "# authors: Mikolas Janota, Joao Marques-Silva" << endl;
cout << "# contributors: Ines Lynce, Vasco Manquinho" << endl;
cout << "# email mikolas@sat.inesc-id.pt" << endl;
cout << "# (C) 2011 Mikolas Janota" << endl;
cout << "# release: " << release << " distribution date: " << dist_date << " change set: " << changeset << endl;
cout << "# Released under the GPL license." << endl;
}
int main(int argc, char** argv) {
print_header();
/* set up signals */
#ifdef EXTERNAL_SOLVER
// assuming external solver received as well
struct sigaction new_act1;
new_act1.sa_handler = SIG_IGN;
sigaction(SIGTERM, &new_act1, 0);
struct sigaction new_act2;
new_act2.sa_handler = SIG_IGN;
sigaction(SIGUSR1, &new_act2, 0);
struct sigaction new_act3;
new_act3.sa_handler = SIG_IGN;
sigaction(SIGUSR2, &new_act3, 0);
#else
signal(SIGHUP, SIG_handler);
signal(SIGTERM, SIG_handler);
signal(SIGABRT, SIG_handler);
signal(SIGUSR1, SIG_handler);
//signal(SIGALRM,SIG_handler);
//alarm(290); // Specify alarm interrupt given timeout
#endif
/* parse options */
Options options;
if (!options.parse(argc, argv)) {
cerr << "Error parsing options. Exiting." << endl;
print_usage(cerr);
exit(1);
}
if (options.get_help()) {
print_usage(cout);
exit(0);
}
#ifdef MAPPING
if (!options.get_mapping_file().empty()) parser.set_maping_file(options.get_mapping_file().c_str());
#endif
/* handling of input and output */
ifstream input_file;
ofstream output_file;
const bool use_stdin = options.get_input_file_name().compare("-")==0;
const bool use_stdout = options.get_output_file_name().empty();
if (!use_stdin) {
input_file.open(options.get_input_file_name().c_str());
if (input_file.fail()) {
cerr<<"Failed to read the input file. Exiting." << endl;
exit(1);
}
}
if (!use_stdout) {
output_file.open(options.get_output_file_name().c_str());
if (output_file.fail()) {
cerr<<"Failed to open the output file. Exiting." << endl;
exit(1);
}
}
istream& input_stream(use_stdin ? cin : input_file);
ostream& output_stream(use_stdout ? cout : output_file);
/* set up of the encoder */
if (options.get_solving_disabled()) parser.disable_solving();
parser.get_encoder().set_opt_edges(1);
parser.get_encoder().set_iv(3);
parser.get_encoder().set_opt_not_removed(true);
#ifdef EXTERNAL_SOLVER
if (!options.get_external_solver().empty ()) solver.set_solver_command(options.get_external_solver ());
if (!options.get_multiplication_string().empty ()) solver.set_multiplication_string(options.get_multiplication_string());
if (options.get_leave_temporary_files()) solver.set_leave_temporary_files();
if (options.get_max_solver()) solver.set_iterative(false);
if (!options.get_temporary_directory().empty ()) {
solver.set_temporary_directory(options.get_temporary_directory());
} else {
char * pPath;
pPath = getenv("TMPDIR");
if (pPath!=NULL) {
string s(pPath);
solver.set_temporary_directory(s);
}
}
#endif
if (options.get_trendy()) parser.get_encoder().set_criterion(TRENDY);
if (options.get_paranoid()) parser.get_encoder().set_criterion(PARANOID);
if (!options.get_user_criterion().empty()) {
vector lexicographic;
if (!parse_lexicographic_specification(options.get_user_criterion().c_str(), lexicographic)) {
cerr<<"Failed to parse the user defined criteria (" << options.get_user_criterion() << "). Exiting." << endl;
exit(1);
}
parser.get_encoder().set_lexicographic(lexicographic);
}
/* run the whole thang */
lexer=new Lexer(input_stream);
parser.get_encoder().set_solution_file(&output_stream);
try {
yyparse();
} catch(ReadException e) {
cerr << "Error in parsing the input file:" << e.what() << endl;
cerr << "Terminating." << endl;
}
exit(0);
}
packup-0.6/dbg_prt.hh 0000644 0001750 0001001 00000005310 11573000740 013705 0 ustar mikolas None /******************************************************************************\
* This file is part of packup. *
* *
* packup is free software: you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* *
* packup is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with packup. If not, see . *
\******************************************************************************/
/*----------------------------------------------------------------------------*\
* Version: $Id: dbg_prt.hh 73 2007-07-26 15:16:48Z jpms $
*
* Author: jpms
*
* Description: Utilities for printing containers.
*
* Copyright (c) 2005-2006, Joao Marques-Silva
\*----------------------------------------------------------------------------*/
#ifndef _DBG_PRT_HH_
#define _DBG_PRT_HH_ 1
#include
template
inline void PRINT_ELEMENTS (const T& coll,
const char* optcstr="", const char* sepstr=" ")
{
typename T::const_iterator pos;
std::cout << optcstr;
for(pos=coll.begin(); pos!=coll.end(); ++pos) {
std::cout << *pos << sepstr;
}
std::cout << std::endl;
}
template
inline void PACK_PRINT_ELEMENTS (const T& coll, const char* optcstr="")
{
typename T::const_iterator pos;
std::cout << optcstr;
for(pos=coll.begin(); pos!=coll.end(); ++pos) {
std::cout << *pos; //((bool)*pos)?1:0; // -> This only works for bool's
}
std::cout << std::endl;
}
template
inline void PRINT_PTR_ELEMENTS (const T& coll,
const char* optcstr="", const char* sepstr=" ")
{
typename T::const_iterator pos;
std::cout << optcstr;
for(pos=coll.begin(); pos!=coll.end(); ++pos) {
std::cout << **pos << sepstr;
}
std::cout << std::endl;
}
#endif /* _DBG_PRT_HH_ */
/*----------------------------------------------------------------------------*/
packup-0.6/Encoder.cc 0000644 0001750 0001001 00000242141 11573000733 013640 0 ustar mikolas None /******************************************************************************\
* This file is part of packup. *
* *
* packup is free software: you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* *
* packup is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with packup. If not, see . *
\******************************************************************************/
/*
* File: Encoder.cc
* Author: mikolas
*
* Created on September 26, 2010, 2:01 PM
* Copyright (C) 2011, Mikolas Janota
*/
#include "Encoder.hh"
#include "PackageVersionVariables.hh"
#include "Encoder.hh"
#include "SolverWrapper.hh"
#include "NotRemoved.hh"
Encoder::Encoder(SolverWrapper& solver,IDManager& id_manager)
:unit_count(0)
,cut_off(INT_MAX)
,psolution_file(NULL)
//---- scalar values initialization
,should_solve(true)
,solver(solver)
,id_manager(id_manager)
//----- variables initialization
, variables(id_manager
#ifdef MAPPING
, variable_names,mapping
#endif
)
// ---- interval_vars initialization
,interval_vars(id_manager
#ifdef MAPPING
, variable_names,mapping
#endif
)
#ifdef CONV_DBG
// ---- printer initialization
, printer (variable_names)
#endif
, valuation(false)
, opt_edges(0)
, iv(3)
, printing_started_or_finished(false)
, opt_not_removed(false)
, not_removed(needed_units)
, cs(false)
//===== end of variable initialization
{
#ifdef CONV_DBG
solver.set_printer(&printer);
#endif
solver.init();
}
Encoder::~Encoder() {}
void Encoder::add_unit(InstallableUnit* unit) {
unit->needed = false;
// Insert the unit into a collection of units
record_unit(read_units, unit);
// Record information about the provides field
handle_provides(unit);
// Record information about the keep field
handle_keep(unit);
}
void Encoder::add_install(CONSTANT PackageVersionsList& list) {
FOR_EACH(PackageVersionsList::const_iterator, i, list)
install.insert(*i);
}
void Encoder::add_upgrade (CONSTANT PackageVersionsList& list)
{upgrade.insert (upgrade.end(), list.begin(), list.end ());}
void Encoder::add_remove (CONSTANT PackageVersionsList& list)
{remove.insert (remove.end(), list.begin(), list.end ());}
void Encoder::set_lexicographic(const vector& lexicographic_ordering) {
OUT ( cerr << "lex: "; print(lexicographic_ordering,cerr); cerr << endl; )
// store the ordering
lexicographic.insert(lexicographic.end(), lexicographic_ordering.begin(),lexicographic_ordering.end());
OUT ( cerr << "lex: "; print(lexicographic,cerr); cerr << endl; )
// determine which information needs to be stored to be able to address the required functions
process_recommends=false;
_process_not_uptodate=false;
FOR_EACH (vector::const_iterator, objective_index, lexicographic) {
CONSTANT Objective objective = *objective_index;
switch (objective.first) {
case COUNT_UNMET_RECOMMENDS:
if (!objective.second) process_recommends=true;
break;
case COUNT_NOT_UP_TO_DATE:
if (!objective.second) _process_not_uptodate=true;
break;
case COUNT_NEW:
case COUNT_REMOVED:
case COUNT_CHANGED:
break;
}
}
}
void Encoder::set_criterion(Criterion optimization_criterion) {
vector lexicographic_ordering;
switch (optimization_criterion)
{
case PARANOID:
lexicographic_ordering.push_back(Objective(COUNT_REMOVED, false));
lexicographic_ordering.push_back(Objective(COUNT_CHANGED, false));
break;
case TRENDY:
lexicographic_ordering.push_back(Objective(COUNT_REMOVED, false));
lexicographic_ordering.push_back(Objective(COUNT_NOT_UP_TO_DATE, false));
lexicographic_ordering.push_back(Objective(COUNT_UNMET_RECOMMENDS, false));
lexicographic_ordering.push_back(Objective(COUNT_NEW, false));
break;
case NO_OPTIMIZATION:
break;
}
set_lexicographic(lexicographic_ordering);
}
void Encoder::handle_keep(InstallableUnit* unit) {
if (!unit->installed) return;
switch (unit->keep) {
case KEEP_VERSION:
install.insert(PackageVersions(unit->name,VERSIONS_EQUALS,unit->version));
break;
case KEEP_PACKAGE:
install.insert(PackageVersions(unit->name,VERSIONS_NONE,0));
break;
case KEEP_FEATURE:
FOR_EACH (PackageVersionList::const_iterator,i,unit->provides) {
PackageVersion f=*i;
if (f.version()==0)
install.insert(PackageVersions(f.name(),VERSIONS_NONE,0));
else
install.insert(PackageVersions(f.name(),VERSIONS_EQUALS,f.version()));
}
break;
case KEEP_NONE:
break;
}
}
void Encoder::handle_provides(InstallableUnit* unit) {
CONSTANT PackageVersionList &provides = unit->provides;
FOR_EACH(PackageVersionList::const_iterator, i, provides) {
CONSTANT PackageVersion& feature = *i;
record_unit(feature_units, feature, unit);
record_version(feature_versions, feature.name(), feature.version());
}
}
void Encoder::slice () {
//process upgrade
FOR_EACH(PackageVersionsList::const_iterator,i,upgrade) need (*i);
//process install
FOR_EACH(PackageVersionsSet::const_iterator,i,install) need (*i);
//process preference
if (gt(COUNT_REMOVED, lexicographic)==CT_MIN) {
FOR_EACH(PackageUnits::const_iterator,index,read_units)
{
UnitVector &unit_vector=*(index->second);
CONSTANT bool any_installed = is_any_installed_package(unit_vector);
//if any package is installed, then all of its versions are needed
if (any_installed) need_packages(index->first, VERSIONS_NONE, 0);
}
}
if (gt(COUNT_NEW, lexicographic)==CT_MAX) {
FOR_EACH(PackageUnits::const_iterator,index,read_units)
{
UnitVector &unit_vector=*(index->second);
CONSTANT bool any_installed = is_any_installed_package(unit_vector);
//if no versions are installed, then all of its versions are needed
if (!any_installed) need_packages(index->first, VERSIONS_NONE, 0);
}
}
if (gt(COUNT_UNMET_RECOMMENDS, lexicographic) == CT_MAX) {
FOR_EACH(PackageUnits::const_iterator,index,read_units)
{
UnitVector &unit_vector=*(index->second);
FOR_EACH (UnitVector::iterator, unit_index, unit_vector)
{
InstallableUnit* unit=*unit_index;
if (!unit->recommends_cnf.empty()) need(unit);
}
}
}
if (gt(COUNT_NOT_UP_TO_DATE, lexicographic)==CT_MAX) {
FOR_EACH(PackageUnits::const_iterator,index,read_units)
{
UnitVector &unit_vector=*(index->second);
if (unit_vector.size()<=1) continue;// if a package is only one version it cannot be not up to date
need_packages(index->first, VERSIONS_NONE, 0);
}
}
slice_changed();
// make sure that variables are introduced for all features provided by needed packages
FOR_EACH(PackageUnits::const_iterator,index,needed_units)
{
UnitVector &unit_vector = *(index->second);
FOR_EACH(UnitVector::iterator, unit_index, unit_vector) {
CONSTANT InstallableUnit& unit = **unit_index;
FOR_EACH(PackageVersionList::const_iterator, feature_index, (unit.provides)) {
CONSTANT PackageVersion& feature = *feature_index;
if (CONTAINS(required_features, feature))
continue; //feature already required, therefore all of its providers have been recorded
if (!variables.has_variable(feature)) {
variables.add_variable_feature(feature);
record_version(needed_feature_versions, feature.name(), feature.version());
}
}
}
}
OUT( cerr << "number of packages: " << unit_count << endl; )
}
void Encoder::slice_changed() {
if (gt(COUNT_CHANGED, lexicographic)==CT_NO) return;
CONSTANT bool maximize = (gt(COUNT_CHANGED, lexicographic)==CT_MAX);
FOR_EACH(PackageUnits::const_iterator,index,read_units)
{
UnitVector &unit_vector=*(index->second);
FOR_EACH (UnitVector::iterator, unit_index, unit_vector)
{
InstallableUnit* unit=*unit_index;
if (maximize && !unit->installed) need(unit);
if (!maximize && unit->installed) need(unit);
}
}
}
void Encoder::need_packages(CONSTANT string &package_name, Operator version_operator, Version operand)
{
CONSTANT PackageUnits::const_iterator i = read_units.find(package_name);
if (i==read_units.end()) return;
CONSTANT UnitVector &vector=*(i->second);
CONSTANT UINT size = vector.size();
for (UINT index = 0; index < size; ++index)
{
InstallableUnit *unit = vector[index];
if (evaluate(unit->version, version_operator, operand))
need (unit);
}
}
void Encoder::need_feature(CONSTANT PackageVersion &feature)
{
if (CONTAINS(required_features, feature)) return; // already traversed
FeatureToUnits::const_iterator i0=feature_units.find(feature);
if (i0!=feature_units.end())
{
OUT ( cerr << "need: " << (feature.name()) << ":" << (feature.version()) << endl; )
// Add the information that the feature is needed
required_features.insert (feature);
variables.add_variable_feature (feature);
record_version (needed_feature_versions,feature.name(),feature.version ());
// All of the providers of the feature are needed
CONSTANT UnitVector &providers_vector=*(i0->second);
FOR_EACH (UnitVector::const_iterator,vi,providers_vector)
need(*vi);
}
}
void Encoder::need_features(CONSTANT string &feature_name, Operator version_operator, Version operand)
{
// Process unversioned providers
need_feature(PackageVersion (feature_name,0));
CONSTANT FeatureToVersions::const_iterator i = feature_versions.find(feature_name);
if (i==feature_versions.end()) return;
CONSTANT VersionSet &vs=*(i->second);
FOR_EACH (VersionSet::const_iterator,vi,vs)
{
CONSTANT Version version=*vi;
if (evaluate(version, version_operator, operand))
need_feature(PackageVersion(feature_name,version));
}
}
void Encoder::need (InstallableUnit* unit)
{
if (unit->needed) return;
if (unit_count > cut_off) return;
++unit_count;
OUT ( cerr << "need: " << (unit->name) << ":" << (unit->version) << endl; )
unit->needed=true;
unit->variable=variables.add_variable_package(PackageVersion (unit->name,unit->version));
OUT( cerr<< "var: " << unit->variable << endl; )
record_unit(needed_units,unit);
need (unit->depends_cnf);
if (process_recommends) need(unit->recommends_cnf);
if (process_not_uptodate()) need_latest(unit->name);
}
void Encoder::need_latest(const string& package_name)
{
PackageUnits::const_iterator index = read_units.find(package_name);
if (index == read_units.end ()) return;
UnitVector &unit_vector=*(index->second);
InstallableUnit* l=NULL;
Version lv=0;
FOR_EACH(UnitVector::const_iterator,ui,unit_vector)
{
InstallableUnit* u=*ui;
if (lvversion) {
lv=u->version;
l=u;
}
}
if (l!=NULL) need(l);
}
void Encoder::need (PackageVersionsCNF cnf) {
FOR_EACH (PackageVersionsCNF::const_iterator,i,cnf)
FOR_EACH (PackageVersionsList::const_iterator,vi, (**i)) need(*vi);
}
void Encoder::need (CONSTANT PackageVersions& versions) {
if (is_feature (versions.name()))
need_features(versions.name(),versions.op(),versions.version());
else
need_packages(versions.name(),versions.op(),versions.version());
}
void Encoder::encode() {
OUT ( cerr << "encode ()" << endl; )
refine_upgrade_request();
// Compute needed units and features (slicing)
slice();
// top bound
solver.set_top(get_top(lexicographic));
//Sort versions
InstallableUnitCmp cmp;
FOR_EACH(PackageUnits::iterator,i,needed_units)
{
UnitVector &uv=*(i->second);
sort(uv.begin(),uv.end(),cmp);
}
FOR_EACH(PackageToVersions::iterator,i,needed_feature_versions)
{
VersionVector &vv=*(i->second);
sort(vv.begin(),vv.end());
}
/// features
encode_provides();
// Package dependencies
FOR_EACH(PackageUnits::const_iterator,i,needed_units)
{
CONSTANT UnitVector &uv = *(i->second);
FOR_EACH(UnitVector::const_iterator,vi,uv)
{
CONSTANT InstallableUnit *unit = *vi;
encode(unit);
}
}
// Install
OUT ( cerr << "install [" <name())) not_removed.add(i->name());
}
OUT ( cerr << "]" <second;
LiteralVector not_remove_clause;
require_up_to_clause(package_name, 0, unit_vector, NULL, not_remove_clause);
solver.output_clause(not_remove_clause);
}
}
bool Encoder::is_any_installed_package(const UnitVector& unit_vector)
{
bool any_installed = false;
FOR_EACH (UnitVector::const_iterator, unit_index, unit_vector)
{
CONSTANT InstallableUnit* unit=*unit_index;
if (unit->installed)
{
any_installed = true;
break;
}
}
return any_installed;
}
bool Encoder::is_installed_feature(const PackageVersion& feature)
{
assert (is_feature(feature.name()));
CONSTANT FeatureToUnits::const_iterator providers_index = feature_units.find(feature);
if (providers_index==feature_units.end()) { assert(false); return false; }
CONSTANT UnitVector& providers =*(providers_index->second);
FOR_EACH (UnitVector::const_iterator, provider_index, providers)
{
CONSTANT InstallableUnit& provider =**provider_index;
if (provider.installed) return true;
}
return false;
}
bool Encoder::find_latest_installed_version_in_original_problem(const string& name, Version& version)
{
Version latest_installed = 0;
bool any_installed = false;
if (is_feature (name))
{
FeatureToVersions::const_iterator i = feature_versions.find(name);
if (i!=feature_versions.end())
{
CONSTANT VersionSet& vs=*(i->second);
FOR_EACH (VersionSet::const_iterator,vi,vs)
{
CONSTANT Version cv=*vi;
if ((cv > latest_installed) && is_installed_feature (PackageVersion (name,cv)))
{
any_installed = true;
latest_installed = cv;
}
}
}
} else {
PackageUnits::const_iterator i=read_units.find(name);
if (i!=read_units.end())
{
CONSTANT UnitVector& uv=*(i->second);
for (int k=uv.size()-1;k>=0;--k)
{
CONSTANT Version cv=uv[k]->version;
if ((cv>latest_installed) && uv[k]->installed)
{
latest_installed = uv[k]->version;
any_installed=true;
}
}
}
}
if (any_installed)
{
version = latest_installed;
return true;
} else return false;
}
void Encoder::refine_upgrade_request()
{
OUT(cerr << "upgrade refine" << endl << " from: ";
collection_printing::print(upgrade,cerr);
cerr << endl;
)
PackageVersionsList refined_list;
FOR_EACH (PackageVersionsList::const_iterator, versions_index, upgrade)
{
CONSTANT PackageVersions& versions = *versions_index;
if (versions.op()!=VERSIONS_NONE)
{
refined_list.push_back(versions);
continue;
}
Version latest_version;
CONSTANT string& name=versions.name();
if (find_latest_installed_version_in_original_problem(name,latest_version))
refined_list.push_back(PackageVersions(name,VERSIONS_GREATER_EQUALS,latest_version));
else
refined_list.push_back(versions);
}
upgrade.clear();
upgrade.insert(upgrade.end(),refined_list.begin(),refined_list.end());
OUT(cerr << " to: ";
collection_printing::print(upgrade,cerr);
cerr << endl;
)
}
bool Encoder::latest_installed_package_version (CONSTANT string &name,Version& latest_version)
{
assert (!is_feature(name));
PackageUnits::const_iterator i=needed_units.find(name);
if (i==needed_units.end()) return false; //no versions of the package
CONSTANT UnitVector& uv=*(i->second);
for (int k=uv.size()-1;k>=0;--k)
{
if (uv[k]->installed)
{
latest_version = uv[k]->version;
return true;
}
}
return false; //no installed versions of the package
}
bool Encoder::latest_installed_feature_version (CONSTANT string &name,Version& version)
{
assert (is_feature(name));
PackageToVersions::const_iterator i = needed_feature_versions.find(name);
if (i==needed_feature_versions.end()) return false;
const VersionVector& vv=*(i->second);
for (int k=vv.size()-1;k>=0;--k)
{
CONSTANT Version ver=vv[k];
CONSTANT PackageVersion f(name,ver);
if (is_installed_feature (f))
{
version = ver;
return true;
}
}
return false;
}
void Encoder::encode_upgrade()
{
OUT(cerr << "upgrade () [" << endl;)
// encode as the request semantics first,
// this is needed if such requirement is stronger than the one given by upgrade semantics
// TODO: possibly can be pruned
FOR_EACH (PackageVersionsList::const_iterator,i,upgrade)
{
LiteralVector literals;
request_to_clause(*i,literals);
solver.output_clause(literals);
}
FOR_EACH (PackageVersionsList::const_iterator,index,upgrade)
{
CONSTANT PackageVersions& request =*index;
CONSTANT string& name = request.name();
if (is_feature (name))
{
Version latest_version;
bool any_installed=latest_installed_feature_version(name,latest_version);
if (any_installed)
{
solver.output_unary_clause (interval_vars.get_require_up(PackageVersion(name,latest_version)));
atmost_1_feature(name,latest_version);
}
Version var;
CONSTANT PackageVersion ipv(name,0);
if (variables.find_variable(ipv,var))
{
solver.output_unary_clause(neg(var));
}
} else {
if (opt_not_removed) not_removed.add(name);
Version latest_version = 0;
if (latest_installed_package_version(name, latest_version))
{
solver.output_unary_clause (interval_vars.get_require_up(PackageVersion(name,latest_version)));
atmost_1(name,latest_version);
}
}
}
OUT(cerr << "]" << endl;)
}
void Encoder::atmost_1_feature (CONSTANT string& name, Version from)
{
assert (is_feature (name));
CONSTANT PackageToVersions::const_iterator i=needed_feature_versions.find(name);
if (i==needed_feature_versions.end ()) return;
CONSTANT VersionVector& vv=*(i->second);
for (UINT i=0;i= from);
CONSTANT Variable variable_j = get_package_version_variable (PackageVersion(name, version_j));
solver.output_binary_clause(neg(variable_i), neg(variable_j));
}
}
}
void Encoder::atmost_1(CONSTANT string& package_name, Version from)
{
assert (!is_feature(package_name));
PackageUnits::const_iterator fi=needed_units.find(package_name);
if (fi==needed_units.end()) return;
CONSTANT UnitVector& vv=*(fi->second);
for (UINT i=0;i= from);
solver.output_binary_clause(neg(ui.variable), neg(uj.variable));
}
}
}
void Encoder::encode_request_remove()
{
OUT(cerr << "request_remove ()" << endl;)
PackageVersionsList::const_iterator index = remove.begin();
CONSTANT PackageVersionsList::const_iterator e = remove.end();
for (; index != e; ++index) {
const PackageVersions& pvs = *index;
LiteralVector term;
disable_to_term(pvs,term);
FOR_EACH(LiteralVector::const_iterator, i, term)
solver.output_unary_clause(*i);
}
}
void Encoder::encode_new(XLINT& total_weight,bool maximize)
{
OUT(cerr<< "new[" << endl;)
const XLINT new_weight=total_weight+1;
FOR_EACH(PackageUnits::const_iterator,index,needed_units)
{
CONSTANT UnitVector& units=*(index->second);
if (units.empty() || is_any_installed_package(units)) continue;
const string& package_name=index->first;
CONSTANT PackageVersion first_version(package_name, units[0]->version);
if (maximize) {//maximization requires at least one version to be installed
solver.output_unary_weighted_clause(
interval_vars.get_require_up(first_version),
new_weight);
} else {//minimization requires all of them to be uninstalled
solver.output_unary_weighted_clause(
interval_vars.get_disable_up(first_version),
new_weight);
}
total_weight+=new_weight;
}
OUT(cerr<< "]";)
}
void Encoder::encode_removed(XLINT& total_weight,bool maximize)
{
OUT(cerr<< "removed [" << endl;)
assert(solver.get_soft_clauses_weight()==total_weight);
CONSTANT XLINT not_rm_weight=total_weight+1;
FOR_EACH(PackageUnits::const_iterator,index,needed_units)
{
CONSTANT UnitVector& unit_vector=*(index->second);
const string& package_name=index->first;
bool any_installed = is_any_installed_package(unit_vector);
if (!any_installed) continue;//if nothing was installed, it cannot be removed
if (opt_not_removed && not_removed.is_not_removed(package_name)) continue; //package detected unremovable
if (maximize) {
// disable all versions of this package
Variable v=interval_vars.get_disable_up(PackageVersion(package_name,unit_vector[0]->version));
solver.output_unary_weighted_clause(v, not_rm_weight);
} else {
// minimization---require at least one version of this package
LiteralVector ls;
require_up_to_clause(package_name,0,index->second,NULL,ls);
solver.output_weighted_clause(
ls,
not_rm_weight);
}
total_weight+=not_rm_weight;
}
OUT(cerr<< "]" << endl;)
}
void Encoder::encode_unmet_recommends(XLINT& total_weight,bool maximize)
{
OUT(cerr<< "recommends[" << endl;)
CONSTANT XLINT recommends_weight=total_weight+1;
assert(solver.get_soft_clauses_weight()==total_weight);
if (maximize) {
//when maximizing made the clauses of unsat
FOR_EACH(PackageUnits::const_iterator,index,needed_units)
{
CONSTANT UnitVector& units=*(index->second);
FOR_EACH (UnitVector::const_iterator, unit_index, units)
{
InstallableUnit *unit =*unit_index;
if (unit->recommends_cnf.empty()) continue;
FOR_EACH (PackageVersionsCNF::const_iterator, clause_index, unit->recommends_cnf)
{
PackageVersionsList& clause =**clause_index;
Variable is_broken = id_manager.new_id();
//encode the condition for the clauses to be broken
FOR_EACH (PackageVersionsList::const_iterator, literal_index, clause)
{
CONSTANT PackageVersions literal =*literal_index;
vector term;
disable_to_term(literal, term);
FOR_EACH (vector::const_iterator,t, term)
solver.output_binary_clause(neg(is_broken),*t);
}
Variable v = id_manager.new_id();
solver.output_binary_clause(neg(v), is_broken);
solver.output_binary_clause(neg(v), unit->variable);
solver.output_unary_weighted_clause(v,recommends_weight);//we are getting a point if the unit is installed and the recommends is broken
}
}
}
} else {
//when minimizing try to satisfy the clauses
FOR_EACH(vector::const_iterator,i,recommends_clauses_pointers)
{
ClausePointer cp=*i;
solver.increase_weight(cp, recommends_weight);
total_weight+=recommends_weight;
}
}
OUT(cerr<< "]";)
}
void Encoder::encode_not_up_to_date(XLINT& total_weight,bool maximize)
{
OUT(cerr<< "not up to date[" << endl;)
assert(solver.get_soft_clauses_weight()==total_weight);
CONSTANT XLINT up_to_date_weight=total_weight+1;
FOR_EACH(PackageUnits::const_iterator,index,needed_units)
{
CONSTANT UnitVector& units=*(index->second);
if (units.size() <= 1) continue; //If only one version of the package exists, the criterion is satisfied automatically
CONSTANT InstallableUnit* latest_version = units[units.size()-1];
CONSTANT Variable v_latest = latest_version->variable;
if (opt_not_removed && not_removed.is_not_removed(index->first))
{//at least one version of this package will be installed
if (maximize) {//disable the latest version
solver.output_unary_weighted_clause(neg(v_latest), up_to_date_weight);
} else {//require the latest version
solver.output_unary_weighted_clause(v_latest, up_to_date_weight);
}
}
else {
CONSTANT Variable any_will_be_installed = new_variable();
vector literals;
if (maximize) literals.push_back(neg(any_will_be_installed));
for (UINT vi=0;vivariable;
if (maximize) literals.push_back(vv);
else solver.output_binary_clause(neg(vv),any_will_be_installed);
}
if (maximize) {//require that at least one version is installed and the last one isn't
Variable auxiliary = id_manager.new_id();
solver.output_clause(literals);
solver.output_binary_clause(neg(auxiliary), any_will_be_installed);
solver.output_binary_clause(neg(auxiliary), neg(v_latest));
solver.output_unary_weighted_clause(auxiliary, up_to_date_weight);
} else { //if any version is installed, then the latest one should be installed as well
solver.output_binary_weighted_clause(neg(any_will_be_installed), v_latest, up_to_date_weight);
}
}
total_weight+=up_to_date_weight;
}
OUT(cerr<< "]";)
}
void Encoder::encode_changed(XLINT& total_weight,bool maximize)
{
CONSTANT XLINT w=total_weight+1;
vector literals;
FOR_EACH(PackageUnits::const_iterator,index,needed_units)
{
CONSTANT UnitVector &unit_vector=*(index->second);
Variable unchanged=-1; // variables that represents that all versions stayed the same, used only for minimization
if (!maximize) {
unchanged=id_manager.new_id();
#ifdef CONV_DBG
string nm="unchanged_" + index->first;
variable_names[unchanged] = nm;
mapping << unchanged << "->" << nm << endl;
#endif
} else {
literals.clear();
}
FOR_EACH (UnitVector::const_iterator, unit_index, unit_vector)
{
CONSTANT InstallableUnit& unit =**unit_index;
LINT l = unit.installed ? unit.variable : neg(unit.variable);
if (!maximize) solver.output_binary_clause(neg(unchanged),l); // each version needs to stay the same
else literals.push_back(-l);//at least one version changed
}
if (!maximize) solver.output_unary_weighted_clause(unchanged,w);
else solver.output_weighted_clause(literals,w);
total_weight+=w;
}
}
XLINT Encoder::get_top(CONSTANT Objective& objective) const
{
switch (objective.first)
{
case COUNT_NEW:
return needed_units.size();
case COUNT_UNMET_RECOMMENDS:
{
UINT recommend_cl_counter=0;
FOR_EACH(PackageUnits::const_iterator,index,needed_units)
{
CONSTANT UnitVector& units=*(index->second);
for (UINT vi=0;virecommends_cnf.size();
}
return recommend_cl_counter;
}
case COUNT_REMOVED:
return needed_units.size();
case COUNT_NOT_UP_TO_DATE:
return needed_units.size();
case COUNT_CHANGED:
return needed_units.size();
}
assert (false);
return 0;
}
XLINT Encoder::get_top(const vector& lexicographic) const
{
XLINT total_weight = 0;
FOR_EACH(vector::const_iterator,objective_index,lexicographic)
{
CONSTANT Objective objective = *objective_index;
total_weight += (total_weight + 1) * get_top(objective);
}
return total_weight + 1;
}
void Encoder::encode_lexicographic() {
XLINT total_weight = 0;
//FOR_EACH_REV(vector::const_reverse_iterator,objective_index,lexicographic)
for (size_t i=lexicographic.size(); i>0; --i) {
CONSTANT Objective objective = lexicographic[i-1];
solver.register_weight(total_weight+1);
switch (objective.first)
{
case COUNT_NEW:
encode_new(total_weight, objective.second);
break;
case COUNT_UNMET_RECOMMENDS:
encode_unmet_recommends(total_weight, objective.second);
break;
case COUNT_REMOVED:
encode_removed(total_weight, objective.second);
break;
case COUNT_NOT_UP_TO_DATE:
encode_not_up_to_date(total_weight, objective.second);
break;
case COUNT_CHANGED:
encode_changed(total_weight, objective.second);
break;
}
}
}
void Encoder::encode_provides()
{
FOR_EACH (PackageToVersions::const_iterator, versions_index, needed_feature_versions)
{
CONSTANT VersionVector& vs = *(versions_index->second);
CONSTANT string& name= versions_index->first;
Variable infinite_variable=-1;
bool infinite_provided = variables.find_variable(PackageVersion (name, 0), infinite_variable);
FOR_EACH (VersionVector::const_iterator,version_index,vs)
{
CONSTANT Version ver =*version_index;
CONSTANT PackageVersion pv(name,ver);
CONSTANT Variable var=get_package_version_variable (pv);
LiteralVector literals;
literals.push_back(neg(var));
if (infinite_provided && ver != 0)
{
solver.output_binary_clause (neg(infinite_variable),var);
literals.push_back(infinite_variable);
}
CONSTANT FeatureToUnits::const_iterator providers_index = feature_units.find(pv);
if (providers_index!= feature_units.end())
{
CONSTANT UnitVector& providers =*(providers_index->second);
FOR_EACH (UnitVector::const_iterator, provider_index, providers)
{
CONSTANT InstallableUnit& provider =**provider_index;
CONSTANT Variable provider_variable=provider.variable;
if (!provider.needed) continue;
solver.output_binary_clause (neg (provider_variable),var);
literals.push_back(provider_variable);
}
}
solver.output_clause (literals);
}
}
}
void Encoder::encode(const InstallableUnit* unit)
{
OUT ( cerr << "encode " << unit->name << " " << unit->version <<"[" <recommends_cnf;
FOR_EACH (PackageVersionsCNF::const_iterator,ci,depends)
{
CONSTANT PackageVersionsList* clause=*ci;
CONSTANT PackageVersionsList::const_iterator e=clause->end();
CONSTANT PackageVersionsList::const_iterator b=clause->begin();
LiteralVector literals;
literals.push_back(neg(unit->variable));
requests_to_clause(b,e, literals);
ClausePointer p=solver.record_clause(literals);
recommends_clauses_pointers.push_back(p);
}
}
void Encoder::encode_depends(const InstallableUnit* unit)
{
CONSTANT PackageVersionsCNF& depends = unit->depends_cnf;
FOR_EACH (PackageVersionsCNF::const_iterator,ci,depends)
{
CONSTANT PackageVersionsList* clause=*ci;
CONSTANT PackageVersionsList::const_iterator e=clause->end();
CONSTANT PackageVersionsList::const_iterator b=clause->begin();
LiteralVector literals;
literals.push_back(neg(unit->variable));
requests_to_clause(b,e, literals);
solver.output_clause(literals);
}
}
void Encoder::encode_conflicts(const InstallableUnit* unit)
{
OUT (cerr<< "local conflicts[" <version > 0);
assert (unit->needed);
FOR_EACH (PackageVersionsList::const_iterator, index, unit->conflicts)
{
CONSTANT PackageVersions pvs=*index;
CONSTANT bool pvs_is_feature = is_feature(pvs.name());
if (pvs_is_feature)
{
bool self_feature_conflict = false;
FOR_EACH (PackageVersionList::const_iterator,feature_index,unit->provides)
{
CONSTANT PackageVersion& feature =*feature_index;
if (SAME_PACKAGE_NAME(pvs.name(),feature.name()))
{
self_feature_conflict = true;
break;
}
}
if (self_feature_conflict)
{
VariableSet providers;
add_providers(pvs,providers);
providers.erase(unit->variable);
conflict_all (unit->variable,providers);
continue;
}
// otherwise treat in not_self_conflict
}
if (SAME_PACKAGE_NAME(pvs.name(),unit->name))
{
encode_package_self_conflict(unit,pvs);
continue;
}
encode_not_self_conflict (unit,pvs);
}
OUT (cerr<< "]"<name);
CONSTANT UnitVector& units = *(i->second);
if (pvs.op()==VERSIONS_NONE)
{
LiteralVector term;
disable_up_to_term(unit->name, unit->version+1, i->second, NULL, term);
disable_down_to_term(unit->name, unit->version-1, i->second, NULL, term);
FOR_EACH(LiteralVector::const_iterator, i, term)
solver.output_binary_clause(neg(unit->variable),*i);
return;
}
FOR_EACH (UnitVector::const_iterator, unit_index, units)
{
InstallableUnit* conflicting_unit = *unit_index;
if (conflicting_unit->version==unit->version) continue;
if (evaluate(conflicting_unit->version,pvs.op(),pvs.version()))
solver.output_binary_clause (neg(unit->variable),neg(conflicting_unit->variable));
}
}
void Encoder::disable_to_term(const PackageVersions& pvs, LiteralVector& term)
{
CONSTANT string& name = pvs.name();
//Check whether it is a feature or not
CONSTANT PackageToVersions::const_iterator fi = needed_feature_versions.find(name);
CONSTANT bool is_feature = fi!=needed_feature_versions.end();
VersionVector* version_vector = NULL;
UnitVector *unit_vector = NULL;
if (is_feature)
{
version_vector = fi->second;
} else
{ //If it is not a feature, look up the pertaining units
CONSTANT PackageUnits::const_iterator pi = needed_units.find(name);
if (pi==needed_units.end())
return;//there is no feature or package of that name
unit_vector = pi->second;
}
UINT old_sz=term.size();
switch (pvs.op()) {
case VERSIONS_NONE:
disable_up_to_term(name, 0, unit_vector, version_vector, term);
break;
case VERSIONS_EQUALS:
{
CONSTANT PackageVersion pv=PackageVersion(pvs.name(), pvs.version());
Variable v;
if (variables.find_variable(pv,v))
{ // generated only if the exact version exists
term.push_back(neg(v));
}
} break;
case VERSIONS_NOT_EQUALS:
disable_up_to_term(name, pvs.version()+1, unit_vector, version_vector, term);
disable_down_to_term(name, pvs.version()-1, unit_vector, version_vector, term);
break;
case VERSIONS_GREATER_EQUALS:
disable_up_to_term(name, pvs.version(), unit_vector, version_vector, term);
break;
case VERSIONS_GREATER:
disable_up_to_term(name, pvs.version()+1, unit_vector, version_vector, term);
break;
case VERSIONS_LESS_EQUALS:
disable_down_to_term(name, pvs.version(), unit_vector, version_vector, term);
break;
case VERSIONS_LESS:
disable_down_to_term(name, pvs.version()-1, unit_vector, version_vector, term);
}
assert (term.size() >= old_sz);
bool generated = old_sz!=term.size();
if (is_feature && !generated)
{
CONSTANT PackageVersion pv(pvs.name(), 0);
Variable v;
if (variables.find_variable(pv,v))
term.push_back(neg(v));
}
}
void Encoder::encode_not_self_conflict(const InstallableUnit* unit, const PackageVersions& pvs)
{
LiteralVector term;
disable_to_term(pvs,term);
CONSTANT Variable current_variable = unit->variable;
FOR_EACH(LiteralVector::const_iterator, i, term)
solver.output_binary_clause(neg(current_variable),*i);
}
void Encoder::requests_to_clause (CONSTANT PackageVersionsList::const_iterator begin,
CONSTANT PackageVersionsList::const_iterator end,
LiteralVector& literals)
{
for (PackageVersionsList::const_iterator i=begin;i!=end; ++i)
{
CONSTANT PackageVersions& pvs=*i;
request_to_clause (pvs, literals);
}
}
bool Encoder::require_up_to_clause(const string& name, Version from,
const UnitVector* unit_vector, const VersionVector* version_vector,
LiteralVector& literals)
{
assert ((version_vector != NULL) ^ (unit_vector != NULL));
CONSTANT bool is_feature = version_vector != NULL;
if (is_feature)
{
int pos;
UINT count=0;
for (pos=version_vector->size() - 1; pos >= 0 && (version_vector->at(pos) >= from); --pos)
++count;
if (count==0) return false;//no versions greater or equal to from
if (count > iv) {// use interval variable
literals.push_back(interval_vars.get_require_up(PackageVersion(name,version_vector->at(pos+1))));
} else {
// use directly the variables of the feature
for (UINT i=pos+1;isize();++i)
{
CONSTANT Version version=version_vector->at(i);
Variable var=-1;
const bool f=variables.find_variable(PackageVersion (name, version), var);
if (!f) assert(0);
literals.push_back(var);
}
}
} else {
int pos;
UINT count=0;
for (pos=unit_vector->size() - 1; pos >= 0 && (unit_vector->at(pos)->version >= from); --pos)
++count;
if (count==0) return false; //no versions greater or equal to from
if (count > iv) { // use interval variable
literals.push_back(interval_vars.get_require_up(PackageVersion(name,unit_vector->at(pos+1)->version)));
} else { // use directly the variables of the unit
for (UINT i=pos+1;isize();++i)
literals.push_back(unit_vector->at(i)->variable);
}
}
return true;
}
bool Encoder::disable_up_to_term(const string& name, Version from,
const UnitVector* unit_vector, const VersionVector* version_vector,
LiteralVector& literals)
{
assert ((version_vector != NULL) ^ (unit_vector != NULL));
CONSTANT bool is_feature = version_vector != NULL;
if (is_feature)
{
int pos;
UINT count=0;
for (pos=version_vector->size() - 1; pos >= 0 && (version_vector->at(pos) >= from); --pos)
++count;
if (count==0) return false;//no versions greater or equal to from
if (count > iv) {// use interval variable
literals.push_back(interval_vars.get_disable_up(PackageVersion(name,version_vector->at(pos+1))));
} else {
// use directly the variables of the feature
for (UINT i=pos+1;isize();++i)
{
CONSTANT Version version=version_vector->at(i);
Variable var=-1;
bool f=variables.find_variable(PackageVersion (name, version), var);
if (!f) assert(0);
literals.push_back(neg(var));
}
}
} else {
int pos;
UINT count=0;
for (pos=unit_vector->size() - 1; pos >= 0 && (unit_vector->at(pos)->version >= from); --pos)
++count;
if (count==0) return false; //no versions greater or equal to from
if (count > iv) { // use interval variable
literals.push_back(interval_vars.get_disable_up(PackageVersion(name,unit_vector->at(pos+1)->version)));
} else { // use directly the variables of the unit
for (UINT i=pos+1;isize();++i)
literals.push_back(neg(unit_vector->at(i)->variable));
}
}
return true;
}
bool Encoder::require_down_to_clause(const string& name, Version from,
const UnitVector* unit_vector, const VersionVector* version_vector,
LiteralVector& literals)
{
assert ((version_vector != NULL) ^ (unit_vector != NULL));
CONSTANT bool is_feature = version_vector != NULL;
if (is_feature)
{
UINT pos;
UINT count=0;
for (pos=0; (pos < version_vector->size()) && (version_vector->at(pos) <= from); ++pos)
++count;
if (count==0) return false;//no versions greater or equal to from
assert(pos>0);
if (count > iv) {// use interval variable
literals.push_back(interval_vars.get_require_down(PackageVersion(name,version_vector->at(pos-1))));
} else {
// use directly the variables of the feature
for (int i=pos-1;i>=0;--i)
{
CONSTANT Version version=version_vector->at(i);
Variable var=-1;
bool f=variables.find_variable(PackageVersion (name, version), var);
if (!f) assert(0);
literals.push_back(var);
}
}
} else {
UINT pos;
UINT count=0;
for (pos=0; (pos < unit_vector->size()) && (unit_vector->at(pos)->version <= from); ++pos)
++count;
if (count==0) return false; //no versions greater or equal to from
assert(pos>0);
if (count > iv) { // use interval variable
literals.push_back(interval_vars.get_require_down(PackageVersion(name,unit_vector->at(pos-1)->version)));
} else { // use directly the variables of the unit
for (int i=pos-1;i>=0;--i)
literals.push_back(unit_vector->at(i)->variable);
}
}
return true;
}
bool Encoder::disable_down_to_term(const string& name, Version from,
const UnitVector* unit_vector, const VersionVector* version_vector,
LiteralVector& literals)
{
assert ((version_vector != NULL) ^ (unit_vector != NULL));
CONSTANT bool is_feature = version_vector != NULL;
if (is_feature)
{
UINT pos;
UINT count=0;
for (pos=0; (pos < version_vector->size()) && (version_vector->at(pos) <= from); ++pos)
++count;
if (count==0) return false;//no versions greater or equal to from
assert(pos>0);
if (count > iv) {// use interval variable
literals.push_back(interval_vars.get_disable_down(PackageVersion(name,version_vector->at(pos-1))));
} else {
// use directly the variables of the feature
for (int i=pos-1;i>=0;--i)
{
CONSTANT Version version=version_vector->at(i);
Variable var=-1;
bool f=variables.find_variable(PackageVersion (name, version), var);
if (!f) assert(0);
literals.push_back(neg(var));
}
}
} else {
UINT pos;
UINT count=0;
for (pos=0; (pos < unit_vector->size()) && (unit_vector->at(pos)->version <= from); ++pos)
++count;
if (count==0) return false; //no versions greater or equal to from
assert(pos>0);
if (count > iv) { // use interval variable
literals.push_back(interval_vars.get_disable_down(PackageVersion(name,unit_vector->at(pos-1)->version)));
} else { // use directly the variables of the unit
for (int i=pos-1;i>=0;--i)
literals.push_back(neg(unit_vector->at(i)->variable));
}
}
return true;
}
void Encoder::request_to_clause (CONSTANT PackageVersions& pvs,LiteralVector& literals) {
CONSTANT string& name = pvs.name();
UnitVector *unit_vector = NULL;
VersionVector *version_vector = NULL;
//Check whether it is a feature or not
CONSTANT PackageToVersions::const_iterator fi = needed_feature_versions.find(name);
CONSTANT bool is_feature = fi!=needed_feature_versions.end();
if (is_feature)
{
version_vector = fi->second;
} else
{ //if it is not a feature, look up the pertaining installable units
CONSTANT PackageUnits::const_iterator pi = needed_units.find(name);
if (pi==needed_units.end())
return;//there is no feature or package of that name
unit_vector = pi->second;
}
bool generated=false;
#ifndef NDEBUG
const size_t old_sz=literals.size();
#endif
switch (pvs.op()) {
case VERSIONS_NONE:
generated = require_up_to_clause(name, 0, unit_vector, version_vector, literals);
break;
case VERSIONS_EQUALS: {
CONSTANT PackageVersion pv=PackageVersion(name,pvs.version());
Variable variable;
if (variables.find_variable(pv,variable)) {
generated = true;
literals.push_back(variable);// insert the requirement only if such version exists
}
}
break;
case VERSIONS_NOT_EQUALS: {
const bool ug=require_up_to_clause(name, pvs.version()+1, unit_vector, version_vector, literals);
const bool dg=require_down_to_clause(name, pvs.version()-1, unit_vector, version_vector, literals);
generated=ug||dg;
}
break;
case VERSIONS_GREATER_EQUALS:
generated = require_up_to_clause(name, pvs.version(), unit_vector, version_vector, literals);
break;
case VERSIONS_GREATER:
generated = require_up_to_clause(name, pvs.version()+1, unit_vector, version_vector, literals);
break;
case VERSIONS_LESS_EQUALS:
generated = require_down_to_clause(name, pvs.version(), unit_vector, version_vector, literals);
break;
case VERSIONS_LESS:
generated = require_down_to_clause(name, pvs.version()-1, unit_vector, version_vector, literals);
}
assert (literals.size() >= old_sz);
assert (generated == (old_sz!=literals.size()));
if (is_feature && !generated) {
//if infinite version provided, use that as an option
Variable variable=-1;
if (variables.find_variable(PackageVersion(name,0), variable))
literals.push_back(variable);//if infinite version provided, use that as an option
}
}
bool Encoder::solution() {
CNF_OUT(cout << "p wcnf " << id_manager.top_id() << " " << solver.get_clause_count() << " " << (solver.get_soft_clauses_weight() + 1) << endl;)
if (!should_solve) {
cerr << "not solving" << endl;
solver.dump(cout);
return false;
} else if (cs) {
cerr << "not solving,cs" << endl;
check_solution();
return false;
}
cerr << "# solving " << endl;
double st = RUSAGE::read_cpu_time();
const bool has_solution = solver.solve();
double et = RUSAGE::read_cpu_time();
cerr << "# solving time:" << et << "--" << st << "s" << endl;
print_solution();
return has_solution;
}
void Encoder::print_solution() {
if (printing_started_or_finished) return;
printing_started_or_finished = true;
ostream& solution_file((psolution_file==NULL) ? cout : *psolution_file);
cerr << "# sol printing (" << RUSAGE::read_cpu_time() << ")" << endl;
const bool has_solution = solver.has_solution();
if (has_solution) {
solution_file << "# beginning of solution from packup" << endl;
CONSTANT IntVector& solution = solver.get_model();
OUT(cerr << "solution:"; printer.print_solution(solution, cerr, true); cerr << endl;)
if (valuation) {
print_valuation(cerr, solver.get_model());
cerr << endl;
cerr << "MSUNCore min unsat: " << solver.get_min_unsat_cost() << endl;
}
FOR_EACH(PackageUnits::const_iterator, i, needed_units) {
CONSTANT UnitVector &vs = *(i->second);
FOR_EACH(UnitVector::const_iterator, vi, vs) {
CONSTANT InstallableUnit& unit = **vi;
CONSTANT Variable pvv = unit.variable;
assert(pvv < solution.size());
if (solution[pvv] > 0) {
solution_file << "package: " << unit.name << endl;
solution_file << "version: " << unit.version << endl;
solution_file << "installed: true" << endl;
solution_file << endl;
}
}
}
solution_file << "# end of solution from packup" << endl;
} else {
cerr << "no solution" << endl;
solution_file << "FAIL" << endl << "no solution (UNSAT)" << endl;
}
cerr.flush();
solution_file.flush();
cerr << "# sol printed" << endl;
}
void Encoder::conflict_all(CONSTANT Variable& pv, CONSTANT VariableSet& set) {
FOR_EACH(VariableSet::const_iterator, index, set) {
Variable v = *index;
solver.output_binary_clause(neg(pv), neg(v));
}
}
void Encoder::add_providers(CONSTANT PackageVersion& feature, VariableSet& providers) {
// Add all providers of the non-versioned feature
CONSTANT FeatureToUnits::const_iterator iii = feature_units.find(feature);
if (iii != feature_units.end()) {
CONSTANT UnitVector& units = *(iii->second);
FOR_EACH(UnitVector::const_iterator, ui, units) {
InstallableUnit *unit = *ui;
if (unit->needed) {
Variable v=-1;
const bool f = variables.find_variable(PackageVersion(unit->name, unit->version), v);
if (!f) assert(0);
providers.insert(v);
}
}
}
}
void Encoder::add_providers(CONSTANT PackageVersions& features, VariableSet& providers) {
// Add all providers of the non-versioned feature
add_providers(PackageVersion(features.name(), 0), providers);
// Look at all the features corresponding to {@code features} and had their providers to the set
PackageToVersions::const_iterator i = needed_feature_versions.find(features.name());
if (i == needed_feature_versions.end()) return;
CONSTANT VersionVector& vs = *(i->second);
FOR_EACH(VersionVector::const_iterator, index, vs) {
CONSTANT Version version = *index;
if (evaluate(version, features.op(), features.version())) {
add_providers(PackageVersion(features.name(), version), providers);
}
}
}
void to_versions(CONSTANT UnitVector& units, VersionVector& versions) {
FOR_EACH(UnitVector::const_iterator, i, units)
versions.push_back((*i)->version);
}
void Encoder::process_interval_variables ()
{
OUT (cerr << "Interval variables[" << endl;)
CONSTANT PackageToVersions& ru=interval_vars.get_require_up ();
CONSTANT PackageToVersions& rd=interval_vars.get_require_down();
CONSTANT PackageToVersions& du=interval_vars.get_disable_up();
CONSTANT PackageToVersions& dd=interval_vars.get_disable_down();
CONSTANT VersionVector empty_vector;
FOR_EACH (PackageToVersions::const_iterator, index, ru)
{
CONSTANT string name = index->first;
VersionVector& intervals=*(index->second);
sort (intervals.begin(),intervals.end());
OUT ( cerr << "intervals " << name;
FOR_EACH (VersionVector::const_iterator,i,intervals) cerr << " " << *i;
cerr<second) : empty_vector ;
process_require_up(name, intervals, vers, true);
} else {
PackageUnits::const_iterator i = needed_units.find(name);
assert (i!= needed_units.end ());
VersionVector versions;
to_versions(*(i->second), versions);
process_require_up(name, intervals, versions, false);
}
}
FOR_EACH (PackageToVersions::const_iterator, index, rd)
{
CONSTANT string name = index->first;
VersionVector& intervals=*(index->second);
sort (intervals.begin(),intervals.end());
OUT ( cerr << "intervals " << name;
FOR_EACH (VersionVector::const_iterator,i,intervals) cerr << " " << *i; cerr<second) : empty_vector ;
process_require_down(name, intervals, vers, true);
} else {
PackageUnits::const_iterator i = needed_units.find(name);
VersionVector versions;
if (i!=needed_units.end ()) to_versions(*(i->second), versions);
process_require_down(name, intervals, versions, false);
}
}
FOR_EACH (PackageToVersions::const_iterator, index, du)
{
CONSTANT string name = index->first;
VersionVector& intervals=*(index->second);
sort (intervals.begin(),intervals.end());
OUT ( cerr << "intervals " << name;
FOR_EACH (VersionVector::const_iterator,i,intervals) cerr << " " << *i;
cerr<second) : empty_vector ;
process_disable_up(name, intervals, vers, true);
} else {
PackageUnits::const_iterator i = needed_units.find(name);
assert (i!= needed_units.end ());
VersionVector versions;
if (i!=needed_units.end ()) to_versions(*(i->second), versions);
process_disable_up(name, intervals, versions, false);
}
}
FOR_EACH (PackageToVersions::const_iterator, index, dd)
{
CONSTANT string name = index->first;
VersionVector& intervals=*(index->second);
sort (intervals.begin(),intervals.end());
OUT ( cerr << "intervals " << name;
FOR_EACH (VersionVector::const_iterator,i,intervals) cerr << " " << *i;
cerr<second) : empty_vector ;
process_disable_down(name, intervals, vers, true);
} else {
PackageUnits::const_iterator i = needed_units.find(name);
assert (i!= needed_units.end ());
VersionVector versions;
if (i!=needed_units.end ()) to_versions(*(i->second), versions);
process_disable_down(name, intervals, versions, false);
}
}
if (opt_edges) encode_edges();
OUT (cerr << "]" << endl;)
}
void Encoder::encode_edges()
{
CONSTANT PackageToVersions& ru=interval_vars.get_require_up ();
CONSTANT PackageToVersions& rd=interval_vars.get_require_down();
CONSTANT PackageToVersions& du=interval_vars.get_disable_up();
CONSTANT PackageToVersions& dd=interval_vars.get_disable_down();
FOR_EACH (PackageToVersions::const_iterator, index, ru)
{
CONSTANT string name = index->first;
assert((index->second)!=NULL);
VersionVector& ru_intervals=*(index->second);
PackageToVersions::const_iterator i=du.find(name);
if (i == du.end()) continue;
assert((i->second)!=NULL);
VersionVector& du_intervals =*(i->second);
UINT rui=0;
UINT dui=0;
while ((rui < ru_intervals.size()) && (duifirst;
assert((index->second)!=NULL);
VersionVector& rd_intervals=*(index->second);
PackageToVersions::const_iterator i=dd.find(name);
if (i == dd.end()) continue;
assert((i->second)!=NULL);
VersionVector& dd_intervals =*(i->second);
int rdi=rd_intervals.size()-1;
int ddi=dd_intervals.size ()-1;
while ((rdi>=0) && (ddi>=0))
{
if (rd_intervals[rdi]>dd_intervals[ddi]) --rdi;
else {
solver.output_binary_clause(neg(interval_vars.get_require_down(PackageVersion(name,rd_intervals[rdi]))),
neg(interval_vars.get_disable_down(PackageVersion(name,dd_intervals[ddi]))));
--ddi;
}
}
}
// FOR_EACH (PackageToVersions::const_iterator, index, ru)
// {
// CONSTANT string name = index->first;
// assert((index->second)!=NULL);
// VersionVector& ru_intervals=*(index->second);
// }
}
void Encoder::process_require_down(const string& package,
const VersionVector& intervals,
const VersionVector& package_versions,
bool is_feature)
{
if (intervals.empty()) return;//No intervals to process, nothing to do
const UINT vsz=package_versions.size();
const UINT isz=intervals.size();
int current_interval_index=isz-1;
int current_version_index=vsz-1;
// find first package version that is within the first interval within an interval
for ( ;current_version_index >= 0; --current_version_index)
{
if (intervals[current_interval_index]>=package_versions[current_version_index])
break;
}
LiteralVector literals;
//Initialize literals with intervals[0] => ...
{
Variable v=interval_vars.get_require_down(PackageVersion(package,intervals[current_interval_index]));
literals.push_back(neg(v));
}
int next_interval_index= current_interval_index>0 ? current_interval_index-1 : -1;
while (current_interval_index>=0) {
// Flush the current literals IF
// all package versions have been processed
// OR the current package version belongs into the next interval
while (current_version_index<0
||
(next_interval_index>=0 && intervals[next_interval_index]>=package_versions[current_version_index])
)
{
Variable next_v=0;
if (next_interval_index>=0) {// link to the next interval (if there is such)
next_v=interval_vars.get_require_down(PackageVersion(package,intervals[next_interval_index]));
literals.push_back(next_v);
} else if (is_feature) {
// PackageVersion (package,0) has already encoutered, if present
// Unversioned feature makes everything true
//Variable infinite_var;
// if (variables.find_variable(PackageVersion (package,0), infinite_var))
// literals.push_back(infinite_var);
}
solver.output_clause(literals); // flush current clause
literals.clear();
// move to the next interval
current_interval_index=next_interval_index;
next_interval_index=current_interval_index>0 ? current_interval_index-1 : -1;
if (current_interval_index>=0) {
literals.push_back(neg(next_v)); // Initialize literals for the next interval
} else {
assert (current_version_index<0);
return;
}
}
// Add current package version to the current interval and move to the next package version
if (current_interval_index>=0 && current_version_index>=0) {
Variable v=get_package_version_variable(
PackageVersion (package,package_versions[current_version_index]));
literals.push_back(v);
--current_version_index;
}
}
}
void Encoder::process_require_up(const string& package,
const VersionVector& intervals,
const VersionVector& package_versions,
bool is_feature/*=false*/)
{
if (intervals.empty()) return;//No intervals to process, nothing to do
UINT current_interval_index=0;
UINT current_version_index=0;
const UINT vsz=package_versions.size();
// find first package version that is within the first interval within an interval
for ( ;current_version_index < vsz; ++current_version_index)
{
if (package_versions[current_version_index]>=intervals[current_interval_index])
break;
}
const UINT isz=intervals.size();
LiteralVector literals;
//Initialize literals with intervals[0] => ...
{
Variable v=interval_vars.get_require_up(PackageVersion(package,intervals[current_interval_index]));
literals.push_back(neg(v));
}
UINT next_interval_index= (current_interval_index+1)=vsz
||
(next_interval_index=intervals[next_interval_index])
)
{
Variable next_v=0;
if (next_interval_index=vsz);
return;
}
}
// Add current package version to the current interval and move to the next package version
if (current_interval_index=intervals[current_interval_index])
break;
}
const UINT isz=intervals.size();
UINT next_interval_index= (current_interval_index+1)=vsz
||
(next_interval_index=intervals[next_interval_index])
)
{
Variable next_v;
if (next_interval_index=isz) {
assert (current_version_index>=vsz);
return;
}
}
// Add current package version to the current interval and move to the next package version
if (current_interval_index=0; --current_version_index)
{
if (intervals[current_interval_index]>=package_versions[current_version_index])
break;
}
int next_interval_index= (current_interval_index-1)>=0 ? current_interval_index-1 : -1;
Variable current_interval_variable = interval_vars.get_disable_down(PackageVersion(package,intervals[current_interval_index]));
while (current_interval_index>=0) {
// Moved to next interval IF
// all package versions have been processed
// OR the current package version belongs into the next interval
while (current_version_index<0
||
(next_interval_index>=0 && intervals[next_interval_index]>=package_versions[current_version_index])
) {
Variable next_v;
if (next_interval_index>=0) {// link to the next interval (if there is such)
next_v=interval_vars.get_disable_down(PackageVersion(package,intervals[next_interval_index]));
solver.output_binary_clause(neg(current_interval_variable), next_v);
} else if (is_feature){
// unversioned feature must be disabled in any case
Variable infinite_var=-1;
if (variables.find_variable(PackageVersion (package,0), infinite_var))
solver.output_binary_clause(neg(current_interval_variable), neg(infinite_var));
}
// move to the next interval
current_interval_index=next_interval_index;
current_interval_variable=next_v;
next_interval_index=(current_interval_index-1)>=0 ? current_interval_index-1 : -1;
if (current_interval_index<0) {
return;
}
}
// Add current package version to the current interval and move to the next package version
if (current_interval_index>=0 && current_version_index>=0) {
Variable v=get_package_version_variable(
PackageVersion (package,package_versions[current_version_index]));
solver.output_binary_clause(neg(current_interval_variable), neg(v));
--current_version_index;
}
}
}
int Encoder::new_score(IntVector& model) {
int new_packages = 0;
FOR_EACH(PackageUnits::const_iterator, index, read_units) {
UnitVector &unit_vector = *(index->second);
bool was_any_installed = false;
bool is_any_installed = false;
FOR_EACH(UnitVector::iterator, unit_index, unit_vector) {
InstallableUnit *unit = *unit_index;
CONSTANT bool installed = is_installed(unit, model);
if (unit->installed) was_any_installed = true;
if (installed) is_any_installed = true;
}
if (!was_any_installed && is_any_installed) ++new_packages;
}
return new_packages;
}
int Encoder::removed_score(IntVector& model)
{
int removed_packages = 0;
FOR_EACH(PackageUnits::const_iterator,index,read_units)
{
UnitVector &unit_vector=*(index->second);
bool was_any_installed = false;
bool is_any_installed = false;
FOR_EACH (UnitVector::iterator, unit_index, unit_vector)
{
InstallableUnit *unit =*unit_index;
CONSTANT bool is_installed = (unit->needed && (model[unit->variable]>0));
if (unit->installed) was_any_installed = true;
if (is_installed) is_any_installed = true;
}
if (was_any_installed && !is_any_installed) --removed_packages;
}
return removed_packages;
}
int Encoder::notuptodate_score(IntVector& model)
{
int violated = 0;
FOR_EACH(PackageUnits::const_iterator,index,read_units)
{
UnitVector &unit_vector=*(index->second);
bool is_any_installed = false;
bool latest_installed = false;
Version latest_version = 0;
FOR_EACH (UnitVector::iterator, unit_index, unit_vector)
{
CONSTANT InstallableUnit *unit = *unit_index;
CONSTANT bool installed = is_installed(unit, model);
if (unit->version > latest_version) {
latest_installed = installed;
latest_version = unit->version;
}
if (installed) is_any_installed = true;
}
if (is_any_installed && !latest_installed) { OUT(cerr << "nu: " << index->first << endl;) --violated; }
}
return violated;
}
int Encoder::changed_score(IntVector& model)
{
int changed_version_sets = 0;
FOR_EACH(PackageUnits::const_iterator,index,read_units)
{
UnitVector &unit_vector=*(index->second);
bool version_set_changed = false;
FOR_EACH (UnitVector::iterator, unit_index, unit_vector)
{
InstallableUnit *unit =*unit_index;
CONSTANT bool is_installed = (unit->needed && (model[unit->variable]>0));
if ((unit->installed) != is_installed) version_set_changed=true;
}
if (version_set_changed) --changed_version_sets;
}
return changed_version_sets;
}
int Encoder::recommends_score(IntVector& model)
{
int score = 0;
FOR_EACH(PackageUnits::const_iterator,index,read_units)
{
const UnitVector &unit_vector=*(index->second);
FOR_EACH (UnitVector::const_iterator, unit_index, unit_vector)
{
CONSTANT InstallableUnit *unit =*unit_index;
if (!is_installed(unit, model)) continue;//ignore things that are not installed
CONSTANT PackageVersionsCNF& cnf = unit->recommends_cnf;
FOR_EACH (PackageVersionsCNF::const_iterator, clause_index, cnf)
{
CONSTANT PackageVersionsList& clause = **clause_index;
bool sat = false;
FOR_EACH (PackageVersionsList::const_iterator,literal_index, clause)
{
PackageVersions literal = *literal_index;
if (sat || is_any_installed(literal, model)) sat = true;
}
if (!sat) {
OUT (cerr << "unsatisfied recommends: ["<< unit->name <<":" << unit->version<<"]";
collection_printing::print(clause,cerr); cerr<needed && (model[unit->variable]>0);
}
bool Encoder::is_any_installed_feature(CONSTANT string &feature_name,
Operator version_operator,
Version operand,
IntVector& model)
{
// Process unversioned providers
if (is_installed_feature(PackageVersion(feature_name,0))) return true;
CONSTANT FeatureToVersions::const_iterator i = feature_versions.find(feature_name);
if (i==feature_versions.end()) return false;
CONSTANT VersionSet &vs=*(i->second);
FOR_EACH (VersionSet::const_iterator,vi,vs)
{
CONSTANT Version version=*vi;
if (evaluate(version, version_operator, operand))
if (is_installed_feature(PackageVersion(feature_name,version)))
return true;
}
return false;
}
bool Encoder::is_any_installed(PackageVersions& package, IntVector& model)
{
if (is_feature (package.name()))
return is_any_installed_feature(package.name(), package.op(), package.version(), model);
const PackageUnits::const_iterator i=needed_units.find(package.name());
if (i==needed_units.end()) return false;
UnitVector& unit_vector = *(i->second);
FOR_EACH (UnitVector::const_iterator, unit_index, unit_vector)
{
InstallableUnit* unit =*unit_index;
if (evaluate(unit->version, package.op(), package.version()))
if (is_installed (unit, model)) return true;
}
return false;
}
bool Encoder::is_installed_feature(const PackageVersion& feature, IntVector& model)
{
assert (is_feature(feature.name()));
CONSTANT FeatureToUnits::const_iterator providers_index = feature_units.find(feature);
if (providers_index==feature_units.end()) { assert(false); return false; }
CONSTANT UnitVector& providers =*(providers_index->second);
FOR_EACH (UnitVector::const_iterator, provider_index, providers)
{
CONSTANT InstallableUnit* provider =*provider_index;
if (is_installed(provider,model)) return true;
}
return false;
}
void Encoder::trendy_score(IntVector& model)
{
cerr << "trendy score[" <<
removed_score(model) << "," <<
notuptodate_score(model) << "," <<
recommends_score(model) << "," <<
new_score(model)
<< "]" << endl;
}
void Encoder::paranoid_score(IntVector& model)
{
const int removed_packages = recommends_score(model);
const int changed_version_sets = changed_score(model);
cerr << "score[" << removed_packages << "," << changed_version_sets << "]" << endl;
}
void Encoder::print_valuation(ostream& output,IntVector& model)
{
output <<"removed(" << removed_score(model) << "),"
<<"not up-to-date (" << notuptodate_score(model) << "),"
<<"recommends (" << recommends_score(model) << "),"
<<"new (" << new_score(model) <<")";
}
void Encoder::check_solution() {
cerr << "cheking solution" <second);
FOR_EACH(UnitVector::const_iterator,vi,uv)
{
CONSTANT InstallableUnit *unit = *vi;
const Version v=unit->version;
PackageVersion pv=PackageVersion(unit->name, v);
const bool c=(stc->find(pv) != stc->end());
// cerr << pv.to_string() << ( c ? " installed" : " not installed" ) << endl;
if (!c) solver.output_unary_clause(neg(unit->variable));
}
}
FOR_EACH(PackageVersionSet::const_iterator, i, (*stc)) {
const PackageVersion &pv=*i;
Variable var;
bool f=variables.find_variable(pv,var);
if (f) {
solver.output_unary_clause(var);
} else {
cerr << "using sliced pck: " << pv.to_string() << endl;
}
}
bool has_solution = solver.solve();
if (has_solution) {
cerr << "is sol" << endl;
cerr << "MSUNCore min unsat: " << solver.get_min_unsat_cost() << endl;
}
else {
cerr << "is not sol" << endl;
}
}
packup-0.6/Encoder.hh 0000644 0001750 0001001 00000027066 11573000733 013661 0 ustar mikolas None /******************************************************************************\
* This file is part of packup. *
* *
* packup is free software: you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* *
* packup is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with packup. If not, see . *
\******************************************************************************/
/*
* File: Encoder.hh
* Author: mikolas
*
* Created on September 26, 2010, 2:01 PM
* Copyright (C) 2011, Mikolas Janota
*/
#ifndef ENCODER_HH
#define ENCODER_HH
#include "common_types.hh"
#include "SolverWrapperTypes.hh"
#include "SolutionReader.hh"
#include "InstallableUnit.hh"
#include "EncoderTypes.hh"
#include "IntervalVariables.hh"
#include "PackageVersionVariables.hh"
#include "SolverWrapper.hh"
#include "Printer.hh"
#include "NotRemoved.hh"
using namespace version_operators;
class Encoder {
public:
Encoder(SolverWrapper& solver,IDManager& id_manager);
virtual ~Encoder();
void add_unit (InstallableUnit* unit);
void add_install (CONSTANT PackageVersionsList& list);
void add_upgrade (CONSTANT PackageVersionsList& list);
void add_remove (CONSTANT PackageVersionsList& list);
void set_criterion(Criterion optimization_criterion);
void set_lexicographic(CONSTANT vector& lexicographic_ordering);
void set_solution_file(ostream* file) {psolution_file = file;}
inline CONSTANT vector& get_lexicographic() const {return lexicographic;}
inline void disable_solving () {should_solve=false;}
inline void set_iv(UINT piv) {iv=piv;}
inline void set_opt_edges(int v=1) {opt_edges=v;}
inline void set_opt_not_removed(bool v=true) {opt_not_removed=v;}
inline bool get_opt_edges(bool v=true) const {return opt_edges;}
inline bool get_opt_not_removed(bool v=true) const {return opt_not_removed;}
inline void enable_valuation() {valuation = true;}
void encode();
bool solution();
void print_solution();
SolverWrapper& get_solver_wrapper();
UINT unit_count;
UINT cut_off;
#ifdef MAPPING
inline unordered_map& get_variable_names() {return variable_names;}
inline ofstream& get_mapping() {return mapping;}
#endif
private:
vector lexicographic;
ostream* psolution_file;
bool should_solve;
SolverWrapper& solver;
IDManager& id_manager;
#ifdef MAPPING
VariableToName variable_names;// Names of variables for debugging purposes.
ofstream mapping; // file for recording mapping from variable numbers to their names
#endif
PackageVersionVariables variables;
IntervalVariables interval_vars;
#ifdef CONV_DBG
Printer printer;
#endif
bool valuation;
int opt_edges; // add redundancy implications between interval variables
bool process_recommends; // flag whether recommends should be taken into account (currently used only for the trendy criterion)
UINT iv;
bool printing_started_or_finished;
vector recommends_clauses_pointers;
PackageUnits read_units; // installable
PackageUnits needed_units;//installable units after slicing
FeatureToUnits feature_units; //units that provide a given feature
FeatureToVersions feature_versions;//versions of a given feature
PackageToVersions needed_feature_versions;//versions of a feature after slicing
PackageVersionSet required_features;//not needed, replace with needed_feature_versions TODO!!
PackageVersionsSet install; // entities that must be installed
PackageVersionsList upgrade; // upgrade requirement
PackageVersionsList remove; // remove requirement
bool opt_not_removed; // flag whether to use optimization "not removed"
NotRemoved not_removed; // a set of packages that will certainly be in the final solution, valid only if opt_not_removed is on
bool is_any_installed_package(const UnitVector& unit_vector);
bool is_installed_feature (CONSTANT PackageVersion& feature);
bool find_latest_installed_version_in_original_problem (CONSTANT string &name,Version& version);
bool latest_installed_feature_version (CONSTANT string &name,Version& version);
bool latest_installed_package_version (CONSTANT string &name,Version& version);
inline bool is_feature (CONSTANT string &name)
{return feature_versions.find(name) != feature_versions.end();}
void handle_keep (InstallableUnit* unit);
void handle_provides (InstallableUnit* unit);
void refine_upgrade_request ();
void encode_lexicographic();
void encode_new(XLINT& total_weight, bool maximize);
void encode_unmet_recommends(XLINT& total_weight,bool maximize);
void encode_not_up_to_date(XLINT& total_weight,bool maximize);
void encode_removed(XLINT& total_weight,bool maximize);
void encode_changed(XLINT& total_weight,bool maximize);
XLINT get_top(CONSTANT Objective& objective) const;
XLINT get_top(CONSTANT vector& lexicographic) const;
void encode_provides ();
void encode_keep ();
void encode_upgrade ();
void atmost_1 (CONSTANT string& package_name, Version from);
void atmost_1_feature (CONSTANT string& package_name, Version from);
void encode_request_remove();
void encode (CONSTANT InstallableUnit* unit);
void encode_conflicts (CONSTANT InstallableUnit* unit);
void encode_depends (CONSTANT InstallableUnit* unit);
void encode_recommends (CONSTANT InstallableUnit* unit);
void encode_package_self_conflict (CONSTANT InstallableUnit* unit,
CONSTANT PackageVersions& pvs);
void encode_not_self_conflict (CONSTANT InstallableUnit* unit,
CONSTANT PackageVersions& pvs);
void slice ();
void slice_changed ();
void need (CONSTANT PackageVersions& versions);
void need_packages(CONSTANT string &package_name, Operator version_operator, Version operand);
void need_features(CONSTANT string &feature_name, Operator version_operator, Version operand);
void need (InstallableUnit* unit);
void need_latest (CONSTANT string& package_name);
void need (PackageVersionsCNF cnf);
void need_feature(CONSTANT PackageVersion &feature);
void request_to_clause (CONSTANT PackageVersions& pvs,
LiteralVector& literals);
void disable_to_term (CONSTANT PackageVersions& pvs,
LiteralVector& term);
bool require_up_to_clause (CONSTANT string& name, Version from,
const UnitVector *unit_vector,
const VersionVector *version_vector,
LiteralVector& literals);
bool require_down_to_clause (CONSTANT string& name, Version from,
const UnitVector *unit_vector,
const VersionVector *version_vector,
LiteralVector& literals);
bool disable_up_to_term (CONSTANT string& name, Version from,
const UnitVector *unit_vector,
const VersionVector *version_vector,
LiteralVector& literals);
bool disable_down_to_term (CONSTANT string& name, Version from,
const UnitVector *unit_vector,
const VersionVector *version_vector,
LiteralVector& literals);
void requests_to_clause (CONSTANT VersionsList::const_iterator begin,
CONSTANT VersionsList::const_iterator end,
LiteralVector& literals);
inline Variable new_variable() { return id_manager.new_id(); }
void conflict_all (CONSTANT Variable& pv, CONSTANT VariableSet& set);
void add_providers(CONSTANT PackageVersions& features, VariableSet& providers);
void add_providers(CONSTANT PackageVersion& feature, VariableSet& providers);
inline Variable get_package_version_variable(CONSTANT PackageVersion& pv) {
Variable return_value=0;
CONSTANT bool found = variables.find_variable(pv, return_value);
#ifdef CONV_DBG
if (!found) { cerr << "no variable for: " << pv.to_string() << endl;}
#endif
if (!found) assert(0);//getting rid of the compiler warning
return return_value;
}
//global processing (for whole package repository)
void process_interval_variables ();
void process_require_up(const string& package,
const VersionVector& intervals,
const VersionVector& package_versions,
bool is_feature=false);
void process_require_down(const string& package,
const VersionVector& intervals,
const VersionVector& package_versions,
bool is_feature=false);
void process_disable_up(const string& package,
const VersionVector& intervals,
const VersionVector& package_versions,
bool is_feature=false);
void process_disable_down(const string& package,
const VersionVector& intervals,
const VersionVector& package_versions,
bool is_feature=false);
void encode_edges();
void assert_not_removed();
void paranoid_score (IntVector& model);
void trendy_score(IntVector& model);
int removed_score(IntVector& model);
int new_score(IntVector& model);
int changed_score(IntVector& model);
int notuptodate_score(IntVector& model);
int recommends_score (IntVector& model);
bool is_installed (const InstallableUnit* unit,IntVector& model);
bool is_any_installed (PackageVersions& package,IntVector& model);
bool is_any_installed_feature(CONSTANT string &feature_name,
Operator version_operator,
Version operand,
IntVector& model);
bool is_installed_feature(const PackageVersion& feature, IntVector& model);
bool _process_not_uptodate;
inline bool process_not_uptodate() {return _process_not_uptodate;}
enum CT { CT_MIN, CT_MAX, CT_NO };
CT gt(OBJECTIVE_FUNCTION o,vector& lex) {
FOR_EACH(vector::const_iterator,oi,lex) {
if (oi->first==o) return oi->second ? CT_MAX : CT_MIN;
}
return CT_NO;
}
void print_valuation(ostream& output,IntVector& model);
public:
bool cs;
PackageVersionSet* stc;
void check_solution();
};
#endif /* ENCODER_HH */
packup-0.6/EncoderTypes.cc 0000644 0001750 0001001 00000005267 11573000733 014673 0 ustar mikolas None /******************************************************************************\
* This file is part of packup. *
* *
* packup is free software: you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* *
* packup is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with packup. If not, see . *
\******************************************************************************/
/* Copyright (C) 2011, Mikolas Janota */
#include "EncoderTypes.hh"
#include "collections.hh"
void record_version (PackageToVersions& vvs, const string& name, Version version)
{
PackageToVersions::iterator i=vvs.find(name);
VersionVector* vs;
if (i == vvs.end ()) {
vs=new VersionVector();
vvs [name]=vs;
} else {
vs=i->second;
}
vs->push_back(version);
}
void record_version (FeatureToVersions& vvs, const string& name, Version version)
{
FeatureToVersions::iterator i=vvs.find(name);
VersionSet* vs;
if (i == vvs.end ()) {
vs=new VersionSet();
vvs[name]=vs;
} else {
vs=i->second;
}
vs->insert(version);
}
void record_unit(FeatureToUnits& ftu, CONSTANT PackageVersion& feature, InstallableUnit *unit)
{
FeatureToUnits::iterator fi=ftu.find(feature);
UnitVector *vector;
if (fi==ftu.end())
{
vector = new UnitVector ();
ftu[feature]=vector;
} else {
vector = fi->second;
}
vector->push_back(unit);
}
void record_unit (PackageUnits& pu, InstallableUnit *unit)
{
CONSTANT string &package_name=unit->name;
PackageUnits::const_iterator i = pu.find (package_name);
UnitVector *vector;
if (i!=pu.end()) vector = i->second;
else {
vector = new UnitVector();
pu[package_name]=vector;
}
vector->push_back(unit);
}
packup-0.6/EncoderTypes.hh 0000644 0001750 0001001 00000004310 11573000733 014671 0 ustar mikolas None /******************************************************************************\
* This file is part of packup. *
* *
* packup is free software: you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* *
* packup is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with packup. If not, see . *
\******************************************************************************/
/*
* File: EncoderTypes.hh
* Author: mikolas
*
* Created on September 26, 2010, 7:35 PM
* Copyright (C) 2011, Mikolas Janota
*/
#ifndef ENCODERTYPES_HH
#define ENCODERTYPES_HH
#include "collections.hh"
#include "InstallableUnit.hh"
typedef vector UnitVector;
typedef vector UnitConstantVector;
typedef unordered_map PackageUnits;
typedef unordered_map PackageConstantUnits;
typedef unordered_map FeatureToUnits;
void record_version (PackageToVersions& vvs, const string& name, Version version);
void record_version (FeatureToVersions& vvs, const string& name, Version version);
void record_unit(FeatureToUnits& ftu, CONSTANT PackageVersion& feature, InstallableUnit *unit);
void record_unit (PackageUnits& pu, InstallableUnit *unit);
#endif /* ENCODERTYPES_HH */
packup-0.6/err_utils.hh 0000644 0001750 0001001 00000004237 11573000740 014303 0 ustar mikolas None /******************************************************************************\
* This file is part of packup. *
* *
* packup is free software: you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* *
* packup is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with packup. If not, see . *
\******************************************************************************/
//jpms:bc
/*----------------------------------------------------------------------------*\
* File: err_utils.hh
*
* Description: Utilities to handle errors.
*
* Author: jpms
*
* Copyright (c) 2010, Joao Marques-Silva
\*----------------------------------------------------------------------------*/
//jpms:ec
#ifndef _ERR_UTILS_H
#define _ERR_UTILS_H 1
#include
using namespace std;
template
void tool_abort(S msg) {
std::cout << "ERROR: " << msg << std::endl; std::cout.flush(); exit(5); }
template
void tool_warn(S msg) {
std::cout << "WARN: " << msg << std::endl; std::cout.flush(); }
template
void tool_info(S msg) {
std::cout << "INFO: " << msg << std::endl; std::cout.flush(); }
#endif /* _ERR_UTILS_H */
/*----------------------------------------------------------------------------*/
packup-0.6/ExternalWrapper.cc 0000644 0001750 0001001 00000034253 11573000733 015407 0 ustar mikolas None /******************************************************************************\
* This file is part of packup. *
* *
* packup is free software: you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* *
* packup is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with packup. If not, see . *
\******************************************************************************/
/*
* File: ExternalWrapper.cc
* Author: mikolas
*
* Created on April 19, 2011, 8:33 AM
* Copyright (C) 2011, Mikolas Janota
*/
#include
#include
#include
#include "ExternalWrapper.hh"
#include "fmtutils.hh"
using std::sort;
ExternalWrapper::ExternalWrapper(IDManager& id_manager)
:min_cost(LONG_MAX)
,solution_value (-1)
,_id_manager(id_manager)
,solver_command("minisat+ -cs -ansi")
,multiplication_string("*")
,temporary_directory("/tmp")
,leave_temporary_files(false)
,iterative(true)
{}
void clause_to_constraint(BasicClause& clause, vector& constraint);
bool ExternalWrapper::solve() {
stamp = time(NULL);
// set up datastructures
const size_t function_count = weights.size();
sorted_weights.insert(sorted_weights.end (),weights.begin(), weights.end ());
sort(sorted_weights.begin(), sorted_weights.end(),greater());
solution_weights.resize(function_count,-1);
functions.resize(function_count);
clause_split.resize(function_count);
split(); // split clauses into the classes according to weight
min_cost=get_top();
return iterative ? solve_it() : solve_max();
}
bool ExternalWrapper::solve_it() {
const size_t function_count = weights.size();
// generate hard clauses
size_t i=constraints.size();
constraints.resize(i+hard_clauses.size());
FOR_EACH(cset_iterator, clause_index, hard_clauses) {
vector& constraint = constraints[i++];
clause_to_constraint(**clause_index, constraint);
}
bool solution_found = false;
if (function_count==0) {
vector dummy;
external_solve(dummy, constraints, model);
solution_found = !model.empty();
}
//solve one by one
for (size_t function_index = 0;function_index < function_count ;++function_index) {
solution_found = solve(function_index);
if (!solution_found) break;
}
return solution_found;
}
bool ExternalWrapper::has_solution() {return !model.empty();}
bool ExternalWrapper::solve(const size_t function_index) {
cerr << "# starting function level " << function_index << endl;
// relaxation of current function
vector& relaxation_literals = functions[function_index];
const BasicClauseVector& clauses=clause_split[function_index];
FOR_EACH(BasicClauseVector::const_iterator,clause_index,clauses) {
BasicClause& clause = **clause_index;
if (clause.size()==1) {
relaxation_literals.push_back(-(*(clause.begin())));
} else {
vector constraint;
const LINT relaxation_variable = _id_manager.new_id();
relaxation_literals.push_back(relaxation_variable);
constraint.push_back(relaxation_variable);
clause_to_constraint(clause, constraint);
constraints.push_back(constraint);
}
}
// call external solver
vector temporary_model;
external_solve(relaxation_literals, constraints, temporary_model);
if (temporary_model.empty()) return false; // stop here
// copy solution to the output model
model.clear();
model.insert (model.end(), temporary_model.begin(), temporary_model.end());
//constrain the following computation based on the score
LINT score = 0;
FOR_EACH(vector::const_iterator,literal_index,relaxation_literals) {
const LINT literal = *literal_index;
const bool fsign = literal>0;
const size_t var = fsign ? (size_t)literal : (size_t)(-literal);
const bool msign = model[var] > 0;
if (!msign) continue;
if (fsign) ++score;
else --score;
}
solution_weights[function_index] = score;
const vector& cs = functions[function_index];
if (cs.size() != 0) {
vector c;
FOR_EACH(vector::const_iterator, literal_index, cs) c.push_back(-(*literal_index));
c.push_back(-score);
constraints.push_back(c);
}
//min_cost = abs(score); //todo
return model.size() != 0; // ? -1 : score;
}
int ExternalWrapper::external_solve(const vector& function, vector< vector >& constraints
,IntVector& tmp_model) {
stringstream strstr;
strstr<::const_iterator, literal_index, function) {
const LINT literal = *literal_index;
const bool sign = literal > 0;
output << " " << (sign ? "+1" : "-1") << multiplication_string << "x" << (sign ? literal : -literal);
}
output << ";" << endl;
}
FOR_EACH(vector< vector >::const_iterator,constraint_index,constraints) {
print_constraint(*constraint_index, output) << endl;// print constraints
}
output.close();
// call the solver
stringstream scommand;
const string output_filename = input_file_name + ".out";
scommand << solver_command << " " << input_file_name << " >" << output_filename;
const string command = scommand.str();
const int retv = system (command.c_str());
cerr << "# " << "external command finished with exit value " << retv << endl;
gzFile of=gzopen(output_filename.c_str(), "rb");
assert(of!=NULL);//TODO
StreamBuffer r(of);
bool sat=false;
tmp_model.resize((size_t)(_id_manager.top_id()+1),0);
while (*r != EOF) {
if (*r != 'v') {// ignore all the other lines
skipLine(r);
} else {
sat=true;
++r; // skip 'v'
while ( (*r != '\n') && (*r != EOF) && (*r != '\r') ) {
skipTrueWhitespace(r);
const bool sign = (*r) != '-';
if ((*r == '+') || (*r == '-')) ++r;
if ((*r == 'x')) ++r;
if (*r < '0' || *r > '9') break;
const LINT l = parseInt(r);
// if ( model.size()<=(size_t)l )
//cerr << "# " << l << " " << (sign ? l : -l) << endl;
assert(tmp_model.size()>(size_t)l);
tmp_model[l] = (sign ? l : -l);
}
assert (*r=='\n');
++r; // skip '\n'
}
}
if (!sat) tmp_model.clear();
if (!leave_temporary_files) {
remove(input_file_name.c_str());
remove(output_filename.c_str());
}
return retv;
}
bool ExternalWrapper::solve_max() {
// call external solver
vector temporary_model;
external_solve_max(temporary_model);
if (temporary_model.empty()) return false; // stop here
// copy solution to the output model
model.clear();
model.insert (model.end(), temporary_model.begin(), temporary_model.end());
//min_cost = abs(score); //todo
return model.size() != 0; // ? -1 : score;
}
int ExternalWrapper::external_solve_max(IntVector& tmp_model) {
stringstream strstr;
strstr<" << output_filename;
const string command = scommand.str();
const int retv = system (command.c_str());
cerr << "# " << "external command finished with exit value " << retv << endl;
gzFile of=gzopen(output_filename.c_str(), "rb");
assert(of!=NULL);//TODO
StreamBuffer r(of);
bool sat=false;
tmp_model.resize((size_t)(_id_manager.top_id()+1),0);
while (*r != EOF) {
if (*r != 'v') {// ignore all the other lines
skipLine(r);
} else {
sat=true;
++r; // skip 'v'
while ( (*r != '\n') && (*r != EOF) && (*r != '\r') ) {
skipTrueWhitespace(r);
const bool sign = (*r) != '-';
if ((*r == '+') || (*r == '-')) ++r;
if (*r < '0' || *r > '9') break;
const LINT l = parseInt(r);
assert(tmp_model.size()>(size_t)l);
tmp_model[l] = (sign ? l : -l);
}
assert (*r=='\n');
++r; // skip '\n'
}
}
if (!sat) tmp_model.clear();
if (!leave_temporary_files) {
remove(input_file_name.c_str());
remove(output_filename.c_str());
}
return retv;
}
void ExternalWrapper::split() {
FOR_EACH(cset_iterator, clause_index, clause_set) {
BasicClause* clause = *clause_index;
if (clause_set.is_cl_hard(clause)) {
hard_clauses.attach_clause(clause);
} else {
XLINT total_weight = clause_set.get_cl_weight(clause);
FOR_EACH(WeightSet::const_iterator,weight_index, weights) {
// split into duplicate clauses
const XLINT weight = *weight_index;
const XLINT k = total_weight/weight;
total_weight %= weight;
for (XLINT i = 0; i& constraint,ostream& output) {
const size_t sz = constraint.size();
assert(sz>=2);
for (size_t index=0; index0;
output << (sign ? "+1" : "-1") << multiplication_string << "x" << (sign ? literal : -literal) << " ";
}
output << " >= " << constraint[sz-1] << ";";
return output;
}
void clause_to_constraint(BasicClause& clause, vector& constraint) {
LINT rh=1;
FOR_EACH(Literator, literal_index, clause) {
const LINT literal = *literal_index;
constraint.push_back(literal);
if (literal<0) --rh;
}
constraint.push_back(rh);
}
size_t ExternalWrapper::get_weight_index(XLINT weight) const {
for (size_t i=0; i::const_iterator, i, clause_split) {
c+=i->size();
}
out << "p wcnf"
<< " " << _id_manager.top_id()
<< " " << c
<< " " << clause_set.get_top()
<< endl;
FOR_EACH(cset_iterator, clause_index, hard_clauses) {
BasicClause& clause = **clause_index;
out << get_top() << " " << clause << endl;
}
for (size_t i=0;i. *
\******************************************************************************/
/*
* File: ExternalWrapper.hh
* Author: mikolas
*
* Created on April 19, 2011, 8:33 AM
* Copyright (C) 2011, Mikolas Janota
*/
#ifndef EXTERNALWRAPPER_HH
#define EXTERNALWRAPPER_HH
#include
#include "common_types.hh"
#include "id_manager.hh"
#include "basic_clset.hh"
#include "SolverWrapperBase.hh"
class ExternalWrapper : public SolverWrapperBase {
public:
ExternalWrapper(IDManager& id_manager);
~ExternalWrapper() {};
virtual void init();
virtual XLINT get_top();
virtual void set_top(XLINT top);
virtual bool solve();
virtual IntVector& get_model() { return model; }
virtual XLINT get_min_unsat_cost() {return min_cost;}
virtual bool register_weight(XLINT weight) {
std::pair r = weights.insert(weight);
return r.second;
}
inline void set_solver_command(const string& solver_command);
inline void set_multiplication_string(const string& _multiplication_string);
inline void set_temporary_directory(const string& value);
inline void set_leave_temporary_files(bool value=true);
void _output_clause (/*const*/ LiteralVector& literals);
void _output_unary_clause(LINT l);
void _output_binary_clause(LINT l1, LINT l2);
void _output_weighted_clause(/*const*/ LiteralVector& literals,XLINT weight);
void _output_unary_weighted_clause(LINT l, XLINT weight);
void _output_binary_weighted_clause(LINT l1, LINT l2, XLINT weight);
BasicClause* _record_clause(LiteralVector& literals);
virtual void _increase_weight(BasicClause* clause, XLINT weight);
virtual void dump(ostream& out);
virtual bool has_solution();
void set_iterative(bool iterative) {this->iterative = iterative;}
bool is_iterative() const {return iterative;}
private:
XLINT min_cost;
XLINT solution_value;
IDManager& _id_manager;
BasicClauseSet clause_set;
BasicClauseSet hard_clauses;
vector clause_split;
vector solution_weights;
vector< vector > functions;
IntVector model;
WeightSet weights;
vector sorted_weights;
int call_counter;
time_t stamp;
string solver_command;
string multiplication_string;
string temporary_directory;
bool leave_temporary_files;
bool iterative;
vector< vector > constraints;
void split();
size_t get_weight_index(XLINT weight) const;
bool solve(size_t function_index);
bool solve_max();
bool solve_it();
int external_solve(const vector& function
,vector< vector >& constraints
,IntVector& tmodel);
int external_solve_max(IntVector& tmodel);
bool has_weight(XLINT weight) const {
FOR_EACH(WeightSet::const_iterator,weight_index, weights)
if (*weight_index==weight) return true;
return false;
}
ostream& print_constraint (const vector& constraint,ostream& output);
};
inline void ExternalWrapper::set_solver_command(const string& _solver_command) {
solver_command =_solver_command; }
inline void ExternalWrapper::set_multiplication_string(const string& _multiplication_string) {
multiplication_string =_multiplication_string; }
inline void ExternalWrapper::set_temporary_directory(const string& value) {
temporary_directory = value; }
inline void ExternalWrapper::set_leave_temporary_files(bool value/*=true*/) {
leave_temporary_files = value; }
#endif /* EXTERNALWRAPPER_HH */
packup-0.6/fmtutils.hh 0000644 0001750 0001001 00000012106 11573000740 014134 0 ustar mikolas None /******************************************************************************\
* This file is part of packup. *
* *
* packup is free software: you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* *
* packup is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with packup. If not, see . *
\******************************************************************************/
//jpms:bc
/*----------------------------------------------------------------------------*\
* File: fmtutils.hh
*
* Description: Utils for parsing DIMACS-based formats.
*
* Author: jpms
*
* Revision: $Id$.
*
* Copyright (c) 2009, Joao Marques-Silva
\*----------------------------------------------------------------------------*/
//jpms:ec
#ifndef _FMTUTILS_H
#define _FMTUTILS_H 1
//jpms:bc
/*----------------------------------------------------------------------------*\
* Utils for DIMACS format parsing
* (This borrows **extensively** from the MiniSAT parser)
\*----------------------------------------------------------------------------*/
//jpms:ec
#define CHUNK_LIMIT 1048576
#define SMALL_CHUNK_LIMIT 1024
class StreamBuffer {
protected:
gzFile in;
char *buf; //buf[CHUNK_LIMIT];
int pos;
int size;
void assureLookahead() {
if (pos >= size) {
pos = 0;
size = gzread(in, buf, sizeof(buf)); } }
virtual void resize_buffer() { buf = new char[CHUNK_LIMIT]; }
public:
StreamBuffer(gzFile i) : in(i), pos(0), size(0) {
resize_buffer(); assureLookahead(); }
virtual ~StreamBuffer() { delete buf; }
int operator * () { return (pos >= size) ? EOF : buf[pos]; }
void operator ++ () { pos++; assureLookahead(); }
};
class SmallStreamBuffer : public StreamBuffer {
protected:
virtual void resize_buffer() { buf = new char[SMALL_CHUNK_LIMIT]; }
public:
SmallStreamBuffer(gzFile i) : StreamBuffer(i) { }
//virtual ~SmallStreamBuffer() { delete buf; }
virtual ~SmallStreamBuffer() { }
};
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
template
static void skipWhitespace(B& in) {
while ((*in >= 9 && *in <= 13) || *in == 32)
++in; }
template
static void skipTrueWhitespace(B& in) { // not including newline
while (*in == ' ' || *in == '\t')
++in; }
template
static void skipTabSpace(B& in) { while (*in == 9 || *in == 32) ++in; }
template
static void skipLine(B& in) {
for (;;){
if (*in == EOF) return;
if (*in == '\n') { ++in; return; }
if (*in == '\r') { ++in; return; }
++in; } }
template
static bool skipEndOfLine(B& in) { // skip newline AND trailing comment/empty lines
if (*in == '\n' || *in == '\r') ++in;
else return false;
skipComments(in);
return true; }
template
static bool skipText(B& in, char* text) {
while (*text != 0){
if (*in != *text) return false;
++in, ++text; }
return true; }
template
static string readString(B& in) {
string rstr;
skipWhitespace(in);
while (*in >= '0' && *in <= '9' ||
*in >= 'a' && *in <= 'z' ||
*in >= 'A' && *in <= 'Z' ||
(*in == '_') || (*in == '.')) {
rstr.push_back(*in); ++in;
}
return rstr; }
template
static LINT parseInt(B& in) {
LINT val = 0;
bool neg = false;
skipWhitespace(in);
if (*in == '-') neg = true, ++in;
else if (*in == '+') ++in;
if (*in < '0' || *in > '9') fprintf(stderr, "PARSE ERROR! Unexpected char: %c\n", *in), exit(3);
while (*in >= '0' && *in <= '9')
val = val*10 + (*in - '0'),
++in;
return neg ? -val : val; }
template
static XLINT parseLongInt(B& in) {
XLINT val = 0;
bool neg = false;
skipWhitespace(in);
if (*in == '-') neg = true, ++in;
else if (*in == '+') ++in;
if (*in < '0' || *in > '9') fprintf(stderr, "PARSE ERROR! Unexpected char: %c\n", *in), exit(3);
while (*in >= '0' && *in <= '9')
val = val*10 + (*in - '0'),
++in;
XLINT rval = (neg) ? (-1*val) : val;
return rval; }
#endif /* _FMTUTILS_H */
/*----------------------------------------------------------------------------*/
packup-0.6/functors.hh 0000644 0001750 0001001 00000004160 11573000740 014131 0 ustar mikolas None /******************************************************************************\
* This file is part of packup. *
* *
* packup is free software: you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* *
* packup is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with packup. If not, see . *
\******************************************************************************/
//jpms:bc
/*----------------------------------------------------------------------------*\
* File: functors.hh
*
* Description:
*
* Author: jpms
*
* Revision: $Id$.
*
* Copyright (c) 2009, Joao Marques-Silva
\*----------------------------------------------------------------------------*/
//jpms:ec
#ifndef _FUNCTORS_H
#define _FUNCTORS_H 1
template struct defprint : public unary_function
{
defprint(ostream& out) : os(out) {}
void operator() (T x) { os << x << ' '; }
ostream& os;
};
template struct ptrprint : public unary_function
{
ptrprint(ostream& out) : os(out) {}
void operator() (T x) { os << *x << endl; }
ostream& os;
};
#endif /* _FUNCTORS_H */
/*----------------------------------------------------------------------------*/
packup-0.6/globals.hh 0000644 0001750 0001001 00000007206 11573000740 013715 0 ustar mikolas None /******************************************************************************\
* This file is part of packup. *
* *
* packup is free software: you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* *
* packup is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with packup. If not, see . *
\******************************************************************************/
/*----------------------------------------------------------------------------*\
* Version: $Id: globals.hh 73 2007-07-26 15:16:48Z jpms $
*
* Author: jpms
*
* Description: Include file that includes all other key include files.
* This is the include file to be included by the header
* files of libraries and tools.
*
* Copyright (c) 2005-2006, Joao Marques-Silva
\*----------------------------------------------------------------------------*/
#ifndef _GLOBALS_HH_
#define _GLOBALS_HH_ 1
#include
#include
#include
#include
#include
#include
#include
using namespace std;
/*----------------------------------------------------------------------------*\
* System configuration
\*----------------------------------------------------------------------------*/
#include "config.hh"
/*----------------------------------------------------------------------------*\
* Macro definition
\*----------------------------------------------------------------------------*/
#include "macros.hh"
/*----------------------------------------------------------------------------*\
* Utils for printing debug information
\*----------------------------------------------------------------------------*/
#include "dbg_prt.hh"
/*----------------------------------------------------------------------------*\
* Definition of types used throughout
\*----------------------------------------------------------------------------*/
#include "basic_types.h"
#include "types.hh"
/*----------------------------------------------------------------------------*\
* Definition of functors used throughout
\*----------------------------------------------------------------------------*/
#include "functors.hh"
/*----------------------------------------------------------------------------*\
* Utils for terminating program execution
\*----------------------------------------------------------------------------*/
#include "err_utils.hh"
/*----------------------------------------------------------------------------*\
* Utils for printing resourse usage information
\*----------------------------------------------------------------------------*/
#include "rusage.hh"
#endif /* _GLOBALS_HH_ */
/*----------------------------------------------------------------------------*/
packup-0.6/id_manager.hh 0000644 0001750 0001001 00000006137 11573000740 014362 0 ustar mikolas None /******************************************************************************\
* This file is part of packup. *
* *
* packup is free software: you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* *
* packup is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with packup. If not, see . *
\******************************************************************************/
/*----------------------------------------------------------------------------*\
* Version: $Id: id_manager.hh 73 2007-07-26 15:16:48Z jpms $
*
* Author: jpms
*
* Description: Management of var IDs. Var ids *must* start at k>0.
*
* Copyright (c) 2005-2006, Joao Marques-Silva
\*----------------------------------------------------------------------------*/
#ifndef _ID_MANAGER_HH_
#define _ID_MANAGER_HH_ 1
#include "globals.hh"
/*----------------------------------------------------------------------------*\
* Class: IDManager
*
* Purpose: Manager of var IDs.
\*----------------------------------------------------------------------------*/
class IDManager {
public:
IDManager(ULINT _min_id) : id_count(_min_id-1), min_id(_min_id) {
assert(_min_id>0); }
IDManager() : id_count(0), min_id(1) { }
~IDManager() { }
public:
inline ULINT new_id() { return ++id_count; }
inline ULINT new_id(ULINT& id) { id = ++id_count; return 1; }
inline ULINT new_ids(ULINT num, ULINT& lb, ULINT& ub) {
lb = id_count + 1;
ub = id_count + num;
id_count += num;
return 1;
}
inline void reg_ids(ULINT maxid) {
if (id_count < maxid) { id_count = maxid; }
}
inline bool exists(ULINT id) { return id <= id_count && id >= min_id; }
inline ULINT top_id() { return id_count; }
inline ULINT range() { return id_count - min_id + 1; }
inline void clear() { id_count = min_id-1; }
void dump(ostream& outs=cout) {
outs << "ID count: " << (id_count-min_id+1) << endl; }
friend ostream & operator << (ostream& outs, IDManager& idmgr) {
idmgr.dump(outs); return outs; }
private:
ULINT id_count; // number of ids used
ULINT min_id; // min id used
};
#endif /* _ID_MANAGER_HH_ */
/*----------------------------------------------------------------------------*/
packup-0.6/InstallableUnit.hh 0000644 0001750 0001001 00000005364 11573000733 015371 0 ustar mikolas None /******************************************************************************\
* This file is part of packup. *
* *
* packup is free software: you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* *
* packup is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with packup. If not, see . *
\******************************************************************************/
/*
* File: InstallableUnit.hh
* Author: mikolas
*
* Created on September 25, 2010, 5:27 PM
* Copyright (C) 2011, Mikolas Janota
*/
#ifndef INSTALLABLEUNIT_HH
#define INSTALLABLEUNIT_HH
#include "collections.hh"
class InstallableUnit
{
public:
string name;
bool installed;
Version version;
PackageVersionList provides;
PackageVersionsList conflicts;
PackageVersionsCNF depends_cnf; // cnf that must be true because of depends
PackageVersionsCNF recommends_cnf; // cnf that is recommended to be true because of reccommends
KeepValue keep;
bool needed;
Variable variable;
inline void dump(ostream& out)
{
out << "package: " << name << endl;
out << "version: " << version << endl;
out << "installed: " << (installed ? "true" : "false") << endl;
out << "provides: ";
collection_printing::print(provides,out);
out << endl;
out << "conflicts: ";
collection_printing::print(conflicts,out);
out << endl;
out << "depends: ";
collection_printing::print(depends_cnf,out);
out << endl;
out << "recommends: ";
collection_printing::print(recommends_cnf,out);
out << endl;
out << "keep: " << to_string(keep) << endl;
}
};
struct InstallableUnitCmp {
inline bool operator()(const InstallableUnit* u1,const InstallableUnit* u2) const
{
return u1->version < u2->version;
}
};
#endif /* INSTALLABLEUNIT_HH */
packup-0.6/IntervalVariables.cc 0000644 0001750 0001001 00000004215 11573000734 015675 0 ustar mikolas None /******************************************************************************\
* This file is part of packup. *
* *
* packup is free software: you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* *
* packup is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with packup. If not, see . *
\******************************************************************************/
/*
* File: IntervalVariables.cc
* Author: mikolas
*
* Created on September 26, 2010, 7:41 PM
* Copyright (C) 2011, Mikolas Janota
*/
#include "IntervalVariables.hh"
#include "EncoderTypes.hh"
Variable IntervalVariables::get_variable(const PackageVersion& pv, PackageVersionMap& map,
PackageToVersions& vvs,
const string& map_name, bool& is_fresh) {
PackageVersionMap::const_iterator index = map.find(pv);
if (index != map.end()) {
is_fresh = false;
return index->second;
}
//cerr << "adding " << pv.to_string() << " to " << map_name << endl;
is_fresh = true;
Variable nv = new_variable();
map[pv] = nv;
#ifdef MAPPING
string nm= map_name + pv.to_string();
variable_names[nv] = nm;
mapping << nv << "->" << nm << endl;
#endif
record_version(vvs, pv.name(), pv.version());
return nv;
}
packup-0.6/IntervalVariables.hh 0000644 0001750 0001001 00000010057 11573000734 015710 0 ustar mikolas None /******************************************************************************\
* This file is part of packup. *
* *
* packup is free software: you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* *
* packup is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with packup. If not, see . *
\******************************************************************************/
/*
* File: IntervalVariables.hh
* Author: mikolas
*
* Created on September 26, 2010, 7:41 PM
* Copyright (C) 2011, Mikolas Janota
*/
#ifndef INTERVALVARIABLES_HH
#define INTERVALVARIABLES_HH
#include "collections.hh"
#include "id_manager.hh"
#include
using std::ofstream;
class IntervalVariables {
public:
IntervalVariables(IDManager& idm
#ifdef MAPPING
, unordered_map& variable_names,
ofstream& mapping
#endif
) : id_manager (idm)
#ifdef MAPPING
, variable_names(variable_names), mapping(mapping)
#endif
{}
bool _dummy;
Variable get_require_up(const PackageVersion& pv)
{return get_variable(pv, require_package_versions_up, require_up, "require_up", _dummy);}
Variable get_require_down(const PackageVersion& pv)
{return get_variable(pv, require_package_versions_down, require_down, "require_down", _dummy);}
Variable get_disable_up(const PackageVersion& pv)
{return get_variable(pv, disable_package_versions_up, disable_up, "disable_up", _dummy);}
Variable get_disable_down(const PackageVersion& pv)
{return get_variable(pv, disable_package_versions_down, disable_down, "disable_down", _dummy);}
inline PackageToVersions get_require_up () const { return require_up; }
inline PackageToVersions get_require_down () const { return require_down; }
inline PackageToVersions get_disable_up () const { return disable_up; }
inline PackageToVersions get_disable_down () const { return disable_down; }
private:
IDManager& id_manager;
#ifdef MAPPING
unordered_map& variable_names;// Names of variables for debugging purposes.
ofstream& mapping;
#endif
// Maps from intervals to the corresponding variables
PackageVersionMap require_package_versions_up,require_package_versions_down;
PackageVersionMap disable_package_versions_up,disable_package_versions_down;
// For each package the following maps record the version intervals used in the dependencies
PackageToVersions require_up;
PackageToVersions require_down;
PackageToVersions disable_up;
PackageToVersions disable_down;
inline Variable new_variable () { return id_manager.new_id(); }
/**
* Get a variable corresponding to the given pair package-version.
* @param pv package-version pair
* @param map a map storing variable IDs for package-version pairs
* @return Variable corresponding to {@code pv} in {@code map}.
* A fresh variable, if {@code pv} is not in {@code map}.
*/
Variable get_variable (const PackageVersion& pv, PackageVersionMap& map,
unordered_map & vvs,
const string& map_name, bool& is_fresh);
};
#endif /* INTERVALVARIABLES_HH */
packup-0.6/Lexer.cc 0000644 0001750 0001001 00000063326 11573000734 013347 0 ustar mikolas None /******************************************************************************\
* This file is part of packup. *
* *
* packup is free software: you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* *
* packup is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with packup. If not, see . *
\******************************************************************************/
#line 1 "l.rl"
#include
#include