Removing Concurrent* & Future classes
They're not needed anymore.
This commit is contained in:
Strahinja Val Markovic
parent
46360219f8
commit
531e564a88
@ -18,7 +18,6 @@
|
||||
#ifndef CLANGCOMPLETE_H_WLKDU0ZV
|
||||
#define CLANGCOMPLETE_H_WLKDU0ZV
|
||||
|
||||
#include "Future.h"
|
||||
#include "UnsavedFile.h"
|
||||
#include "Diagnostic.h"
|
||||
#include "TranslationUnitStore.h"
|
||||
|
||||
@ -18,9 +18,6 @@
|
||||
#ifndef COMPILATIONDATABASE_H_ZT7MQXPG
|
||||
#define COMPILATIONDATABASE_H_ZT7MQXPG
|
||||
|
||||
#include "Future.h"
|
||||
#include "ConcurrentStack.h"
|
||||
|
||||
#include <vector>
|
||||
#include <string>
|
||||
#include <boost/utility.hpp>
|
||||
|
||||
@ -18,7 +18,6 @@
|
||||
#ifndef TRANSLATIONUNIT_H_XQ7I6SVA
|
||||
#define TRANSLATIONUNIT_H_XQ7I6SVA
|
||||
|
||||
#include "Future.h"
|
||||
#include "UnsavedFile.h"
|
||||
#include "Diagnostic.h"
|
||||
#include "Location.h"
|
||||
|
||||
@ -21,6 +21,7 @@
|
||||
#include "exceptions.h"
|
||||
|
||||
#include <boost/thread/locks.hpp>
|
||||
#include <boost/make_shared.hpp>
|
||||
#include <boost/functional/hash.hpp>
|
||||
|
||||
using boost::lock_guard;
|
||||
|
||||
@ -1,79 +0,0 @@
|
||||
// Copyright (C) 2011, 2012 Strahinja Val Markovic <val@markovic.io>
|
||||
//
|
||||
// This file is part of YouCompleteMe.
|
||||
//
|
||||
// YouCompleteMe 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.
|
||||
//
|
||||
// YouCompleteMe 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 YouCompleteMe. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
#ifndef CONCURRENTLATESTVALUE_H_SYF1JPPG
|
||||
#define CONCURRENTLATESTVALUE_H_SYF1JPPG
|
||||
|
||||
#include <boost/thread.hpp>
|
||||
#include <boost/utility.hpp>
|
||||
|
||||
namespace YouCompleteMe {
|
||||
|
||||
// This is is basically a multi-consumer single-producer queue, only with the
|
||||
// twist that we only care about the latest value set. So the GUI thread is the
|
||||
// setter, and the worker threads are the workers. The workers wait in line on
|
||||
// the condition variable and when the setter sets a value, a worker is chosen
|
||||
// to consume it.
|
||||
//
|
||||
// The point is that we always want to have one "fresh" worker thread ready to
|
||||
// work on our latest value. If a newer value is set, then we don't care what
|
||||
// happens to the old values.
|
||||
//
|
||||
// This implementation is mutex-based and is not lock-free. Normally using a
|
||||
// lock-free data structure makes more sense, but since the GUI thread goes
|
||||
// through VimL and Python on every keystroke, there's really no point. Those 5
|
||||
// nanoseconds it takes to lock a mutex are laughably negligible compared to the
|
||||
// VimL/Python overhead.
|
||||
template <typename T>
|
||||
class ConcurrentLatestValue : boost::noncopyable {
|
||||
public:
|
||||
|
||||
ConcurrentLatestValue() : empty_( true ) {}
|
||||
|
||||
void Set( const T &data ) {
|
||||
{
|
||||
boost::unique_lock< boost::mutex > lock( mutex_ );
|
||||
latest_ = data;
|
||||
empty_ = false;
|
||||
}
|
||||
|
||||
condition_variable_.notify_one();
|
||||
}
|
||||
|
||||
T Get() {
|
||||
boost::unique_lock< boost::mutex > lock( mutex_ );
|
||||
|
||||
while ( empty_ ) {
|
||||
condition_variable_.wait( lock );
|
||||
}
|
||||
|
||||
empty_ = true;
|
||||
return latest_;
|
||||
}
|
||||
|
||||
|
||||
private:
|
||||
T latest_;
|
||||
bool empty_;
|
||||
boost::mutex mutex_;
|
||||
boost::condition_variable condition_variable_;
|
||||
|
||||
};
|
||||
|
||||
} // namespace YouCompleteMe
|
||||
|
||||
#endif /* end of include guard: CONCURRENTLATESTVALUE_H_SYF1JPPG */
|
||||
@ -1,89 +0,0 @@
|
||||
// Copyright (C) 2011, 2012 Strahinja Val Markovic <val@markovic.io>
|
||||
//
|
||||
// This file is part of YouCompleteMe.
|
||||
//
|
||||
// YouCompleteMe 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.
|
||||
//
|
||||
// YouCompleteMe 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 YouCompleteMe. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
#ifndef CONCURRENTSTACK_H_TGI0GOR6
|
||||
#define CONCURRENTSTACK_H_TGI0GOR6
|
||||
|
||||
#include <boost/thread.hpp>
|
||||
#include <boost/utility.hpp>
|
||||
#include <stack>
|
||||
|
||||
namespace YouCompleteMe {
|
||||
|
||||
template <typename T>
|
||||
class ConcurrentStack : boost::noncopyable {
|
||||
public:
|
||||
|
||||
void Push( const T &data ) {
|
||||
{
|
||||
boost::unique_lock< boost::mutex > lock( mutex_ );
|
||||
stack_.push( data );
|
||||
}
|
||||
|
||||
condition_variable_.notify_one();
|
||||
}
|
||||
|
||||
|
||||
T Pop() {
|
||||
boost::unique_lock< boost::mutex > lock( mutex_ );
|
||||
|
||||
while ( stack_.empty() ) {
|
||||
condition_variable_.wait( lock );
|
||||
}
|
||||
|
||||
T top = stack_.top();
|
||||
stack_.pop();
|
||||
return top;
|
||||
}
|
||||
|
||||
|
||||
// Gets all the items from the stack and appends them to the input vector.
|
||||
// Does not wait for the stack to get items; if the stack is empty, returns
|
||||
// false and does not touch the input vector.
|
||||
bool PopAllNoWait( std::vector< T > &items ) {
|
||||
boost::unique_lock< boost::mutex > lock( mutex_ );
|
||||
|
||||
if ( stack_.empty() )
|
||||
return false;
|
||||
|
||||
int num_items = stack_.size();
|
||||
items.reserve( num_items + items.size() );
|
||||
|
||||
for ( int i = 0; i < num_items; ++i ) {
|
||||
items.push_back( stack_.top() );
|
||||
stack_.pop();
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
bool Empty() {
|
||||
boost::unique_lock< boost::mutex > lock( mutex_ );
|
||||
return stack_.empty();
|
||||
}
|
||||
|
||||
private:
|
||||
std::stack< T > stack_;
|
||||
boost::mutex mutex_;
|
||||
boost::condition_variable condition_variable_;
|
||||
|
||||
};
|
||||
|
||||
} // namespace YouCompleteMe
|
||||
|
||||
#endif /* end of include guard: CONCURRENTSTACK_H_TGI0GOR6 */
|
||||
@ -1,78 +0,0 @@
|
||||
// Copyright (C) 2011, 2012 Strahinja Val Markovic <val@markovic.io>
|
||||
//
|
||||
// This file is part of YouCompleteMe.
|
||||
//
|
||||
// YouCompleteMe 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.
|
||||
//
|
||||
// YouCompleteMe 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 YouCompleteMe. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
#ifndef FUTURE_H_NR1U6MZS
|
||||
#define FUTURE_H_NR1U6MZS
|
||||
|
||||
#include <boost/thread.hpp>
|
||||
#include <boost/make_shared.hpp>
|
||||
#include <boost/shared_ptr.hpp>
|
||||
#include <boost/function.hpp>
|
||||
|
||||
namespace YouCompleteMe {
|
||||
|
||||
class Result;
|
||||
typedef boost::shared_ptr< boost::packaged_task< void > > VoidTask;
|
||||
|
||||
template< typename T >
|
||||
boost::shared_ptr< T > ReturnValueAsShared(
|
||||
boost::function< T() > func ) {
|
||||
return boost::make_shared< T >( func() );
|
||||
}
|
||||
|
||||
|
||||
template< typename T >
|
||||
class Future {
|
||||
public:
|
||||
Future() {};
|
||||
Future( boost::shared_future< T > future )
|
||||
: future_( boost::move( future ) ) {}
|
||||
|
||||
bool ResultsReady() {
|
||||
// It's OK to return true since GetResults will just return a
|
||||
// default-constructed value if the future_ is uninitialized. If we don't
|
||||
// return true for this case, any loop waiting on ResultsReady will wait
|
||||
// forever.
|
||||
if ( future_.get_state() == boost::future_state::uninitialized )
|
||||
return true;
|
||||
|
||||
return future_.is_ready();
|
||||
}
|
||||
|
||||
|
||||
void Wait() {
|
||||
future_.wait();
|
||||
}
|
||||
|
||||
|
||||
T GetResults() {
|
||||
try {
|
||||
return future_.get();
|
||||
} catch ( boost::future_uninitialized & ) {
|
||||
// Do nothing and return a T()
|
||||
}
|
||||
|
||||
return T();
|
||||
}
|
||||
|
||||
private:
|
||||
boost::shared_future< T > future_;
|
||||
};
|
||||
|
||||
} // namespace YouCompleteMe
|
||||
|
||||
#endif /* end of include guard: FUTURE_H_NR1U6MZS */
|
||||
@ -18,10 +18,7 @@
|
||||
#ifndef COMPLETER_H_7AR4UGXE
|
||||
#define COMPLETER_H_7AR4UGXE
|
||||
|
||||
#include "ConcurrentLatestValue.h"
|
||||
#include "ConcurrentStack.h"
|
||||
#include "IdentifierDatabase.h"
|
||||
#include "Future.h"
|
||||
|
||||
#include <boost/utility.hpp>
|
||||
#include <boost/unordered_map.hpp>
|
||||
|
||||
Loading…
Reference in New Issue
Block a user