static void
tracker_extract_finalize (GObject *object)
{
TrackerExtractPrivate *priv;
priv = TRACKER_EXTRACT_GET_PRIVATE (object);
/* FIXME: Shutdown modules? */
g_hash_table_destroy (priv->single_thread_extractors);
g_thread_pool_free (priv->thread_pool, TRUE, FALSE);
if (!priv->disable_summary_on_finalize) {
report_statistics (object);
}
#ifdef HAVE_LIBSTREAMANALYZER
tracker_topanalyzer_shutdown ();
#endif /* HAVE_STREAMANALYZER */
g_hash_table_destroy (priv->statistics_data);
g_mutex_clear (&priv->task_mutex);
G_OBJECT_CLASS (tracker_extract_parent_class)->finalize (object);
}
int main() {
bool error = false;
std::chrono::seconds seconds(std::chrono::seconds::zero());
{
smt::NonReentrantTimer<std::chrono::seconds> timer(seconds);
do {
// global array ought to be initially nondeterministic
crv::make_any(aux);
crv_main();
error |= smt::sat == dfs_checker().check();
} while (dfs_checker().find_next_path() && !error);
}
if (error)
std::cout << "Found bug!" << std::endl;
else
std::cout << "Could not find any bugs." << std::endl;
report_statistics(dfs_checker().solver().stats(), dfs_checker().stats(), seconds);
return error;
}
int main() {
bool error = false;
std::chrono::seconds seconds(std::chrono::seconds::zero());
{
smt::NonReentrantTimer<std::chrono::seconds> timer(seconds);
do {
crv_main();
#ifndef FORCE_BRANCH
error |= smt::sat == dfs_checker().check();
#endif
} while (dfs_checker().find_next_path() && !error);
}
if (error)
std::cout << "Found bug!" << std::endl;
else
std::cout << "Could not find any bugs." << std::endl;
report_statistics(dfs_checker().solver().stats(), dfs_checker().stats(), seconds);
return error;
}
path_searcht::resultt path_searcht::operator()(
const goto_functionst &goto_functions)
{
#ifdef PATH_SYMEX_FORK
// Disable output because there is no meaningful way
// to write text when multiple path_search processes
// run concurrently. This could be remedied by piping
// to individual files or inter-process communication,
// a performance bottleneck, however.
*messaget::mstream.message_handler=NULL;
#endif
locst locs(ns);
var_mapt var_map(ns);
locs.build(goto_functions);
// this is the container for the history-forest
path_symex_historyt history;
queue.push_back(initial_state(var_map, locs, history));
// set up the statistics
number_of_paths=0;
number_of_instructions=0;
number_of_dropped_states=0;
number_of_VCCs=0;
number_of_VCCs_after_simplification=0;
number_of_failed_properties=0;
number_of_fast_forward_steps=0;
// stop the time
start_time=current_time();
initialize_property_map(goto_functions);
while(!queue.empty())
{
// Pick a state from the queue,
// according to some heuristic.
queuet::iterator state=pick_state();
// fast forwarding required?
if(state->is_lazy())
{
assert(state->is_executable());
assert(state->history.is_nil());
// keep allocated memory, this is faster than
// instantiating a new empty vector and map
history.clear();
var_map.clear();
state->history=path_symex_step_reft(history);
// restore all fields of a lazy state by symbolic
// execution along previously recorded branches
const queuet::size_type queue_size=queue.size();
do
{
number_of_fast_forward_steps++;
path_symex(*state, queue);
#ifdef PATH_SYMEX_OUTPUT
status() << "Fast forward thread " << state->get_current_thread()
<< "/" << state->threads.size()
<< " PC " << state->pc() << messaget::eom;
#endif
}
while(state->is_lazy() && state->is_executable());
assert(queue.size() == queue_size);
}
// TODO: check lazy states before fast forwarding, or perhaps it
// is better to even check before inserting into queue
if(drop_state(*state))
{
number_of_dropped_states++;
queue.erase(state);
continue;
}
if(!state->is_executable())
{
queue.erase(state);
continue;
}
// count only executable instructions
number_of_instructions++;
#ifdef PATH_SYMEX_OUTPUT
status() << "Queue " << queue.size()
<< " thread " << state->get_current_thread()
<< "/" << state->threads.size()
<< " PC " << state->pc() << messaget::eom;
#endif
// an error, possibly?
if(state->get_instruction()->is_assert())
{
if(show_vcc)
do_show_vcc(*state, ns);
else
{
check_assertion(*state, ns);
// all assertions failed?
if(number_of_failed_properties==property_map.size())
break;
}
}
#ifdef PATH_SYMEX_FORK
if(try_await())
{
debug() << "Child process has terminated "
"so exit parent" << messaget::eom;
break;
}
#endif
// execute and record whether a "branch" occurred
const queuet::size_type queue_size = queue.size();
path_symex(*state, queue);
assert(queue_size <= queue.size());
number_of_paths += (queue.size() - queue_size);
}
#ifdef PATH_SYMEX_FORK
int exit_status=await();
if(exit_status==0 && number_of_failed_properties!=0)
{
// the eldest child process (if any) reports found bugs
report_statistics();
return UNSAFE;
}
else
{
// either a child found and reported a bug or
// the parent's search partition is safe
switch (exit_status)
{
case 0: return SAFE;
case 10: return UNSAFE;
default: return ERROR;
}
}
#else
report_statistics();
return number_of_failed_properties==0?SAFE:UNSAFE;
#endif
}
int LbfgsbOptimizer::solve()
{
// Solution vector
ap::real_1d_array x0;
x0.setbounds(1, x.dim);
// copy current x into x0
for(size_t i = 0; i < x.dim; i++)
{
x0(i+1) = x.val[i];
}
ap::integer_1d_array nbd;
ap::real_1d_array l;
ap::real_1d_array u;
nbd.setbounds(1, x.dim);
l.setbounds(1, x.dim);
u.setbounds(1, x.dim);
// Set bounds
if(binary)
{
bounds_binary(nbd, l, u);
}
else
{
bounds(nbd, l, u);
}
// Lancelot: gamma_bar = 0.1
double gamma_bar = 0.1; // < 1 :
// Lancelot: tau = 0.1
double tau = 0.1; // # < 1
// Lancelot: alpha_eta = 0.1
double alpha_eta = 0.01; // # min(1, self._alpha_omega)
//Lancelot: beta_eta = 0.9
double beta_eta = 0.9; // # min(1, self._beta_omega)
//Lancelot: alpha_omega = 1.0
double alpha_omega = 4.0;
//Lancelot: beta_omega = 1.0
double beta_omega = 4.0;
// Lancelot: omega_bar = firtsg/pow(std::min(mu, gamma_bar), alpha_omega);
double omega_bar = 0.5;
// Lancelot: eta_bar = firtsc/pow(std::min(mu, gamma_bar), alpha_eta);
double eta_bar = 1.0;
double mu_bar = 0.9; // must be <= 1
mu = mu_bar;
// Lancelot: alpha = min(mu, gamma_bar)
double alpha = std::min(mu, gamma_bar);
// Lancelot: eta = max(etamin, eta_bar*pow(alpha, alpha_eta))
// svnvish: BUGBUG what is etamin?
// etamin is the minimum norm of the constraint violation
double eta = eta_bar*pow(alpha, alpha_eta);
// Lancelot: omega = max(omemin, omega_bar*pow(alpha, alpha_omega))
// svnvish: BUGBUG what is omemin?
// omemin is the tolerance for kkt gap
double omega = omega_bar*pow(alpha, alpha_omega);
DenseVector W;
W.val = x.val;
W.dim = num_weak_learners;
for(size_t iteration = 0; iteration < LBFGSB::max_iterations; iteration++)
{
double epsg = omega;
double epsf = 0;
double epsx = 0;
int info;
lbfgsbminimize(x.dim,
std::min(x.dim, LBFGSB::lbfgsb_m),
x0,
epsg,
epsf,
epsx,
LBFGSB::lbfgsb_max_iterations,
nbd,
l,
u,
(void*) this,
info);
// copy current solution into x
for(size_t i = 0; i < x.dim; i++)
{
x.val[i] = x0(i+1);
}
const double w_gap = sum(W) - 1.0;
// std::cout << "info: " << info << std::endl;
// assert(info > 0);
assert(info == 4);
if(std::abs(w_gap) < eta)
{
if(std::abs(w_gap) < Optimizer::wt_sum_tol)
{
if(duality_gap_met())
{
// // svnvish: BUGBUG
// // Extra gradient computation happening here
// // Better to use norm gaps
// dvec gradk = grad();
// if(converged(grad())){
report_statistics();
break;
}
}
lambda = lambda - (w_gap/mu);
//mu = mu;
alpha = mu;
eta = eta*pow(alpha, beta_eta);
omega = omega*pow(alpha, beta_omega);
}
else
{
//lambda = lambda;
mu *= tau;
alpha = mu*gamma_bar;
eta = eta_bar*pow(alpha, beta_eta);
omega = omega_bar*pow(alpha, beta_omega);
}
} // end of "for each iteration"
// This is not a memory leak!
W.val = NULL;
W.dim = 0;
return 0;
} // end of LbfgsbOptimizer::solve()
void *Consume (void *arg)
/* Consumer thread function. */
{
msg_block_t *pmb;
statistics_t * ps;
int my_number, tstatus;
struct timespec timeout, delta;
delta.tv_sec = 2;
delta.tv_nsec = 0;
/* Create thread-specific storage key */
tstatus = pthread_once (&once_control, once_init_function);
if (tstatus != 0) err_abort (tstatus, "One time init failed");
pmb = (msg_block_t *)arg;
/* Allocate storage for thread-specific statistics */
ps = calloc (sizeof(statistics_t), 1);
if (ps == NULL) errno_abort ("Cannot allocate memory");
tstatus = pthread_setspecific (ts_key, ps);
if (tstatus != 0) err_abort (tstatus, "Error setting ts storage");
ps->pmblock = pmb;
/* Give this thread a unique number */
/* Note that the mutex is "overloaded" to protect data */
/* outside the message block structure */
tstatus = pthread_mutex_lock (&pmb->nGuard);
if (tstatus != 0) err_abort (tstatus, "Lock error");
ps->th_number = thread_number++;
tstatus = pthread_mutex_unlock (&pmb->nGuard);
if (tstatus != 0) err_abort (tstatus, "Unlock error");
/* Consume the NEXT message when prompted by the user */
while (!pmb->fStop) { /* This is the only thread accessing stdin, stdout */
tstatus = pthread_mutex_lock (&pmb->nGuard);
if (tstatus != 0) err_abort (tstatus, "Lock error");
/* Get the next message. Use a timed wait so as to be able */
/* to sample the stop flag peridically. */
do {
pthread_get_expiration_np (&delta, &timeout);
tstatus = pthread_cond_timedwait
(&pmb->mReady, &pmb->nGuard, &timeout);
if (tstatus != 0 && tstatus != ETIMEDOUT)
err_abort (tstatus, "CV wait error");
} while (!pmb->f_ready && !pmb->fStop);
if (!pmb->fStop) {
/* printf ("Message received\n"); */
accumulate_statistics ();
pmb->f_consumed = 1;
pmb->f_ready = 0;
}
tstatus = pthread_cond_signal (&pmb->mconsumed);
if (tstatus != 0) err_abort (tstatus, "Signal error");
tstatus = pthread_mutex_unlock (&pmb->nGuard);
if (tstatus != 0) err_abort (tstatus, "Unlock error");
}
/* Shutdown. Report the statistics */
tstatus = pthread_mutex_lock (&pmb->nGuard);
if (tstatus != 0) err_abort (tstatus, "Lock error");
report_statistics ();
tstatus = pthread_mutex_unlock (&pmb->nGuard);
if (tstatus != 0) err_abort (tstatus, "Unlock error");
/* Terminate the consumer thread. The destructor will */
/* free the memory allocated for the statistics */
return NULL;
}
path_searcht::resultt path_searcht::operator()(
const goto_functionst &goto_functions)
{
locst locs(ns);
var_mapt var_map(ns);
locs.build(goto_functions);
// this is the container for the history-forest
path_symex_historyt history;
queue.push_back(initial_state(var_map, locs, history));
// set up the statistics
number_of_dropped_states=0;
number_of_paths=0;
number_of_VCCs=0;
number_of_steps=0;
number_of_feasible_paths=0;
number_of_infeasible_paths=0;
number_of_VCCs_after_simplification=0;
number_of_failed_properties=0;
number_of_locs=locs.size();
// stop the time
start_time=current_time();
initialize_property_map(goto_functions);
while(!queue.empty())
{
number_of_steps++;
// Pick a state from the queue,
// according to some heuristic.
// The state moves to the head of the queue.
pick_state();
// move into temporary queue
queuet tmp_queue;
tmp_queue.splice(
tmp_queue.begin(), queue, queue.begin(), ++queue.begin());
try
{
statet &state=tmp_queue.front();
// record we have seen it
loc_data[state.get_pc().loc_number].visited=true;
debug() << "Loc: #" << state.get_pc().loc_number
<< ", queue: " << queue.size()
<< ", depth: " << state.get_depth();
for(const auto & s : queue)
debug() << ' ' << s.get_depth();
debug() << eom;
if(drop_state(state))
{
number_of_dropped_states++;
number_of_paths++;
continue;
}
if(!state.is_executable())
{
number_of_paths++;
continue;
}
if(eager_infeasibility &&
state.last_was_branch() &&
!is_feasible(state))
{
number_of_infeasible_paths++;
number_of_paths++;
continue;
}
if(number_of_steps%1000==0)
{
status() << "Queue " << queue.size()
<< " thread " << state.get_current_thread()
<< '/' << state.threads.size()
<< " PC " << state.pc() << messaget::eom;
}
// an error, possibly?
if(state.get_instruction()->is_assert())
{
if(show_vcc)
do_show_vcc(state);
else
{
check_assertion(state);
// all assertions failed?
if(number_of_failed_properties==property_map.size())
break;
}
}
// execute
path_symex(state, tmp_queue);
// put at head of main queue
queue.splice(queue.begin(), tmp_queue);
}
catch(const std::string &e)
{
error() << e << eom;
number_of_dropped_states++;
}
catch(const char *e)
{
error() << e << eom;
number_of_dropped_states++;
}
catch(int)
{
number_of_dropped_states++;
}
}
report_statistics();
return number_of_failed_properties==0?SAFE:UNSAFE;
}
void measure_difference(ghog::lib::HogDescriptor* hog1,
ghog::lib::HogDescriptor* hog2,
std::string hog_name1,
std::string hog_name2,
std::vector< std::string > image_list,
cv::Size img_size,
cv::Size window_size,
int num_experiments,
boost::random::mt19937 random_gen)
{
std::cout << "Running difference experiment on descriptors " << hog_name1
<< " and " << hog_name2 << ", with " << image_list.size()
<< " images, using " << num_experiments << " windows of size "
<< window_size << std::endl;
cv::Size descriptor_size(hog1->get_descriptor_size(), 1);
cv::Mat input_img1;
cv::Mat normalized_img1;
cv::Mat grad_mag1;
cv::Mat grad_phase1;
cv::Mat descriptor1;
hog1->alloc_buffer(img_size, CV_32FC3, input_img1);
hog1->alloc_buffer(window_size, CV_32FC3, normalized_img1);
hog1->alloc_buffer(window_size, CV_32FC1, grad_mag1);
hog1->alloc_buffer(window_size, CV_32FC1, grad_phase1);
hog1->alloc_buffer(descriptor_size, CV_32FC1, descriptor1);
cv::Mat input_img2;
cv::Mat normalized_img2;
cv::Mat grad_mag2;
cv::Mat grad_phase2;
cv::Mat descriptor2;
hog2->alloc_buffer(img_size, CV_32FC3, input_img2);
hog2->alloc_buffer(window_size, CV_32FC3, normalized_img2);
hog2->alloc_buffer(window_size, CV_32FC1, grad_mag2);
hog2->alloc_buffer(window_size, CV_32FC1, grad_phase2);
hog2->alloc_buffer(descriptor_size, CV_32FC1, descriptor2);
boost::random::uniform_smallint< int > dist_w(1,
input_img1.cols - window_size.width - 2);
boost::random::uniform_smallint< int > dist_h(1,
input_img1.rows - window_size.height - 2);
std::vector< double > errors_normalization;
std::vector< double > magnitude_similarity;
std::vector< double > phase_similarity;
std::vector< double > descriptor_similarity;
std::vector< double > total_similarity;
std::cout << "Calculating partial difference" << std::endl;
for(int i = 0; i < image_list.size(); ++i)
{
cv::imread(image_list[i], CV_LOAD_IMAGE_COLOR).convertTo(input_img1,
CV_32FC3);
cv::imread(image_list[i], CV_LOAD_IMAGE_COLOR).convertTo(input_img2,
CV_32FC3);
input_img1 /= 256.0;
input_img2 /= 256.0;
for(int j = 0; j < num_experiments; ++j)
{
int pos_x = dist_w(random_gen);
int pos_y = dist_h(random_gen);
input_img1.rowRange(pos_y, pos_y + window_size.height).colRange(
pos_x, pos_x + window_size.width).copyTo(normalized_img1);
input_img2.rowRange(pos_y, pos_y + window_size.height).colRange(
pos_x, pos_x + window_size.width).copyTo(normalized_img2);
hog1->image_normalization_sync(normalized_img1);
hog2->image_normalization_sync(normalized_img2);
errors_normalization.push_back(
compare_matrices(normalized_img1, normalized_img2));
normalized_img1.copyTo(normalized_img2);
hog1->calc_gradient_sync(normalized_img1, grad_mag1, grad_phase1);
hog2->calc_gradient_sync(normalized_img2, grad_mag2, grad_phase2);
magnitude_similarity.push_back(
compare_matrices(grad_mag1, grad_mag2));
phase_similarity.push_back(
compare_matrices(grad_phase1, grad_phase2));
grad_mag1.copyTo(grad_mag2);
grad_phase1.copyTo(grad_phase2);
hog1->create_descriptor_sync(grad_mag1, grad_phase1, descriptor1);
hog2->create_descriptor_sync(grad_mag2, grad_phase2, descriptor2);
descriptor_similarity.push_back(
compare_matrices(descriptor1, descriptor2));
}
}
std::cout << "Error on image normalization:" << std::endl;
report_statistics(errors_normalization, 1, "normalized euclidian distance");
std::cout << "Error on magnitude calculation:" << std::endl;
report_statistics(magnitude_similarity, 1, "normalized euclidian distance");
std::cout << "Error on phase calculation:" << std::endl;
report_statistics(phase_similarity, 1, "normalized euclidian distance");
std::cout << "Error on descriptor calculation:" << std::endl;
report_statistics(descriptor_similarity, 1,
"normalized euclidian distance");
std::cout << "Calculating complete difference" << std::endl;
for(int i = 0; i < image_list.size(); ++i)
{
cv::imread(image_list[i], CV_LOAD_IMAGE_COLOR).convertTo(input_img1,
CV_32FC3);
cv::imread(image_list[i], CV_LOAD_IMAGE_COLOR).convertTo(input_img2,
CV_32FC3);
input_img1 /= 256.0;
input_img2 /= 256.0;
for(int j = 0; j < num_experiments; ++j)
{
int pos_x = dist_w(random_gen);
int pos_y = dist_h(random_gen);
input_img1.rowRange(pos_y, pos_y + window_size.height).colRange(
pos_x, pos_x + window_size.width).copyTo(normalized_img1);
input_img2.rowRange(pos_y, pos_y + window_size.height).colRange(
pos_x, pos_x + window_size.width).copyTo(normalized_img2);
hog1->image_normalization_sync(input_img1);
hog1->calc_gradient_sync(normalized_img1, grad_mag1, grad_phase1);
hog1->create_descriptor_sync(grad_mag1, grad_phase1, descriptor1);
hog2->image_normalization_sync(input_img2);
hog2->calc_gradient_sync(normalized_img2, grad_mag2, grad_phase2);
hog2->create_descriptor_sync(grad_mag2, grad_phase2, descriptor2);
total_similarity.push_back(
compare_matrices(descriptor1, descriptor2));
}
}
std::cout << "Total similarity :" << std::endl;
report_statistics(total_similarity, 1, "normalized euclidian distance");
std::cout << std::endl;
}
