Currently job artifacts in CI/CD pipelines on LRZ GitLab never expire. Starting from Wed 26.1.2022 the default expiration time will be 30 days (GitLab default). Currently existing artifacts in already completed jobs will not be affected by the change. The latest artifacts for all jobs in the latest successful pipelines will be kept. More information: https://gitlab.lrz.de/help/user/admin_area/settings/continuous_integration.html#default-artifacts-expiration

Commit 4700bbba authored by Christian Schulte zu Berge's avatar Christian Schulte zu Berge
Browse files

Removed unlockInExtraThread flag from AbstractProcessor::process() - this is...

Removed unlockInExtraThread flag from AbstractProcessor::process() - this is no longer needed as signal handling is done asynchroneously now anyway.

#ref 384

Conflicts:
	core/pipeline/abstractprocessor.cpp

Conflicts:
	core/pipeline/abstractprocessor.cpp
	core/pipeline/abstractprocessor.h
parent 8671e65c
......@@ -43,11 +43,6 @@
#define CAMPVIS_CORE_API
#endif
#endif
#ifdef DLL_TEMPLATE_INST
// declare and instantiate sigslot templates for symbol ex-/import
class CAMPVIS_CORE_API sigslot::SIGSLOT_DEFAULT_MT_POLICY;
template class CAMPVIS_CORE_API sigslot::has_slots<sigslot::SIGSLOT_DEFAULT_MT_POLICY>;
#endif
#else
// building/including static library -> do nothing
#define CAMPVIS_CORE_API
......
......@@ -142,7 +142,7 @@ namespace campvis {
return *_data;
}
void AbstractPipeline::executeProcessor(AbstractProcessor* processor, bool unlockInExtraThred) {
void AbstractPipeline::executeProcessor(AbstractProcessor* processor) {
tgtAssert(processor != 0, "Processor must not be 0.");
// execute processor if needed
......@@ -219,12 +219,12 @@ namespace campvis {
tgtAssert(_canvas != 0, "Set a valid canvas before calling this method!");
GLJobProc.enqueueJob(
_canvas,
makeJobOnHeap<AbstractPipeline, AbstractProcessor*, bool>(this, &AbstractPipeline::executeProcessor, processor, true),
makeJobOnHeap<AbstractPipeline, AbstractProcessor*>(this, &AbstractPipeline::executeProcessor, processor),
OpenGLJobProcessor::SerialJob);
}
void AbstractPipeline::executeProcessorAndCheckOpenGLState(AbstractProcessor* processor) {
AbstractPipeline::executeProcessor(processor, true);
AbstractPipeline::executeProcessor(processor);
#ifdef CAMPVIS_DEBUG
tgtAssert(getGlBool(GL_DEPTH_TEST) == false, "Invalid OpenGL state after processor execution, GL_DEPTH_TEST != false.");
......
......@@ -177,9 +177,8 @@ namespace campvis {
/**
* Executes the processor \a processor on the pipeline's data and locks its properties meanwhile.
* \param processor Processor to execute.
* \param unlockInExtraThred If true, the call to processor->unlock() will be done in an extra thread.
*/
void executeProcessor(AbstractProcessor* processor, bool unlockInExtraThred);
void executeProcessor(AbstractProcessor* processor);
/**
* Acquires and locks the OpenGL context, executes the processor \a processor on the pipeline's data
......
......@@ -132,7 +132,7 @@ namespace campvis {
}
void AbstractProcessor::process(DataContainer& data, bool unlockInExtraThread) {
void AbstractProcessor::process(DataContainer& data) {
if (hasInvalidShader()) {
updateShader();
validate(INVALID_SHADER);
......@@ -143,7 +143,7 @@ namespace campvis {
}
// use a scoped lock for exception safety
AbstractProcessor::ScopedLock lock(this, unlockInExtraThread);
AbstractProcessor::ScopedLock lock(this);
tgtAssert(_locked == true, "Processor not locked, this should not happen!");
if (hasInvalidResult()) {
......@@ -173,23 +173,4 @@ namespace campvis {
tbb::spin_rw_mutex::scoped_lock lock(_mtxInvalidationMap, true);
_invalidationMap[&prop] = invalidationLevel;
}
// ================================================================================================
AbstractProcessor::ScopedLock::ScopedLock(AbstractProcessor* p, bool unlockInExtraThread)
: _p(p)
, _unlockInExtraThread(unlockInExtraThread)
{
_p->lockProcessor();
}
AbstractProcessor::ScopedLock::~ScopedLock() {
// Unlocking processors might be expensive, since a long chain of invalidations might be started
// -> do this in another thread...
if (_unlockInExtraThread)
SimpleJobProc.enqueueJob(makeJob(_p, &AbstractProcessor::unlockProcessor));
else
_p->unlockProcessor();
}
}
......@@ -66,16 +66,21 @@ namespace campvis {
/**
* Constructs a new Scoped lock, locking \a p and unlocking \a p on destruction.
* \param p Processor to lock
* \param unlockInExtraThread Unlock \a p in extra thread (since this might be an expensive operation)
*/
ScopedLock(AbstractProcessor* p, bool unlockInExtraThread);
ScopedLock(AbstractProcessor* p)
: _p(p)
{
_p->lockProcessor();
};
/// Destructor, unlocks the processor
~ScopedLock();
~ScopedLock() {
_p->unlockProcessor();
};
AbstractProcessor* _p; ///< The processor to lock
bool _unlockInExtraThread; ///< Unlock _p in extra thread (since this might be an expensive operation)
};
/**
* Available invalidation levels
......@@ -175,9 +180,8 @@ namespace campvis {
* with respect to the current invalidation level.
*
* \param data DataContainer to work on.
* \param unlockInExtraThread Flag whether the processor shall be unlockedin an extra thread (since unlock might be expensive).
**/
void process(DataContainer& data, bool unlockInExtraThread = false);
void process(DataContainer& data);
/**
* Gets the flag whether this processor is currently enabled.
......
......@@ -75,7 +75,7 @@ namespace campvis {
OpenGLJobProcessor::SerialJob);
}
else {
SimpleJobProc.enqueueJob(makeJob<AutoEvaluationPipeline, AbstractProcessor*, bool>(this, &AutoEvaluationPipeline::executeProcessor, processor, false));
SimpleJobProc.enqueueJob(makeJob<AutoEvaluationPipeline, AbstractProcessor*>(this, &AutoEvaluationPipeline::executeProcessor, processor));
}
}
else {
......
......@@ -41,7 +41,7 @@ namespace campvis {
* generateHeader() to define computeGradient(tex, texParams, texCoords) in GLSL calling
* the selected function.
*/
class CAMPVIS_CORE_API ProcessorDecoratorGradient : public AbstractProcessorDecorator, public sigslot::has_slots<> {
class CAMPVIS_CORE_API ProcessorDecoratorGradient : public AbstractProcessorDecorator, public sigslot::has_slots {
public:
/// Method for online-calculating gradients
enum GradientMethod {
......
......@@ -242,6 +242,7 @@ namespace sigslot {
void erase(const const_iterator& it) { *it = nullptr; };
void erase(const const_iterator& begin, const const_iterator& end);
bool empty() const;
protected:
StorageType _storage;
......@@ -272,6 +273,20 @@ namespace sigslot {
}
}
template<typename T>
bool sigslot::concurrent_pointer_list<T>::empty() const {
iterator it = begin();
iterator itEnd = end();
for (/* nothing here */; it != itEnd; ++it) {
if (*it != nullptr) {
return false;
}
}
return true;
}
// ================================================================================================
/// Base class for signal handles that provides an interface to emit the signal.
......@@ -421,14 +436,14 @@ namespace sigslot {
// ================================================================================================
class _signal_base
class SIGSLOT_API _signal_base
{
public:
virtual void slot_disconnect(has_slots* pslot) = 0;
virtual void slot_duplicate(has_slots const* poldslot, has_slots* pnewslot) = 0;
};
class has_slots
class SIGSLOT_API has_slots
{
private:
typedef concurrent_pointer_list<_signal_base> sender_set;
......
......@@ -35,7 +35,7 @@ namespace campvis {
/**
* Data object storing information about selected predicates and their settings.
*/
class PointPredicateHistogram : public sigslot::has_slots<> {
class PointPredicateHistogram : public sigslot::has_slots {
public:
/**
......
......@@ -45,7 +45,7 @@ namespace campvis {
* others, they will share the pointer (instead of copying around as with other properties)!
* Therefore, we use a std::shared_ptr.
*/
class PointPredicateHistogramProperty : public AbstractProperty, public sigslot::has_slots<> {
class PointPredicateHistogramProperty : public AbstractProperty, public sigslot::has_slot {
public:
/**
* Creates a new PointPredicateHistogramProperty
......
......@@ -325,7 +325,7 @@ namespace campvis {
}
// lock this processor, so that the slice orientation's setting does not change
AbstractProcessor::ScopedLock lock(this, false);
AbstractProcessor::ScopedLock lock(this);
if (me->y() <= p_sliceRenderSize.getValue().y) {
_sliceExtractor.p_sliceOrientation.selectByOption(SliceExtractor::XY_PLANE);
......
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment