diff --git a/CMakeLists.txt b/CMakeLists.txt index 681649a3f..abca484e9 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -107,7 +107,6 @@ set(sources magnet_uri parse_url ConvertUTF - thread xml_parse version diff --git a/Jamfile b/Jamfile index a34351664..81792bd46 100644 --- a/Jamfile +++ b/Jamfile @@ -650,7 +650,6 @@ SOURCES = magnet_uri parse_url ConvertUTF - thread xml_parse version peer_class diff --git a/docs/gen_reference_doc.py b/docs/gen_reference_doc.py index a4f6caece..9d0ab45f2 100644 --- a/docs/gen_reference_doc.py +++ b/docs/gen_reference_doc.py @@ -97,7 +97,6 @@ category_mapping = { 'sha1_hash.hpp': 'Utility', 'hasher.hpp': 'Utility', 'identify_client.hpp': 'Utility', - 'thread.hpp': 'Utility', 'ip_filter.hpp': 'Filter', 'session_settings.hpp': 'Settings', 'settings_pack.hpp': 'Settings', diff --git a/examples/connection_tester.cpp b/examples/connection_tester.cpp index fa306dd61..0499e26aa 100644 --- a/examples/connection_tester.cpp +++ b/examples/connection_tester.cpp @@ -37,12 +37,12 @@ POSSIBILITY OF SUCH DAMAGE. #include "libtorrent/error_code.hpp" #include "libtorrent/io.hpp" #include "libtorrent/torrent_info.hpp" -#include "libtorrent/thread.hpp" #include "libtorrent/create_torrent.hpp" #include "libtorrent/hasher.hpp" #include "libtorrent/socket_io.hpp" #include "libtorrent/file_pool.hpp" #include +#include #include #include #include @@ -801,10 +801,10 @@ void generate_torrent(std::vector& buf, int size, int num_files libtorrent::create_torrent t(fs, piece_size); // generate the hashes in 4 threads - thread t1(boost::bind(&hasher_thread, &t, 0, 1 * num_pieces / 4, piece_size, false)); - thread t2(boost::bind(&hasher_thread, &t, 1 * num_pieces / 4, 2 * num_pieces / 4, piece_size, false)); - thread t3(boost::bind(&hasher_thread, &t, 2 * num_pieces / 4, 3 * num_pieces / 4, piece_size, false)); - thread t4(boost::bind(&hasher_thread, &t, 3 * num_pieces / 4, 4 * num_pieces / 4, piece_size, true)); + std::thread t1(&hasher_thread, &t, 0, 1 * num_pieces / 4, piece_size, false); + std::thread t2(&hasher_thread, &t, 1 * num_pieces / 4, 2 * num_pieces / 4, piece_size, false); + std::thread t3(&hasher_thread, &t, 2 * num_pieces / 4, 3 * num_pieces / 4, piece_size, false); + std::thread t4(&hasher_thread, &t, 3 * num_pieces / 4, 4 * num_pieces / 4, piece_size, true); t1.join(); t2.join(); @@ -1045,7 +1045,7 @@ int main(int argc, char* argv[]) std::vector conns; conns.reserve(num_connections); - const int num_threads = 2; + int const num_threads = 2; io_service ios[num_threads]; for (int i = 0; i < num_connections; ++i) { @@ -1064,8 +1064,8 @@ int main(int argc, char* argv[]) } } - thread t1(boost::bind(&io_thread, &ios[0])); - thread t2(boost::bind(&io_thread, &ios[1])); + std::thread t1(&io_thread, &ios[0]); + std::thread t2(&io_thread, &ios[1]); t1.join(); t2.join(); diff --git a/include/libtorrent/Makefile.am b/include/libtorrent/Makefile.am index c592ae154..f6f18fc13 100644 --- a/include/libtorrent/Makefile.am +++ b/include/libtorrent/Makefile.am @@ -128,7 +128,6 @@ nobase_include_HEADERS = \ storage_defs.hpp \ tailqueue.hpp \ string_util.hpp \ - thread.hpp \ thread_pool.hpp \ time.hpp \ timestamp_history.hpp \ diff --git a/include/libtorrent/alert_manager.hpp b/include/libtorrent/alert_manager.hpp index 6216f68eb..2f664cea0 100644 --- a/include/libtorrent/alert_manager.hpp +++ b/include/libtorrent/alert_manager.hpp @@ -35,7 +35,6 @@ POSSIBILITY OF SUCH DAMAGE. #include "libtorrent/config.hpp" #include "libtorrent/alert.hpp" -#include "libtorrent/thread.hpp" #include "libtorrent/heterogeneous_queue.hpp" #include "libtorrent/stack_allocator.hpp" @@ -49,6 +48,8 @@ POSSIBILITY OF SUCH DAMAGE. #include #include #include // for std::forward +#include +#include #include "libtorrent/aux_/disable_warnings_pop.hpp" @@ -74,7 +75,7 @@ namespace libtorrent { template void emplace_alert(Args&&... args) { - mutex::scoped_lock lock(m_mutex); + std::unique_lock lock(m_mutex); #ifndef TORRENT_NO_DEPRECATE if (m_dispatch) { @@ -102,7 +103,7 @@ namespace libtorrent { template bool should_post() const { - mutex::scoped_lock lock(m_mutex); + std::lock_guard lock(m_mutex); if (m_alerts[m_generation].size() >= m_queue_size_limit * (1 + T::priority)) { @@ -115,13 +116,13 @@ namespace libtorrent { void set_alert_mask(boost::uint32_t m) { - mutex::scoped_lock lock(m_mutex); + std::lock_guard lock(m_mutex); m_alert_mask = m; } boost::uint32_t alert_mask() const { - mutex::scoped_lock lock(m_mutex); + std::lock_guard lock(m_mutex); return m_alert_mask; } @@ -144,10 +145,10 @@ namespace libtorrent { alert_manager(alert_manager const&); alert_manager& operator=(alert_manager const&); - void maybe_notify(alert* a, mutex::scoped_lock& lock); + void maybe_notify(alert* a, std::unique_lock& lock); - mutable mutex m_mutex; - condition_variable m_condition; + mutable std::mutex m_mutex; + std::condition_variable m_condition; boost::uint32_t m_alert_mask; int m_queue_size_limit; @@ -171,7 +172,7 @@ namespace libtorrent { int m_generation; // this is where all alerts are queued up. There are two heterogenous - // queues to double buffer the thread access. The mutex in the alert + // queues to double buffer the thread access. The std::mutex in the alert // manager gives exclusive access to m_alerts[m_generation] and // m_allocations[m_generation] whereas the other copy is exclusively // used by the client thread. diff --git a/include/libtorrent/aux_/session_call.hpp b/include/libtorrent/aux_/session_call.hpp index 957d777a2..a9a443818 100644 --- a/include/libtorrent/aux_/session_call.hpp +++ b/include/libtorrent/aux_/session_call.hpp @@ -34,7 +34,6 @@ POSSIBILITY OF SUCH DAMAGE. #define TORRENT_SESSION_CALL_HPP_INCLUDED #include "libtorrent/config.hpp" -#include "libtorrent/thread.hpp" #include "libtorrent/aux_/session_impl.hpp" #include @@ -44,13 +43,13 @@ namespace libtorrent { namespace aux { void blocking_call(); void dump_call_profile(); -void fun_wrap(bool& done, condition_variable& e, mutex& m, boost::function f); +void fun_wrap(bool& done, std::condition_variable& e, std::mutex& m, boost::function f); template -void fun_ret(R& ret, bool& done, condition_variable& e, mutex& m, boost::function f) +void fun_ret(R& ret, bool& done, std::condition_variable& e, std::mutex& m, boost::function f) { ret = f(); - mutex::scoped_lock l(m); + std::unique_lock l(m); done = true; e.notify_all(); } diff --git a/include/libtorrent/aux_/session_impl.hpp b/include/libtorrent/aux_/session_impl.hpp index bc2faccae..969e1ae40 100644 --- a/include/libtorrent/aux_/session_impl.hpp +++ b/include/libtorrent/aux_/session_impl.hpp @@ -48,6 +48,8 @@ POSSIBILITY OF SUCH DAMAGE. #include #include #include +#include +#include #include // for va_start, va_end #include @@ -76,7 +78,6 @@ POSSIBILITY OF SUCH DAMAGE. #include "libtorrent/disk_io_thread.hpp" #include "libtorrent/udp_socket.hpp" #include "libtorrent/assert.hpp" -#include "libtorrent/thread.hpp" #include "libtorrent/alert_manager.hpp" // for alert_manager #include "libtorrent/deadline_timer.hpp" #include "libtorrent/socket_io.hpp" // for print_address @@ -609,8 +610,8 @@ namespace libtorrent // used when posting synchronous function // calls to session_impl and torrent objects - mutable libtorrent::mutex mut; - mutable libtorrent::condition_variable cond; + mutable std::mutex mut; + mutable std::condition_variable cond; // cork a peer and schedule a delayed uncork // does nothing if the peer is already corked diff --git a/include/libtorrent/bandwidth_manager.hpp b/include/libtorrent/bandwidth_manager.hpp index 26b99b14e..29b25db24 100644 --- a/include/libtorrent/bandwidth_manager.hpp +++ b/include/libtorrent/bandwidth_manager.hpp @@ -45,7 +45,6 @@ POSSIBILITY OF SUCH DAMAGE. #include "libtorrent/assert.hpp" #include "libtorrent/bandwidth_limit.hpp" #include "libtorrent/bandwidth_queue_entry.hpp" -#include "libtorrent/thread.hpp" #include "libtorrent/bandwidth_socket.hpp" #include "libtorrent/time.hpp" diff --git a/include/libtorrent/debug.hpp b/include/libtorrent/debug.hpp index 44cb6be53..628d7a99f 100644 --- a/include/libtorrent/debug.hpp +++ b/include/libtorrent/debug.hpp @@ -42,7 +42,6 @@ POSSIBILITY OF SUCH DAMAGE. #if defined TORRENT_ASIO_DEBUGGING -#include "libtorrent/thread.hpp" #include "libtorrent/time.hpp" #include "libtorrent/aux_/disable_warnings_push.hpp" @@ -75,7 +74,7 @@ namespace libtorrent // defined in session_impl.cpp extern std::map _async_ops; extern int _async_ops_nthreads; - extern mutex _async_ops_mutex; + extern std::mutex _async_ops_mutex; // timestamp -> operation struct wakeup_t @@ -88,14 +87,14 @@ namespace libtorrent inline bool has_outstanding_async(char const* name) { - mutex::scoped_lock l(_async_ops_mutex); + std::lock_guard l(_async_ops_mutex); std::map::iterator i = _async_ops.find(name); return i != _async_ops.end(); } inline void add_outstanding_async(char const* name) { - mutex::scoped_lock l(_async_ops_mutex); + std::lock_guard l(_async_ops_mutex); async_t& a = _async_ops[name]; if (a.stack.empty()) { @@ -113,7 +112,7 @@ namespace libtorrent inline void complete_async(char const* name) { - mutex::scoped_lock l(_async_ops_mutex); + std::lock_guard l(_async_ops_mutex); async_t& a = _async_ops[name]; TORRENT_ASSERT(a.refs > 0); --a.refs; @@ -139,19 +138,19 @@ namespace libtorrent inline void async_inc_threads() { - mutex::scoped_lock l(_async_ops_mutex); + std::lock_guard l(_async_ops_mutex); ++_async_ops_nthreads; } inline void async_dec_threads() { - mutex::scoped_lock l(_async_ops_mutex); + std::lock_guard l(_async_ops_mutex); --_async_ops_nthreads; } inline int log_async() { - mutex::scoped_lock l(_async_ops_mutex); + std::lock_guard l(_async_ops_mutex); int ret = 0; for (std::map::iterator i = _async_ops.begin() , end(_async_ops.end()); i != end; ++i) diff --git a/include/libtorrent/disk_buffer_pool.hpp b/include/libtorrent/disk_buffer_pool.hpp index 79f46a169..c964ffd28 100644 --- a/include/libtorrent/disk_buffer_pool.hpp +++ b/include/libtorrent/disk_buffer_pool.hpp @@ -38,6 +38,7 @@ POSSIBILITY OF SUCH DAMAGE. #include "libtorrent/aux_/disable_warnings_push.hpp" #include +#include #include #include #include @@ -53,7 +54,6 @@ POSSIBILITY OF SUCH DAMAGE. #include "libtorrent/aux_/disable_warnings_pop.hpp" -#include "libtorrent/thread.hpp" #include "libtorrent/io_service_fwd.hpp" #include "libtorrent/file.hpp" // for iovec_t @@ -71,7 +71,7 @@ namespace libtorrent #if TORRENT_USE_ASSERTS bool is_disk_buffer(char* buffer - , mutex::scoped_lock& l) const; + , std::unique_lock& l) const; bool is_disk_buffer(char* buffer) const; #endif @@ -90,7 +90,7 @@ namespace libtorrent boost::uint32_t in_use() const { - mutex::scoped_lock l(m_pool_mutex); + std::unique_lock l(m_pool_mutex); return m_in_use; } boost::uint32_t num_to_evict(int num_needed = 0); @@ -100,8 +100,8 @@ namespace libtorrent protected: - void free_buffer_impl(char* buf, mutex::scoped_lock& l); - char* allocate_buffer_impl(mutex::scoped_lock& l, char const* category); + void free_buffer_impl(char* buf, std::unique_lock& l); + char* allocate_buffer_impl(std::unique_lock& l, char const* category); // number of bytes per block. The BitTorrent // protocol defines the block size to 16 KiB. @@ -137,9 +137,9 @@ namespace libtorrent private: - void check_buffer_level(mutex::scoped_lock& l); + void check_buffer_level(std::unique_lock& l); - mutable mutex m_pool_mutex; + mutable std::mutex m_pool_mutex; int m_cache_buffer_chunk_size; diff --git a/include/libtorrent/disk_io_thread.hpp b/include/libtorrent/disk_io_thread.hpp index 4801c3d09..69cb62ddc 100644 --- a/include/libtorrent/disk_io_thread.hpp +++ b/include/libtorrent/disk_io_thread.hpp @@ -45,7 +45,6 @@ POSSIBILITY OF SUCH DAMAGE. #include "libtorrent/disk_interface.hpp" #include "libtorrent/performance_counters.hpp" #include "libtorrent/aux_/session_settings.hpp" -#include "libtorrent/thread.hpp" #include "libtorrent/aux_/disable_warnings_push.hpp" @@ -54,7 +53,9 @@ POSSIBILITY OF SUCH DAMAGE. #include #include #include -#include +#include +#include +#include #ifndef TORRENT_DISABLE_POOL_ALLOCATOR #include #endif @@ -452,7 +453,7 @@ namespace libtorrent void fail_jobs(storage_error const& e, jobqueue_t& jobs_); void fail_jobs_impl(storage_error const& e, jobqueue_t& src, jobqueue_t& dst); - void check_cache_level(mutex::scoped_lock& l, jobqueue_t& completed_jobs); + void check_cache_level(std::unique_lock& l, jobqueue_t& completed_jobs); void perform_job(disk_io_job* j, jobqueue_t& completed_jobs); @@ -461,11 +462,11 @@ namespace libtorrent void add_fence_job(piece_manager* storage, disk_io_job* j , bool user_add = true); - // assumes l is locked (cache mutex). + // assumes l is locked (cache std::mutex). // writes out the blocks [start, end) (releases the lock // during the file operation) int flush_range(cached_piece_entry* p, int start, int end - , jobqueue_t& completed_jobs, mutex::scoped_lock& l); + , jobqueue_t& completed_jobs, std::unique_lock& l); // low level flush operations, used by flush_range int build_iovec(cached_piece_entry* pe, int start, int end @@ -477,12 +478,12 @@ namespace libtorrent , storage_error const& error , jobqueue_t& completed_jobs); - // assumes l is locked (the cache mutex). + // assumes l is locked (the cache std::mutex). // assumes pe->hash to be set. // If there are new blocks in piece 'pe' that have not been // hashed by the partial_hash object attached to this piece, // the piece will - void kick_hasher(cached_piece_entry* pe, mutex::scoped_lock& l); + void kick_hasher(cached_piece_entry* pe, std::unique_lock& l); // flags to pass in to flush_cache() enum flush_flags_t @@ -498,13 +499,13 @@ namespace libtorrent // used for asserts and only applies for fence jobs flush_expect_clear = 8 }; - void flush_cache(piece_manager* storage, boost::uint32_t flags, jobqueue_t& completed_jobs, mutex::scoped_lock& l); - void flush_expired_write_blocks(jobqueue_t& completed_jobs, mutex::scoped_lock& l); - void flush_piece(cached_piece_entry* pe, int flags, jobqueue_t& completed_jobs, mutex::scoped_lock& l); + void flush_cache(piece_manager* storage, boost::uint32_t flags, jobqueue_t& completed_jobs, std::unique_lock& l); + void flush_expired_write_blocks(jobqueue_t& completed_jobs, std::unique_lock& l); + void flush_piece(cached_piece_entry* pe, int flags, jobqueue_t& completed_jobs, std::unique_lock& l); - int try_flush_hashed(cached_piece_entry* p, int cont_blocks, jobqueue_t& completed_jobs, mutex::scoped_lock& l); + int try_flush_hashed(cached_piece_entry* p, int cont_blocks, jobqueue_t& completed_jobs, std::unique_lock& l); - void try_flush_write_blocks(int num, jobqueue_t& completed_jobs, mutex::scoped_lock& l); + void try_flush_write_blocks(int num, jobqueue_t& completed_jobs, std::unique_lock& l); // used to batch reclaiming of blocks to once per cycle void commit_reclaimed_blocks(); @@ -528,7 +529,7 @@ namespace libtorrent boost::atomic m_num_running_threads; // the actual threads running disk jobs - std::vector > m_threads; + std::vector m_threads; aux::session_settings m_settings; @@ -545,7 +546,7 @@ namespace libtorrent file_pool m_file_pool; // disk cache - mutable mutex m_cache_mutex; + mutable std::mutex m_cache_mutex; block_cache m_disk_cache; enum { @@ -580,10 +581,10 @@ namespace libtorrent // used to wake up the disk IO thread when there are new // jobs on the job queue (m_queued_jobs) - condition_variable m_job_cond; + std::condition_variable m_job_cond; - // mutex to protect the m_queued_jobs list - mutable mutex m_job_mutex; + // std::mutex to protect the m_queued_jobs list + mutable std::mutex m_job_mutex; // jobs queued for servicing jobqueue_t m_queued_jobs; @@ -591,7 +592,7 @@ namespace libtorrent // when using more than 2 threads, this is // used for just hashing jobs, just for threads // dedicated to do hashing - condition_variable m_hash_job_cond; + std::condition_variable m_hash_job_cond; jobqueue_t m_queued_hash_jobs; // used to rate limit disk performance warnings @@ -602,12 +603,12 @@ namespace libtorrent // a message is posted to the network thread, which // will then drain the queue and execute the jobs' // handler functions - mutex m_completed_jobs_mutex; + std::mutex m_completed_jobs_mutex; jobqueue_t m_completed_jobs; // these are blocks that have been returned by the main thread // but they haven't been freed yet. This is used to batch - // reclaiming of blocks, to only need one mutex lock per cycle + // reclaiming of blocks, to only need one std::mutex lock per cycle std::vector m_blocks_to_reclaim; // when this is true, there is an outstanding message in the diff --git a/include/libtorrent/disk_job_pool.hpp b/include/libtorrent/disk_job_pool.hpp index 3b6915cc2..95b48c616 100644 --- a/include/libtorrent/disk_job_pool.hpp +++ b/include/libtorrent/disk_job_pool.hpp @@ -34,7 +34,7 @@ POSSIBILITY OF SUCH DAMAGE. #define TORRENT_DISK_JOB_POOL #include "libtorrent/config.hpp" -#include "libtorrent/thread.hpp" +#include #include "libtorrent/aux_/disable_warnings_push.hpp" @@ -68,7 +68,7 @@ namespace libtorrent // total number of in-use write jobs int m_write_jobs; - mutex m_job_mutex; + std::mutex m_job_mutex; boost::pool<> m_job_pool; }; } diff --git a/include/libtorrent/extensions.hpp b/include/libtorrent/extensions.hpp index 92e4686b1..621f9e387 100644 --- a/include/libtorrent/extensions.hpp +++ b/include/libtorrent/extensions.hpp @@ -59,24 +59,20 @@ POSSIBILITY OF SUCH DAMAGE. // dead locks and race conditions. Since a plugin has access to internal // structures it is also quite easy to sabotage libtorrent's operation. // -// All the callbacks in this interface are called with the main libtorrent thread -// mutex locked. And they are always called from the libtorrent network thread. In +// All the callbacks are always called from the libtorrent network thread. In // case portions of your plugin are called from other threads, typically the main // thread, you cannot use any of the member functions on the internal structures // in libtorrent, since those require the mutex to be locked. Furthermore, you would // also need to have a mutex on your own shared data within the plugin, to make // sure it is not accessed at the same time from the libtorrent thread (through a -// callback). See `boost thread's mutex`_. If you need to send out a message from -// another thread, it is advised to use an internal queue, and do the actual -// sending in ``tick()``. +// callback). If you need to send out a message from another thread, it is +// advised to use an internal queue, and do the actual sending in ``tick()``. // // Since the plugin interface gives you easy access to internal structures, it // is not supported as a stable API. Plugins should be considered specific to a // specific version of libtorrent. Although, in practice the internals mostly // don't change that dramatically. // -// .. _`boost thread's mutex`: http://www.boost.org/doc/html/mutex.html -// // // plugin-interface // ================ diff --git a/include/libtorrent/file.hpp b/include/libtorrent/file.hpp index 736e94752..00b0ebf4a 100644 --- a/include/libtorrent/file.hpp +++ b/include/libtorrent/file.hpp @@ -242,7 +242,7 @@ namespace libtorrent // open the file for reading and writing read_write = 2, - + // the mask for the bits determining read or write mode rw_mask = read_only | write_only | read_write, diff --git a/include/libtorrent/file_pool.hpp b/include/libtorrent/file_pool.hpp index 27f495ed0..4623df107 100644 --- a/include/libtorrent/file_pool.hpp +++ b/include/libtorrent/file_pool.hpp @@ -34,9 +34,9 @@ POSSIBILITY OF SUCH DAMAGE. #define TORRENT_FILE_POOL_HPP #include +#include #include "libtorrent/file.hpp" #include "libtorrent/time.hpp" -#include "libtorrent/thread.hpp" #include "libtorrent/file_storage.hpp" #include "libtorrent/aux_/time.hpp" @@ -120,7 +120,7 @@ namespace libtorrent private: - void remove_oldest(mutex::scoped_lock& l); + void remove_oldest(std::unique_lock& l); int m_size; bool m_low_prio_io; @@ -137,12 +137,12 @@ namespace libtorrent // maps storage pointer, file index pairs to the // lru entry for the file typedef std::map, lru_file_entry> file_set; - + file_set m_files; #if TORRENT_USE_ASSERTS std::vector > m_deleted_storages; #endif - mutable mutex m_mutex; + mutable std::mutex m_mutex; }; } diff --git a/include/libtorrent/kademlia/dht_tracker.hpp b/include/libtorrent/kademlia/dht_tracker.hpp index 98cab668b..91c014908 100644 --- a/include/libtorrent/kademlia/dht_tracker.hpp +++ b/include/libtorrent/kademlia/dht_tracker.hpp @@ -50,7 +50,6 @@ POSSIBILITY OF SUCH DAMAGE. #include "libtorrent/session_settings.hpp" #include "libtorrent/udp_socket.hpp" #include "libtorrent/socket.hpp" -#include "libtorrent/thread.hpp" #include "libtorrent/deadline_timer.hpp" #include "libtorrent/aux_/array_view.hpp" diff --git a/include/libtorrent/kademlia/node.hpp b/include/libtorrent/kademlia/node.hpp index 00df8b611..7bfbe40da 100644 --- a/include/libtorrent/kademlia/node.hpp +++ b/include/libtorrent/kademlia/node.hpp @@ -36,6 +36,7 @@ POSSIBILITY OF SUCH DAMAGE. #include #include #include +#include #include #include @@ -51,7 +52,6 @@ POSSIBILITY OF SUCH DAMAGE. #include // for udp::endpoint #include #include -#include #include #include @@ -182,13 +182,13 @@ public: void add_traversal_algorithm(traversal_algorithm* a) { - mutex_t::scoped_lock l(m_mutex); + std::lock_guard l(m_mutex); m_running_requests.insert(a); } void remove_traversal_algorithm(traversal_algorithm* a) { - mutex_t::scoped_lock l(m_mutex); + std::lock_guard l(m_mutex); m_running_requests.erase(a); } @@ -231,8 +231,7 @@ private: libtorrent::dht_settings const& m_settings; - typedef libtorrent::mutex mutex_t; - mutex_t m_mutex; + std::mutex m_mutex; // this list must be destructed after the rpc manager // since it might have references to it diff --git a/include/libtorrent/natpmp.hpp b/include/libtorrent/natpmp.hpp index f4b2be886..ea8a74579 100644 --- a/include/libtorrent/natpmp.hpp +++ b/include/libtorrent/natpmp.hpp @@ -36,9 +36,11 @@ POSSIBILITY OF SUCH DAMAGE. #include "libtorrent/io_service_fwd.hpp" #include "libtorrent/socket.hpp" #include "libtorrent/address.hpp" -#include "libtorrent/thread.hpp" #include "libtorrent/error_code.hpp" #include "libtorrent/deadline_timer.hpp" +#include "libtorrent/time.hpp" + +#include #include "libtorrent/aux_/disable_warnings_push.hpp" @@ -75,22 +77,22 @@ public: void close(); private: - + boost::shared_ptr self() { return shared_from_this(); } - void update_mapping(int i, mutex::scoped_lock& l); - void send_map_request(int i, mutex::scoped_lock& l); - void send_get_ip_address_request(mutex::scoped_lock& l); + void update_mapping(int i, std::unique_lock& l); + void send_map_request(int i, std::unique_lock& l); + void send_get_ip_address_request(std::unique_lock& l); void resend_request(int i, error_code const& e); void on_reply(error_code const& e , std::size_t bytes_transferred); - void try_next_mapping(int i, mutex::scoped_lock& l); - void update_expiration_timer(mutex::scoped_lock& l); + void try_next_mapping(int i, std::unique_lock& l); + void update_expiration_timer(std::unique_lock& l); void mapping_expired(error_code const& e, int i); - void close_impl(mutex::scoped_lock& l); + void close_impl(std::unique_lock& l); - void log(char const* msg, mutex::scoped_lock& l); - void disable(error_code const& ec, mutex::scoped_lock& l); + void log(char const* msg, std::unique_lock& l); + void disable(error_code const& ec, std::unique_lock& l); struct mapping_t { @@ -133,7 +135,7 @@ private: log_callback_t m_log_callback; std::vector m_mappings; - + // the endpoint to the nat router udp::endpoint m_nat_endpoint; @@ -145,7 +147,7 @@ private: // current retry count int m_retry_count; - // used to receive responses in + // used to receive responses in char m_response_buffer[16]; // router external IP address @@ -153,7 +155,7 @@ private: // the endpoint we received the message from udp::endpoint m_remote; - + // the udp socket used to communicate // with the NAT router udp::socket m_socket; @@ -167,12 +169,13 @@ private: // the mapping index that will expire next int m_next_refresh; - + bool m_disabled; bool m_abort; - mutable mutex m_mutex; + // TODO:3 is this object really acceessed from multiple threads? + mutable std::mutex m_mutex; }; } diff --git a/include/libtorrent/part_file.hpp b/include/libtorrent/part_file.hpp index 87c8e2297..00be91670 100644 --- a/include/libtorrent/part_file.hpp +++ b/include/libtorrent/part_file.hpp @@ -34,6 +34,7 @@ POSSIBILITY OF SUCH DAMAGE. #include #include +#include #include #include @@ -42,7 +43,6 @@ POSSIBILITY OF SUCH DAMAGE. #include "libtorrent/config.hpp" #include "libtorrent/file.hpp" #include "libtorrent/error_code.hpp" -#include "libtorrent/thread.hpp" // for mutex namespace libtorrent { @@ -82,7 +82,7 @@ namespace libtorrent // this mutex must be held while accessing the data // structure. Not while reading or writing from the file though! // it's important to support multithreading - mutex m_mutex; + std::mutex m_mutex; // this is a list of unallocated slots in the part file // within the m_num_allocated range diff --git a/include/libtorrent/performance_counters.hpp b/include/libtorrent/performance_counters.hpp index 702d8ddfa..586db44a0 100644 --- a/include/libtorrent/performance_counters.hpp +++ b/include/libtorrent/performance_counters.hpp @@ -34,7 +34,6 @@ POSSIBILITY OF SUCH DAMAGE. #define TORRENT_PERFORMANCE_COUNTERS_HPP_INCLUDED #include "libtorrent/config.hpp" -#include "libtorrent/thread.hpp" #include "libtorrent/aux_/disable_warnings_push.hpp" @@ -457,7 +456,7 @@ namespace libtorrent #else // if the atomic type is't lock-free, use a single lock instead, for // the whole array - mutable mutex m_mutex; + mutable std::mutex m_mutex; boost::int64_t m_stats_counter[num_counters]; #endif }; diff --git a/include/libtorrent/session.hpp b/include/libtorrent/session.hpp index a5c9395ac..f45ff004c 100644 --- a/include/libtorrent/session.hpp +++ b/include/libtorrent/session.hpp @@ -35,6 +35,7 @@ POSSIBILITY OF SUCH DAMAGE. #include #include +#include #include "libtorrent/aux_/disable_warnings_push.hpp" @@ -51,7 +52,6 @@ POSSIBILITY OF SUCH DAMAGE. #include "libtorrent/storage.hpp" #include "libtorrent/session_settings.hpp" #include "libtorrent/session_handle.hpp" -#include "libtorrent/thread.hpp" #ifndef TORRENT_NO_DEPRECATE #include "libtorrent/fingerprint.hpp" @@ -131,14 +131,14 @@ namespace libtorrent private: session_proxy( boost::shared_ptr ios - , boost::shared_ptr t + , std::shared_ptr t , boost::shared_ptr impl) : m_io_service(ios) , m_thread(t) , m_impl(impl) {} boost::shared_ptr m_io_service; - boost::shared_ptr m_thread; + std::shared_ptr m_thread; boost::shared_ptr m_impl; }; @@ -289,7 +289,7 @@ namespace libtorrent // data shared between the main thread // and the working thread boost::shared_ptr m_io_service; - boost::shared_ptr m_thread; + std::shared_ptr m_thread; boost::shared_ptr m_impl; }; diff --git a/include/libtorrent/storage.hpp b/include/libtorrent/storage.hpp index 77b76abe6..8fe0976d6 100644 --- a/include/libtorrent/storage.hpp +++ b/include/libtorrent/storage.hpp @@ -38,6 +38,7 @@ POSSIBILITY OF SUCH DAMAGE. #include "libtorrent/aux_/disable_warnings_push.hpp" #include +#include #include #include #include @@ -55,7 +56,6 @@ POSSIBILITY OF SUCH DAMAGE. #include "libtorrent/hasher.hpp" #include "libtorrent/file.hpp" #include "libtorrent/disk_buffer_holder.hpp" -#include "libtorrent/thread.hpp" #include "libtorrent/storage_defs.hpp" #include "libtorrent/allocator.hpp" #include "libtorrent/file_pool.hpp" // pool_file_status @@ -589,7 +589,7 @@ namespace libtorrent // must be held when accessing m_has_fence and // m_blocked_jobs - mutable mutex m_mutex; + mutable std::mutex m_mutex; }; // this class keeps track of which pieces, belonging to diff --git a/include/libtorrent/thread.hpp b/include/libtorrent/thread.hpp deleted file mode 100644 index 4ef92bb8f..000000000 --- a/include/libtorrent/thread.hpp +++ /dev/null @@ -1,95 +0,0 @@ -/* - -Copyright (c) 2009-2016, Arvid Norberg -All rights reserved. - -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions -are met: - - * Redistributions of source code must retain the above copyright - notice, this list of conditions and the following disclaimer. - * Redistributions in binary form must reproduce the above copyright - notice, this list of conditions and the following disclaimer in - the documentation and/or other materials provided with the distribution. - * Neither the name of the author nor the names of its - contributors may be used to endorse or promote products derived - from this software without specific prior written permission. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" -AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE -IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE -ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE -LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR -CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF -SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS -INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN -CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) -ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE -POSSIBILITY OF SUCH DAMAGE. - -*/ - -#ifndef TORRENT_THREAD_HPP_INCLUDED -#define TORRENT_THREAD_HPP_INCLUDED - -#include "libtorrent/config.hpp" -#include "libtorrent/assert.hpp" -#include "libtorrent/time.hpp" - -#include "libtorrent/aux_/disable_warnings_push.hpp" - -#if defined TORRENT_WINDOWS || defined TORRENT_CYGWIN -// asio assumes that the windows error codes are defined already -#include -#endif - -#if defined TORRENT_BEOS -#include -#endif - -#include // for auto_ptr required by asio - -#include -#include -#include -#include - -#include "libtorrent/aux_/disable_warnings_pop.hpp" - -namespace libtorrent -{ - typedef boost::asio::detail::thread thread; - typedef boost::asio::detail::mutex mutex; - typedef boost::asio::detail::event event; - - // internal - void sleep(int milliseconds); - - struct TORRENT_EXTRA_EXPORT condition_variable - { - condition_variable(); - ~condition_variable(); - void wait(mutex::scoped_lock& l); - void wait_for(mutex::scoped_lock& l, time_duration rel_time); - void notify_all(); - void notify(); - private: -#ifdef BOOST_HAS_PTHREADS - pthread_cond_t m_cond; -#elif defined TORRENT_WINDOWS || defined TORRENT_CYGWIN - HANDLE m_sem; - mutex m_mutex; - int m_num_waiters; -#elif defined TORRENT_BEOS - sem_id m_sem; - mutex m_mutex; - int m_num_waiters; -#else -#error not implemented -#endif - }; -} - -#endif - diff --git a/include/libtorrent/thread_pool.hpp b/include/libtorrent/thread_pool.hpp index a66a78207..bcbabe74f 100644 --- a/include/libtorrent/thread_pool.hpp +++ b/include/libtorrent/thread_pool.hpp @@ -34,8 +34,9 @@ POSSIBILITY OF SUCH DAMAGE. #define TORRENT_THREAD_POOL #include "libtorrent/config.hpp" -#include "libtorrent/thread.hpp" -#include +#include +#include +#include #include #include #include @@ -59,20 +60,23 @@ namespace libtorrent while (m_num_threads < n) { ++m_num_threads; - m_threads.push_back(boost::shared_ptr( - new thread(boost::bind(&thread_pool::thread_fun, this, int(m_num_threads)-1)))); + m_threads.emplace_back(&thread_pool::thread_fun + , this, int(m_num_threads)-1); } } else { while (m_num_threads > n) { --m_num_threads; } - mutex::scoped_lock l(m_mutex); - m_cond.notify_all(); - l.unlock(); + { + std::lock_guard l(m_mutex); + m_cond.notify_all(); + } if (wait) { for (int i = m_num_threads; i < int(m_threads.size()); ++i) - m_threads[i]->join(); + { + m_threads[i].join(); + } } // this will detach the threads m_threads.resize(m_num_threads); @@ -93,14 +97,14 @@ namespace libtorrent else { retain_job(e); - mutex::scoped_lock l(m_mutex); + std::lock_guard l(m_mutex); m_queue.push_back(e); // we only need to signal if the threads // may have been put to sleep. If the size // previous to adding the new job was > 0 // they don't need waking up. if (m_queue.size() == 1) - m_cond.notify(); + m_cond.notify_one(); return true; } } @@ -116,7 +120,7 @@ namespace libtorrent { for (;;) { - mutex::scoped_lock l(m_mutex); + std::unique_lock l(m_mutex); while (m_queue.empty() && thread_id < m_num_threads) m_cond.wait(l); // if the number of wanted thread is decreased, @@ -138,25 +142,25 @@ namespace libtorrent { // when we're terminating the last hasher thread, make sure // there are no more scheduled jobs - mutex::scoped_lock l(m_mutex); + std::lock_guard l(m_mutex); TORRENT_ASSERT(m_queue.empty()); } #endif } - // the mutex only protects m_cond and m_queue + // the std::mutex only protects m_cond and m_queue // all other members are only used from a single // thread (the user of this class, i.e. the disk // thread). - mutex m_mutex; - condition_variable m_cond; + std::mutex m_mutex; + std::condition_variable m_cond; std::deque m_queue; - std::vector > m_threads; + std::vector m_threads; // this is a counter which is atomically incremented // by each thread as it's started up, in order to // assign a unique id to each thread - boost::atomic m_num_threads; + std::atomic m_num_threads; }; } diff --git a/include/libtorrent/tracker_manager.hpp b/include/libtorrent/tracker_manager.hpp index 109c85fc5..6f9949438 100644 --- a/include/libtorrent/tracker_manager.hpp +++ b/include/libtorrent/tracker_manager.hpp @@ -41,7 +41,7 @@ POSSIBILITY OF SUCH DAMAGE. #include #include #include -#include +#include #include #include @@ -64,8 +64,8 @@ POSSIBILITY OF SUCH DAMAGE. #include "libtorrent/deadline_timer.hpp" #include "libtorrent/union_endpoint.hpp" #include "libtorrent/io_service.hpp" -#include "libtorrent/thread.hpp" #include "libtorrent/aux_/array_view.hpp" +#include "libtorrent/time.hpp" namespace libtorrent { @@ -274,7 +274,8 @@ namespace libtorrent int m_completion_timeout; - mutable mutex m_mutex; + // TODO: 3 is this object really accessed from multiple threads? + mutable std::mutex m_mutex; // used for timeouts // this is set when the request has been sent @@ -397,7 +398,7 @@ namespace libtorrent private: - mutable mutex m_mutex; + mutable std::mutex m_mutex; // maps transactionid to the udp_tracker_connection // TODO: this should be unique_ptr in the future diff --git a/include/libtorrent/udp_socket.hpp b/include/libtorrent/udp_socket.hpp index f3338ce3f..bae96abe0 100644 --- a/include/libtorrent/udp_socket.hpp +++ b/include/libtorrent/udp_socket.hpp @@ -38,7 +38,6 @@ POSSIBILITY OF SUCH DAMAGE. #include "libtorrent/error_code.hpp" #include "libtorrent/session_settings.hpp" #include "libtorrent/buffer.hpp" -#include "libtorrent/thread.hpp" #include "libtorrent/deadline_timer.hpp" #include "libtorrent/debug.hpp" #include "libtorrent/aux_/array_view.hpp" diff --git a/include/libtorrent/udp_tracker_connection.hpp b/include/libtorrent/udp_tracker_connection.hpp index 275d6723e..be2ff0551 100644 --- a/include/libtorrent/udp_tracker_connection.hpp +++ b/include/libtorrent/udp_tracker_connection.hpp @@ -122,7 +122,7 @@ namespace libtorrent }; static std::map m_connection_cache; - static mutex m_cache_mutex; + static std::mutex m_cache_mutex; udp::endpoint m_target; diff --git a/include/libtorrent/upnp.hpp b/include/libtorrent/upnp.hpp index 720e72205..b7277c0fc 100644 --- a/include/libtorrent/upnp.hpp +++ b/include/libtorrent/upnp.hpp @@ -37,7 +37,6 @@ POSSIBILITY OF SUCH DAMAGE. #include "libtorrent/error_code.hpp" #include "libtorrent/broadcast_socket.hpp" #include "libtorrent/http_connection.hpp" -#include "libtorrent/thread.hpp" #include "libtorrent/deadline_timer.hpp" #include "libtorrent/enum_net.hpp" #include "libtorrent/resolver.hpp" @@ -48,6 +47,7 @@ POSSIBILITY OF SUCH DAMAGE. #include #include #include +#include namespace libtorrent { @@ -174,7 +174,7 @@ public: // the router, it can be queried through this function. std::string router_model() { - mutex::scoped_lock l(m_mutex); + std::unique_lock l(m_mutex); return m_model; } @@ -183,8 +183,8 @@ private: boost::shared_ptr self() { return shared_from_this(); } void map_timer(error_code const& ec); - void try_map_upnp(mutex::scoped_lock& l, bool timer = false); - void discover_device_impl(mutex::scoped_lock& l); + void try_map_upnp(std::unique_lock& l, bool timer = false); + void discover_device_impl(std::unique_lock& l); static address_v4 upnp_multicast_address; static udp::endpoint upnp_multicast_endpoint; @@ -199,8 +199,8 @@ private: , std::size_t bytes_transferred); struct rootdevice; - void next(rootdevice& d, int i, mutex::scoped_lock& l); - void update_map(rootdevice& d, int i, mutex::scoped_lock& l); + void next(rootdevice& d, int i, std::unique_lock& l); + void update_map(rootdevice& d, int i, std::unique_lock& l); void on_upnp_xml(error_code const& e @@ -217,15 +217,15 @@ private: , int mapping, http_connection& c); void on_expire(error_code const& e); - void disable(error_code const& ec, mutex::scoped_lock& l); - void return_error(int mapping, int code, mutex::scoped_lock& l); - void log(char const* msg, mutex::scoped_lock& l); + void disable(error_code const& ec, std::unique_lock& l); + void return_error(int mapping, int code, std::unique_lock& l); + void log(char const* msg, std::unique_lock& l); void get_ip_address(rootdevice& d); void delete_port_mapping(rootdevice& d, int i); void create_port_mapping(http_connection& c, rootdevice& d, int i); void post(upnp::rootdevice const& d, char const* soap - , char const* soap_action, mutex::scoped_lock& l); + , char const* soap_action, std::unique_lock& l); int num_mappings() const { return int(m_mappings.size()); } @@ -394,7 +394,8 @@ private: bool m_closing; bool m_ignore_non_routers; - mutex m_mutex; + // TODO: 3 is this class really accessed from multiple threads? + std::mutex m_mutex; std::string m_model; diff --git a/include/libtorrent/utp_stream.hpp b/include/libtorrent/utp_stream.hpp index 0d7127a8c..d3bdf9dfa 100644 --- a/include/libtorrent/utp_stream.hpp +++ b/include/libtorrent/utp_stream.hpp @@ -38,6 +38,7 @@ POSSIBILITY OF SUCH DAMAGE. #include "libtorrent/io.hpp" #include "libtorrent/packet_buffer.hpp" #include "libtorrent/error_code.hpp" +#include "libtorrent/time.hpp" #include "libtorrent/aux_/disable_warnings_push.hpp" diff --git a/src/Makefile.am b/src/Makefile.am index 603fe29c6..ad6ffdbdd 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -125,7 +125,6 @@ libtorrent_rasterbar_la_SOURCES = \ storage.cpp \ session_stats.cpp \ string_util.cpp \ - thread.cpp \ torrent.cpp \ torrent_handle.cpp \ torrent_info.cpp \ diff --git a/src/alert_manager.cpp b/src/alert_manager.cpp index 77473aa5e..82dfcf815 100644 --- a/src/alert_manager.cpp +++ b/src/alert_manager.cpp @@ -51,7 +51,7 @@ namespace libtorrent alert* alert_manager::wait_for_alert(time_duration max_wait) { - mutex::scoped_lock lock(m_mutex); + std::unique_lock lock(m_mutex); if (!m_alerts[m_generation].empty()) return m_alerts[m_generation].front(); @@ -64,7 +64,7 @@ namespace libtorrent return NULL; } - void alert_manager::maybe_notify(alert* a, mutex::scoped_lock& lock) + void alert_manager::maybe_notify(alert* a, std::unique_lock& lock) { if (m_alerts[m_generation].size() == 1) { @@ -116,7 +116,7 @@ namespace libtorrent void alert_manager::set_dispatch_function( boost::function)> const& fun) { - mutex::scoped_lock lock(m_mutex); + std::unique_lock lock(m_mutex); m_dispatch = fun; @@ -142,7 +142,7 @@ namespace libtorrent void alert_manager::set_notify_function(boost::function const& fun) { - mutex::scoped_lock lock(m_mutex); + std::unique_lock lock(m_mutex); m_notify = fun; if (!m_alerts[m_generation].empty()) { @@ -161,7 +161,7 @@ namespace libtorrent void alert_manager::get_all(std::vector& alerts) { - mutex::scoped_lock lock(m_mutex); + std::lock_guard lock(m_mutex); alerts.clear(); if (m_alerts[m_generation].empty()) return; @@ -177,13 +177,13 @@ namespace libtorrent bool alert_manager::pending() const { - mutex::scoped_lock lock(m_mutex); + std::lock_guard lock(m_mutex); return !m_alerts[m_generation].empty(); } int alert_manager::set_alert_queue_size_limit(int queue_size_limit_) { - mutex::scoped_lock lock(m_mutex); + std::lock_guard lock(m_mutex); std::swap(m_queue_size_limit, queue_size_limit_); return queue_size_limit_; diff --git a/src/disk_buffer_pool.cpp b/src/disk_buffer_pool.cpp index d566d1237..73964a062 100644 --- a/src/disk_buffer_pool.cpp +++ b/src/disk_buffer_pool.cpp @@ -134,7 +134,7 @@ namespace libtorrent { int ret = 0; - mutex::scoped_lock l(m_pool_mutex); + std::unique_lock l(m_pool_mutex); if (m_exceeded_max_size) ret = m_in_use - (std::min)(m_low_watermark, int(m_max_use - m_observers.size()*2)); @@ -152,9 +152,9 @@ namespace libtorrent // and if we're in fact below the low watermark. If so, we need to // post the notification messages to the peers that are waiting for // more buffers to received data into - void disk_buffer_pool::check_buffer_level(mutex::scoped_lock& l) + void disk_buffer_pool::check_buffer_level(std::unique_lock& l) { - TORRENT_ASSERT(l.locked()); + TORRENT_ASSERT(l.owns_lock()); if (!m_exceeded_max_size || m_in_use > m_low_watermark) return; m_exceeded_max_size = false; @@ -168,10 +168,10 @@ namespace libtorrent #if TORRENT_USE_ASSERTS bool disk_buffer_pool::is_disk_buffer(char* buffer - , mutex::scoped_lock& l) const + , std::unique_lock& l) const { TORRENT_ASSERT(m_magic == 0x1337); - TORRENT_ASSERT(l.locked()); + TORRENT_ASSERT(l.owns_lock()); TORRENT_UNUSED(l); #if TORRENT_HAVE_MMAP @@ -198,14 +198,14 @@ namespace libtorrent bool disk_buffer_pool::is_disk_buffer(char* buffer) const { - mutex::scoped_lock l(m_pool_mutex); + std::unique_lock l(m_pool_mutex); return is_disk_buffer(buffer, l); } #endif char* disk_buffer_pool::allocate_buffer(char const* category) { - mutex::scoped_lock l(m_pool_mutex); + std::unique_lock l(m_pool_mutex); return allocate_buffer_impl(l, category); } @@ -219,7 +219,7 @@ namespace libtorrent char* disk_buffer_pool::allocate_buffer(bool& exceeded , boost::shared_ptr o, char const* category) { - mutex::scoped_lock l(m_pool_mutex); + std::unique_lock l(m_pool_mutex); char* ret = allocate_buffer_impl(l, category); if (m_exceeded_max_size) { @@ -233,7 +233,7 @@ namespace libtorrent // fills in the iovec array with the buffers int disk_buffer_pool::allocate_iovec(file::iovec_t* iov, int iov_len) { - mutex::scoped_lock l(m_pool_mutex); + std::unique_lock l(m_pool_mutex); for (int i = 0; i < iov_len; ++i) { iov[i].iov_base = allocate_buffer_impl(l, "pending read"); @@ -254,18 +254,18 @@ namespace libtorrent void disk_buffer_pool::free_iovec(file::iovec_t* iov, int iov_len) { // TODO: perhaps we should sort the buffers here? - mutex::scoped_lock l(m_pool_mutex); + std::unique_lock l(m_pool_mutex); for (int i = 0; i < iov_len; ++i) free_buffer_impl(static_cast(iov[i].iov_base), l); check_buffer_level(l); } - char* disk_buffer_pool::allocate_buffer_impl(mutex::scoped_lock& l + char* disk_buffer_pool::allocate_buffer_impl(std::unique_lock& l , char const*) { TORRENT_ASSERT(m_settings_set); TORRENT_ASSERT(m_magic == 0x1337); - TORRENT_ASSERT(l.locked()); + TORRENT_ASSERT(l.owns_lock()); TORRENT_UNUSED(l); char* ret; @@ -339,7 +339,7 @@ namespace libtorrent // sort the pointers in order to maximize cache hits std::sort(bufvec, end); - mutex::scoped_lock l(m_pool_mutex); + std::unique_lock l(m_pool_mutex); for (; bufvec != end; ++bufvec) { char* buf = *bufvec; @@ -352,7 +352,7 @@ namespace libtorrent void disk_buffer_pool::free_buffer(char* buf) { - mutex::scoped_lock l(m_pool_mutex); + std::unique_lock l(m_pool_mutex); free_buffer_impl(buf, l); check_buffer_level(l); } @@ -362,7 +362,7 @@ namespace libtorrent { TORRENT_UNUSED(ec); - mutex::scoped_lock l(m_pool_mutex); + std::unique_lock l(m_pool_mutex); // 0 cache_buffer_chunk_size means 'automatic' (i.e. // proportional to the total disk cache size) @@ -515,13 +515,13 @@ namespace libtorrent #endif } - void disk_buffer_pool::free_buffer_impl(char* buf, mutex::scoped_lock& l) + void disk_buffer_pool::free_buffer_impl(char* buf, std::unique_lock& l) { TORRENT_ASSERT(buf); TORRENT_ASSERT(m_magic == 0x1337); TORRENT_ASSERT(m_settings_set); TORRENT_ASSERT(is_disk_buffer(buf, l)); - TORRENT_ASSERT(l.locked()); + TORRENT_ASSERT(l.owns_lock()); TORRENT_UNUSED(l); #if TORRENT_HAVE_MMAP @@ -581,7 +581,7 @@ namespace libtorrent { TORRENT_ASSERT(m_magic == 0x1337); #ifndef TORRENT_DISABLE_POOL_ALLOCATOR - mutex::scoped_lock l(m_pool_mutex); + std::unique_lock l(m_pool_mutex); if (m_using_pool_allocator) m_pool.release_memory(); #endif diff --git a/src/disk_io_thread.cpp b/src/disk_io_thread.cpp index 6fbb12f86..5aed6e14e 100644 --- a/src/disk_io_thread.cpp +++ b/src/disk_io_thread.cpp @@ -103,7 +103,7 @@ namespace libtorrent void debug_log(char const* fmt, ...) { #if DEBUG_DISK_THREAD - static mutex log_mutex; + static std::mutex log_mutex; static const time_point start = clock_type::now(); va_list v; va_start(v, fmt); @@ -115,7 +115,7 @@ namespace libtorrent if (!prepend_time) { prepend_time = (usr[len-1] == '\n'); - mutex::scoped_lock l(log_mutex); + std::unique_lock l(log_mutex); fputs(usr, stderr); return; } @@ -124,7 +124,7 @@ namespace libtorrent int t = total_milliseconds(clock_type::now() - start); snprintf(buf, sizeof(buf), "%05d: [%p] %s", t, pthread_self(), usr); prepend_time = (usr[len-1] == '\n'); - mutex::scoped_lock l(log_mutex); + std::unique_lock l(log_mutex); fputs(buf, stderr); #else TORRENT_UNUSED(fmt); @@ -215,7 +215,7 @@ namespace libtorrent } // TODO: 1 it would be nice to have the number of threads be set dynamically - void disk_io_thread::set_num_threads(int i, bool wait) + void disk_io_thread::set_num_threads(int const i, bool const wait) { TORRENT_ASSERT(m_magic == 0x1337); if (i == m_num_threads) return; @@ -241,20 +241,24 @@ namespace libtorrent // the magic number 3 is also used in add_job() // every 4:th thread is a hasher thread if ((thread_id & 0x3) == 3) type = hasher_thread; - m_threads.push_back(boost::shared_ptr( - new thread(boost::bind(&disk_io_thread::thread_fun, this - , thread_id, type, work)))); + m_threads.emplace_back(&disk_io_thread::thread_fun, this + , thread_id, type, work); } } else { while (m_num_threads > i) { --m_num_threads; } - mutex::scoped_lock l(m_job_mutex); + std::unique_lock l(m_job_mutex); m_job_cond.notify_all(); m_hash_job_cond.notify_all(); l.unlock(); - if (wait) for (int j = m_num_threads; j < m_threads.size(); ++j) m_threads[j]->join(); - // this will detach the threads + for (int j = m_num_threads; j < m_threads.size(); ++j) + { + if (wait) + m_threads[j].join(); + else + m_threads[j].detach(); + } m_threads.resize(m_num_threads); } } @@ -275,7 +279,7 @@ namespace libtorrent TORRENT_ASSERT(m_magic == 0x1337); TORRENT_ASSERT(m_outstanding_reclaim_message); m_outstanding_reclaim_message = false; - mutex::scoped_lock l(m_cache_mutex); + std::unique_lock l(m_cache_mutex); for (int i = 0; i < m_blocks_to_reclaim.size(); ++i) m_disk_cache.reclaim_block(m_blocks_to_reclaim[i]); m_blocks_to_reclaim.clear(); @@ -284,7 +288,7 @@ namespace libtorrent void disk_io_thread::set_settings(settings_pack const* pack, alert_manager& alerts) { TORRENT_ASSERT(m_magic == 0x1337); - mutex::scoped_lock l(m_cache_mutex); + std::unique_lock l(m_cache_mutex); apply_pack(pack, m_settings); error_code ec; m_disk_cache.set_settings(m_settings, ec); @@ -297,10 +301,10 @@ namespace libtorrent // flush all blocks that are below p->hash.offset, since we've // already hashed those blocks, they won't cause any read-back int disk_io_thread::try_flush_hashed(cached_piece_entry* p, int cont_block - , jobqueue_t& completed_jobs, mutex::scoped_lock& l) + , jobqueue_t& completed_jobs, std::unique_lock& l) { TORRENT_ASSERT(m_magic == 0x1337); - TORRENT_ASSERT(l.locked()); + TORRENT_ASSERT(l.owns_lock()); TORRENT_ASSERT(cont_block > 0); if (p->hash == 0 && !p->hashing_done) { @@ -737,9 +741,9 @@ namespace libtorrent // issues write operations for blocks in the given // range on the given piece. int disk_io_thread::flush_range(cached_piece_entry* pe, int start, int end - , jobqueue_t& completed_jobs, mutex::scoped_lock& l) + , jobqueue_t& completed_jobs, std::unique_lock& l) { - TORRENT_ASSERT(l.locked()); + TORRENT_ASSERT(l.owns_lock()); INVARIANT_CHECK; DLOG("flush_range: piece=%d [%d, %d)\n" @@ -799,9 +803,9 @@ namespace libtorrent } void disk_io_thread::flush_piece(cached_piece_entry* pe, int flags - , jobqueue_t& completed_jobs, mutex::scoped_lock& l) + , jobqueue_t& completed_jobs, std::unique_lock& l) { - TORRENT_ASSERT(l.locked()); + TORRENT_ASSERT(l.owns_lock()); if (flags & flush_delete_cache) { // delete dirty blocks and post handlers with @@ -832,7 +836,7 @@ namespace libtorrent } void disk_io_thread::flush_cache(piece_manager* storage, boost::uint32_t flags - , jobqueue_t& completed_jobs, mutex::scoped_lock& l) + , jobqueue_t& completed_jobs, std::unique_lock& l) { if (storage) { @@ -855,7 +859,7 @@ namespace libtorrent flush_piece(pe, flags, completed_jobs, l); } #if TORRENT_USE_ASSERTS - TORRENT_ASSERT(l.locked()); + TORRENT_ASSERT(l.owns_lock()); // if the user asked to delete the cache for this storage // we really should not have any pieces left. This is only called // from disk_io_thread::do_delete, which is a fence job and should @@ -903,7 +907,7 @@ namespace libtorrent // blocks of write cache line size, but try to flush all old blocks // this is why we pass in 1 as cont_block to the flushing functions void disk_io_thread::try_flush_write_blocks(int num, jobqueue_t& completed_jobs - , mutex::scoped_lock& l) + , std::unique_lock& l) { DLOG("try_flush_write_blocks: %d\n", num); @@ -977,7 +981,7 @@ namespace libtorrent } void disk_io_thread::flush_expired_write_blocks(jobqueue_t& completed_jobs - , mutex::scoped_lock& l) + , std::unique_lock& l) { DLOG("flush_expired_write_blocks\n"); @@ -1064,7 +1068,7 @@ namespace libtorrent // below the number of blocks we flushed by the time we're done flushing // that's why we need to call this fairly often. Both before and after // a disk job is executed - void disk_io_thread::check_cache_level(mutex::scoped_lock& l, jobqueue_t& completed_jobs) + void disk_io_thread::check_cache_level(std::unique_lock& l, jobqueue_t& completed_jobs) { // when the read cache is disabled, always try to evict all read cache // blocks @@ -1096,7 +1100,7 @@ namespace libtorrent #if DEBUG_DISK_THREAD { - mutex::scoped_lock l(m_cache_mutex); + std::unique_lock l(m_cache_mutex); DLOG("perform_job job: %s ( %s%s) piece: %d offset: %d outstanding: %d\n" , job_action_name[j->action] @@ -1112,7 +1116,7 @@ namespace libtorrent // TODO: instead of doing this. pass in the settings to each storage_interface // call. Each disk thread could hold its most recent understanding of the settings // in a shared_ptr, and update it every time it wakes up from a job. That way - // each access to the settings won't require a mutex to be held. + // each access to the settings won't require a std::mutex to be held. if (storage && storage->get_storage_impl()->m_settings == 0) storage->get_storage_impl()->m_settings = &m_settings; @@ -1130,14 +1134,14 @@ namespace libtorrent m_stats_counters.inc_stats_counter(counters::num_running_disk_jobs, -1); - mutex::scoped_lock l(m_cache_mutex); + std::unique_lock l(m_cache_mutex); if (m_cache_check_state == cache_check_idle) { m_cache_check_state = cache_check_active; while (m_cache_check_state != cache_check_idle) { check_cache_level(l, completed_jobs); - TORRENT_ASSERT(l.locked()); + TORRENT_ASSERT(l.owns_lock()); --m_cache_check_state; } } @@ -1149,7 +1153,7 @@ namespace libtorrent if (ret == retry_job) { - mutex::scoped_lock l2(m_job_mutex); + std::unique_lock l2(m_job_mutex); // to avoid busy looping here, give up // our quanta in case there aren't any other // jobs to run in between @@ -1163,7 +1167,7 @@ namespace libtorrent bool need_sleep = m_queued_jobs.empty(); m_queued_jobs.push_back(j); l2.unlock(); - if (need_sleep) sleep(0); + if (need_sleep) std::this_thread::yield(); return; } @@ -1221,7 +1225,7 @@ namespace libtorrent file::iovec_t* iov = TORRENT_ALLOCA(file::iovec_t, iov_len); - mutex::scoped_lock l(m_cache_mutex); + std::unique_lock l(m_cache_mutex); int evict = m_disk_cache.num_to_evict(iov_len); if (evict > 0) m_disk_cache.try_evict_blocks(evict); @@ -1243,7 +1247,7 @@ namespace libtorrent { ret = do_uncached_read(j); - mutex::scoped_lock l2(m_cache_mutex); + std::unique_lock l2(m_cache_mutex); pe = m_disk_cache.find_piece(j); if (pe) maybe_issue_queued_read_jobs(pe, completed_jobs); return ret; @@ -1260,7 +1264,7 @@ namespace libtorrent // at this point, all the buffers are allocated and iov is initizalied // and the blocks have their refcounters incremented, so no other thread - // can remove them. We can now release the cache mutex and dive into the + // can remove them. We can now release the cache std::mutex and dive into the // disk operations. int const file_flags = file_flags_for_job(j @@ -1455,7 +1459,7 @@ namespace libtorrent INVARIANT_CHECK; TORRENT_ASSERT(j->d.io.buffer_size <= m_disk_cache.block_size()); - mutex::scoped_lock l(m_cache_mutex); + std::unique_lock l(m_cache_mutex); cached_piece_entry* pe = m_disk_cache.find_piece(j); if (pe && pe->hashing_done) @@ -1537,7 +1541,7 @@ namespace libtorrent j->requester = requester; j->callback = handler; - mutex::scoped_lock l(m_cache_mutex); + std::unique_lock l(m_cache_mutex); int ret = prep_read_job_impl(j); l.unlock(); @@ -1557,7 +1561,7 @@ namespace libtorrent // and if it doesn't have a picece allocated, it allocates // one and it sets outstanding_read flag and possibly queues // up the job in the piece read job list - // the cache mutex must be held when calling this + // the cache std::mutex must be held when calling this // // returns 0 if the job succeeded immediately // 1 if it needs to be added to the job queue @@ -1655,7 +1659,7 @@ namespace libtorrent j->flags = flags; #if TORRENT_USE_ASSERTS - mutex::scoped_lock l3_(m_cache_mutex); + std::unique_lock l3_(m_cache_mutex); cached_piece_entry* pe = m_disk_cache.find_piece(j); if (pe) { @@ -1670,7 +1674,7 @@ namespace libtorrent #endif #if TORRENT_USE_ASSERTS && defined TORRENT_EXPENSIVE_INVARIANT_CHECKS - mutex::scoped_lock l2_(m_cache_mutex); + std::unique_lock l2_(m_cache_mutex); std::pair range = m_disk_cache.all_pieces(); for (block_cache::iterator i = range.first; i != range.second; ++i) { @@ -1685,7 +1689,7 @@ namespace libtorrent #endif #if !defined TORRENT_DISABLE_POOL_ALLOCATOR && TORRENT_USE_ASSERTS - mutex::scoped_lock l_(m_cache_mutex); + std::unique_lock l_(m_cache_mutex); TORRENT_ASSERT(m_disk_cache.is_disk_buffer(j->buffer.disk_block)); l_.unlock(); #endif @@ -1705,7 +1709,7 @@ namespace libtorrent return; } - mutex::scoped_lock l(m_cache_mutex); + std::unique_lock l(m_cache_mutex); // if we succeed in adding the block to the cache, the job will // be added along with it. we may not free j if so cached_piece_entry* dpe = m_disk_cache.add_dirty_block(j); @@ -1755,7 +1759,7 @@ namespace libtorrent int piece_size = storage->files()->piece_size(piece); // first check to see if the hashing is already done - mutex::scoped_lock l(m_cache_mutex); + std::unique_lock l(m_cache_mutex); cached_piece_entry* pe = m_disk_cache.find_piece(j); if (pe && !pe->hashing && pe->hash && pe->hash->offset == piece_size) { @@ -1823,7 +1827,7 @@ namespace libtorrent jobqueue_t completed_jobs; // remove outstanding jobs belonging to this torrent - mutex::scoped_lock l2(m_job_mutex); + std::unique_lock l2(m_job_mutex); // TODO: maybe the tailqueue_iterator should contain a pointer-pointer // instead and have an unlink function @@ -1844,7 +1848,7 @@ namespace libtorrent } l2.unlock(); - mutex::scoped_lock l(m_cache_mutex); + std::unique_lock l(m_cache_mutex); flush_cache(storage, flush_delete_cache, completed_jobs, l); l.unlock(); @@ -1906,7 +1910,7 @@ namespace libtorrent , boost::function const& handler) { // remove outstanding hash jobs belonging to this torrent - mutex::scoped_lock l2(m_job_mutex); + std::unique_lock l2(m_job_mutex); disk_io_job* qj = m_queued_hash_jobs.get_all(); jobqueue_t to_abort; @@ -2040,7 +2044,7 @@ namespace libtorrent void disk_io_thread::clear_read_cache(piece_manager* storage) { - mutex::scoped_lock l(m_cache_mutex); + std::unique_lock l(m_cache_mutex); jobqueue_t jobs; boost::unordered_set const& cache = storage->cached_pieces(); @@ -2081,7 +2085,7 @@ namespace libtorrent void disk_io_thread::clear_piece(piece_manager* storage, int index) { - mutex::scoped_lock l(m_cache_mutex); + std::unique_lock l(m_cache_mutex); cached_piece_entry* pe = m_disk_cache.find_piece(storage, index); if (pe == 0) return; @@ -2103,7 +2107,7 @@ namespace libtorrent fail_jobs(storage_error(boost::asio::error::operation_aborted), jobs); } - void disk_io_thread::kick_hasher(cached_piece_entry* pe, mutex::scoped_lock& l) + void disk_io_thread::kick_hasher(cached_piece_entry* pe, std::unique_lock& l) { if (!pe->hash) return; if (pe->hashing) return; @@ -2268,7 +2272,7 @@ namespace libtorrent int const file_flags = file_flags_for_job(j , m_settings.get_bool(settings_pack::coalesce_reads)); - mutex::scoped_lock l(m_cache_mutex); + std::unique_lock l(m_cache_mutex); cached_piece_entry* pe = m_disk_cache.find_piece(j); if (pe) @@ -2430,7 +2434,6 @@ namespace libtorrent { TORRENT_ASSERT(j->error.ec && j->error.operation != 0); m_disk_cache.free_buffer(static_cast(iov.iov_base)); - l.lock(); break; } @@ -2444,7 +2447,6 @@ namespace libtorrent , boost::asio::error::get_misc_category()); j->error.operation = storage_error::read; m_disk_cache.free_buffer(static_cast(iov.iov_base)); - l.lock(); break; } @@ -2519,7 +2521,7 @@ namespace libtorrent // if this assert fails, something's wrong with the fence logic TORRENT_ASSERT(j->storage->num_outstanding_jobs() == 1); - mutex::scoped_lock l(m_cache_mutex); + std::unique_lock l(m_cache_mutex); flush_cache(j->storage.get(), flush_write_cache, completed_jobs, l); l.unlock(); @@ -2535,7 +2537,7 @@ namespace libtorrent // if this assert fails, something's wrong with the fence logic TORRENT_ASSERT(j->storage->num_outstanding_jobs() == 1); - mutex::scoped_lock l(m_cache_mutex); + std::unique_lock l(m_cache_mutex); #if TORRENT_USE_ASSERTS m_disk_cache.mark_deleted(*j->storage->files()); #endif @@ -2579,7 +2581,7 @@ namespace libtorrent // issue write commands for all dirty blocks // and clear all read jobs - mutex::scoped_lock l(m_cache_mutex); + std::unique_lock l(m_cache_mutex); flush_cache(j->storage.get(), flush_read_cache | flush_write_cache , completed_jobs, l); l.unlock(); @@ -2603,7 +2605,7 @@ namespace libtorrent int const file_flags = file_flags_for_job(j , m_settings.get_bool(settings_pack::coalesce_reads)); - mutex::scoped_lock l(m_cache_mutex); + std::unique_lock l(m_cache_mutex); cached_piece_entry* pe = m_disk_cache.find_piece(j); if (pe == NULL) @@ -2635,7 +2637,7 @@ namespace libtorrent int ret = 0; int offset = 0; - // TODO: it would be nice to not have to lock the mutex every + // TODO: it would be nice to not have to lock the std::mutex every // turn through this loop for (int i = 0; i < blocks_in_piece; ++i) { @@ -2727,7 +2729,7 @@ namespace libtorrent { // These are atomic_counts, so it's safe to access them from // a different thread - mutex::scoped_lock jl(m_job_mutex); + std::unique_lock jl(m_job_mutex); c.set_value(counters::num_read_jobs, read_jobs_in_use()); c.set_value(counters::num_write_jobs, write_jobs_in_use()); @@ -2737,7 +2739,7 @@ namespace libtorrent jl.unlock(); - mutex::scoped_lock l(m_cache_mutex); + std::unique_lock l(m_cache_mutex); // gauges c.set_value(counters::disk_blocks_in_use, m_disk_cache.in_use()); @@ -2748,7 +2750,7 @@ namespace libtorrent void disk_io_thread::get_cache_info(cache_status* ret, bool no_pieces , piece_manager const* storage) const { - mutex::scoped_lock l(m_cache_mutex); + std::unique_lock l(m_cache_mutex); #ifndef TORRENT_NO_DEPRECATE ret->total_used_buffers = m_disk_cache.in_use(); @@ -2837,7 +2839,7 @@ namespace libtorrent l.unlock(); #ifndef TORRENT_NO_DEPRECATE - mutex::scoped_lock jl(m_job_mutex); + std::unique_lock jl(m_job_mutex); ret->queued_jobs = m_queued_jobs.size() + m_queued_hash_jobs.size(); jl.unlock(); #endif @@ -2845,7 +2847,7 @@ namespace libtorrent int disk_io_thread::do_flush_piece(disk_io_job* j, jobqueue_t& completed_jobs) { - mutex::scoped_lock l(m_cache_mutex); + std::unique_lock l(m_cache_mutex); cached_piece_entry* pe = m_disk_cache.find_piece(j); if (pe == NULL) return 0; @@ -2864,7 +2866,7 @@ namespace libtorrent // triggered by another mechanism. int disk_io_thread::do_flush_hashed(disk_io_job* j, jobqueue_t& completed_jobs) { - mutex::scoped_lock l(m_cache_mutex); + std::unique_lock l(m_cache_mutex); cached_piece_entry* pe = m_disk_cache.find_piece(j); @@ -2907,7 +2909,7 @@ namespace libtorrent try_flush_hashed(pe, m_settings.get_int( settings_pack::write_cache_line_size), completed_jobs, l); - TORRENT_ASSERT(l.locked()); + TORRENT_ASSERT(l.owns_lock()); --pe->piece_refcount; @@ -2918,7 +2920,7 @@ namespace libtorrent int disk_io_thread::do_flush_storage(disk_io_job* j, jobqueue_t& completed_jobs) { - mutex::scoped_lock l(m_cache_mutex); + std::unique_lock l(m_cache_mutex); flush_cache(j->storage.get(), flush_write_cache, completed_jobs, l); return 0; } @@ -2964,7 +2966,7 @@ namespace libtorrent // have been evicted int disk_io_thread::do_clear_piece(disk_io_job* j, jobqueue_t& completed_jobs) { - mutex::scoped_lock l(m_cache_mutex); + std::unique_lock l(m_cache_mutex); cached_piece_entry* pe = m_disk_cache.find_piece(j); if (pe == 0) return 0; @@ -3026,7 +3028,7 @@ namespace libtorrent int ret = storage->raise_fence(j, fj, m_stats_counters); if (ret == disk_job_fence::fence_post_fence) { - mutex::scoped_lock l(m_job_mutex); + std::unique_lock l(m_job_mutex); TORRENT_ASSERT((j->flags & disk_io_job::in_progress) || !j->storage); // prioritize fence jobs since they're blocking other jobs m_queued_jobs.push_front(j); @@ -3052,7 +3054,7 @@ namespace libtorrent // now, we have to make sure that all outstanding jobs on this // storage actually get flushed, in order for the fence job to // be executed - mutex::scoped_lock l(m_job_mutex); + std::unique_lock l(m_job_mutex); TORRENT_ASSERT((fj->flags & disk_io_job::in_progress) || !fj->storage); m_queued_jobs.push_front(fj); @@ -3084,7 +3086,7 @@ namespace libtorrent // block cache, and then get issued if (j->flags & disk_io_job::in_progress) { - mutex::scoped_lock l(m_job_mutex); + std::unique_lock l(m_job_mutex); TORRENT_ASSERT((j->flags & disk_io_job::in_progress) || !j->storage); m_queued_jobs.push_back(j); @@ -3118,7 +3120,7 @@ namespace libtorrent return; } - mutex::scoped_lock l(m_job_mutex); + std::unique_lock l(m_job_mutex); TORRENT_ASSERT((j->flags & disk_io_job::in_progress) || !j->storage); @@ -3156,7 +3158,7 @@ namespace libtorrent void disk_io_thread::submit_jobs() { - mutex::scoped_lock l(m_job_mutex); + std::unique_lock l(m_job_mutex); if (!m_queued_jobs.empty()) m_job_cond.notify_all(); if (!m_queued_hash_jobs.empty()) @@ -3168,7 +3170,7 @@ namespace libtorrent time_point now = clock_type::now(); if (now <= m_last_cache_expiry + seconds(5)) return; - mutex::scoped_lock l(m_cache_mutex); + std::unique_lock l(m_cache_mutex); DLOG("blocked_jobs: %d queued_jobs: %d num_threads %d\n" , int(m_stats_counters[counters::blocked_disk_jobs]) , m_queued_jobs.size(), int(m_num_threads)); @@ -3196,13 +3198,13 @@ namespace libtorrent ++m_num_running_threads; m_stats_counters.inc_stats_counter(counters::num_running_threads, 1); - mutex::scoped_lock l(m_job_mutex); + std::unique_lock l(m_job_mutex); for (;;) { disk_io_job* j = 0; if (type == generic_thread) { - TORRENT_ASSERT(l.locked()); + TORRENT_ASSERT(l.owns_lock()); while (m_queued_jobs.empty() && thread_id < m_num_threads) m_job_cond.wait(l); // if the number of wanted threads is decreased, @@ -3219,7 +3221,7 @@ namespace libtorrent } else if (type == hasher_thread) { - TORRENT_ASSERT(l.locked()); + TORRENT_ASSERT(l.owns_lock()); while (m_queued_hash_jobs.empty() && thread_id < m_num_threads) m_hash_job_cond.wait(l); if (m_queued_hash_jobs.empty() && thread_id >= m_num_threads) break; j = m_queued_hash_jobs.pop_front(); @@ -3263,13 +3265,13 @@ namespace libtorrent // This is not supposed to happen because the disk thread is now scheduled // for shut down after all peers have shut down (see // session_impl::abort_stage2()). - mutex::scoped_lock l2(m_cache_mutex); + std::unique_lock l2(m_cache_mutex); TORRENT_ASSERT_VAL(m_disk_cache.pinned_blocks() == 0 , m_disk_cache.pinned_blocks()); while (m_disk_cache.pinned_blocks() > 0) { l2.unlock(); - sleep(100); + std::this_thread::sleep_for(milliseconds(100)); l2.lock(); } l2.unlock(); @@ -3402,7 +3404,7 @@ namespace libtorrent if (j->action == disk_io_job::write) { - mutex::scoped_lock l(m_cache_mutex); + std::unique_lock l(m_cache_mutex); cached_piece_entry* pe = m_disk_cache.find_piece(j); if (pe) { @@ -3415,7 +3417,7 @@ namespace libtorrent #endif jobqueue_t other_jobs; jobqueue_t flush_jobs; - mutex::scoped_lock l_(m_cache_mutex); + std::unique_lock l_(m_cache_mutex); while (new_jobs.size() > 0) { disk_io_job* j = new_jobs.pop_front(); @@ -3480,7 +3482,7 @@ namespace libtorrent } l_.unlock(); - mutex::scoped_lock l(m_job_mutex); + std::unique_lock l(m_job_mutex); m_queued_jobs.append(other_jobs); l.unlock(); @@ -3493,7 +3495,7 @@ namespace libtorrent m_job_cond.notify_all(); } - mutex::scoped_lock l(m_completed_jobs_mutex); + std::unique_lock l(m_completed_jobs_mutex); bool need_post = m_completed_jobs.size() == 0; m_completed_jobs.append(jobs); @@ -3512,7 +3514,7 @@ namespace libtorrent // This is run in the network thread void disk_io_thread::call_job_handlers(void* userdata) { - mutex::scoped_lock l(m_completed_jobs_mutex); + std::unique_lock l(m_completed_jobs_mutex); #if DEBUG_DISK_THREAD DLOG("call_job_handlers (%d)\n", m_completed_jobs.size()); diff --git a/src/disk_job_pool.cpp b/src/disk_job_pool.cpp index 2b0d4b193..e5b8c85c4 100644 --- a/src/disk_job_pool.cpp +++ b/src/disk_job_pool.cpp @@ -50,7 +50,7 @@ namespace libtorrent disk_io_job* disk_job_pool::allocate_job(int type) { - mutex::scoped_lock l(m_job_mutex); + std::unique_lock l(m_job_mutex); disk_io_job* ptr = static_cast(m_job_pool.malloc()); m_job_pool.set_next_size(100); if (ptr == 0) return 0; @@ -78,11 +78,11 @@ namespace libtorrent #endif int type = j->action; j->~disk_io_job(); - mutex::scoped_lock l(m_job_mutex); + std::lock_guard l(m_job_mutex); if (type == disk_io_job::read) --m_read_jobs; else if (type == disk_io_job::write) --m_write_jobs; --m_jobs_in_use; - m_job_pool.free(j); + m_job_pool.free(j); } void disk_job_pool::free_jobs(disk_io_job** j, int num) @@ -98,13 +98,13 @@ namespace libtorrent if (type == disk_io_job::read) ++read_jobs; else if (type == disk_io_job::write) ++write_jobs; } - - mutex::scoped_lock l(m_job_mutex); + + std::lock_guard l(m_job_mutex); m_read_jobs -= read_jobs; m_write_jobs -= write_jobs; m_jobs_in_use -= num; for (int i = 0; i < num; ++i) - m_job_pool.free(j[i]); + m_job_pool.free(j[i]); } } diff --git a/src/escape_string.cpp b/src/escape_string.cpp index cb6ac0f3d..eb9dc17e4 100644 --- a/src/escape_string.cpp +++ b/src/escape_string.cpp @@ -37,6 +37,7 @@ POSSIBILITY OF SUCH DAMAGE. #include #include #include +#include #include #include @@ -63,8 +64,6 @@ POSSIBILITY OF SUCH DAMAGE. #include "libtorrent/random.hpp" #include "libtorrent/utf8.hpp" -#include "libtorrent/thread.hpp" - #include "libtorrent/aux_/escape_string.hpp" #include "libtorrent/string_util.hpp" // for to_string @@ -540,9 +539,9 @@ namespace libtorrent std::string convert_to_native(std::string const& s) { - static mutex iconv_mutex; + static std::mutex iconv_mutex; // only one thread can use this handle at a time - mutex::scoped_lock l(iconv_mutex); + std::lock_guard l(iconv_mutex); // the empty string represents the local dependent encoding static iconv_t iconv_handle = iconv_open("", "UTF-8"); @@ -552,9 +551,9 @@ namespace libtorrent std::string convert_from_native(std::string const& s) { - static mutex iconv_mutex; + static std::mutex iconv_mutex; // only one thread can use this handle at a time - mutex::scoped_lock l(iconv_mutex); + std::lock_guard l(iconv_mutex); // the empty string represents the local dependent encoding static iconv_t iconv_handle = iconv_open("UTF-8", ""); diff --git a/src/file.cpp b/src/file.cpp index f90d26f47..3ed87fd9d 100644 --- a/src/file.cpp +++ b/src/file.cpp @@ -69,7 +69,6 @@ POSSIBILITY OF SUCH DAMAGE. #ifdef TORRENT_DEBUG_FILE_LEAKS #include -#include "libtorrent/thread.hpp" #endif // for convert_to_wstring and convert_to_native @@ -2259,24 +2258,24 @@ typedef struct _FILE_ALLOCATED_RANGE_BUFFER { #ifdef TORRENT_DEBUG_FILE_LEAKS std::set global_file_handles; - mutex file_handle_mutex; + std::mutex file_handle_mutex; file_handle::file_handle() { - mutex::scoped_lock l(file_handle_mutex); + std::lock_guard l(file_handle_mutex); global_file_handles.insert(this); stack[0] = 0; } file_handle::file_handle(file* f): m_file(f) { - mutex::scoped_lock l(file_handle_mutex); + std::lock_guard l(file_handle_mutex); global_file_handles.insert(this); if (f) print_backtrace(stack, sizeof(stack), 10); else stack[0] = 0; } file_handle::file_handle(file_handle const& fh) { - mutex::scoped_lock l(file_handle_mutex); + std::lock_guard l(file_handle_mutex); global_file_handles.insert(this); m_file = fh.m_file; if (m_file) print_backtrace(stack, sizeof(stack), 10); @@ -2284,7 +2283,7 @@ typedef struct _FILE_ALLOCATED_RANGE_BUFFER { } file_handle::~file_handle() { - mutex::scoped_lock l(file_handle_mutex); + std::lock_guard l(file_handle_mutex); global_file_handles.erase(this); stack[0] = 0; } @@ -2297,7 +2296,7 @@ typedef struct _FILE_ALLOCATED_RANGE_BUFFER { file_handle::operator bool() const { return m_file.get(); } file_handle& file_handle::reset(file* f) { - mutex::scoped_lock l(file_handle_mutex); + std::lock_guard l(file_handle_mutex); if (f) print_backtrace(stack, sizeof(stack), 10); else stack[0] = 0; l.unlock(); @@ -2308,7 +2307,7 @@ typedef struct _FILE_ALLOCATED_RANGE_BUFFER { void print_open_files(char const* event, char const* name) { FILE* out = fopen("open_files.log", "a+"); - mutex::scoped_lock l(file_handle_mutex); + std::lock_guard l(file_handle_mutex); fprintf(out, "\n\nEVENT: %s TORRENT: %s\n\n", event, name); for (std::set::iterator i = global_file_handles.begin() , end(global_file_handles.end()); i != end; ++i) diff --git a/src/file_pool.cpp b/src/file_pool.cpp index 5fb8ee066..e372ed35e 100644 --- a/src/file_pool.cpp +++ b/src/file_pool.cpp @@ -129,12 +129,12 @@ namespace libtorrent { // potentially used to hold a reference to a file object that's // about to be destructed. If we have such object we assign it to - // this member to be destructed after we release the mutex. On some + // this member to be destructed after we release the std::mutex. On some // operating systems (such as OSX) closing a file may take a long - // time. We don't want to hold the mutex for that. + // time. We don't want to hold the std::mutex for that. file_handle defer_destruction; - mutex::scoped_lock l(m_mutex); + std::unique_lock l(m_mutex); #if TORRENT_USE_ASSERTS // we're not allowed to open a file @@ -230,7 +230,7 @@ namespace libtorrent void file_pool::get_status(std::vector* files, void* st) const { - mutex::scoped_lock l(m_mutex); + std::unique_lock l(m_mutex); file_set::const_iterator start = m_files.lower_bound(std::make_pair(st, 0)); file_set::const_iterator end = m_files.upper_bound(std::make_pair(st, INT_MAX)); @@ -245,7 +245,7 @@ namespace libtorrent } } - void file_pool::remove_oldest(mutex::scoped_lock& l) + void file_pool::remove_oldest(std::unique_lock& l) { file_set::iterator i = std::min_element(m_files.begin(), m_files.end() , boost::bind(&lru_file_entry::last_use, boost::bind(&file_set::value_type::second, _1)) @@ -263,7 +263,7 @@ namespace libtorrent void file_pool::release(void* st, int file_index) { - mutex::scoped_lock l(m_mutex); + std::unique_lock l(m_mutex); file_set::iterator i = m_files.find(std::make_pair(st, file_index)); if (i == m_files.end()) return; @@ -280,7 +280,7 @@ namespace libtorrent // storage. If 0 is passed, all files are closed void file_pool::release(void* st) { - mutex::scoped_lock l(m_mutex); + std::unique_lock l(m_mutex); if (st == 0) { @@ -309,7 +309,7 @@ namespace libtorrent #if TORRENT_USE_ASSERTS void file_pool::mark_deleted(file_storage const& fs) { - mutex::scoped_lock l(m_mutex); + std::unique_lock l(m_mutex); m_deleted_storages.push_back(std::make_pair(fs.name() , static_cast(&fs))); if(m_deleted_storages.size() > 100) @@ -318,7 +318,7 @@ namespace libtorrent bool file_pool::assert_idle_files(void* st) const { - mutex::scoped_lock l(m_mutex); + std::unique_lock l(m_mutex); for (file_set::const_iterator i = m_files.begin(); i != m_files.end(); ++i) @@ -332,7 +332,7 @@ namespace libtorrent void file_pool::resize(int size) { - mutex::scoped_lock l(m_mutex); + std::unique_lock l(m_mutex); TORRENT_ASSERT(size > 0); diff --git a/src/http_connection.cpp b/src/http_connection.cpp index 26e2cc08b..b813b9184 100644 --- a/src/http_connection.cpp +++ b/src/http_connection.cpp @@ -42,6 +42,7 @@ POSSIBILITY OF SUCH DAMAGE. #include "libtorrent/aux_/time.hpp" #include "libtorrent/random.hpp" #include "libtorrent/debug.hpp" +#include "libtorrent/time.hpp" #include "libtorrent/aux_/disable_warnings_push.hpp" diff --git a/src/kademlia/node.cpp b/src/kademlia/node.cpp index db45db6d0..32b1875d5 100644 --- a/src/kademlia/node.cpp +++ b/src/kademlia/node.cpp @@ -727,7 +727,7 @@ time_duration node::connection_timeout() void node::status(std::vector& table , std::vector& requests) { - mutex_t::scoped_lock l(m_mutex); + std::lock_guard l(m_mutex); m_table.status(table); @@ -756,7 +756,7 @@ void node::update_stats_counters(counters& c) const // TODO: 2 use the non deprecated function instead of this one void node::status(session_status& s) { - mutex_t::scoped_lock l(m_mutex); + std::lock_guard l(m_mutex); m_table.status(s); s.dht_torrents = int(m_storage->num_torrents()); diff --git a/src/natpmp.cpp b/src/natpmp.cpp index 557571a12..035fd5d7a 100644 --- a/src/natpmp.cpp +++ b/src/natpmp.cpp @@ -83,7 +83,7 @@ natpmp::natpmp(io_service& ios void natpmp::start() { - mutex::scoped_lock l(m_mutex); + std::unique_lock l(m_mutex); error_code ec; address gateway = get_default_gateway(m_socket.get_io_service(), ec); @@ -137,7 +137,7 @@ void natpmp::start() } } -void natpmp::send_get_ip_address_request(mutex::scoped_lock& l) +void natpmp::send_get_ip_address_request(std::unique_lock& l) { using namespace libtorrent::detail; @@ -153,7 +153,7 @@ void natpmp::send_get_ip_address_request(mutex::scoped_lock& l) bool natpmp::get_mapping(int index, int& local_port, int& external_port, int& protocol) const { - mutex::scoped_lock l(m_mutex); + std::unique_lock l(m_mutex); TORRENT_ASSERT(index < int(m_mappings.size()) && index >= 0); if (index >= int(m_mappings.size()) || index < 0) return false; @@ -165,14 +165,14 @@ bool natpmp::get_mapping(int index, int& local_port, int& external_port, int& pr return true; } -void natpmp::log(char const* msg, mutex::scoped_lock& l) +void natpmp::log(char const* msg, std::unique_lock& l) { l.unlock(); m_log_callback(msg); l.lock(); } -void natpmp::disable(error_code const& ec, mutex::scoped_lock& l) +void natpmp::disable(error_code const& ec, std::unique_lock& l) { m_disabled = true; @@ -192,7 +192,7 @@ void natpmp::disable(error_code const& ec, mutex::scoped_lock& l) void natpmp::delete_mapping(int index) { - mutex::scoped_lock l(m_mutex); + std::unique_lock l(m_mutex); TORRENT_ASSERT(index < int(m_mappings.size()) && index >= 0); if (index >= int(m_mappings.size()) || index < 0) return; @@ -212,7 +212,7 @@ void natpmp::delete_mapping(int index) int natpmp::add_mapping(protocol_type p, int external_port, int local_port) { - mutex::scoped_lock l(m_mutex); + std::unique_lock l(m_mutex); if (m_disabled) return -1; @@ -249,7 +249,7 @@ int natpmp::add_mapping(protocol_type p, int external_port, int local_port) return mapping_index; } -void natpmp::try_next_mapping(int i, mutex::scoped_lock& l) +void natpmp::try_next_mapping(int i, std::unique_lock& l) { #ifdef NATPMP_LOG time_point now = aux::time_now(); @@ -296,7 +296,7 @@ void natpmp::try_next_mapping(int i, mutex::scoped_lock& l) update_mapping(m - m_mappings.begin(), l); } -void natpmp::update_mapping(int i, mutex::scoped_lock& l) +void natpmp::update_mapping(int i, std::unique_lock& l) { if (i == int(m_mappings.size())) { @@ -329,7 +329,7 @@ void natpmp::update_mapping(int i, mutex::scoped_lock& l) } } -void natpmp::send_map_request(int i, mutex::scoped_lock& l) +void natpmp::send_map_request(int i, std::unique_lock& l) { using namespace libtorrent::detail; @@ -383,7 +383,7 @@ void natpmp::resend_request(int i, error_code const& e) { COMPLETE_ASYNC("natpmp::resend_request"); if (e) return; - mutex::scoped_lock l(m_mutex); + std::unique_lock l(m_mutex); if (m_currently_mapping != i) return; // if we're shutting down, don't retry, just move on @@ -403,7 +403,7 @@ void natpmp::resend_request(int i, error_code const& e) void natpmp::on_reply(error_code const& e , std::size_t bytes_transferred) { - mutex::scoped_lock l(m_mutex); + std::unique_lock l(m_mutex); COMPLETE_ASYNC("natpmp::on_reply"); @@ -575,7 +575,7 @@ void natpmp::on_reply(error_code const& e try_next_mapping(index, l); } -void natpmp::update_expiration_timer(mutex::scoped_lock& l) +void natpmp::update_expiration_timer(std::unique_lock& l) { if (m_abort) return; @@ -643,7 +643,7 @@ void natpmp::mapping_expired(error_code const& e, int i) { COMPLETE_ASYNC("natpmp::mapping_expired"); if (e) return; - mutex::scoped_lock l(m_mutex); + std::unique_lock l(m_mutex); char msg[200]; snprintf(msg, sizeof(msg), "mapping %u expired", i); log(msg, l); @@ -654,11 +654,11 @@ void natpmp::mapping_expired(error_code const& e, int i) void natpmp::close() { - mutex::scoped_lock l(m_mutex); + std::unique_lock l(m_mutex); close_impl(l); } -void natpmp::close_impl(mutex::scoped_lock& l) +void natpmp::close_impl(std::unique_lock& l) { m_abort = true; log("closing", l); diff --git a/src/part_file.cpp b/src/part_file.cpp index b6e51f340..45c1ffcd6 100644 --- a/src/part_file.cpp +++ b/src/part_file.cpp @@ -178,7 +178,7 @@ namespace libtorrent int part_file::writev(file::iovec_t const* bufs, int num_bufs, int piece, int offset, error_code& ec) { TORRENT_ASSERT(offset >= 0); - mutex::scoped_lock l(m_mutex); + std::unique_lock l(m_mutex); open_file(file::read_write, ec); if (ec) return -1; @@ -200,7 +200,7 @@ namespace libtorrent , int piece, int offset, error_code& ec) { TORRENT_ASSERT(offset >= 0); - mutex::scoped_lock l(m_mutex); + std::unique_lock l(m_mutex); boost::unordered_map::iterator i = m_piece_map.find(piece); if (i == m_piece_map.end()) @@ -244,7 +244,7 @@ namespace libtorrent void part_file::free_piece(int piece) { - mutex::scoped_lock l(m_mutex); + std::lock_guard l(m_mutex); boost::unordered_map::iterator i = m_piece_map.find(piece); if (i == m_piece_map.end()) return; @@ -261,7 +261,7 @@ namespace libtorrent void part_file::move_partfile(std::string const& path, error_code& ec) { - mutex::scoped_lock l(m_mutex); + std::lock_guard l(m_mutex); flush_metadata_impl(ec); if (ec) return; @@ -301,7 +301,7 @@ namespace libtorrent void part_file::export_file(file& f, boost::int64_t offset, boost::int64_t size, error_code& ec) { - mutex::scoped_lock l(m_mutex); + std::unique_lock l(m_mutex); int piece = offset / m_piece_size; int const end = ((offset + size) + m_piece_size - 1) / m_piece_size; @@ -366,7 +366,7 @@ namespace libtorrent void part_file::flush_metadata(error_code& ec) { - mutex::scoped_lock l(m_mutex); + std::lock_guard l(m_mutex); flush_metadata_impl(ec); } diff --git a/src/performance_counters.cpp b/src/performance_counters.cpp index cc737d720..97eae3cf5 100644 --- a/src/performance_counters.cpp +++ b/src/performance_counters.cpp @@ -61,7 +61,7 @@ namespace libtorrent { c.m_stats_counter[i].load(boost::memory_order_relaxed) , boost::memory_order_relaxed); #else - mutex::scoped_lock l(c.m_mutex); + std::lock_guard l(c.m_mutex); memcpy(m_stats_counter, c.m_stats_counter, sizeof(m_stats_counter)); #endif } @@ -75,8 +75,8 @@ namespace libtorrent { c.m_stats_counter[i].load(boost::memory_order_relaxed) , boost::memory_order_relaxed); #else - mutex::scoped_lock l(m_mutex); - mutex::scoped_lock l2(c.m_mutex); + std::lock_guard l(m_mutex); + std::lock_guard l2(c.m_mutex); memcpy(m_stats_counter, c.m_stats_counter, sizeof(m_stats_counter)); #endif return *this; @@ -93,7 +93,7 @@ namespace libtorrent { #if BOOST_ATOMIC_LLONG_LOCK_FREE == 2 return m_stats_counter[i].load(boost::memory_order_relaxed); #else - mutex::scoped_lock l(m_mutex); + std::lock_guard l(m_mutex); return m_stats_counter[i]; #endif } @@ -114,7 +114,7 @@ namespace libtorrent { TORRENT_ASSERT(pv + value >= 0); return pv + value; #else - mutex::scoped_lock l(m_mutex); + std::lock_guard l(m_mutex); TORRENT_ASSERT(m_stats_counter[c] + value >= 0); return m_stats_counter[c] += value; #endif @@ -139,7 +139,7 @@ namespace libtorrent { new_value = (current * (100-ratio) + value * ratio) / 100; } #else - mutex::scoped_lock l(m_mutex); + std::lock_guard l(m_mutex); boost::int64_t current = m_stats_counter[c]; m_stats_counter[c] = (current * (100-ratio) + value * ratio) / 100; #endif @@ -153,7 +153,7 @@ namespace libtorrent { #if BOOST_ATOMIC_LLONG_LOCK_FREE == 2 m_stats_counter[c].store(value); #else - mutex::scoped_lock l(m_mutex); + std::lock_guard l(m_mutex); // if this assert fires, someone is trying to decrement a counter // which is not allowed. Counters are monotonically increasing diff --git a/src/random.cpp b/src/random.cpp index 092d9ca99..13b9e5f3c 100644 --- a/src/random.cpp +++ b/src/random.cpp @@ -61,6 +61,8 @@ namespace libtorrent boost::uint32_t random() { + // TODO: versions prior to msvc-14 (visual studio 2015) do + // not generate thread safe initialization of statics static random_device dev; static mt19937 random_engine(dev()); return uniform_int_distribution(0, UINT_MAX)(random_engine); diff --git a/src/session.cpp b/src/session.cpp index e002e8a83..1566cdf13 100644 --- a/src/session.cpp +++ b/src/session.cpp @@ -40,6 +40,8 @@ POSSIBILITY OF SUCH DAMAGE. #include #include #include +#include +#include #include #include @@ -369,8 +371,8 @@ namespace libtorrent if (internal_executor) { // start a thread for the message pump - m_thread = boost::make_shared(boost::bind(&io_service::run - , m_io_service.get())); + m_thread = std::make_shared( + [&]() { m_io_service->run(); }); } } diff --git a/src/session_call.cpp b/src/session_call.cpp index e6bf859a5..0a771cd6e 100644 --- a/src/session_call.cpp +++ b/src/session_call.cpp @@ -35,7 +35,7 @@ POSSIBILITY OF SUCH DAMAGE. namespace libtorrent { namespace aux { #ifdef TORRENT_PROFILE_CALLS -static mutex g_calls_mutex; +static std::mutex g_calls_mutex; static boost::unordered_map g_blocking_calls; #endif @@ -44,7 +44,7 @@ void blocking_call() #ifdef TORRENT_PROFILE_CALLS char stack[2048]; print_backtrace(stack, sizeof(stack), 20); - mutex::scoped_lock l(g_calls_mutex); + std::unique_lock l(g_calls_mutex); g_blocking_calls[stack] += 1; #endif } @@ -56,7 +56,7 @@ void dump_call_profile() std::map profile; - mutex::scoped_lock l(g_calls_mutex); + std::unique_lock l(g_calls_mutex); for (boost::unordered_map::const_iterator i = g_blocking_calls.begin() , end(g_blocking_calls.end()); i != end; ++i) { @@ -71,10 +71,10 @@ void dump_call_profile() #endif } -void fun_wrap(bool& done, condition_variable& e, mutex& m, boost::function f) +void fun_wrap(bool& done, std::condition_variable& e, std::mutex& m, boost::function f) { f(); - mutex::scoped_lock l(m); + std::unique_lock l(m); done = true; e.notify_all(); } @@ -82,7 +82,7 @@ void fun_wrap(bool& done, condition_variable& e, mutex& m, boost::function l(ses.mut); while (!done) { ses.cond.wait(l); }; } diff --git a/src/session_impl.cpp b/src/session_impl.cpp index cdafcc4da..60c6c9e27 100644 --- a/src/session_impl.cpp +++ b/src/session_impl.cpp @@ -198,7 +198,7 @@ namespace libtorrent { std::map _async_ops; std::deque _wakeups; int _async_ops_nthreads = 0; - mutex _async_ops_mutex; + std::mutex _async_ops_mutex; #endif socket_job::~socket_job() {} @@ -6078,6 +6078,7 @@ namespace aux { void session_impl::update_network_threads() { + // TODO: 3 this is a mess int num_threads = m_settings.get_int(settings_pack::network_threads); int num_pools = num_threads > 0 ? num_threads : 1; while (num_pools > m_net_thread_pool.size()) diff --git a/src/storage.cpp b/src/storage.cpp index 81e98e622..24c8f653f 100644 --- a/src/storage.cpp +++ b/src/storage.cpp @@ -180,7 +180,7 @@ namespace libtorrent #ifdef TORRENT_DISK_STATS static boost::atomic event_id; - static mutex disk_access_mutex; + static std::mutex disk_access_mutex; // this is opened and closed by the disk_io_thread class FILE* g_access_log = NULL; @@ -210,7 +210,7 @@ namespace libtorrent detail::write_uint32(fileid, ptr); detail::write_uint8(flags, ptr); - mutex::scoped_lock l(disk_access_mutex); + std::unique_lock l(disk_access_mutex); int ret = fwrite(event, 1, sizeof(event), g_access_log); l.unlock(); if (ret != sizeof(event)) @@ -1513,7 +1513,7 @@ namespace libtorrent int disk_job_fence::job_complete(disk_io_job* j, tailqueue& jobs) { - mutex::scoped_lock l(m_mutex); + std::lock_guard l(m_mutex); TORRENT_ASSERT(j->flags & disk_io_job::in_progress); j->flags &= ~disk_io_job::in_progress; @@ -1604,7 +1604,7 @@ namespace libtorrent bool disk_job_fence::is_blocked(disk_io_job* j) { - mutex::scoped_lock l(m_mutex); + std::lock_guard l(m_mutex); DLOG(stderr, "[%p] is_blocked: fence: %d num_outstanding: %d\n" , static_cast(this), m_has_fence, int(m_outstanding_jobs)); @@ -1631,13 +1631,13 @@ namespace libtorrent bool disk_job_fence::has_fence() const { - mutex::scoped_lock l(m_mutex); + std::lock_guard l(m_mutex); return m_has_fence != 0; } int disk_job_fence::num_blocked() const { - mutex::scoped_lock l(m_mutex); + std::lock_guard l(m_mutex); return m_blocked_jobs.size(); } @@ -1650,7 +1650,7 @@ namespace libtorrent TORRENT_ASSERT((j->flags & disk_io_job::fence) == 0); j->flags |= disk_io_job::fence; - mutex::scoped_lock l(m_mutex); + std::lock_guard l(m_mutex); DLOG(stderr, "[%p] raise_fence: fence: %d num_outstanding: %d\n" , static_cast(this), m_has_fence, int(m_outstanding_jobs)); diff --git a/src/thread.cpp b/src/thread.cpp index 3dc2726b7..20d3cf412 100644 --- a/src/thread.cpp +++ b/src/thread.cpp @@ -30,7 +30,6 @@ POSSIBILITY OF SUCH DAMAGE. */ -#include "libtorrent/thread.hpp" #include "libtorrent/assert.hpp" #ifdef TORRENT_BEOS @@ -60,26 +59,26 @@ namespace libtorrent #ifdef BOOST_HAS_PTHREADS - condition_variable::condition_variable() + std::condition_variable::condition_variable() { pthread_cond_init(&m_cond, 0); } - condition_variable::~condition_variable() + std::condition_variable::~condition_variable() { pthread_cond_destroy(&m_cond); } - void condition_variable::wait(mutex::scoped_lock& l) + void std::condition_variable::wait(std::unique_lock& l) { - TORRENT_ASSERT(l.locked()); + TORRENT_ASSERT(l.owns_lock()); // wow, this is quite a hack pthread_cond_wait(&m_cond, reinterpret_cast(&l.mutex())); } - void condition_variable::wait_for(mutex::scoped_lock& l, time_duration rel_time) + void std::condition_variable::wait_for(std::unique_lock& l, time_duration rel_time) { - TORRENT_ASSERT(l.locked()); + TORRENT_ASSERT(l.owns_lock()); struct timeval tv; struct timespec ts; @@ -92,17 +91,17 @@ namespace libtorrent pthread_cond_timedwait(&m_cond, reinterpret_cast(&l.mutex()), &ts); } - void condition_variable::notify_all() + void std::condition_variable::notify_all() { pthread_cond_broadcast(&m_cond); } - void condition_variable::notify() + void std::condition_variable::notify() { pthread_cond_signal(&m_cond); } #elif defined TORRENT_WINDOWS || defined TORRENT_CYGWIN - condition_variable::condition_variable() + std::condition_variable::condition_variable() : m_num_waiters(0) { #if _WIN32_WINNT == 0x0501 @@ -112,14 +111,14 @@ namespace libtorrent #endif } - condition_variable::~condition_variable() + std::condition_variable::~condition_variable() { CloseHandle(m_sem); } - void condition_variable::wait(mutex::scoped_lock& l) + void std::condition_variable::wait(std::unique_lock& l) { - TORRENT_ASSERT(l.locked()); + TORRENT_ASSERT(l.owns_lock()); ++m_num_waiters; l.unlock(); WaitForSingleObjectEx(m_sem, INFINITE, FALSE); @@ -127,9 +126,9 @@ namespace libtorrent --m_num_waiters; } - void condition_variable::wait_for(mutex::scoped_lock& l, time_duration rel_time) + void std::condition_variable::wait_for(std::unique_lock& l, time_duration rel_time) { - TORRENT_ASSERT(l.locked()); + TORRENT_ASSERT(l.owns_lock()); ++m_num_waiters; l.unlock(); WaitForSingleObjectEx(m_sem, total_milliseconds(rel_time), FALSE); @@ -137,30 +136,30 @@ namespace libtorrent --m_num_waiters; } - void condition_variable::notify_all() + void std::condition_variable::notify_all() { ReleaseSemaphore(m_sem, m_num_waiters, 0); } - void condition_variable::notify() + void std::condition_variable::notify() { ReleaseSemaphore(m_sem, (std::min)(m_num_waiters, 1), 0); } #elif defined TORRENT_BEOS - condition_variable::condition_variable() + std::condition_variable::condition_variable() : m_num_waiters(0) { m_sem = create_sem(0, 0); } - condition_variable::~condition_variable() + std::condition_variable::~condition_variable() { delete_sem(m_sem); } - void condition_variable::wait(mutex::scoped_lock& l) + void std::condition_variable::wait(std::unique_lock& l) { - TORRENT_ASSERT(l.locked()); + TORRENT_ASSERT(l.owns_lock()); ++m_num_waiters; l.unlock(); acquire_sem(m_sem); @@ -168,9 +167,9 @@ namespace libtorrent --m_num_waiters; } - void condition_variable::wait_for(mutex::scoped_lock& l, time_duration rel_time) + void std::condition_variable::wait_for(std::unique_lock& l, time_duration rel_time) { - TORRENT_ASSERT(l.locked()); + TORRENT_ASSERT(l.owns_lock()); ++m_num_waiters; l.unlock(); acquire_sem_etc(m_sem, 1, B_RELATIVE_TIMEOUT, total_microseconds(rel_time)); @@ -178,12 +177,12 @@ namespace libtorrent --m_num_waiters; } - void condition_variable::notify_all() + void std::condition_variable::notify_all() { release_sem_etc(m_sem, m_num_waiters, 0); } - void condition_variable::notify() + void std::condition_variable::notify() { release_sem_etc(m_sem, (std::min)(m_num_waiters, 1), 0); } diff --git a/src/torrent_handle.cpp b/src/torrent_handle.cpp index 9e7ae2fda..279393f43 100644 --- a/src/torrent_handle.cpp +++ b/src/torrent_handle.cpp @@ -56,7 +56,6 @@ POSSIBILITY OF SUCH DAMAGE. #include "libtorrent/aux_/session_call.hpp" #include "libtorrent/invariant_check.hpp" #include "libtorrent/utf8.hpp" -#include "libtorrent/thread.hpp" #include "libtorrent/announce_entry.hpp" #if TORRENT_COMPLETE_TYPES_REQUIRED @@ -653,11 +652,11 @@ namespace libtorrent { static boost::shared_ptr holder[4]; static int cursor = 0; - static mutex holder_mutex; + static std::mutex holder_mutex; boost::shared_ptr r = torrent_file(); - mutex::scoped_lock l(holder_mutex); + std::lock_guard l(holder_mutex); holder[cursor++] = r; cursor = cursor % (sizeof(holder) / sizeof(holder[0])); return *r; diff --git a/src/tracker_manager.cpp b/src/tracker_manager.cpp index 0049efc8c..9871c9799 100644 --- a/src/tracker_manager.cpp +++ b/src/tracker_manager.cpp @@ -235,7 +235,7 @@ namespace libtorrent void tracker_manager::remove_request(tracker_connection const* c) { - mutex::scoped_lock l(m_mutex); + std::lock_guard l(m_mutex); http_conns_t::iterator i = std::find_if(m_http_conns.begin() , m_http_conns.end() @@ -270,7 +270,7 @@ namespace libtorrent , tracker_request req , boost::weak_ptr c) { - mutex::scoped_lock l(m_mutex); + std::lock_guard l(m_mutex); TORRENT_ASSERT(req.num_want >= 0); TORRENT_ASSERT(!m_abort || req.event == tracker_request::stopped); if (m_abort && req.event != tracker_request::stopped) return; @@ -405,7 +405,7 @@ namespace libtorrent void tracker_manager::abort_all_requests(bool all) { // removes all connections except 'event=stopped'-requests - mutex::scoped_lock l(m_mutex); + std::unique_lock l(m_mutex); m_abort = true; http_conns_t close_http_connections; @@ -459,13 +459,13 @@ namespace libtorrent bool tracker_manager::empty() const { - mutex::scoped_lock l(m_mutex); + std::lock_guard l(m_mutex); return m_http_conns.empty() && m_udp_conns.empty(); } int tracker_manager::num_requests() const { - mutex::scoped_lock l(m_mutex); + std::lock_guard l(m_mutex); return m_http_conns.size() + m_udp_conns.size(); } } diff --git a/src/udp_tracker_connection.cpp b/src/udp_tracker_connection.cpp index 9c1abfaab..9c4a38474 100644 --- a/src/udp_tracker_connection.cpp +++ b/src/udp_tracker_connection.cpp @@ -64,7 +64,7 @@ namespace libtorrent std::map udp_tracker_connection::m_connection_cache; - mutex udp_tracker_connection::m_cache_mutex; + std::mutex udp_tracker_connection::m_cache_mutex; udp_tracker_connection::udp_tracker_connection( io_service& ios @@ -277,7 +277,7 @@ namespace libtorrent void udp_tracker_connection::start_announce() { - mutex::scoped_lock l(m_cache_mutex); + std::unique_lock l(m_cache_mutex); std::map::iterator cc = m_connection_cache.find(m_target.address()); if (cc != m_connection_cache.end()) @@ -463,7 +463,7 @@ namespace libtorrent update_transaction_id(); boost::uint64_t const connection_id = read_int64(buf); - mutex::scoped_lock l(m_cache_mutex); + std::lock_guard l(m_cache_mutex); connection_cache_entry& cce = m_connection_cache[m_target.address()]; cce.connection_id = connection_id; cce.expires = aux::time_now() + seconds(m_man.settings().get_int(settings_pack::udp_tracker_token_expiry)); diff --git a/src/upnp.cpp b/src/upnp.cpp index 2b5fb2e1e..847fa5848 100644 --- a/src/upnp.cpp +++ b/src/upnp.cpp @@ -107,21 +107,21 @@ upnp::~upnp() void upnp::discover_device() { - mutex::scoped_lock l(m_mutex); + std::unique_lock l(m_mutex); if (m_socket.num_send_sockets() == 0) log("No network interfaces to broadcast to", l); discover_device_impl(l); } -void upnp::log(char const* msg, mutex::scoped_lock& l) +void upnp::log(char const* msg, std::unique_lock& l) { l.unlock(); m_log_callback(msg); l.lock(); } -void upnp::discover_device_impl(mutex::scoped_lock& l) +void upnp::discover_device_impl(std::unique_lock& l) { const char msearch[] = "M-SEARCH * HTTP/1.1\r\n" @@ -163,7 +163,7 @@ int upnp::add_mapping(upnp::protocol_type p, int external_port, int local_port) // external port 0 means _every_ port TORRENT_ASSERT(external_port != 0); - mutex::scoped_lock l(m_mutex); + std::unique_lock l(m_mutex); char msg[500]; snprintf(msg, sizeof(msg), "adding port map: [ protocol: %s ext_port: %u " @@ -211,7 +211,7 @@ int upnp::add_mapping(upnp::protocol_type p, int external_port, int local_port) void upnp::delete_mapping(int mapping) { - mutex::scoped_lock l(m_mutex); + std::unique_lock l(m_mutex); if (mapping >= int(m_mappings.size())) return; @@ -257,7 +257,7 @@ void upnp::resend_request(error_code const& ec) boost::shared_ptr me(self()); - mutex::scoped_lock l(m_mutex); + std::unique_lock l(m_mutex); if (m_closing) return; @@ -312,7 +312,7 @@ void upnp::on_reply(udp::endpoint const& from, char* buffer { boost::shared_ptr me(self()); - mutex::scoped_lock l(m_mutex); + std::unique_lock l(m_mutex); using namespace libtorrent::detail; @@ -557,11 +557,11 @@ void upnp::map_timer(error_code const& ec) if (ec) return; if (m_closing) return; - mutex::scoped_lock l(m_mutex); + std::unique_lock l(m_mutex); try_map_upnp(l, true); } -void upnp::try_map_upnp(mutex::scoped_lock& l, bool timer) +void upnp::try_map_upnp(std::unique_lock& l, bool timer) { if (m_devices.empty()) return; @@ -627,7 +627,7 @@ void upnp::try_map_upnp(mutex::scoped_lock& l, bool timer) } void upnp::post(upnp::rootdevice const& d, char const* soap - , char const* soap_action, mutex::scoped_lock& l) + , char const* soap_action, std::unique_lock& l) { TORRENT_ASSERT(d.magic == 1337); TORRENT_ASSERT(d.upnp_connection); @@ -652,7 +652,7 @@ void upnp::post(upnp::rootdevice const& d, char const* soap void upnp::create_port_mapping(http_connection& c, rootdevice& d, int i) { - mutex::scoped_lock l(m_mutex); + std::unique_lock l(m_mutex); TORRENT_ASSERT(d.magic == 1337); @@ -694,7 +694,7 @@ void upnp::create_port_mapping(http_connection& c, rootdevice& d, int i) post(d, soap, soap_action, l); } -void upnp::next(rootdevice& d, int i, mutex::scoped_lock& l) +void upnp::next(rootdevice& d, int i, std::unique_lock& l) { if (i < num_mappings() - 1) { @@ -711,7 +711,7 @@ void upnp::next(rootdevice& d, int i, mutex::scoped_lock& l) } } -void upnp::update_map(rootdevice& d, int i, mutex::scoped_lock& l) +void upnp::update_map(rootdevice& d, int i, std::unique_lock& l) { TORRENT_ASSERT(d.magic == 1337); TORRENT_ASSERT(i < int(d.mapping.size())); @@ -777,7 +777,7 @@ void upnp::update_map(rootdevice& d, int i, mutex::scoped_lock& l) void upnp::delete_port_mapping(rootdevice& d, int i) { - mutex::scoped_lock l(m_mutex); + std::unique_lock l(m_mutex); TORRENT_ASSERT(d.magic == 1337); @@ -880,7 +880,7 @@ void upnp::on_upnp_xml(error_code const& e { boost::shared_ptr me(self()); - mutex::scoped_lock l(m_mutex); + std::unique_lock l(m_mutex); TORRENT_ASSERT(d.magic == 1337); if (d.upnp_connection && d.upnp_connection.get() == &c) @@ -993,7 +993,7 @@ void upnp::on_upnp_xml(error_code const& e void upnp::get_ip_address(rootdevice& d) { - mutex::scoped_lock l(m_mutex); + std::unique_lock l(m_mutex); TORRENT_ASSERT(d.magic == 1337); @@ -1021,7 +1021,7 @@ void upnp::get_ip_address(rootdevice& d) post(d, soap, soap_action, l); } -void upnp::disable(error_code const& ec, mutex::scoped_lock& l) +void upnp::disable(error_code const& ec, std::unique_lock& l) { m_disabled = true; @@ -1163,7 +1163,7 @@ void upnp::on_upnp_get_ip_address_response(error_code const& e { boost::shared_ptr me(self()); - mutex::scoped_lock l(m_mutex); + std::unique_lock l(m_mutex); TORRENT_ASSERT(d.magic == 1337); if (d.upnp_connection && d.upnp_connection.get() == &c) @@ -1246,7 +1246,7 @@ void upnp::on_upnp_map_response(error_code const& e { boost::shared_ptr me(self()); - mutex::scoped_lock l(m_mutex); + std::unique_lock l(m_mutex); TORRENT_ASSERT(d.magic == 1337); if (d.upnp_connection && d.upnp_connection.get() == &c) @@ -1388,7 +1388,7 @@ void upnp::on_upnp_map_response(error_code const& e next(d, mapping, l); } -void upnp::return_error(int mapping, int code, mutex::scoped_lock& l) +void upnp::return_error(int mapping, int code, std::unique_lock& l) { int num_errors = sizeof(error_codes) / sizeof(error_codes[0]); error_code_t* end = error_codes + num_errors; @@ -1414,7 +1414,7 @@ void upnp::on_upnp_unmap_response(error_code const& e { boost::shared_ptr me(self()); - mutex::scoped_lock l(m_mutex); + std::unique_lock l(m_mutex); TORRENT_ASSERT(d.magic == 1337); if (d.upnp_connection && d.upnp_connection.get() == &c) @@ -1478,7 +1478,7 @@ void upnp::on_expire(error_code const& ec) time_point now = aux::time_now(); time_point next_expire = max_time(); - mutex::scoped_lock l(m_mutex); + std::unique_lock l(m_mutex); for (std::set::iterator i = m_devices.begin() , end(m_devices.end()); i != end; ++i) @@ -1512,7 +1512,7 @@ void upnp::on_expire(error_code const& ec) void upnp::close() { - mutex::scoped_lock l(m_mutex); + std::unique_lock l(m_mutex); error_code ec; m_refresh_timer.cancel(ec); diff --git a/src/utp_stream.cpp b/src/utp_stream.cpp index bf07d9549..42e3b88f2 100644 --- a/src/utp_stream.cpp +++ b/src/utp_stream.cpp @@ -63,7 +63,7 @@ char const* socket_state_names[] = { "NONE", "SYN_SENT", "CONNECTED", "FIN_SENT" static struct utp_logger { FILE* utp_log_file; - mutex utp_log_mutex; + std::mutex utp_log_mutex; utp_logger() : utp_log_file(NULL) {} ~utp_logger() @@ -77,7 +77,7 @@ void utp_log(char const* fmt, ...) { if (log_file_holder.utp_log_file == NULL) return; - mutex::scoped_lock lock(log_file_holder.utp_log_mutex); + std::lock_guard lock(log_file_holder.utp_log_mutex); static time_point start = clock_type::now(); fprintf(log_file_holder.utp_log_file, "[%012" PRId64 "] ", total_microseconds(clock_type::now() - start)); va_list l; diff --git a/test/dht_server.cpp b/test/dht_server.cpp index 84b8a3459..f30fb98cc 100644 --- a/test/dht_server.cpp +++ b/test/dht_server.cpp @@ -30,7 +30,6 @@ POSSIBILITY OF SUCH DAMAGE. */ -#include "libtorrent/thread.hpp" #include "libtorrent/bencode.hpp" #include "libtorrent/entry.hpp" #include "libtorrent/address.hpp" @@ -43,12 +42,15 @@ POSSIBILITY OF SUCH DAMAGE. #include #include +#include #include #if defined TORRENT_DEBUG && TORRENT_USE_IOSTREAM #include #endif +#include + using namespace libtorrent; struct dht_server @@ -59,7 +61,7 @@ struct dht_server udp::socket m_socket; int m_port; - boost::shared_ptr m_thread; + boost::shared_ptr m_thread; dht_server() : m_dht_requests(0) @@ -89,7 +91,7 @@ struct dht_server fprintf(stderr, "%s: DHT initialized on port %d\n", time_now_string(), m_port); - m_thread.reset(new libtorrent::thread(boost::bind(&dht_server::thread_fun, this))); + m_thread = boost::make_shared(&dht_server::thread_fun, this); } ~dht_server() diff --git a/test/peer_server.cpp b/test/peer_server.cpp index 8297acfec..477d7fc29 100644 --- a/test/peer_server.cpp +++ b/test/peer_server.cpp @@ -30,7 +30,6 @@ POSSIBILITY OF SUCH DAMAGE. */ -#include "libtorrent/thread.hpp" #include "libtorrent/bencode.hpp" #include "libtorrent/entry.hpp" #include "libtorrent/address.hpp" @@ -44,8 +43,12 @@ POSSIBILITY OF SUCH DAMAGE. #include #include +#include #include +#include +#include + using namespace libtorrent; struct peer_server @@ -56,7 +59,7 @@ struct peer_server tcp::acceptor m_acceptor; int m_port; - boost::shared_ptr m_thread; + std::shared_ptr m_thread; peer_server() : m_peer_requests(0) @@ -92,7 +95,7 @@ struct peer_server fprintf(stderr, "%s: PEER peer initialized on port %d\n", time_now_string(), m_port); - m_thread.reset(new libtorrent::thread(boost::bind(&peer_server::thread_fun, this))); + m_thread = std::make_shared(&peer_server::thread_fun, this); } ~peer_server() @@ -119,7 +122,7 @@ struct peer_server error_code ec; tcp::endpoint from; tcp::socket socket(m_ios); - condition_variable cond; + std::condition_variable cond; bool done = false; m_acceptor.async_accept(socket, from, boost::bind(&new_connection, _1, &ec, &done)); while (!done) diff --git a/test/setup_transfer.cpp b/test/setup_transfer.cpp index 6d9d89e8c..710a56656 100644 --- a/test/setup_transfer.cpp +++ b/test/setup_transfer.cpp @@ -37,7 +37,6 @@ POSSIBILITY OF SUCH DAMAGE. #include "libtorrent/session.hpp" #include "libtorrent/hasher.hpp" #include "libtorrent/http_parser.hpp" -#include "libtorrent/thread.hpp" #include "libtorrent/assert.hpp" #include "libtorrent/alert_types.hpp" #include "libtorrent/create_torrent.hpp" @@ -46,7 +45,6 @@ POSSIBILITY OF SUCH DAMAGE. #include "libtorrent/instantiate_connection.hpp" #include "libtorrent/ip_filter.hpp" #include "libtorrent/session_stats.hpp" -#include "libtorrent/thread.hpp" #include "libtorrent/random.hpp" #include "libtorrent/torrent_info.hpp" #include "libtorrent/broadcast_socket.hpp" // for supports_ipv6() diff --git a/test/swarm_suite.cpp b/test/swarm_suite.cpp index 2e89fd7ca..81701d499 100644 --- a/test/swarm_suite.cpp +++ b/test/swarm_suite.cpp @@ -34,7 +34,6 @@ POSSIBILITY OF SUCH DAMAGE. #include "libtorrent/session_settings.hpp" #include "libtorrent/hasher.hpp" #include "libtorrent/alert_types.hpp" -#include "libtorrent/thread.hpp" #include "libtorrent/time.hpp" #include "libtorrent/random.hpp" #include diff --git a/test/test_alert_manager.cpp b/test/test_alert_manager.cpp index 0fcb3b0ff..4fffba867 100644 --- a/test/test_alert_manager.cpp +++ b/test/test_alert_manager.cpp @@ -35,13 +35,14 @@ POSSIBILITY OF SUCH DAMAGE. #include "libtorrent/torrent_handle.hpp" #include "libtorrent/alert_types.hpp" #include "libtorrent/extensions.hpp" -#include "libtorrent/thread.hpp" #include "setup_transfer.hpp" #include #include #include +#include + using namespace libtorrent; TORRENT_TEST(limit) @@ -258,7 +259,7 @@ TORRENT_TEST(wait_for_alert) mgr.get_all(alerts); start = clock_type::now(); - libtorrent::thread posting_thread(boost::bind(&post_torrent_added, &mgr)); + std::thread posting_thread(&post_torrent_added, &mgr); a = mgr.wait_for_alert(seconds(10)); end = clock_type::now(); diff --git a/test/test_auto_unchoke.cpp b/test/test_auto_unchoke.cpp index 9e731875d..d852704b9 100644 --- a/test/test_auto_unchoke.cpp +++ b/test/test_auto_unchoke.cpp @@ -35,7 +35,6 @@ POSSIBILITY OF SUCH DAMAGE. #include "libtorrent/hasher.hpp" #include "libtorrent/alert_types.hpp" #include "libtorrent/ip_filter.hpp" -#include "libtorrent/thread.hpp" #include #include diff --git a/test/test_lsd.cpp b/test/test_lsd.cpp index 09d106c8c..752e13d52 100644 --- a/test/test_lsd.cpp +++ b/test/test_lsd.cpp @@ -34,7 +34,6 @@ POSSIBILITY OF SUCH DAMAGE. #include "libtorrent/session_settings.hpp" #include "libtorrent/torrent_status.hpp" #include "libtorrent/hasher.hpp" -#include "libtorrent/thread.hpp" #include #include "test.hpp" diff --git a/test/test_pex.cpp b/test/test_pex.cpp index 2b305f926..8d7adeeca 100644 --- a/test/test_pex.cpp +++ b/test/test_pex.cpp @@ -38,7 +38,6 @@ POSSIBILITY OF SUCH DAMAGE. #include "libtorrent/session_settings.hpp" #include "libtorrent/hasher.hpp" #include "libtorrent/extensions/ut_pex.hpp" -#include "libtorrent/thread.hpp" #include "libtorrent/ip_filter.hpp" #include "libtorrent/torrent_status.hpp" #include diff --git a/test/test_priority.cpp b/test/test_priority.cpp index dc4685202..45c2482ef 100644 --- a/test/test_priority.cpp +++ b/test/test_priority.cpp @@ -35,7 +35,6 @@ POSSIBILITY OF SUCH DAMAGE. #include "libtorrent/hasher.hpp" #include "libtorrent/alert_types.hpp" #include "libtorrent/bencode.hpp" -#include "libtorrent/thread.hpp" #include "libtorrent/time.hpp" #include "libtorrent/file.hpp" #include "libtorrent/torrent_info.hpp" diff --git a/test/test_recheck.cpp b/test/test_recheck.cpp index 4b290e7ee..a59653958 100644 --- a/test/test_recheck.cpp +++ b/test/test_recheck.cpp @@ -35,7 +35,6 @@ POSSIBILITY OF SUCH DAMAGE. #include "libtorrent/hasher.hpp" #include "libtorrent/alert_types.hpp" #include "libtorrent/bencode.hpp" -#include "libtorrent/thread.hpp" #include "libtorrent/time.hpp" #include "libtorrent/file.hpp" #include "libtorrent/error_code.hpp" diff --git a/test/test_ssl.cpp b/test/test_ssl.cpp index 8edc41a25..d88cb8f1e 100644 --- a/test/test_ssl.cpp +++ b/test/test_ssl.cpp @@ -32,7 +32,6 @@ POSSIBILITY OF SUCH DAMAGE. #include "libtorrent/session.hpp" #include "libtorrent/alert_types.hpp" -#include "libtorrent/thread.hpp" #include "libtorrent/file.hpp" #include "libtorrent/session_status.hpp" #include "libtorrent/torrent_info.hpp" diff --git a/test/test_storage.cpp b/test/test_storage.cpp index 4270400ca..0295ca15d 100644 --- a/test/test_storage.cpp +++ b/test/test_storage.cpp @@ -42,7 +42,6 @@ POSSIBILITY OF SUCH DAMAGE. #include "libtorrent/alert_types.hpp" #include "libtorrent/aux_/session_impl.hpp" #include "libtorrent/create_torrent.hpp" -#include "libtorrent/thread.hpp" #include "libtorrent/torrent_info.hpp" #include "libtorrent/read_resume_data.hpp" @@ -466,7 +465,7 @@ void test_check_files(std::string const& test_path boost::shared_ptr dummy; boost::shared_ptr pm = boost::make_shared(new default_storage(p), dummy, &fs); - libtorrent::mutex lock; + std::mutex lock; bool done = false; add_torrent_params frd; diff --git a/test/test_threads.cpp b/test/test_threads.cpp index 55b60109e..22fe079f4 100644 --- a/test/test_threads.cpp +++ b/test/test_threads.cpp @@ -38,24 +38,23 @@ POSSIBILITY OF SUCH DAMAGE. #include "libtorrent/aux_/disable_warnings_pop.hpp" -#include "libtorrent/thread.hpp" #include "test.hpp" #include "setup_transfer.hpp" // for test_sleep using namespace libtorrent; -void fun(condition_variable* s, libtorrent::mutex* m, int* waiting, int i) +void fun(std::condition_variable* s, std::mutex* m, int* waiting, int i) { fprintf(stderr, "thread %d waiting\n", i); - libtorrent::mutex::scoped_lock l(*m); + std::unique_lock l(*m); *waiting += 1; s->wait(l); fprintf(stderr, "thread %d done\n", i); } -void increment(condition_variable* s, libtorrent::mutex* m, int* waiting, boost::atomic* c) +void increment(std::condition_variable* s, std::mutex* m, int* waiting, boost::atomic* c) { - libtorrent::mutex::scoped_lock l(*m); + std::unique_lock l(*m); *waiting += 1; s->wait(l); l.unlock(); @@ -63,9 +62,9 @@ void increment(condition_variable* s, libtorrent::mutex* m, int* waiting, boost: ++*c; } -void decrement(condition_variable* s, libtorrent::mutex* m, int* waiting, boost::atomic* c) +void decrement(std::condition_variable* s, std::mutex* m, int* waiting, boost::atomic* c) { - libtorrent::mutex::scoped_lock l(*m); + std::unique_lock l(*m); *waiting += 1; s->wait(l); l.unlock(); @@ -75,17 +74,17 @@ void decrement(condition_variable* s, libtorrent::mutex* m, int* waiting, boost: TORRENT_TEST(threads) { - condition_variable cond; - libtorrent::mutex m; - std::list threads; + std::condition_variable cond; + std::mutex m; + std::vector threads; int waiting = 0; for (int i = 0; i < 20; ++i) { - threads.push_back(new libtorrent::thread(boost::bind(&fun, &cond, &m, &waiting, i))); + threads.emplace_back(&fun, &cond, &m, &waiting, i); } // make sure all threads are waiting on the condition_variable - libtorrent::mutex::scoped_lock l(m); + std::unique_lock l(m); while (waiting < 20) { l.unlock(); @@ -96,19 +95,15 @@ TORRENT_TEST(threads) cond.notify_all(); l.unlock(); - for (std::list::iterator i = threads.begin(); i != threads.end(); ++i) - { - (*i)->join(); - delete *i; - } + for (auto& t : threads) t.join(); threads.clear(); waiting = 0; boost::atomic c(0); for (int i = 0; i < 3; ++i) { - threads.push_back(new libtorrent::thread(boost::bind(&increment, &cond, &m, &waiting, &c))); - threads.push_back(new libtorrent::thread(boost::bind(&decrement, &cond, &m, &waiting, &c))); + threads.emplace_back(&increment, &cond, &m, &waiting, &c); + threads.emplace_back(&decrement, &cond, &m, &waiting, &c); } // make sure all threads are waiting on the condition_variable @@ -123,11 +118,7 @@ TORRENT_TEST(threads) cond.notify_all(); l.unlock(); - for (std::list::iterator i = threads.begin(); i != threads.end(); ++i) - { - (*i)->join(); - delete *i; - } + for (auto& t : threads) t.join(); TEST_CHECK(c == 0); } diff --git a/test/test_time.cpp b/test/test_time.cpp index f8ddd30da..2986545c7 100644 --- a/test/test_time.cpp +++ b/test/test_time.cpp @@ -34,21 +34,21 @@ POSSIBILITY OF SUCH DAMAGE. #include "setup_transfer.hpp" // for test_sleep #include "libtorrent/time.hpp" -#include "libtorrent/thread.hpp" #include +#include using namespace libtorrent; -void check_timer_loop(mutex& m, time_point& last, condition_variable& cv) +void check_timer_loop(std::mutex& m, time_point& last, std::condition_variable& cv) { - mutex::scoped_lock l(m); + std::unique_lock l(m); cv.wait(l); l.unlock(); for (int i = 0; i < 10000; ++i) { - mutex::scoped_lock l(m); + std::lock_guard l(m); time_point now = clock_type::now(); TEST_CHECK(now >= last); last = now; @@ -80,13 +80,13 @@ TORRENT_TEST(time) TEST_CHECK(now >= last); last = now; } - - mutex m; - condition_variable cv; - libtorrent::thread t1(boost::bind(&check_timer_loop, boost::ref(m), boost::ref(last), boost::ref(cv))); - libtorrent::thread t2(boost::bind(&check_timer_loop, boost::ref(m), boost::ref(last), boost::ref(cv))); - libtorrent::thread t3(boost::bind(&check_timer_loop, boost::ref(m), boost::ref(last), boost::ref(cv))); - libtorrent::thread t4(boost::bind(&check_timer_loop, boost::ref(m), boost::ref(last), boost::ref(cv))); + + std::mutex m; + std::condition_variable cv; + std::thread t1(&check_timer_loop, boost::ref(m), boost::ref(last), boost::ref(cv)); + std::thread t2(&check_timer_loop, boost::ref(m), boost::ref(last), boost::ref(cv)); + std::thread t3(&check_timer_loop, boost::ref(m), boost::ref(last), boost::ref(cv)); + std::thread t4(&check_timer_loop, boost::ref(m), boost::ref(last), boost::ref(cv)); test_sleep(100); diff --git a/test/test_torrent.cpp b/test/test_torrent.cpp index 9d6b4379a..26ed23807 100644 --- a/test/test_torrent.cpp +++ b/test/test_torrent.cpp @@ -36,7 +36,6 @@ POSSIBILITY OF SUCH DAMAGE. #include "libtorrent/hasher.hpp" #include "libtorrent/create_torrent.hpp" #include "libtorrent/alert_types.hpp" -#include "libtorrent/thread.hpp" #include "libtorrent/torrent.hpp" #include #include diff --git a/test/test_transfer.cpp b/test/test_transfer.cpp index 50360a583..b629ee744 100644 --- a/test/test_transfer.cpp +++ b/test/test_transfer.cpp @@ -35,7 +35,6 @@ POSSIBILITY OF SUCH DAMAGE. #include "libtorrent/hasher.hpp" #include "libtorrent/alert_types.hpp" #include "libtorrent/bencode.hpp" -#include "libtorrent/thread.hpp" #include "libtorrent/time.hpp" #include "libtorrent/file.hpp" #include "libtorrent/torrent_info.hpp" @@ -83,7 +82,7 @@ struct test_storage : default_storage void set_limit(int lim) { - mutex::scoped_lock l(m_mutex); + std::lock_guard l(m_mutex); m_limit = lim; } @@ -95,7 +94,7 @@ struct test_storage : default_storage , int flags , storage_error& se) { - mutex::scoped_lock l(m_mutex); + std::unique_lock l(m_mutex); if (m_written >= m_limit) { std::cerr << "storage written: " << m_written << " limit: " << m_limit << std::endl; @@ -115,7 +114,7 @@ struct test_storage : default_storage int m_written; int m_limit; - mutex m_mutex; + std::mutex m_mutex; }; storage_interface* test_storage_constructor(storage_params const& params) diff --git a/test/test_utp.cpp b/test/test_utp.cpp index 767e1a177..f5c39dbbc 100644 --- a/test/test_utp.cpp +++ b/test/test_utp.cpp @@ -35,7 +35,6 @@ POSSIBILITY OF SUCH DAMAGE. #include "libtorrent/hasher.hpp" #include "libtorrent/alert_types.hpp" #include "libtorrent/bencode.hpp" -#include "libtorrent/thread.hpp" #include "libtorrent/time.hpp" #include "libtorrent/file.hpp" #include diff --git a/test/udp_tracker.cpp b/test/udp_tracker.cpp index 2ca947756..171eeb763 100644 --- a/test/udp_tracker.cpp +++ b/test/udp_tracker.cpp @@ -30,7 +30,6 @@ POSSIBILITY OF SUCH DAMAGE. */ -#include "libtorrent/thread.hpp" #include "libtorrent/bencode.hpp" #include "libtorrent/entry.hpp" #include "libtorrent/address.hpp" @@ -45,12 +44,15 @@ POSSIBILITY OF SUCH DAMAGE. #include #include +#include #include #if defined TORRENT_DEBUG && TORRENT_USE_IOSTREAM #include #endif +#include + using namespace libtorrent; struct udp_tracker @@ -62,7 +64,7 @@ struct udp_tracker int m_port; bool m_abort; - boost::shared_ptr m_thread; + boost::shared_ptr m_thread; void on_udp_receive(error_code const& ec, size_t bytes_transferred, udp::endpoint* from, char* buffer, int size) { @@ -171,7 +173,7 @@ struct udp_tracker fprintf(stderr, "%s: UDP tracker initialized on port %d\n", time_now_string(), m_port); - m_thread.reset(new libtorrent::thread(boost::bind(&udp_tracker::thread_fun, this))); + m_thread = boost::make_shared(&udp_tracker::thread_fun, this); } void stop() diff --git a/test/web_seed_suite.cpp b/test/web_seed_suite.cpp index 393f19946..864ae713b 100644 --- a/test/web_seed_suite.cpp +++ b/test/web_seed_suite.cpp @@ -37,7 +37,6 @@ POSSIBILITY OF SUCH DAMAGE. #include "libtorrent/storage.hpp" #include "libtorrent/bencode.hpp" #include "libtorrent/create_torrent.hpp" -#include "libtorrent/thread.hpp" #include "libtorrent/alert_types.hpp" #include "libtorrent/torrent_info.hpp" #include "libtorrent/announce_entry.hpp"