333 lines
9.2 KiB
C++
Executable File
333 lines
9.2 KiB
C++
Executable File
/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
|
|
/*
|
|
* Main authors:
|
|
* Christian Schulte <schulte@gecode.org>
|
|
*
|
|
* Copyright:
|
|
* Christian Schulte, 2016
|
|
*
|
|
* This file is part of Gecode, the generic constraint
|
|
* development environment:
|
|
* http://www.gecode.org
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining
|
|
* a copy of this software and associated documentation files (the
|
|
* "Software"), to deal in the Software without restriction, including
|
|
* without limitation the rights to use, copy, modify, merge, publish,
|
|
* distribute, sublicense, and/or sell copies of the Software, and to
|
|
* permit persons to whom the Software is furnished to do so, subject to
|
|
* the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be
|
|
* included in all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
|
* LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
|
* OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
|
* WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
*
|
|
*/
|
|
|
|
namespace Gecode {
|
|
|
|
/// Class to provide synchronization
|
|
class TracerBase : public HeapAllocated {
|
|
protected:
|
|
/// Mutex to provide synchronization
|
|
GECODE_KERNEL_EXPORT
|
|
static Support::Mutex m;
|
|
};
|
|
|
|
template<class View> class ViewTraceRecorder;
|
|
|
|
/**
|
|
* \brief Tracer that process view trace information
|
|
* \ingroup TaskTrace
|
|
*/
|
|
template<class View>
|
|
class ViewTracer : public TracerBase {
|
|
template<class ViewForTraceRecorder> friend class ViewTraceRecorder;
|
|
private:
|
|
/**
|
|
* \brief Init function synchronization
|
|
*
|
|
* Just calls the actual init function protected by a mutex.
|
|
*
|
|
*/
|
|
void _init(const Space& home, const ViewTraceRecorder<View>& t);
|
|
/**
|
|
* \brief Prune function synchronization
|
|
*
|
|
* Just calls the actual prune function protected by a mutex.
|
|
*
|
|
*/
|
|
void _prune(const Space& home, const ViewTraceRecorder<View>& t,
|
|
const ViewTraceInfo& vti,
|
|
int i, typename TraceTraits<View>::TraceDelta& d);
|
|
/**
|
|
* \brief Fail function synchronization
|
|
*
|
|
* Just calls the actual fail function protected by a mutex.
|
|
*
|
|
*/
|
|
void _fail(const Space& home, const ViewTraceRecorder<View>& t);
|
|
/**
|
|
* \brief Fixpoint function synchronization
|
|
*
|
|
* Just calls the actual fixpoint function protected by a mutex.
|
|
*/
|
|
void _fix(const Space& home, const ViewTraceRecorder<View>& t);
|
|
/**
|
|
* \brief Done function synchronization
|
|
*
|
|
* Just calls the actual done function protected by a mutex.
|
|
*/
|
|
void _done(const Space& home, const ViewTraceRecorder<View>& t);
|
|
public:
|
|
/// Constructor
|
|
ViewTracer(void);
|
|
/**
|
|
* \brief Init function
|
|
*
|
|
* The init function is called when the trace collector has
|
|
* been initialized.
|
|
*/
|
|
virtual void init(const Space& home,
|
|
const ViewTraceRecorder<View>& t) = 0;
|
|
/**
|
|
* \brief Prune function
|
|
*
|
|
* The variable at position \a i has been modified where
|
|
* the modification is described by \a d. Additional
|
|
* information about how the variable has been changed is
|
|
* provided by the trace collector \a t and execution
|
|
* information \a ei.
|
|
*/
|
|
virtual void prune(const Space& home,
|
|
const ViewTraceRecorder<View>& t,
|
|
const ViewTraceInfo& vti,
|
|
int i, typename TraceTraits<View>::TraceDelta& d) = 0;
|
|
/**
|
|
* \brief Fail function
|
|
*
|
|
* The fail function is called whenever \a home containing the
|
|
* trace collector \a t has been failed.
|
|
*/
|
|
virtual void fail(const Space& home,
|
|
const ViewTraceRecorder<View>& t) = 0;
|
|
/**
|
|
* \brief Fixpoint function
|
|
*
|
|
* The fixpoint function is called whenever \a home containing
|
|
* the trace collector \a t reaches a fixpoint (and fixpoint
|
|
* tracing is enabled).
|
|
*/
|
|
virtual void fix(const Space& home,
|
|
const ViewTraceRecorder<View>& t) = 0;
|
|
/**
|
|
* \brief Done function
|
|
*
|
|
* The done function is called whenever the trace collector \a t
|
|
* is done and will terminate.
|
|
*/
|
|
virtual void done(const Space& home,
|
|
const ViewTraceRecorder<View>& t) = 0;
|
|
/// Destructor
|
|
virtual ~ViewTracer(void);
|
|
};
|
|
|
|
|
|
|
|
|
|
/**
|
|
* \brief Tracer
|
|
* \ingroup TaskTrace
|
|
*/
|
|
class Tracer : public TracerBase {
|
|
friend class Space;
|
|
friend class PostInfo;
|
|
private:
|
|
/**
|
|
* \brief Propagate function synchronization
|
|
*
|
|
* Just calls the actual propagate function protected by a mutex.
|
|
*
|
|
*/
|
|
void _propagate(const Space& home, const PropagateTraceInfo& pti);
|
|
/**
|
|
* \brief Commit function synchronization
|
|
*
|
|
* Just calls the actual commit function protected by a mutex.
|
|
*
|
|
*/
|
|
void _commit(const Space& home, const CommitTraceInfo& cti);
|
|
/**
|
|
* \brief Post function synchronization
|
|
*
|
|
* Just calls the actual post function protected by a mutex.
|
|
*
|
|
*/
|
|
void _post(const Space& home, const PostTraceInfo& pti);
|
|
public:
|
|
/// Constructor
|
|
Tracer(void);
|
|
/**
|
|
* \brief Propagate function
|
|
*
|
|
* The propagate function is called when a propagator has been
|
|
* executed.
|
|
*/
|
|
virtual void propagate(const Space& home,
|
|
const PropagateTraceInfo& pti) = 0;
|
|
/**
|
|
* \brief Commit function
|
|
*
|
|
* The commit function is called when a brancher has executed
|
|
* a commit operation.
|
|
*/
|
|
virtual void commit(const Space& home,
|
|
const CommitTraceInfo& cti) = 0;
|
|
/**
|
|
* \brief Post function
|
|
*
|
|
* The post function is called when an attempt to post a propagator
|
|
* has been executed.
|
|
*/
|
|
virtual void post(const Space& home,
|
|
const PostTraceInfo& pti) = 0;
|
|
/// Destructor
|
|
virtual ~Tracer(void);
|
|
};
|
|
|
|
|
|
/**
|
|
* \brief Default tracer
|
|
* \ingroup TaskTrace
|
|
*/
|
|
class GECODE_KERNEL_EXPORT StdTracer : public Tracer {
|
|
protected:
|
|
/// Output stream to use
|
|
std::ostream& os;
|
|
public:
|
|
/// Initialize with output stream \a os
|
|
StdTracer(std::ostream& os = std::cerr);
|
|
/**
|
|
* \brief Propagate function
|
|
*
|
|
* The propagate function is called when a propagator has been
|
|
* executed.
|
|
*/
|
|
virtual void propagate(const Space& home,
|
|
const PropagateTraceInfo& pti);
|
|
/**
|
|
* \brief Commit function
|
|
*
|
|
* The commit function is called when a brancher has executed
|
|
* a commit operation.
|
|
*/
|
|
virtual void commit(const Space& home,
|
|
const CommitTraceInfo& cti);
|
|
/**
|
|
* \brief Post function
|
|
*
|
|
* The post function is called when an attempt to post a propagator
|
|
* has been executed.
|
|
*/
|
|
virtual void post(const Space& home,
|
|
const PostTraceInfo& pti);
|
|
/// Default tracer (printing to std::cerr)
|
|
static StdTracer def;
|
|
};
|
|
|
|
|
|
/*
|
|
* View tracer
|
|
*/
|
|
|
|
template<class View>
|
|
forceinline
|
|
ViewTracer<View>::ViewTracer(void) {
|
|
}
|
|
|
|
template<class View>
|
|
forceinline void
|
|
ViewTracer<View>::_init(const Space& home,
|
|
const ViewTraceRecorder<View>& t) {
|
|
Support::Lock l(m);
|
|
init(home,t);
|
|
}
|
|
template<class View>
|
|
forceinline void
|
|
ViewTracer<View>::_prune(const Space& home,
|
|
const ViewTraceRecorder<View>& t,
|
|
const ViewTraceInfo& vti,
|
|
int i, typename TraceTraits<View>::TraceDelta& d) {
|
|
Support::Lock l(m);
|
|
prune(home,t,vti,i,d);
|
|
}
|
|
template<class View>
|
|
forceinline void
|
|
ViewTracer<View>::_fail(const Space& home,
|
|
const ViewTraceRecorder<View>& t) {
|
|
Support::Lock l(m);
|
|
fail(home,t);
|
|
}
|
|
template<class View>
|
|
forceinline void
|
|
ViewTracer<View>::_fix(const Space& home,
|
|
const ViewTraceRecorder<View>& t) {
|
|
Support::Lock l(m);
|
|
fix(home,t);
|
|
}
|
|
template<class View>
|
|
forceinline void
|
|
ViewTracer<View>::_done(const Space& home,
|
|
const ViewTraceRecorder<View>& t) {
|
|
Support::Lock l(m);
|
|
done(home,t);
|
|
}
|
|
|
|
template<class View>
|
|
forceinline
|
|
ViewTracer<View>::~ViewTracer(void) {
|
|
}
|
|
|
|
|
|
/*
|
|
* Tracer
|
|
*/
|
|
|
|
forceinline
|
|
Tracer::Tracer(void) {
|
|
}
|
|
|
|
forceinline void
|
|
Tracer::_propagate(const Space& home,
|
|
const PropagateTraceInfo& pti) {
|
|
Support::Lock l(m);
|
|
propagate(home,pti);
|
|
}
|
|
forceinline void
|
|
Tracer::_commit(const Space& home,
|
|
const CommitTraceInfo& cti) {
|
|
Support::Lock l(m);
|
|
commit(home,cti);
|
|
}
|
|
forceinline void
|
|
Tracer::_post(const Space& home,
|
|
const PostTraceInfo& pti) {
|
|
Support::Lock l(m);
|
|
post(home,pti);
|
|
}
|
|
|
|
forceinline
|
|
Tracer::~Tracer(void) {
|
|
}
|
|
|
|
}
|
|
|
|
// STATISTICS: kernel-trace
|