void dispose_lookahead()
{
dispose_tree();
FREE( treeArray );
#ifdef NO_TRANSLATOR
FREE( size_diff );
#endif
#ifdef EQ
FREE( lengthWeight );
#endif
FREE_OFFSET( EqDiff );
// FREE_OFFSET( diff );
// FREE_OFFSET( diff_tmp );
FREE_OFFSET( NBCounter );
FREE_OFFSET( WNBCounter );
FREE_OFFSET( failed_DL_stamp );
FREE( diff_table );
FREE( diff_depth );
FREE( lookaheadArray );
FREE( look_fixstack );
FREE( look_resstack );
FREE( forced_literal_array );
}
void freeTernaryImp( int *_tImpTable, int **_tImp, int *_tImpSize )
{
FREE_OFFSET( _tImp );
FREE_OFFSET( _tImpSize );
FREE( _tImpTable );
}
void free_big_clauses_datastructures()
{
FREE_OFFSET( big_occ );
FREE_OFFSET( clause_set );
FREE( literal_list );
FREE( clause_list );
FREE( clause_length );
FREE( clause_database );
}
void disposeSolver()
{
if( kSAT_flag )
{
free_big_clauses_datastructures();
FREE( clause_reduction );
FREE( big_global_table );
FREE( clause_red_depth );
FREE( clause_SAT_flag );
FREE_OFFSET( big_to_binary );
FREE_OFFSET( btb_size );
}
free_BinaryImp();
dispose_lookahead();
dispose_preselection();
dispose_freevars();
FREE_OFFSET( TernaryImp );
FREE_OFFSET( TernaryImpSize );
FREE_OFFSET( tmpTernaryImpSize );
FREE_OFFSET( bImp_stamps );
FREE_OFFSET( bImp_satisfied );
FREE_OFFSET( node_stamps );
FREE( tmpEqImpSize );
FREE( impstack );
FREE( rstack );
}
/*
MALLOCS: -
REALLOCS: -
FREES: Cv[ * ], Cv, Clength, timeAssignments, VeqDepends
*/
void disposeFormula()
{
int i;
/*
Can also be used to delete a partial formula, because Cv[ i ]
is initialized to NULL. IMPORTANT: according to 'man free',
free( void *ptr ) does nothing iff ( ptr == NULL ). This
behaviour is vital to disposeFormula() and other parts of
the solver where memory is freed.
*/
if( Cv != NULL )
{
for( i = 0; i < nrofclauses; i++ )
free( Cv[ i ] );
free( Cv );
Cv = NULL;
}
/*
IMPORTANT: timeAssignments should be corrected before
attempting this. (In the lookahead, nrofvars is added to both
pointers to speed up indexing.) Neglecting this correction
means Segfault Suicide!
*/
FREE_OFFSET( timeAssignments );
FREE( VeqDepends );
FREE( Clength );
/*
Update cnf structure.
*/
original_nrofvars = 0;
original_nrofclauses = 0;
nrofvars = 0;
nrofclauses = 0;
dispose_equivalence();
}
int initSolver()
{
int i, j, _tmp;
/* initialise global counters */
current_node_stamp = 1;
lookDead = 0;
mainDead = 0;
#ifdef COUNT_SAT
count_sat = 0;
#endif
solution_bin = 0;
solution_bits = 63;
#ifdef DISTRIBUTION
first_time = 0;
skip_flag = 0;
first_depth = 20;
#endif
currentNodeNumber = 1;
UNSATflag = 0;
/* allocate recursion stack */
/* tree is max. nrofvars deep and we thus have max. nrofvars STACK_BLOCKS
-> 2 * nrofvars should be enough for everyone :)
*/
INIT_ARRAY( r , 3 * nrofvars + 1 );
INIT_ARRAY( imp , INITIAL_ARRAY_SIZE );
INIT_ARRAY( subsume , INITIAL_ARRAY_SIZE );
INIT_ARRAY( bieq , INITIAL_ARRAY_SIZE );
INIT_ARRAY( newbi , INITIAL_ARRAY_SIZE );
INIT_ARRAY( sub , INITIAL_ARRAY_SIZE );
MALLOC_OFFSET( bImp_satisfied, int, nrofvars, 2 );
MALLOC_OFFSET( bImp_start, int, nrofvars, 2 );
MALLOC_OFFSET( bImp_stamps, int, nrofvars, 0 );
MALLOC_OFFSET( node_stamps, tstamp, nrofvars, 0 );
tmpEqImpSize = (int*) malloc( sizeof(int) * (nrofvars+1) );
init_lookahead();
init_preselection();
#ifdef DISTRIBUTION
init_direction();
#endif
tmpTernaryImpSize = (int* ) malloc( sizeof(int ) * ( 2*nrofvars+1 ) );
#ifdef TERNARYLOOK
TernaryImp = (int**) malloc( sizeof(int*) * ( 2*nrofvars+1 ) );
TernaryImpSize = (int* ) malloc( sizeof(int ) * ( 2*nrofvars+1 ) );
for( i = 0; i <= 2 * nrofvars; i++ )
{
tmpTernaryImpSize[ i ] = 0;
TernaryImpSize [ i ] = 0;
}
for( i = 0; i < nrofclauses; i++ )
if( Clength[ i ] == 3 )
for( j = 0; j < 3; j++ )
TernaryImpSize[ Cv[ i ][ j ] + nrofvars ]++;
for( i = 0; i <= 2 * nrofvars; i++ )
TernaryImp[ i ] = (int*) malloc(sizeof(int)*(4*TernaryImpSize[i]+4));
tmpTernaryImpSize += nrofvars;
TernaryImp += nrofvars;
TernaryImpSize += nrofvars;
fill_ternary_implication_arrays();
for( i = -nrofvars; i <= nrofvars; i++ )
// tmpTernaryImpSize[ i ] = 2 * tmpTernaryImpSize[ i ] + 2;
tmpTernaryImpSize[ i ] = 4 * TernaryImpSize[ i ] + 2;
// branch_on_dummies_from_long_clauses();
while( AddTernaryResolvents() );
for( i = -nrofvars; i <= nrofvars; i++ )
free( TernaryImp[ i ] );
FREE_OFFSET( TernaryImp );
FREE_OFFSET( TernaryImpSize );
#else
tmpTernaryImpSize += nrofvars;
#endif
/* initialise global datastructures */
#ifdef GLOBAL_AUTARKY
MALLOC_OFFSET( TernaryImpReduction, int, nrofvars, 0 );
if( kSAT_flag )
{
int _nrofliterals = 0;
for( i = 0; i < nrofbigclauses; ++i )
_nrofliterals += clause_length[ i ];
clause_reduction = (int*) malloc( sizeof(int ) * nrofbigclauses );
clause_red_depth = (int*) malloc( sizeof(int ) * nrofbigclauses );
big_global_table = (int*) malloc( sizeof(int ) * _nrofliterals );
clause_SAT_flag = (int*) malloc( sizeof(int ) * nrofbigclauses );
MALLOC_OFFSET( big_to_binary, int*, nrofvars, NULL );
MALLOC_OFFSET( btb_size, int , nrofvars, 0 );
for( i = 0; i < nrofbigclauses; ++i )
{
clause_reduction[ i ] = 0;
clause_red_depth[ i ] = nrofvars;
clause_SAT_flag [ i ] = 0;
}
int tmp = 0;
for( i = 1; i <= nrofvars; i++ )
{
big_to_binary[ i ] = (int*) &big_global_table[ tmp ];
tmp += big_occ[ i ];
big_to_binary[ -i ] = (int*) &big_global_table[ tmp ];
tmp += big_occ[ -i ];
}
assert( tmp == _nrofliterals );
}
#endif
TernaryImp = (int**) malloc( sizeof(int*) * ( 2*nrofvars+1 ) );
TernaryImpSize = (int* ) malloc( sizeof(int ) * ( 2*nrofvars+1 ) );
TernaryImpLast = (int* ) malloc( sizeof(int ) * ( 2*nrofvars+1 ) );
TernaryImpTable = (int* ) malloc( sizeof(int ) * ( 6*nrofclauses+1 ) );
TernaryImp += nrofvars;
TernaryImpSize += nrofvars;
TernaryImpLast += nrofvars;
if( simplify_formula() == UNSAT ) return UNSAT;
for( i = -nrofvars; i <= nrofvars; i++ )
{
tmpTernaryImpSize[ i ] = 0;
TernaryImpSize [ i ] = 0;
bImp_satisfied [ i ] = 2; //waarom staat dit hier?
}
for( i = 0; i < nrofclauses; i++ )
if( Clength[ i ] == 3 )
for( j = 0; j < 3; j++ )
TernaryImpSize[ Cv[ i ][ j ] ]++;
_tmp = 0;
for( i = -nrofvars; i <= nrofvars; i++ )
{
TernaryImp[ i ] = TernaryImpTable + 2 * _tmp;
_tmp += TernaryImpSize[ i ];
TernaryImpLast[ i ] = TernaryImpSize[ i ];
}
fill_ternary_implication_arrays();
rebuild_BinaryImp();
init_freevars();
for( i = 0; i < nrofceq ; i++ )
assert( CeqSizes[ i ] != 1 );
#ifdef EQ
for( i = 0; i < nrofceq ; i++ )
if( CeqSizes[ i ] == 2 )
DPLL_propagate_binary_equivalence( i );
#endif
#ifdef DETECT_COMPONENTS
init_localbranching();
#endif
#ifdef CUT_OFF
solution_bits = CUT_OFF - 1;
#endif
push_stack_blocks();
return 1;
}
