diff --git a/ChangeLog b/ChangeLog index 4cfe1fd96..5c71ae0f6 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,5 @@ + * deprecate time functions, expose typedefs of boost::chrono in the libtorrent + namespace instead * deprecate file_base feature in file_storage/torrent_info * improve piece picker support for reverse picking (used for snubbed peers) to not cause priority inversion for regular peers diff --git a/docs/gen_reference_doc.py b/docs/gen_reference_doc.py index 3a1ee9eee..036c7be97 100644 --- a/docs/gen_reference_doc.py +++ b/docs/gen_reference_doc.py @@ -84,7 +84,6 @@ category_mapping = { 'lazy_entry.hpp': 'Bencoding', 'entry.hpp': 'Bencoding', 'time.hpp': 'Time', - 'ptime.hpp': 'Time', 'escape_string.hpp': 'String', 'string_util.hpp': 'String', 'utf8.hpp': 'String', diff --git a/examples/client_test.cpp b/examples/client_test.cpp index f26b66ef3..f227099d0 100644 --- a/examples/client_test.cpp +++ b/examples/client_test.cpp @@ -127,7 +127,7 @@ bool sleep_and_input(int* c, int sleep) // sets the terminal to single-character mode // and resets when destructed set_keypress s; - libtorrent::ptime start = libtorrent::time_now_hires(); + libtorrent::time_point start = libtorrent::clock_type::now(); int ret = 0; retry: fd_set set; @@ -142,7 +142,7 @@ retry: } if (errno == EINTR) { - if (total_milliseconds(libtorrent::time_now_hires() - start) < sleep) + if (total_milliseconds(libtorrent::clock_type::now() - start) < sleep) goto retry; return false; } @@ -1188,7 +1188,7 @@ void print_piece(libtorrent::partial_piece_info* pp char const* cache_kind_str[] = {"read", "write", "read-volatile"}; snprintf(str, sizeof(str), " %3d cache age: %-5.1f state: %s%s\n" , cs ? cs->next_to_hash : 0 - , cs ? (total_milliseconds(time_now() - cs->last_use) / 1000.f) : 0.f + , cs ? (total_milliseconds(clock_type::now() - cs->last_use) / 1000.f) : 0.f , cs ? cache_kind_str[cs->kind] : "N/A" , ts && ts->pieces.size() ? (ts->pieces[piece] ? " have" : " dont-have") : ""); out += str; @@ -1296,7 +1296,7 @@ int main(int argc, char* argv[]) std::deque events; - ptime next_dir_scan = time_now(); + time_point next_dir_scan = clock_type::now(); // the string is the filename of the .torrent file, but only if // it was added through the directory monitor. It is used to @@ -2055,7 +2055,7 @@ int main(int argc, char* argv[]) if (print_trackers) { std::vector tr = h.trackers(); - ptime now = time_now(); + time_point now = clock_type::now(); for (std::vector::iterator i = tr.begin() , end(tr.end()); i != end; ++i) { @@ -2263,12 +2263,12 @@ int main(int argc, char* argv[]) fflush(stdout); if (!monitor_dir.empty() - && next_dir_scan < time_now()) + && next_dir_scan < clock_type::now()) { scan_dir(monitor_dir, ses, files, non_files , allocation_mode, save_path, torrent_upload_limit , torrent_download_limit); - next_dir_scan = time_now() + seconds(poll_interval); + next_dir_scan = clock_type::now() + seconds(poll_interval); } } diff --git a/examples/connection_tester.cpp b/examples/connection_tester.cpp index 5c56937ae..506d1add3 100644 --- a/examples/connection_tester.cpp +++ b/examples/connection_tester.cpp @@ -153,7 +153,7 @@ struct peer_conn , blocks_received(0) , blocks_sent(0) , num_pieces(num_pieces) - , start_time(time_now_hires()) + , start_time(clock_type::now()) , churn(churn_) , corrupt(corrupt_) , endpoint(ep) @@ -222,8 +222,8 @@ struct peer_conn int blocks_received; int blocks_sent; int num_pieces; - ptime start_time; - ptime end_time; + time_point start_time; + time_point end_time; int churn; bool corrupt; tcp::endpoint endpoint; @@ -408,7 +408,7 @@ struct peer_conn void close(char const* fmt, error_code const& ec) { - end_time = time_now_hires(); + end_time = clock_type::now(); char tmp[1024]; snprintf(tmp, sizeof(tmp), fmt, ec.message().c_str()); int time = total_milliseconds(end_time - start_time); diff --git a/include/libtorrent/Makefile.am b/include/libtorrent/Makefile.am index 8fc551cae..8b7512983 100644 --- a/include/libtorrent/Makefile.am +++ b/include/libtorrent/Makefile.am @@ -147,13 +147,15 @@ nobase_include_HEADERS = \ web_peer_connection.hpp \ xml_parse.hpp \ \ - $(GEOIP_H) \ - tommath.h \ - tommath_class.h \ - tommath_superclass.h \ + tommath.h \ + tommath_class.h \ + tommath_superclass.h \ \ - aux_/session_impl.hpp \ - aux_/session_settings.hpp\ + aux_/session_call.hpp \ + aux_/session_impl.hpp \ + aux_/session_settings.hpp \ + aux_/session_interface.hpp \ + aux_/time.hpp \ \ extensions/lt_trackers.hpp \ extensions/metadata_transfer.hpp \ diff --git a/include/libtorrent/alert.hpp b/include/libtorrent/alert.hpp index 66ffafd26..7291caa00 100644 --- a/include/libtorrent/alert.hpp +++ b/include/libtorrent/alert.hpp @@ -197,7 +197,7 @@ namespace libtorrent { virtual ~alert(); // a timestamp is automatically created in the constructor - ptime timestamp() const; + time_point timestamp() const; // returns an integer that is unique to this alert type. It can be // compared against a specific alert by querying a static constant called ``alert_type`` @@ -256,7 +256,7 @@ namespace libtorrent { virtual std::auto_ptr clone() const = 0; private: - ptime m_timestamp; + time_point m_timestamp; }; #ifndef BOOST_NO_EXCEPTIONS diff --git a/include/libtorrent/aux_/session_impl.hpp b/include/libtorrent/aux_/session_impl.hpp index 8505b761e..2b7db3941 100644 --- a/include/libtorrent/aux_/session_impl.hpp +++ b/include/libtorrent/aux_/session_impl.hpp @@ -950,18 +950,18 @@ namespace libtorrent void recalculate_unchoke_slots(); void recalculate_optimistic_unchoke_slots(); - ptime m_created; - boost::int64_t session_time() const { return total_seconds(time_now() - m_created); } + time_point m_created; + boost::int64_t session_time() const { return total_seconds(aux::time_now() - m_created); } - ptime m_last_tick; - ptime m_last_second_tick; + time_point m_last_tick; + time_point m_last_second_tick; // the last time we went through the peers // to decide which ones to choke/unchoke - ptime m_last_choke; + time_point m_last_choke; // the time when the next rss feed needs updating - ptime m_next_rss_update; + time_point m_next_rss_update; // update any rss feeds that need updating and // recalculate m_next_rss_update diff --git a/include/libtorrent/aux_/time.hpp b/include/libtorrent/aux_/time.hpp new file mode 100644 index 000000000..f33338fc1 --- /dev/null +++ b/include/libtorrent/aux_/time.hpp @@ -0,0 +1,56 @@ +/* + +Copyright (c) 2015, 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_AUX_TIME_HPP +#define TORRENT_AUX_TIME_HPP + +#include "libtorrent/config.hpp" +#include "libtorrent/time.hpp" +#include +#include + +namespace libtorrent { namespace aux +{ + // TODO: 3 this is only used for debug logging. It should probably not + // be included unconditionally + TORRENT_EXTRA_EXPORT char const* time_now_string(); + + std::string log_time(); + + // returns the current time, as represented by time_point. The + // resolution of this timer is about 100 ms. + time_point const& time_now(); + +} } + +#endif + diff --git a/include/libtorrent/bandwidth_manager.hpp b/include/libtorrent/bandwidth_manager.hpp index 87da4f839..fddab0a45 100644 --- a/include/libtorrent/bandwidth_manager.hpp +++ b/include/libtorrent/bandwidth_manager.hpp @@ -98,7 +98,7 @@ private: #ifdef TORRENT_VERBOSE_BANDWIDTH_LIMIT std::ofstream m_log; - ptime m_start; + time_point m_start; #endif }; diff --git a/include/libtorrent/block_cache.hpp b/include/libtorrent/block_cache.hpp index 409e13bfc..066756023 100644 --- a/include/libtorrent/block_cache.hpp +++ b/include/libtorrent/block_cache.hpp @@ -211,7 +211,7 @@ namespace libtorrent // plus the minimum amount of time the block is guaranteed // to stay in the cache //TODO: make this 32 bits and to count seconds since the block cache was created - ptime expire; + time_point expire; boost::uint64_t piece:22; diff --git a/include/libtorrent/bt_peer_connection.hpp b/include/libtorrent/bt_peer_connection.hpp index 2dc1d3964..d18bd9ffe 100644 --- a/include/libtorrent/bt_peer_connection.hpp +++ b/include/libtorrent/bt_peer_connection.hpp @@ -256,7 +256,7 @@ namespace libtorrent #if TORRENT_USE_INVARIANT_CHECKS void check_invariant() const; - ptime m_last_choke; + time_point m_last_choke; #endif private: diff --git a/include/libtorrent/debug.hpp b/include/libtorrent/debug.hpp index fad26747b..fae14d1e2 100644 --- a/include/libtorrent/debug.hpp +++ b/include/libtorrent/debug.hpp @@ -74,7 +74,7 @@ namespace libtorrent // timestamp -> operation struct wakeup_t { - ptime timestamp; + time_point timestamp; boost::uint64_t context_switches; char const* operation; }; @@ -117,7 +117,7 @@ namespace libtorrent { _wakeups.push_back(wakeup_t()); wakeup_t& w = _wakeups.back(); - w.timestamp = time_now_hires(); + w.timestamp = clock_type::now(); #ifdef __MACH__ task_events_info teinfo; mach_msg_type_number_t t_info_count = TASK_EVENTS_INFO_COUNT; diff --git a/include/libtorrent/disk_io_thread.hpp b/include/libtorrent/disk_io_thread.hpp index f70523abe..d733f26f3 100644 --- a/include/libtorrent/disk_io_thread.hpp +++ b/include/libtorrent/disk_io_thread.hpp @@ -75,7 +75,7 @@ namespace libtorrent // the time when a block was last written to this piece. The older // a piece is, the more likely it is to be flushed to disk. - ptime last_use; + time_point last_use; // The index of the next block that needs to be hashed. // Blocks are hashed as they are downloaded in order to not @@ -520,9 +520,9 @@ namespace libtorrent void* m_userdata; // the last time we expired write blocks from the cache - ptime m_last_cache_expiry; + time_point m_last_cache_expiry; - ptime m_last_file_check; + time_point m_last_file_check; // LRU cache of open files file_pool m_file_pool; @@ -583,7 +583,7 @@ namespace libtorrent tailqueue m_queued_hash_jobs; // used to rate limit disk performance warnings - ptime m_last_disk_aio_performance_warning; + time_point m_last_disk_aio_performance_warning; // function to be posted to the network thread to post // an alert (used for performance warnings) diff --git a/include/libtorrent/file_pool.hpp b/include/libtorrent/file_pool.hpp index 16a9acf98..05f77db9f 100644 --- a/include/libtorrent/file_pool.hpp +++ b/include/libtorrent/file_pool.hpp @@ -38,6 +38,7 @@ POSSIBILITY OF SUCH DAMAGE. #include "libtorrent/time.hpp" #include "libtorrent/thread.hpp" #include "libtorrent/file_storage.hpp" +#include "libtorrent/aux_/time.hpp" namespace libtorrent { @@ -48,7 +49,7 @@ namespace libtorrent int file_index; // a (high precision) timestamp of when the file was last used. - ptime last_use; + time_point last_use; // ``open_mode`` is a bitmask of the file flags this file is currently opened with. These // are the flags used in the ``file::open()`` function. This enum is defined as a member @@ -126,10 +127,10 @@ namespace libtorrent struct lru_file_entry { - lru_file_entry(): key(0), last_use(time_now()), mode(0) {} + lru_file_entry(): key(0), last_use(aux::time_now()), mode(0) {} mutable file_handle file_ptr; void* key; - ptime last_use; + time_point last_use; int mode; }; diff --git a/include/libtorrent/http_connection.hpp b/include/libtorrent/http_connection.hpp index 703e64171..5f5d80ca3 100644 --- a/include/libtorrent/http_connection.hpp +++ b/include/libtorrent/http_connection.hpp @@ -176,8 +176,8 @@ private: // as all the quota was used. deadline_timer m_limiter_timer; - ptime m_last_receive; - ptime m_start_time; + time_point m_last_receive; + time_point m_start_time; // specifies whether or not the connection is // configured to use a proxy diff --git a/include/libtorrent/ip_voter.hpp b/include/libtorrent/ip_voter.hpp index 1508faf2c..f867abb48 100644 --- a/include/libtorrent/ip_voter.hpp +++ b/include/libtorrent/ip_voter.hpp @@ -36,7 +36,7 @@ POSSIBILITY OF SUCH DAMAGE. #include #include "libtorrent/address.hpp" #include "libtorrent/bloom_filter.hpp" -#include "libtorrent/time.hpp" // for ptime +#include "libtorrent/time.hpp" // for time_point namespace libtorrent { @@ -101,7 +101,7 @@ namespace libtorrent // the last time we rotated this ip_voter. i.e. threw // away all the votes and started from scratch, in case // our IP has changed - ptime m_last_rotate; + time_point m_last_rotate; }; // this keeps track of multiple external IPs (for now, just IPv6 and IPv4, but diff --git a/include/libtorrent/kademlia/dht_tracker.hpp b/include/libtorrent/kademlia/dht_tracker.hpp index 568e24eac..91b89a86e 100644 --- a/include/libtorrent/kademlia/dht_tracker.hpp +++ b/include/libtorrent/kademlia/dht_tracker.hpp @@ -146,7 +146,7 @@ namespace libtorrent { namespace dht std::vector m_send_buf; dos_blocker m_blocker; - ptime m_last_new_key; + time_point m_last_new_key; deadline_timer m_timer; deadline_timer m_connection_timer; deadline_timer m_refresh_timer; diff --git a/include/libtorrent/kademlia/dos_blocker.hpp b/include/libtorrent/kademlia/dos_blocker.hpp index c54aa6501..811cb5200 100644 --- a/include/libtorrent/kademlia/dos_blocker.hpp +++ b/include/libtorrent/kademlia/dos_blocker.hpp @@ -50,7 +50,7 @@ namespace libtorrent { namespace dht // called every time we receive an incoming packet. Returns // true if we should let the packet through, and false if // it's blocked - bool incoming(address addr, ptime now); + bool incoming(address addr, time_point now); void set_rate_limit(int l) { @@ -71,7 +71,7 @@ namespace libtorrent { namespace dht { node_ban_entry(): count(0) {} address src; - ptime limit; + time_point limit; int count; }; diff --git a/include/libtorrent/kademlia/node.hpp b/include/libtorrent/kademlia/node.hpp index fe2bfdd6b..de8e6b274 100644 --- a/include/libtorrent/kademlia/node.hpp +++ b/include/libtorrent/kademlia/node.hpp @@ -107,7 +107,7 @@ bool TORRENT_EXTRA_EXPORT verify_message(lazy_entry const* msg, key_desc_t const // to remove stale peers struct peer_entry { - ptime added; + time_point added; tcp::endpoint addr; bool seed; }; @@ -129,7 +129,7 @@ struct dht_immutable_item // popularity if we reach the limit of items to store bloom_filter<128> ips; // the last time we heard about this - ptime last_seen; + time_point last_seen; // number of IPs in the bloom filter int num_announcers; // size of malloced space pointed to by value @@ -322,11 +322,11 @@ private: dht_immutable_table_t m_immutable_table; dht_mutable_table_t m_mutable_table; - ptime m_last_tracker_tick; + time_point m_last_tracker_tick; // the last time we issued a bootstrap or a refresh on our own ID, to expand // the routing table buckets close to us. - ptime m_last_self_refresh; + time_point m_last_self_refresh; // secret random numbers used to create write tokens int m_secret[2]; diff --git a/include/libtorrent/kademlia/node_entry.hpp b/include/libtorrent/kademlia/node_entry.hpp index 6bc5acada..eefc66162 100644 --- a/include/libtorrent/kademlia/node_entry.hpp +++ b/include/libtorrent/kademlia/node_entry.hpp @@ -37,11 +37,7 @@ POSSIBILITY OF SUCH DAMAGE. #include "libtorrent/socket.hpp" #include "libtorrent/address.hpp" #include "libtorrent/union_endpoint.hpp" -#include "libtorrent/time.hpp" // for time_now() - -#ifdef TORRENT_DHT_VERBOSE_LOGGING -#include "libtorrent/time.hpp" -#endif +#include "libtorrent/aux_/time.hpp" // for aux::time_now() namespace libtorrent { namespace dht { @@ -50,7 +46,7 @@ struct node_entry { node_entry(node_id const& id_, udp::endpoint ep, int roundtriptime = 0xffff , bool pinged = false) - : last_queried(pinged ? time_now() : min_time()) + : last_queried(pinged ? aux::time_now() : min_time()) , id(id_) , a(ep.address().to_v4().to_bytes()) , p(ep.port()) @@ -58,7 +54,7 @@ struct node_entry , timeout_count(pinged ? 0 : 0xff) { #ifdef TORRENT_DHT_VERBOSE_LOGGING - first_seen = time_now(); + first_seen = aux::time_now(); #endif } @@ -71,7 +67,7 @@ struct node_entry , timeout_count(0xff) { #ifdef TORRENT_DHT_VERBOSE_LOGGING - first_seen = time_now(); + first_seen = aux::time_now(); #endif } @@ -83,7 +79,7 @@ struct node_entry , timeout_count(0xff) { #ifdef TORRENT_DHT_VERBOSE_LOGGING - first_seen = time_now(); + first_seen = aux::time_now(); #endif } @@ -106,11 +102,11 @@ struct node_entry int port() const { return p; } #ifdef TORRENT_DHT_VERBOSE_LOGGING - ptime first_seen; + time_point first_seen; #endif // the time we last received a response for a request to this peer - ptime last_queried; + time_point last_queried; node_id id; diff --git a/include/libtorrent/kademlia/observer.hpp b/include/libtorrent/kademlia/observer.hpp index 2151e14dc..2923046ba 100644 --- a/include/libtorrent/kademlia/observer.hpp +++ b/include/libtorrent/kademlia/observer.hpp @@ -98,7 +98,7 @@ struct observer : boost::noncopyable // is being destructed void abort(); - ptime sent() const { return m_sent; } + time_point sent() const { return m_sent; } void set_target(udp::endpoint const& ep); address target_addr() const; @@ -130,7 +130,7 @@ protected: void done(); - ptime m_sent; + time_point m_sent; const boost::intrusive_ptr m_algorithm; diff --git a/include/libtorrent/kademlia/routing_table.hpp b/include/libtorrent/kademlia/routing_table.hpp index 7a9911a9e..0deb676ac 100644 --- a/include/libtorrent/kademlia/routing_table.hpp +++ b/include/libtorrent/kademlia/routing_table.hpp @@ -218,7 +218,7 @@ private: // the last time we refreshed our own bucket // refreshed every 15 minutes - mutable ptime m_last_self_refresh; + mutable time_point m_last_self_refresh; // this is a set of all the endpoints that have // been identified as router nodes. They will diff --git a/include/libtorrent/kademlia/rpc_manager.hpp b/include/libtorrent/kademlia/rpc_manager.hpp index c9e365de3..07e1a0539 100644 --- a/include/libtorrent/kademlia/rpc_manager.hpp +++ b/include/libtorrent/kademlia/rpc_manager.hpp @@ -123,7 +123,7 @@ private: udp_socket_interface* m_sock; routing_table& m_table; - ptime m_timer; + time_point m_timer; node_id m_our_id; boost::uint32_t m_allocated_observers:31; boost::uint32_t m_destructing:1; diff --git a/include/libtorrent/natpmp.hpp b/include/libtorrent/natpmp.hpp index a818837d5..0d8dc0eab 100644 --- a/include/libtorrent/natpmp.hpp +++ b/include/libtorrent/natpmp.hpp @@ -105,7 +105,7 @@ private: int action; // the time the port mapping will expire - ptime expires; + time_point expires; // the local port for this mapping. If this is set // to 0, the mapping is not in use diff --git a/include/libtorrent/peer_connection.hpp b/include/libtorrent/peer_connection.hpp index cc17bb338..087e56287 100644 --- a/include/libtorrent/peer_connection.hpp +++ b/include/libtorrent/peer_connection.hpp @@ -479,8 +479,8 @@ namespace libtorrent std::vector const& allowed_fast(); std::vector const& suggested_pieces() const { return m_suggested_pieces; } - ptime connected_time() const { return m_connect; } - ptime last_received() const { return m_last_receive; } + time_point connected_time() const { return m_connect; } + time_point last_received() const { return m_last_receive; } // this will cause this peer_connection to be disconnected. virtual void disconnect(error_code const& ec @@ -555,9 +555,9 @@ namespace libtorrent #endif #if defined TORRENT_LOGGING - ptime m_connect_time; - ptime m_bitfield_time; - ptime m_unchoke_time; + time_point m_connect_time; + time_point m_bitfield_time; + time_point m_unchoke_time; #endif // the message handlers are called @@ -714,7 +714,7 @@ namespace libtorrent { return m_statistics.total_payload_upload() - m_uploaded_at_last_unchoke; } // the time we last unchoked this peer - ptime time_of_last_unchoke() const + time_point time_of_last_unchoke() const { return m_last_unchoke; } // called when the disk write buffer is drained again, and we can @@ -813,7 +813,7 @@ namespace libtorrent int preferred_caching() const; void fill_send_buffer(); void on_disk_read_complete(disk_io_job const* j, peer_request r - , ptime issue_time); + , time_point issue_time); void on_disk_write_complete(disk_io_job const* j , peer_request r, boost::shared_ptr t); void on_seed_mode_hashed(disk_io_job const* j); @@ -913,29 +913,29 @@ namespace libtorrent // the time when we last got a part of a // piece packet from this peer - ptime m_last_piece; + time_point m_last_piece; // the time we sent a request to // this peer the last time - ptime m_last_request; + time_point m_last_request; // the time we received the last // piece request from the peer - ptime m_last_incoming_request; + time_point m_last_incoming_request; // the time when we unchoked this peer - ptime m_last_unchoke; + time_point m_last_unchoke; // if we're unchoked by this peer, this // was the time - ptime m_last_unchoked; + time_point m_last_unchoked; // the time we last choked this peer. min_time() in // case we never unchoked it - ptime m_last_choke; + time_point m_last_choke; // timeouts - ptime m_last_receive; - ptime m_last_sent; + time_point m_last_receive; + time_point m_last_sent; // the time when the first entry in the request queue was requested. Used // for request timeout. it doesn't necessarily represent the time when a @@ -944,23 +944,23 @@ namespace libtorrent // Once we get that response, we set it to the current time. // for more information, see the blog post at: // http://blog.libtorrent.org/2011/11/block-request-time-outs/ - ptime m_requested; + time_point m_requested; // a timestamp when the remote download rate // was last updated - ptime m_remote_dl_update; + time_point m_remote_dl_update; // the time when async_connect was called // or when the incoming connection was established - ptime m_connect; + time_point m_connect; // the time when this peer sent us a not_interested message // the last time. - ptime m_became_uninterested; + time_point m_became_uninterested; // the time when we sent a not_interested message to // this peer the last time. - ptime m_became_uninteresting; + time_point m_became_uninteresting; // the total payload download bytes // at the last unchoke round. This is used to diff --git a/include/libtorrent/resolver.hpp b/include/libtorrent/resolver.hpp index caad09c39..873df0a0d 100644 --- a/include/libtorrent/resolver.hpp +++ b/include/libtorrent/resolver.hpp @@ -62,7 +62,7 @@ private: struct dns_cache_entry { - ptime last_seen; + time_point last_seen; std::vector
addresses; }; diff --git a/include/libtorrent/session.hpp b/include/libtorrent/session.hpp index b09e7820a..cad44856d 100644 --- a/include/libtorrent/session.hpp +++ b/include/libtorrent/session.hpp @@ -128,8 +128,10 @@ namespace libtorrent TORRENT_EXPORT void high_performance_seed(settings_pack& set); #ifndef TORRENT_NO_DEPRECATE - TORRENT_EXPORT session_settings min_memory_usage(); - TORRENT_EXPORT session_settings high_performance_seed(); + TORRENT_DEPRECATED_PREFIX + TORRENT_EXPORT session_settings min_memory_usage() TORRENT_DEPRECATED; + TORRENT_DEPRECATED_PREFIX + TORRENT_EXPORT session_settings high_performance_seed() TORRENT_DEPRECATED; #endif #ifndef TORRENT_CFG diff --git a/include/libtorrent/time.hpp b/include/libtorrent/time.hpp index 1b530ce91..f1d55c95a 100644 --- a/include/libtorrent/time.hpp +++ b/include/libtorrent/time.hpp @@ -33,7 +33,6 @@ POSSIBILITY OF SUCH DAMAGE. #ifndef TORRENT_TIME_HPP_INCLUDED #define TORRENT_TIME_HPP_INCLUDED -#include #include "libtorrent/config.hpp" #include @@ -43,31 +42,7 @@ POSSIBILITY OF SUCH DAMAGE. #include #endif -#include - -// OVERVIEW -// -// This section contains fundamental time types used internally by -// libtorrent and exposed through various places in the API. The two -// basic types are ``ptime`` and ``time_duration``. The first represents -// a point in time and the second the difference between two points -// in time. -// -// The internal representation of these types is implementation defined -// and they can only be constructed via one of the construction functions -// that take a well defined time unit (seconds, minutes, etc.). They can -// only be turned into well defined time units by the accessor functions -// (total_microseconds(), etc.). -// -// .. note:: -// In a future version of libtorrent, these types will be replaced -// by the standard timer types from ``std::chrono``. -// - -namespace libtorrent -{ - TORRENT_EXTRA_EXPORT char const* time_now_string(); - std::string log_time(); +namespace libtorrent { #if defined BOOST_ASIO_HAS_STD_CHRONO typedef std::chrono::high_resolution_clock clock_type; @@ -75,23 +50,9 @@ namespace libtorrent typedef boost::chrono::high_resolution_clock clock_type; #endif - typedef clock_type::time_point ptime; + typedef clock_type::time_point time_point; typedef clock_type::duration time_duration; - // returns the current time, as represented by ptime. The - // resolution of this timer is about 100 ms. - TORRENT_EXPORT ptime const& time_now(); - - // returns the current time as represented by ptime. This is - // more expensive than time_now(), but provides as high resolution - // as the operating system can provide. - inline ptime time_now_hires() { return clock_type::now(); } - - // the earliest and latest possible time points - // representable by ptime. - inline ptime min_time() { return (clock_type::time_point::min)(); } - inline ptime max_time() { return (clock_type::time_point::max)(); } - #if defined BOOST_ASIO_HAS_STD_CHRONO using std::chrono::seconds; using std::chrono::milliseconds; @@ -108,6 +69,9 @@ namespace libtorrent using boost::chrono::duration_cast; #endif + inline time_point min_time() { return (time_point::min)(); } + inline time_point max_time() { return (time_point::max)(); } + template boost::int64_t total_seconds(T td) { return duration_cast(td).count(); } @@ -120,6 +84,24 @@ namespace libtorrent boost::int64_t total_microseconds(T td) { return duration_cast(td).count(); } +#ifndef TORRENT_NO_DEPRECATE + + TORRENT_DEPRECATED_PREFIX + time_point time_now() TORRENT_DEPRECATED; + + TORRENT_DEPRECATED_PREFIX + time_point time_now_hires() TORRENT_DEPRECATED; + + inline time_point time_now() + { return clock_type::now(); } + + inline time_point time_now_hires() + { return clock_type::now(); } + + typedef time_point ptime TORRENT_DEPRECATED; + +#endif + } #endif // TORRENT_TIME_HPP_INCLUDED diff --git a/include/libtorrent/torrent.hpp b/include/libtorrent/torrent.hpp index 808f0a748..4229f5962 100644 --- a/include/libtorrent/torrent.hpp +++ b/include/libtorrent/torrent.hpp @@ -122,11 +122,11 @@ namespace libtorrent struct time_critical_piece { // when this piece was first requested - ptime first_requested; + time_point first_requested; // when this piece was last requested - ptime last_requested; + time_point last_requested; // by what time we want this piece - ptime deadline; + time_point deadline; // 1 = send alert with piece data when available int flags; // how many peers it's been requested from @@ -151,7 +151,7 @@ namespace libtorrent , web_seed_entry::headers_t const& extra_headers_ = web_seed_entry::headers_t()); // if this is > now, we can't reconnect yet - ptime retry; + time_point retry; // if the hostname of the web seed has been resolved, // these are its IP addresses @@ -729,10 +729,10 @@ namespace libtorrent // returns the absolute time when the next tracker // announce will take place. - ptime next_announce() const; + time_point next_announce() const; // forcefully sets next_announce to the current time - void force_tracker_request(ptime, int tracker_idx); + void force_tracker_request(time_point, int tracker_idx); void scrape_tracker(); void announce_with_tracker(boost::uint8_t e = tracker_request::none @@ -1029,7 +1029,7 @@ namespace libtorrent #if defined TORRENT_LOGGING virtual void debug_log(const char* fmt, ...) const; void log_to_all_peers(char const* message); - ptime m_dht_start_time; + time_point m_dht_start_time; #endif // DEBUG @@ -1181,7 +1181,7 @@ namespace libtorrent void update_peer_interest(bool was_finished); void prioritize_udp_trackers(); - void update_tracker_timer(ptime now); + void update_tracker_timer(time_point now); static void on_tracker_announce_disp(boost::weak_ptr p , error_code const& e); diff --git a/include/libtorrent/torrent_info.hpp b/include/libtorrent/torrent_info.hpp index 4e046e885..a41887e5f 100644 --- a/include/libtorrent/torrent_info.hpp +++ b/include/libtorrent/torrent_info.hpp @@ -116,10 +116,10 @@ namespace libtorrent int min_announce_in() const; // the time of next tracker announce - ptime next_announce; + time_point next_announce; // no announces before this time - ptime min_announce; + time_point min_announce; // TODO: include the number of peers received from this tracker, at last // announce @@ -196,7 +196,7 @@ namespace libtorrent #ifndef TORRENT_NO_DEPRECATE // deprecated in 1.0 TORRENT_DEPRECATED_PREFIX - bool will_announce(ptime now) const TORRENT_DEPRECATED + bool will_announce(time_point now) const TORRENT_DEPRECATED { return now <= next_announce && (fails < fail_limit || fail_limit == 0) @@ -209,7 +209,7 @@ namespace libtorrent // argument is necessary because once we become a seed, we // need to announce right away, even if the re-announce timer // hasn't expired yet. - bool can_announce(ptime now, bool is_seed) const; + bool can_announce(time_point now, bool is_seed) const; // returns true if the last time we tried to announce to this // tracker succeeded, or if we haven't tried yet. diff --git a/include/libtorrent/tracker_manager.hpp b/include/libtorrent/tracker_manager.hpp index 1de5b4f7b..afc905b4b 100644 --- a/include/libtorrent/tracker_manager.hpp +++ b/include/libtorrent/tracker_manager.hpp @@ -262,10 +262,10 @@ namespace libtorrent // used for timeouts // this is set when the request has been sent - ptime m_start_time; + time_point m_start_time; // this is set every time something is received - ptime m_read_time; + time_point m_read_time; // the asio async operation deadline_timer m_timeout; diff --git a/include/libtorrent/udp_socket.hpp b/include/libtorrent/udp_socket.hpp index c96723ea3..83cbcbcf2 100644 --- a/include/libtorrent/udp_socket.hpp +++ b/include/libtorrent/udp_socket.hpp @@ -278,7 +278,7 @@ namespace libtorrent int m_rate_limit; int m_quota; - ptime m_last_tick; + time_point m_last_tick; }; } diff --git a/include/libtorrent/udp_tracker_connection.hpp b/include/libtorrent/udp_tracker_connection.hpp index 6280d9a9d..2a37b0a2a 100644 --- a/include/libtorrent/udp_tracker_connection.hpp +++ b/include/libtorrent/udp_tracker_connection.hpp @@ -124,7 +124,7 @@ namespace libtorrent struct connection_cache_entry { boost::int64_t connection_id; - ptime expires; + time_point expires; }; static std::map m_connection_cache; diff --git a/include/libtorrent/upnp.hpp b/include/libtorrent/upnp.hpp index 204346e7d..8dcd33391 100644 --- a/include/libtorrent/upnp.hpp +++ b/include/libtorrent/upnp.hpp @@ -232,7 +232,7 @@ private: {} // the time the port mapping will expire - ptime expires; + time_point expires; int action; @@ -375,7 +375,7 @@ private: // cache of interfaces mutable std::vector m_interfaces; - mutable ptime m_last_if_update; + mutable time_point m_last_if_update; }; } diff --git a/include/libtorrent/utp_socket_manager.hpp b/include/libtorrent/utp_socket_manager.hpp index c759d68a1..d06c1a143 100644 --- a/include/libtorrent/utp_socket_manager.hpp +++ b/include/libtorrent/utp_socket_manager.hpp @@ -64,7 +64,7 @@ namespace libtorrent virtual void socket_drained(); - void tick(ptime now); + void tick(time_point now); tcp::endpoint local_endpoint(address const& remote, error_code& ec) const; int local_port(error_code& ec) const; @@ -139,11 +139,11 @@ namespace libtorrent // the timestamp for the last time we updated // the routing table - mutable ptime m_last_route_update; + mutable time_point m_last_route_update; // cache of interfaces mutable std::vector m_interfaces; - mutable ptime m_last_if_update; + mutable time_point m_last_if_update; // the buffer size of the socket. This is used // to now lower the buffer size diff --git a/include/libtorrent/utp_stream.hpp b/include/libtorrent/utp_stream.hpp index ca19f8625..2754a305a 100644 --- a/include/libtorrent/utp_stream.hpp +++ b/include/libtorrent/utp_stream.hpp @@ -149,10 +149,10 @@ utp_socket_impl* construct_utp_impl(boost::uint16_t recv_id void detach_utp_impl(utp_socket_impl* s); void delete_utp_impl(utp_socket_impl* s); bool should_delete(utp_socket_impl* s); -void tick_utp_impl(utp_socket_impl* s, ptime now); +void tick_utp_impl(utp_socket_impl* s, time_point now); void utp_init_mtu(utp_socket_impl* s, int link_mtu, int utp_mtu); bool utp_incoming_packet(utp_socket_impl* s, char const* p - , int size, udp::endpoint const& ep, ptime receive_time); + , int size, udp::endpoint const& ep, time_point receive_time); bool utp_match(utp_socket_impl* s, udp::endpoint const& ep, boost::uint16_t id); udp::endpoint utp_remote_endpoint(utp_socket_impl* s); boost::uint16_t utp_receive_id(utp_socket_impl* s); diff --git a/src/alert.cpp b/src/alert.cpp index 7f090a400..1bed110b8 100644 --- a/src/alert.cpp +++ b/src/alert.cpp @@ -42,13 +42,14 @@ POSSIBILITY OF SUCH DAMAGE. #include "libtorrent/escape_string.hpp" #include "libtorrent/extensions.hpp" #include "libtorrent/torrent.hpp" +#include "libtorrent/aux_/time.hpp" #include namespace libtorrent { - alert::alert() : m_timestamp(time_now()) {} + alert::alert() : m_timestamp(aux::time_now()) {} alert::~alert() {} - ptime alert::timestamp() const { return m_timestamp; } + time_point alert::timestamp() const { return m_timestamp; } torrent_alert::torrent_alert(torrent_handle const& h) : handle(h) diff --git a/src/bandwidth_manager.cpp b/src/bandwidth_manager.cpp index 9b8cdce83..a175ddf25 100644 --- a/src/bandwidth_manager.cpp +++ b/src/bandwidth_manager.cpp @@ -48,7 +48,7 @@ namespace libtorrent #ifdef TORRENT_VERBOSE_BANDWIDTH_LIMIT if (log) m_log.open("bandwidth_limiter.log", std::ios::trunc); - m_start = time_now(); + m_start = aux::time_now(); #endif } diff --git a/src/block_cache.cpp b/src/block_cache.cpp index 1ec574ee5..1315f25ff 100644 --- a/src/block_cache.cpp +++ b/src/block_cache.cpp @@ -43,6 +43,7 @@ POSSIBILITY OF SUCH DAMAGE. #include "libtorrent/alloca.hpp" #include "libtorrent/alert_dispatcher.hpp" #include "libtorrent/performance_counters.hpp" +#include "libtorrent/aux_/time.hpp" #ifdef TORRENT_DEBUG #include "libtorrent/random.hpp" @@ -323,7 +324,7 @@ void block_cache::bump_lru(cached_piece_entry* p) // move to the back (MRU) of the list lru_list->erase(p); lru_list->push_back(p); - p->expire = time_now(); + p->expire = aux::time_now(); } // this is called for pieces that we're reading from, when they @@ -397,7 +398,7 @@ void block_cache::cache_hit(cached_piece_entry* p, void* requester, bool volatil m_lru[p->cache_state].erase(p); m_lru[target_queue].push_back(p); p->cache_state = target_queue; - p->expire = time_now(); + p->expire = aux::time_now(); #if TORRENT_USE_ASSERTS switch (p->cache_state) { @@ -435,7 +436,7 @@ void block_cache::update_cache_state(cached_piece_entry* p) src->erase(p); dst->push_back(p); - p->expire = time_now(); + p->expire = aux::time_now(); p->cache_state = desired_state; #if TORRENT_USE_ASSERTS switch (p->cache_state) @@ -475,7 +476,7 @@ cached_piece_entry* block_cache::allocate_piece(disk_io_job const* j, int cache_ cached_piece_entry pe; pe.piece = j->piece; pe.storage = j->storage; - pe.expire = time_now(); + pe.expire = aux::time_now(); pe.blocks_in_piece = blocks_in_piece; pe.blocks.reset(new (std::nothrow) cached_block_entry[blocks_in_piece]); pe.cache_state = cache_state; @@ -542,7 +543,7 @@ cached_piece_entry* block_cache::allocate_piece(disk_io_job const* j, int cache_ m_lru[p->cache_state].erase(p); p->cache_state = cache_state; m_lru[p->cache_state].push_back(p); - p->expire = time_now(); + p->expire = aux::time_now(); #if TORRENT_USE_ASSERTS switch (p->cache_state) { @@ -1480,7 +1481,7 @@ void block_cache::check_invariant() const for (int i = 0; i < cached_piece_entry::num_lrus; ++i) { - ptime timeout = min_time(); + time_point timeout = min_time(); for (list_iterator p = m_lru[i].iterate(); p.get(); p.next()) { diff --git a/src/disk_io_thread.cpp b/src/disk_io_thread.cpp index 745d7b629..be46e7445 100644 --- a/src/disk_io_thread.cpp +++ b/src/disk_io_thread.cpp @@ -163,7 +163,7 @@ namespace libtorrent , m_num_running_threads(0) , m_userdata(userdata) , m_last_cache_expiry(min_time()) - , m_last_file_check(time_now_hires()) + , m_last_file_check(clock_type::now()) , m_file_pool(40) , m_disk_cache(block_size, ios, boost::bind(&disk_io_thread::trigger_cache_trim, this), alert_disp) , m_stats_counters(cnt) @@ -628,7 +628,7 @@ namespace libtorrent TORRENT_PIECE_ASSERT(num_blocks > 0, pe); m_stats_counters.inc_stats_counter(counters::num_writing_threads, 1); - ptime start_time = time_now_hires(); + time_point start_time = clock_type::now(); int block_size = m_disk_cache.block_size(); #if DEBUG_DISK_THREAD @@ -662,7 +662,7 @@ namespace libtorrent if (!failed) { TORRENT_PIECE_ASSERT(!error, pe); - boost::uint32_t write_time = total_microseconds(time_now_hires() - start_time); + boost::uint32_t write_time = total_microseconds(clock_type::now() - start_time); m_write_time.add_sample(write_time / num_blocks); m_stats_counters.inc_stats_counter(counters::num_blocks_written, num_blocks); @@ -976,11 +976,11 @@ namespace libtorrent { DLOG("flush_expired_write_blocks\n"); - ptime now = time_now(); + time_point now = aux::time_now(); time_duration expiration_limit = seconds(m_settings.get_int(settings_pack::cache_expiry)); #if TORRENT_USE_ASSERTS - ptime timeout = min_time(); + time_point timeout = min_time(); #endif cached_piece_entry** to_flush = TORRENT_ALLOCA(cached_piece_entry*, 200); @@ -1139,7 +1139,7 @@ namespace libtorrent TORRENT_ASSERT(j->action < sizeof(job_functions)/sizeof(job_functions[0])); - ptime start_time = time_now_hires(); + time_point start_time = clock_type::now(); m_stats_counters.inc_stats_counter(counters::num_running_disk_jobs, 1); @@ -1190,7 +1190,7 @@ namespace libtorrent j->ret = ret; - ptime now = time_now_hires(); + time_point now = clock_type::now(); m_job_time.add_sample(total_microseconds(now - start_time)); completed_jobs.push_back(j); } @@ -1205,7 +1205,7 @@ namespace libtorrent return -1; } - ptime start_time = time_now_hires(); + time_point start_time = clock_type::now(); int file_flags = file_flags_for_job(j); file::iovec_t b = { j->buffer, size_t(j->d.io.buffer_size) }; @@ -1217,7 +1217,7 @@ namespace libtorrent if (!j->error.ec) { - boost::uint32_t read_time = total_microseconds(time_now_hires() - start_time); + boost::uint32_t read_time = total_microseconds(clock_type::now() - start_time); m_read_time.add_sample(read_time); m_stats_counters.inc_stats_counter(counters::num_read_back); @@ -1313,14 +1313,14 @@ namespace libtorrent // disk operations. int file_flags = file_flags_for_job(j); - ptime start_time = time_now_hires(); + time_point start_time = clock_type::now(); ret = j->storage->get_storage_impl()->readv(iov, iov_len , j->piece, adjusted_offset, file_flags, j->error); if (!j->error.ec) { - boost::uint32_t read_time = total_microseconds(time_now_hires() - start_time); + boost::uint32_t read_time = total_microseconds(clock_type::now() - start_time); m_read_time.add_sample(read_time / iov_len); m_stats_counters.inc_stats_counter(counters::num_blocks_read, iov_len); @@ -1461,7 +1461,7 @@ namespace libtorrent int disk_io_thread::do_uncached_write(disk_io_job* j) { - ptime start_time = time_now_hires(); + time_point start_time = clock_type::now(); file::iovec_t b = { j->buffer, size_t(j->d.io.buffer_size) }; int file_flags = file_flags_for_job(j); @@ -1476,7 +1476,7 @@ namespace libtorrent if (!j->error.ec) { - boost::uint32_t write_time = total_microseconds(time_now_hires() - start_time); + boost::uint32_t write_time = total_microseconds(clock_type::now() - start_time); m_write_time.add_sample(write_time); m_stats_counters.inc_stats_counter(counters::num_blocks_written); @@ -2188,7 +2188,7 @@ namespace libtorrent l.unlock(); - ptime start_time = time_now_hires(); + time_point start_time = clock_type::now(); for (int i = cursor; i < end; ++i) { @@ -2198,7 +2198,7 @@ namespace libtorrent ph->offset += size; } - boost::uint64_t hash_time = total_microseconds(time_now_hires() - start_time); + boost::uint64_t hash_time = total_microseconds(clock_type::now() - start_time); l.lock(); @@ -2277,7 +2277,7 @@ namespace libtorrent DLOG("do_hash: (uncached) reading (piece: %d block: %d)\n" , int(j->piece), i); - ptime start_time = time_now_hires(); + time_point start_time = clock_type::now(); iov.iov_len = (std::min)(block_size, piece_size - offset); ret = j->storage->get_storage_impl()->readv(&iov, 1, j->piece @@ -2286,7 +2286,7 @@ namespace libtorrent if (!j->error.ec) { - boost::uint32_t read_time = total_microseconds(time_now_hires() - start_time); + boost::uint32_t read_time = total_microseconds(clock_type::now() - start_time); m_read_time.add_sample(read_time); m_stats_counters.inc_stats_counter(counters::num_blocks_read); @@ -2474,7 +2474,7 @@ namespace libtorrent DLOG("do_hash: reading (piece: %d block: %d)\n", int(pe->piece), i); - ptime start_time = time_now_hires(); + time_point start_time = clock_type::now(); TORRENT_PIECE_ASSERT(ph->offset == i * block_size, pe); ret = j->storage->get_storage_impl()->readv(&iov, 1, j->piece @@ -2502,7 +2502,7 @@ namespace libtorrent if (!j->error.ec) { - boost::uint32_t read_time = total_microseconds(time_now_hires() - start_time); + boost::uint32_t read_time = total_microseconds(clock_type::now() - start_time); m_read_time.add_sample(read_time); m_stats_counters.inc_stats_counter(counters::num_read_back); @@ -2720,7 +2720,7 @@ namespace libtorrent DLOG("do_cache_piece: reading (piece: %d block: %d)\n" , int(pe->piece), i); - ptime start_time = time_now_hires(); + time_point start_time = clock_type::now(); ret = j->storage->get_storage_impl()->readv(&iov, 1, j->piece , offset, file_flags, j->error); @@ -2733,7 +2733,7 @@ namespace libtorrent if (!j->error.ec) { - boost::uint32_t read_time = total_microseconds(time_now_hires() - start_time); + boost::uint32_t read_time = total_microseconds(clock_type::now() - start_time); m_read_time.add_sample(read_time); m_stats_counters.inc_stats_counter(counters::num_blocks_read); @@ -3218,7 +3218,7 @@ namespace libtorrent if (thread_id == 0) { // there's no need for all threads to be doing this - ptime now = time_now_hires(); + time_point now = clock_type::now(); if (now > m_last_cache_expiry + seconds(5)) { mutex::scoped_lock l2(m_cache_mutex); diff --git a/src/file_pool.cpp b/src/file_pool.cpp index a3c0d362e..472e06dd6 100644 --- a/src/file_pool.cpp +++ b/src/file_pool.cpp @@ -36,6 +36,7 @@ POSSIBILITY OF SUCH DAMAGE. #include "libtorrent/file_pool.hpp" #include "libtorrent/error_code.hpp" #include "libtorrent/file_storage.hpp" // for file_entry +#include "libtorrent/aux_/time.hpp" namespace libtorrent { @@ -143,7 +144,7 @@ namespace libtorrent if (i != m_files.end()) { lru_file_entry& e = i->second; - e.last_use = time_now(); + e.last_use = aux::time_now(); if (e.key != st && ((e.mode & file::rw_mask) != file::read_only || (m & file::rw_mask) != file::read_only)) diff --git a/src/http_connection.cpp b/src/http_connection.cpp index fce743bfc..8b236566b 100644 --- a/src/http_connection.cpp +++ b/src/http_connection.cpp @@ -39,6 +39,7 @@ POSSIBILITY OF SUCH DAMAGE. #include "libtorrent/socket_type.hpp" // for async_shutdown #include "libtorrent/resolver_interface.hpp" #include "libtorrent/settings_pack.hpp" +#include "libtorrent/aux_/time.hpp" #if defined TORRENT_ASIO_DEBUGGING #include "libtorrent/debug.hpp" @@ -75,8 +76,8 @@ http_connection::http_connection(io_service& ios , m_filter_handler(fh) , m_timer(ios) , m_limiter_timer(ios) - , m_last_receive(time_now()) - , m_start_time(time_now()) + , m_last_receive(aux::time_now()) + , m_start_time(aux::time_now()) , m_read_pos(0) , m_redirects(5) , m_max_bottled_buffer_size(max_bottled_buffer_size) @@ -414,7 +415,7 @@ void http_connection::on_timeout(boost::weak_ptr p if (c->m_abort) return; - ptime now = time_now_hires(); + time_point now = clock_type::now(); if (c->m_start_time + c->m_completion_timeout < now || c->m_last_receive + c->m_read_timeout < now) @@ -597,7 +598,7 @@ void http_connection::on_connect(error_code const& e) TORRENT_ASSERT(m_connecting); m_connecting = false; - m_last_receive = time_now_hires(); + m_last_receive = clock_type::now(); m_start_time = m_last_receive; if (!e) { @@ -812,7 +813,7 @@ void http_connection::on_read(error_code const& e callback(e, &m_recvbuffer[0] + m_parser.body_start() , m_read_pos - m_parser.body_start()); m_read_pos = 0; - m_last_receive = time_now_hires(); + m_last_receive = clock_type::now(); } else if (m_bottled && m_parser.finished()) { @@ -826,7 +827,7 @@ void http_connection::on_read(error_code const& e TORRENT_ASSERT(!m_bottled); callback(e, &m_recvbuffer[0], m_read_pos); m_read_pos = 0; - m_last_receive = time_now_hires(); + m_last_receive = clock_type::now(); } // if we've hit the limit, double the buffer size diff --git a/src/ip_voter.cpp b/src/ip_voter.cpp index 2743121c3..be38a6f97 100644 --- a/src/ip_voter.cpp +++ b/src/ip_voter.cpp @@ -34,7 +34,7 @@ POSSIBILITY OF SUCH DAMAGE. #include "libtorrent/broadcast_socket.hpp" // for is_any() etc. #include "libtorrent/socket_io.hpp" // for hash_address #include "libtorrent/random.hpp" // for random() -#include "libtorrent/time.hpp" // for time_now() +#include "libtorrent/aux_/time.hpp" // for aux::time_now() #include @@ -43,14 +43,14 @@ namespace libtorrent ip_voter::ip_voter() : m_total_votes(0) , m_valid_external(false) - , m_last_rotate(time_now()) + , m_last_rotate(aux::time_now()) { } // returns true if our external IP changed bool ip_voter::maybe_rotate() { - ptime now = time_now(); + time_point now = aux::time_now(); // if we have more than or equal to 50 votes, // we rotate. Also, if it's been more than 5 minutes diff --git a/src/kademlia/dht_tracker.cpp b/src/kademlia/dht_tracker.cpp index ddaa2240e..8ef1897e9 100644 --- a/src/kademlia/dht_tracker.cpp +++ b/src/kademlia/dht_tracker.cpp @@ -141,7 +141,7 @@ namespace libtorrent { namespace dht , m_dht(&ses, this, settings, extract_node_id(state) , ses.external_address().external_address(address_v4()), &ses, cnt) , m_sock(sock) - , m_last_new_key(time_now() - minutes(int(key_refresh))) + , m_last_new_key(aux::time_now() - minutes(int(key_refresh))) , m_timer(sock.get_io_service()) , m_connection_timer(sock.get_io_service()) , m_refresh_timer(sock.get_io_service()) @@ -250,7 +250,7 @@ namespace libtorrent { namespace dht m_timer.expires_from_now(minutes(tick_period), ec); m_timer.async_wait(boost::bind(&dht_tracker::tick, self(), _1)); - ptime now = time_now(); + time_point now = aux::time_now(); if (now - minutes(int(key_refresh)) > m_last_new_key) { m_last_new_key = now; @@ -383,7 +383,7 @@ namespace libtorrent { namespace dht return true; } - if (!m_blocker.incoming(ep.address(), time_now())) + if (!m_blocker.incoming(ep.address(), aux::time_now())) return true; using libtorrent::entry; diff --git a/src/kademlia/dos_blocker.cpp b/src/kademlia/dos_blocker.cpp index 6fa047fca..2e275af3a 100644 --- a/src/kademlia/dos_blocker.cpp +++ b/src/kademlia/dos_blocker.cpp @@ -54,7 +54,7 @@ namespace libtorrent { namespace dht } } - bool dos_blocker::incoming(address addr, ptime now) + bool dos_blocker::incoming(address addr, time_point now) { node_ban_entry* match = 0; node_ban_entry* min = m_ban_nodes; diff --git a/src/kademlia/logging.cpp b/src/kademlia/logging.cpp index 02522a7ca..8ffecf015 100644 --- a/src/kademlia/logging.cpp +++ b/src/kademlia/logging.cpp @@ -32,6 +32,7 @@ POSSIBILITY OF SUCH DAMAGE. #include "libtorrent/kademlia/logging.hpp" #include "libtorrent/time.hpp" +#include "libtorrent/aux_/time.hpp" namespace libtorrent { namespace dht { @@ -39,7 +40,7 @@ namespace libtorrent { namespace dht : log_(log) { if (log_.enabled()) - log_ << time_now_string() << " [" << log.id() << "] "; + log_ << libtorrent::aux::time_now_string() << " [" << log.id() << "] "; } log_event::~log_event() diff --git a/src/kademlia/node.cpp b/src/kademlia/node.cpp index 9036fe8fb..e55d7ba46 100644 --- a/src/kademlia/node.cpp +++ b/src/kademlia/node.cpp @@ -78,7 +78,7 @@ void purge_peers(std::set& peers) , end(peers.end()); i != end;) { // the peer has timed out - if (i->added + minutes(int(announce_interval * 1.5f)) < time_now()) + if (i->added + minutes(int(announce_interval * 1.5f)) < aux::time_now()) { #ifdef TORRENT_DHT_VERBOSE_LOGGING TORRENT_LOG(node) << "peer timed out at: " << i->addr; @@ -102,7 +102,7 @@ node_impl::node_impl(alert_dispatcher* alert_disp , m_table(m_id, 8, settings) , m_rpc(m_id, m_table, sock) , m_observer(observer) - , m_last_tracker_tick(time_now()) + , m_last_tracker_tick(aux::time_now()) , m_last_self_refresh(min_time()) , m_post_alert(alert_disp) , m_sock(sock) @@ -178,7 +178,7 @@ void node_impl::bootstrap(std::vector const& nodes make_id_secret(target); boost::intrusive_ptr r(new dht::bootstrap(*this, target, f)); - m_last_self_refresh = time_now(); + m_last_self_refresh = aux::time_now(); #ifdef TORRENT_DHT_VERBOSE_LOGGING int count = 0; @@ -453,7 +453,7 @@ void node_impl::tick() { // every now and then we refresh our own ID, just to keep // expanding the routing table buckets closer to us. - ptime now = time_now(); + time_point now = aux::time_now(); if (m_last_self_refresh + minutes(10) < now) { node_id target = m_id; @@ -521,7 +521,7 @@ void node_impl::send_single_refresh(udp::endpoint const& ep, int bucket time_duration node_impl::connection_timeout() { time_duration d = m_rpc.tick(); - ptime now(time_now()); + time_point now(aux::time_now()); if (now - minutes(2) < m_last_tracker_tick) return d; m_last_tracker_tick = now; @@ -1008,7 +1008,7 @@ void node_impl::incoming_request(msg const& m, entry& e) peer_entry peer; peer.addr = tcp::endpoint(m.addr.address(), port); - peer.added = time_now(); + peer.added = aux::time_now(); peer.seed = msg_keys[4] && msg_keys[4]->int_value(); std::set::iterator i = v->peers.find(peer); if (i != v->peers.end()) v->peers.erase(i++); @@ -1231,7 +1231,7 @@ void node_impl::incoming_request(msg const& m, entry& e) m_table.node_seen(id, m.addr, 0xffff); - f->last_seen = time_now(); + f->last_seen = aux::time_now(); // maybe increase num_announcers if we haven't seen this IP before sha1_hash iphash; diff --git a/src/kademlia/routing_table.cpp b/src/kademlia/routing_table.cpp index cbfcb97db..cbe00434f 100644 --- a/src/kademlia/routing_table.cpp +++ b/src/kademlia/routing_table.cpp @@ -215,7 +215,7 @@ void routing_table::print_state(std::ostream& os) const os << "\n"; } - ptime now = time_now(); + time_point now = aux::time_now(); os << "\nnodes:"; int bucket_index = 0; @@ -366,7 +366,7 @@ out: // make sure we don't pick the same node again next time we want to refresh // the routing table if (candidate) - candidate->last_queried = time_now(); + candidate->last_queried = aux::time_now(); return candidate; } @@ -988,7 +988,7 @@ void routing_table::node_failed(node_id const& nid, udp::endpoint const& ep) " ip: " << j->ep() << " fails: " << j->fail_count() << " pinged: " << j->pinged() << - " up-time: " << total_seconds(time_now() - j->first_seen); + " up-time: " << total_seconds(aux::time_now() - j->first_seen); #endif return; } @@ -1008,7 +1008,7 @@ void routing_table::node_failed(node_id const& nid, udp::endpoint const& ep) " ip: " << j->ep() << " fails: " << j->fail_count() << " pinged: " << j->pinged() << - " up-time: " << total_seconds(time_now() - j->first_seen); + " up-time: " << total_seconds(aux::time_now() - j->first_seen); #endif // if this node has failed too many times, or if this node diff --git a/src/kademlia/rpc_manager.cpp b/src/kademlia/rpc_manager.cpp index b6dfc2f81..e6ece84b9 100644 --- a/src/kademlia/rpc_manager.cpp +++ b/src/kademlia/rpc_manager.cpp @@ -85,9 +85,9 @@ void observer::set_target(udp::endpoint const& ep) { #ifdef TORRENT_DHT_VERBOSE_LOGGING // use high resolution timers for logging - m_sent = time_now_hires(); + m_sent = clock_type::now(); #else - m_sent = time_now(); + m_sent = aux::time_now(); #endif m_port = ep.port(); @@ -168,7 +168,7 @@ rpc_manager::rpc_manager(node_id const& our_id : m_pool_allocator(observer_size, 10) , m_sock(sock) , m_table(table) - , m_timer(time_now()) + , m_timer(aux::time_now()) , m_our_id(our_id) , m_allocated_observers(0) , m_destructing(false) @@ -316,7 +316,7 @@ bool rpc_manager::incoming(msg const& m, node_id* id, libtorrent::dht_settings c return false; } - ptime now = time_now_hires(); + time_point now = clock_type::now(); #ifdef TORRENT_DHT_VERBOSE_LOGGING std::ofstream reply_stats("round_trip_ms.log", std::ios::app); @@ -388,7 +388,7 @@ time_duration rpc_manager::tick() std::vector short_timeouts; time_duration ret = seconds(short_timeout); - ptime now = time_now(); + time_point now = aux::time_now(); for (transactions_t::iterator i = m_transactions.begin(); i != m_transactions.end();) diff --git a/src/kademlia/traversal_algorithm.cpp b/src/kademlia/traversal_algorithm.cpp index 81e80b6f6..0168ee860 100644 --- a/src/kademlia/traversal_algorithm.cpp +++ b/src/kademlia/traversal_algorithm.cpp @@ -503,7 +503,7 @@ void traversal_algorithm::status(dht_lookup& l) l.first_timeout = 0; int last_sent = INT_MAX; - ptime now = time_now(); + time_point now = aux::time_now(); for (std::vector::iterator i = m_results.begin() , end(m_results.end()); i != end; ++i) { diff --git a/src/lt_trackers.cpp b/src/lt_trackers.cpp index 2204e9cf5..654e7002d 100644 --- a/src/lt_trackers.cpp +++ b/src/lt_trackers.cpp @@ -227,7 +227,7 @@ namespace libtorrent { namespace #ifdef TORRENT_LOGGING std::stringstream log_line; - log_line << time_now_string() << " <== LT_TEX [ " + log_line << aux::time_now_string() << " <== LT_TEX [ " "added: "; #endif @@ -332,7 +332,7 @@ namespace libtorrent { namespace #ifdef TORRENT_LOGGING std::stringstream log_line; - log_line << time_now_string() << " ==> LT_TEX [ " + log_line << aux::time_now_string() << " ==> LT_TEX [ " "added: "; #endif entry tex; diff --git a/src/metadata_transfer.cpp b/src/metadata_transfer.cpp index 0cf8a9884..4b1e86fc9 100644 --- a/src/metadata_transfer.cpp +++ b/src/metadata_transfer.cpp @@ -466,7 +466,7 @@ namespace libtorrent { namespace } break; case 2: // have no data - m_no_metadata = time_now(); + m_no_metadata = aux::time_now(); if (m_waiting_metadata_request) m_tp.cancel_metadata_request(m_last_metadata_request); m_waiting_metadata_request = false; @@ -498,13 +498,13 @@ namespace libtorrent { namespace m_last_metadata_request = m_tp.metadata_request(); write_metadata_request(m_last_metadata_request); m_waiting_metadata_request = true; - m_metadata_request = time_now(); + m_metadata_request = aux::time_now(); } } bool has_metadata() const { - return time_now() - minutes(5) > m_no_metadata; + return aux::time_now() - minutes(5) > m_no_metadata; } private: @@ -527,11 +527,11 @@ namespace libtorrent { namespace // this is set to the current time each time we get a // "I don't have metadata" message. - ptime m_no_metadata; + time_point m_no_metadata; // this is set to the time when we last sent // a request for metadata to this peer - ptime m_metadata_request; + time_point m_metadata_request; // if we're waiting for a metadata request // this was the request we sent diff --git a/src/natpmp.cpp b/src/natpmp.cpp index c404003af..b85000bbc 100644 --- a/src/natpmp.cpp +++ b/src/natpmp.cpp @@ -43,7 +43,7 @@ POSSIBILITY OF SUCH DAMAGE. #include "libtorrent/enum_net.hpp" #include "libtorrent/socket_io.hpp" #include "libtorrent/io_service.hpp" -//#include "libtorrent/random.hpp" +#include "libtorrent/aux_/time.hpp" #if BOOST_VERSION < 103500 #include @@ -233,7 +233,7 @@ int natpmp::add_mapping(protocol_type p, int external_port, int local_port) int mapping_index = i - m_mappings.begin(); #ifdef NATPMP_LOG - ptime now = time_now(); + time_point now = aux::time_now(); for (std::vector::iterator m = m_mappings.begin() , end(m_mappings.end()); m != end; ++m) { @@ -254,7 +254,7 @@ int natpmp::add_mapping(protocol_type p, int external_port, int local_port) void natpmp::try_next_mapping(int i, mutex::scoped_lock& l) { #ifdef NATPMP_LOG - ptime now = time_now(); + time_point now = aux::time_now(); for (std::vector::iterator m = m_mappings.begin() , end(m_mappings.end()); m != end; ++m) { @@ -399,7 +399,7 @@ void natpmp::resend_request(int i, error_code const& e) m_currently_mapping = -1; m_mappings[i].action = mapping_t::action_none; // try again in two hours - m_mappings[i].expires = time_now() + hours(2); + m_mappings[i].expires = aux::time_now() + hours(2); try_next_mapping(i, l); return; } @@ -543,7 +543,7 @@ void natpmp::on_reply(error_code const& e } else { - m->expires = time_now() + seconds(int(lifetime * 0.7f)); + m->expires = aux::time_now() + seconds(int(lifetime * 0.7f)); m->external_port = public_port; } @@ -560,7 +560,7 @@ void natpmp::on_reply(error_code const& e int ev = errors::no_error; if (result >= 1 && result <= 5) ev = errors[result - 1]; - m->expires = time_now() + hours(2); + m->expires = aux::time_now() + hours(2); l.unlock(); m_callback(index, address(), 0, error_code(ev, get_libtorrent_category())); l.lock(); @@ -586,7 +586,7 @@ void natpmp::update_expiration_timer(mutex::scoped_lock& l) { if (m_abort) return; - ptime now = time_now() + milliseconds(100); + time_point now = aux::time_now() + milliseconds(100); #ifdef NATPMP_LOG std::cout << time_now_string() << " update_expiration_timer " << std::endl; for (std::vector::iterator i = m_mappings.begin() @@ -601,7 +601,7 @@ void natpmp::update_expiration_timer(mutex::scoped_lock& l) << " ]" << std::endl; } #endif - ptime min_expire = now + seconds(3600); + time_point min_expire = now + seconds(3600); int min_index = -1; for (std::vector::iterator i = m_mappings.begin() , end(m_mappings.end()); i != end; ++i) @@ -633,7 +633,7 @@ void natpmp::update_expiration_timer(mutex::scoped_lock& l) #ifdef NATPMP_LOG std::cout << time_now_string() << " next expiration [" " i: " << min_index - << " ttl: " << total_seconds(min_expire - time_now()) + << " ttl: " << total_seconds(min_expire - aux::time_now()) << " ]" << std::endl; #endif error_code ec; @@ -675,7 +675,7 @@ void natpmp::close_impl(mutex::scoped_lock& l) log("closing", l); #ifdef NATPMP_LOG std::cout << time_now_string() << " close" << std::endl; - ptime now = time_now(); + time_point now = aux::time_now(); #endif if (m_disabled) return; for (std::vector::iterator i = m_mappings.begin() diff --git a/src/peer_connection.cpp b/src/peer_connection.cpp index fbaef3223..18b109e27 100644 --- a/src/peer_connection.cpp +++ b/src/peer_connection.cpp @@ -71,6 +71,7 @@ POSSIBILITY OF SUCH DAMAGE. #include "libtorrent/ip_filter.hpp" #include "libtorrent/kademlia/node_id.hpp" #include "libtorrent/close_reason.hpp" +#include "libtorrent/aux_/time.hpp" #ifdef TORRENT_DEBUG #include @@ -111,7 +112,7 @@ namespace libtorrent // uint32_t length char event[32]; char* ptr = event; - detail::write_uint64(time_now_hires().time_since_epoch().count(), ptr); + detail::write_uint64(clock_type::now().time_since_epoch().count(), ptr); memcpy(ptr, &ih[0], 8); ptr += 8; detail::write_uint32(uintptr_t(p) & 0xffffffff, ptr); @@ -151,19 +152,19 @@ namespace libtorrent , m_allocator(*pack.allocator) , m_ios(*pack.ios) , m_work(m_ios) - , m_last_piece(time_now()) - , m_last_request(time_now()) + , m_last_piece(aux::time_now()) + , m_last_request(aux::time_now()) , m_last_incoming_request(min_time()) - , m_last_unchoke(time_now()) - , m_last_unchoked(time_now()) + , m_last_unchoke(aux::time_now()) + , m_last_unchoked(aux::time_now()) , m_last_choke(min_time()) - , m_last_receive(time_now()) - , m_last_sent(time_now()) + , m_last_receive(aux::time_now()) + , m_last_sent(aux::time_now()) , m_requested(min_time()) - , m_remote_dl_update(time_now()) - , m_connect(time_now()) - , m_became_uninterested(time_now()) - , m_became_uninteresting(time_now()) + , m_remote_dl_update(aux::time_now()) + , m_connect(aux::time_now()) + , m_became_uninterested(aux::time_now()) + , m_became_uninteresting(aux::time_now()) , m_downloaded_at_last_round(0) , m_uploaded_at_last_round(0) , m_uploaded_at_last_unchoke(0) @@ -416,7 +417,7 @@ namespace libtorrent m_socket->async_connect(m_remote , boost::bind(&peer_connection::on_connection_complete, self(), _1)); - m_connect = time_now_hires(); + m_connect = clock_type::now(); sent_syn(m_remote.address().is_v6()); @@ -1000,11 +1001,11 @@ namespace libtorrent // if we haven't received any data recently, the current download rate // is not representative - if (time_now() - m_last_piece > seconds(30) && m_download_rate_peak > 0) + if (aux::time_now() - m_last_piece > seconds(30) && m_download_rate_peak > 0) { rate = m_download_rate_peak; } - else if (time_now() - m_last_unchoked < seconds(5) + else if (aux::time_now() - m_last_unchoked < seconds(5) && m_statistics.total_payload_upload() < 2 * 0x4000) { // if we're have only been unchoked for a short period of time, @@ -1165,7 +1166,7 @@ namespace libtorrent INVARIANT_CHECK; #if defined TORRENT_LOGGING - m_connect_time = time_now_hires(); + m_connect_time = clock_type::now(); peer_log("*** attached to torrent"); #endif @@ -1567,7 +1568,7 @@ namespace libtorrent TORRENT_ASSERT(t); #if defined TORRENT_LOGGING - m_unchoke_time = time_now_hires(); + m_unchoke_time = clock_type::now(); t->debug_log("UNCHOKE [%p] (%d ms)", this, int(total_milliseconds(m_unchoke_time - m_bitfield_time))); #endif @@ -1586,7 +1587,7 @@ namespace libtorrent m_counters.inc_stats_counter(counters::num_peers_down_unchoked); m_peer_choked = false; - m_last_unchoked = time_now(); + m_last_unchoked = aux::time_now(); if (is_disconnecting()) return; if (is_interesting()) @@ -1717,7 +1718,7 @@ namespace libtorrent } #endif - m_became_uninterested = time_now(); + m_became_uninterested = aux::time_now(); #if defined TORRENT_LOGGING peer_log("<== NOT_INTERESTED"); @@ -2025,7 +2026,7 @@ namespace libtorrent m_bitfield_received = true; #if defined TORRENT_LOGGING - m_bitfield_time = time_now_hires(); + m_bitfield_time = clock_type::now(); t->debug_log("HANDSHAKE [%p] (%d ms)", this, int(total_milliseconds(m_bitfield_time - m_connect_time))); #endif // if we don't have metadata yet @@ -2337,7 +2338,7 @@ namespace libtorrent // allow peers to send request up to 2 seconds after getting choked, // then disconnect them - if (time_now() - seconds(2) > m_last_choke + if (aux::time_now() - seconds(2) > m_last_choke && can_disconnect(error_code(errors::too_many_requests_when_choked, get_libtorrent_category()))) { disconnect(errors::too_many_requests_when_choked, op_bittorrent, 2); @@ -2359,7 +2360,7 @@ namespace libtorrent if (log) write_request_log(log, t->info_hash(), this, r); #endif - m_last_incoming_request = time_now(); + m_last_incoming_request = aux::time_now(); fill_send_buffer(); } } @@ -2384,7 +2385,7 @@ namespace libtorrent void peer_connection::incoming_piece_fragment(int bytes) { TORRENT_ASSERT(is_single_thread()); - m_last_piece = time_now(); + m_last_piece = aux::time_now(); TORRENT_ASSERT(m_outstanding_bytes >= bytes); m_outstanding_bytes -= bytes; if (m_outstanding_bytes < 0) m_outstanding_bytes = 0; @@ -2629,7 +2630,7 @@ namespace libtorrent return; } - ptime now = time_now_hires(); + time_point now = clock_type::now(); t->need_picker(); @@ -2727,7 +2728,7 @@ namespace libtorrent #if defined TORRENT_LOGGING t->debug_log("PIECE [%p] (%d ms) (%d)", this - , int(total_milliseconds(time_now_hires() - m_unchoke_time)), t->num_have()); + , int(total_milliseconds(clock_type::now() - m_unchoke_time)), t->num_have()); peer_log("*** FILE ASYNC WRITE [ piece: %d | s: %x | l: %x ]" , p.piece, p.start, p.length); @@ -3064,7 +3065,7 @@ namespace libtorrent m_bitfield_received = true; #if defined TORRENT_LOGGING - m_bitfield_time = time_now_hires(); + m_bitfield_time = clock_type::now(); t->debug_log("HANDSHAKE [%p] (%d ms)", this, int(total_milliseconds(m_bitfield_time - m_connect_time))); #endif @@ -3136,7 +3137,7 @@ namespace libtorrent m_bitfield_received = true; #if defined TORRENT_LOGGING - m_bitfield_time = time_now_hires(); + m_bitfield_time = clock_type::now(); t->debug_log("HANDSHAKE [%p] (%d ms)", this, int(total_milliseconds(m_bitfield_time - m_connect_time))); #endif m_have_piece.clear_all(); @@ -3166,7 +3167,7 @@ namespace libtorrent #if defined TORRENT_LOGGING { - ptime now = time_now_hires(); + time_point now = clock_type::now(); t->debug_log("ALLOW FAST [%p] (%d ms)", this, int(total_milliseconds(now - m_connect_time))); if (m_peer_choked) m_unchoke_time = now; } @@ -3526,7 +3527,7 @@ namespace libtorrent m_counters.inc_stats_counter(counters::num_peers_up_unchoked, -1); m_choked = true; - m_last_choke = time_now(); + m_last_choke = aux::time_now(); m_num_invalid_requests = 0; // reject the requests we have in the queue @@ -3582,7 +3583,7 @@ namespace libtorrent m_sent_suggests = true; } - m_last_unchoke = time_now(); + m_last_unchoke = aux::time_now(); write_unchoke(); m_counters.inc_stats_counter(counters::num_peers_up_unchoked_all); if (!ignore_unchoke_slots()) @@ -3635,7 +3636,7 @@ namespace libtorrent write_not_interested(); - m_became_uninteresting = time_now(); + m_became_uninteresting = aux::time_now(); #if defined TORRENT_LOGGING peer_log("==> NOT_INTERESTED"); @@ -3811,7 +3812,7 @@ namespace libtorrent #endif { write_request(r); - m_last_request = time_now(); + m_last_request = aux::time_now(); } #if defined TORRENT_LOGGING @@ -3822,7 +3823,7 @@ namespace libtorrent , m_request_large_blocks?"large":"single"); #endif } - m_last_piece = time_now(); + m_last_piece = aux::time_now(); if (!m_download_queue.empty() && empty_download_queue) @@ -3830,10 +3831,10 @@ namespace libtorrent // This means we just added a request to this connection that // previously did not have a request. That's when we start the // request timeout. - m_requested = time_now(); + m_requested = aux::time_now(); #if defined TORRENT_LOGGING t->debug_log("REQUEST [%p] (%d ms)", this - , int(total_milliseconds(time_now_hires() - m_unchoke_time))); + , int(total_milliseconds(clock_type::now() - m_unchoke_time))); #endif } } @@ -4225,7 +4226,7 @@ namespace libtorrent TORRENT_ASSERT(is_single_thread()); TORRENT_ASSERT(!associated_torrent().expired()); - ptime now = time_now(); + time_point now = aux::time_now(); p.download_rate_peak = m_download_rate_peak; p.upload_rate_peak = m_upload_rate_peak; @@ -4485,7 +4486,7 @@ namespace libtorrent void peer_connection::second_tick(int tick_interval_ms) { TORRENT_ASSERT(is_single_thread()); - ptime now = time_now(); + time_point now = aux::time_now(); boost::shared_ptr me(self()); // the invariant check must be run before me is destructed @@ -4984,7 +4985,7 @@ namespace libtorrent t->inc_refcount("async_read"); m_disk_thread.async_read(&t->storage(), r , boost::bind(&peer_connection::on_disk_read_complete - , self(), _1, r, time_now_hires()), this); + , self(), _1, r, clock_type::now()), this); } m_requests.erase(m_requests.begin() + i); @@ -5054,14 +5055,14 @@ namespace libtorrent } void peer_connection::on_disk_read_complete(disk_io_job const* j - , peer_request r, ptime issue_time) + , peer_request r, time_point issue_time) { TORRENT_ASSERT(is_single_thread()); // return value: // 0: success, piece passed hash check // -1: disk failure - int disk_rtt = int(total_microseconds(time_now_hires() - issue_time)); + int disk_rtt = int(total_microseconds(clock_type::now() - issue_time)); #if defined TORRENT_LOGGING peer_log("*** FILE ASYNC READ COMPLETE [ ret: %d | piece: %d | s: %x | l: %x" @@ -5960,7 +5961,7 @@ namespace libtorrent } while (bytes_transferred > 0); - m_last_receive = time_now(); + m_last_receive = aux::time_now(); if (is_seed()) { @@ -6041,7 +6042,7 @@ namespace libtorrent #endif #if defined TORRENT_LOGGING || defined TORRENT_USE_OPENSSL - ptime completed = time_now_hires(); + time_point completed = clock_type::now(); #endif INVARIANT_CHECK; @@ -6085,7 +6086,7 @@ namespace libtorrent m_counters.inc_stats_counter(counters::num_peers_connected); if (m_disconnecting) return; - m_last_receive = time_now(); + m_last_receive = aux::time_now(); error_code ec; m_local = m_socket->local_endpoint(ec); @@ -6217,7 +6218,7 @@ namespace libtorrent m_send_buffer.pop_front(bytes_transferred); - ptime now = time_now_hires(); + time_point now = clock_type::now(); for (std::vector::iterator i = m_download_queue.begin() , end(m_download_queue.end()); i != end; ++i) @@ -6554,7 +6555,7 @@ namespace libtorrent #endif time_duration d; - d = time_now() - m_last_sent; + d = aux::time_now() - m_last_sent; if (total_seconds(d) < timeout() / 2) return; if (m_connecting) return; @@ -6568,7 +6569,7 @@ namespace libtorrent peer_log("==> KEEPALIVE"); #endif - m_last_sent = time_now(); + m_last_sent = aux::time_now(); write_keepalive(); } diff --git a/src/resolver.cpp b/src/resolver.cpp index 246dbe4c0..0775d238e 100644 --- a/src/resolver.cpp +++ b/src/resolver.cpp @@ -33,6 +33,7 @@ POSSIBILITY OF SUCH DAMAGE. #include "libtorrent/resolver.hpp" #include #include "libtorrent/debug.hpp" +#include "libtorrent/aux_/time.hpp" namespace libtorrent { @@ -58,7 +59,7 @@ namespace libtorrent } dns_cache_entry& ce = m_cache[hostname]; - ptime now = time_now(); + time_point now = aux::time_now(); ce.last_seen = now; ce.addresses.clear(); while (i != tcp::resolver::iterator()) @@ -95,7 +96,7 @@ namespace libtorrent { // keep cache entries valid for m_timeout seconds if ((flags & resolver_interface::prefer_cache) - || i->second.last_seen + m_timeout >= time_now()) + || i->second.last_seen + m_timeout >= aux::time_now()) { error_code ec; m_ios.post(boost::bind(h, ec, i->second.addresses)); diff --git a/src/session_impl.cpp b/src/session_impl.cpp index 1f1d10a44..1f1fb834c 100644 --- a/src/session_impl.cpp +++ b/src/session_impl.cpp @@ -383,7 +383,7 @@ namespace aux { , m_suggest_timer(0) , m_peak_up_rate(0) , m_peak_down_rate(0) - , m_created(time_now_hires()) + , m_created(clock_type::now()) , m_last_tick(m_created) , m_last_second_tick(m_created - milliseconds(900)) , m_last_choke(m_created) @@ -2360,7 +2360,7 @@ retry: #ifdef TORRENT_USE_OPENSSL // add the current time to the PRNG, to add more unpredictability - boost::uint64_t now = time_now_hires().time_since_epoch().count(); + boost::uint64_t now = clock_type::now().time_since_epoch().count(); // assume 12 bits of entropy (i.e. about 8 milliseconds) RAND_add(&now, 8, 1.5); #endif @@ -2694,11 +2694,11 @@ retry: // than a system call and can be // used where more accurate time // is not necessary - extern ptime g_current_time; + extern time_point g_current_time; initialize_timer::initialize_timer() { - g_current_time = time_now_hires(); + g_current_time = clock_type::now(); } int session_impl::rate_limit(peer_class_t c, int channel) const @@ -2810,7 +2810,7 @@ retry: // submit all disk jobs when we leave this function deferred_submit_jobs(); - ptime now = time_now_hires(); + time_point now = clock_type::now(); aux::g_current_time = now; // too expensive // INVARIANT_CHECK; @@ -3252,8 +3252,8 @@ retry: void session_impl::update_rss_feeds() { time_t now_posix = time(0); - ptime min_update = max_time(); - ptime now = time_now(); + time_point min_update = max_time(); + time_point now = aux::time_now(); for (std::vector >::iterator i = m_feeds.begin(), end(m_feeds.end()); i != end; ++i) { @@ -3262,7 +3262,7 @@ retry: if (delta <= 0) delta = f.update_feed(); TORRENT_ASSERT(delta >= 0); - ptime next_update = now + seconds(delta); + time_point next_update = now + seconds(delta); if (next_update < min_update) min_update = next_update; } m_next_rss_update = min_update; @@ -3854,7 +3854,7 @@ retry: TORRENT_ASSERT(is_single_thread()); INVARIANT_CHECK; - ptime now = time_now(); + time_point now = aux::time_now(); time_duration unchoke_interval = now - m_last_choke; m_last_choke = now; @@ -4378,7 +4378,7 @@ retry: for (int i = 0; i < counters::num_counters; ++i) values[i] = m_stats_counters[i]; - alert->timestamp = total_microseconds(time_now_hires() - m_created); + alert->timestamp = total_microseconds(clock_type::now() - m_created); m_alerts.post_alert_ptr(alert.release()); } @@ -5628,9 +5628,9 @@ retry: FILE* f = fopen("wakeups.log", "w+"); if (f != NULL) { - ptime m = min_time(); + time_point m = min_time(); if (_wakeups.size() > 0) m = _wakeups[0].timestamp; - ptime prev = m; + time_point prev = m; boost::uint64_t prev_csw = 0; if (_wakeups.size() > 0) prev_csw = _wakeups[0].context_switches; fprintf(f, "abs. time\trel. time\tctx switch\tidle-wakeup\toperation\n"); diff --git a/src/storage.cpp b/src/storage.cpp index fd2f364cc..cd8d9df4f 100644 --- a/src/storage.cpp +++ b/src/storage.cpp @@ -115,7 +115,7 @@ namespace libtorrent op_end = 2 }; - void write_access_log(boost::uint64_t offset, boost::uint32_t fileid, int flags, ptime timestamp) + void write_access_log(boost::uint64_t offset, boost::uint32_t fileid, int flags, time_point timestamp) { if (g_access_log == NULL) return; @@ -1201,7 +1201,7 @@ namespace libtorrent #ifdef TORRENT_DISK_STATS int flags = ((op.mode & file::rw_mask) == file::read_only) ? op_read : op_write; - write_access_log(adjusted_offset, handle->file_id(), op_start | flags, time_now_hires()); + write_access_log(adjusted_offset, handle->file_id(), op_start | flags, clock_type::now()); #endif bytes_transferred = (int)((*handle).*op.op)(adjusted_offset @@ -1211,7 +1211,7 @@ namespace libtorrent TORRENT_ASSERT(e || bytes_transferred >= 0); #ifdef TORRENT_DISK_STATS - write_access_log(adjusted_offset + bytes_transferred, handle->file_id(), op_end | flags, time_now_hires()); + write_access_log(adjusted_offset + bytes_transferred, handle->file_id(), op_end | flags, clock_type::now()); #endif TORRENT_ASSERT(bytes_transferred <= bufs_size(tmp_bufs, num_tmp_bufs)); } diff --git a/src/time.cpp b/src/time.cpp index 1cf561623..8192520fb 100644 --- a/src/time.cpp +++ b/src/time.cpp @@ -42,25 +42,22 @@ POSSIBILITY OF SUCH DAMAGE. #include #endif -namespace libtorrent +namespace libtorrent { namespace aux { - namespace aux - { - // used to cache the current time - // every 100 ms. This is cheaper - // than a system call and can be - // used where more accurate time - // is not necessary - ptime g_current_time; - } + // used to cache the current time + // every 100 ms. This is cheaper + // than a system call and can be + // used where more accurate time + // is not necessary + time_point g_current_time; - TORRENT_EXPORT ptime const& time_now() { return aux::g_current_time; } + time_point const& time_now() { return aux::g_current_time; } TORRENT_EXTRA_EXPORT char const* time_now_string() { - static const ptime start = time_now_hires(); + static const time_point start = clock_type::now(); static char ret[200]; - int t = total_milliseconds(time_now_hires() - start); + int t = total_milliseconds(clock_type::now() - start); int h = t / 1000 / 60 / 60; t -= h * 60 * 60 * 1000; int m = t / 1000 / 60; @@ -74,10 +71,10 @@ namespace libtorrent std::string log_time() { - static const ptime start = time_now_hires(); + static const time_point start = clock_type::now(); char ret[200]; - snprintf(ret, sizeof(ret), "%" PRId64, total_microseconds(time_now_hires() - start)); + snprintf(ret, sizeof(ret), "%" PRId64, total_microseconds(clock_type::now() - start)); return ret; } -} +} } diff --git a/src/torrent.cpp b/src/torrent.cpp index c98edf8a2..b60b4de51 100644 --- a/src/torrent.cpp +++ b/src/torrent.cpp @@ -124,7 +124,7 @@ namespace libtorrent web_seed_t::web_seed_t(web_seed_entry const& wse) : web_seed_entry(wse) - , retry(time_now()) + , retry(aux::time_now()) , peer_info(tcp::endpoint(), true, 0) , supports_keepalive(true) , resolving(false) @@ -138,7 +138,7 @@ namespace libtorrent , std::string const& auth_ , web_seed_entry::headers_t const& extra_headers_) : web_seed_entry(url_, type_, auth_, extra_headers_) - , retry(time_now()) + , retry(aux::time_now()) , peer_info(tcp::endpoint(), true, 0) , supports_keepalive(true) , resolving(false) @@ -1551,7 +1551,7 @@ namespace libtorrent // this is needed for openssl < 1.0 to decrypt keys created by openssl 1.0+ OpenSSL_add_all_algorithms(); - boost::uint64_t now = time_now_hires().time_since_epoch().count(); + boost::uint64_t now = clock_type::now().time_since_epoch().count(); // assume 9 bits of entropy (i.e. about 1 millisecond) RAND_add(&now, 8, 1.125); RAND_add(&info_hash()[0], 20, 3); @@ -2805,7 +2805,7 @@ namespace libtorrent #if defined TORRENT_LOGGING debug_log("START DHT announce"); - m_dht_start_time = time_now_hires(); + m_dht_start_time = clock_type::now(); #endif // if we're a seed, we tell the DHT for better scrape stats @@ -2837,7 +2837,7 @@ namespace libtorrent #if defined TORRENT_LOGGING debug_log("END DHT announce (%d ms) (%d peers)" - , int(total_milliseconds(time_now_hires() - m_dht_start_time)) + , int(total_milliseconds(clock_type::now() - m_dht_start_time)) , int(peers.size())); #endif @@ -2930,7 +2930,7 @@ namespace libtorrent req.num_want = (req.event == tracker_request::stopped) ?0:settings().get_int(settings_pack::num_want); - ptime now = time_now_hires(); + time_point now = clock_type::now(); // the tier is kept as INT_MAX until we find the first // tracker that works, then it's set to that tracker's @@ -3167,7 +3167,7 @@ namespace libtorrent , aux::session_interface::source_tracker , *tracker_ips.begin()); - ptime now = time_now(); + time_point now = aux::time_now(); int interval = resp.interval; if (interval < settings().get_int(settings_pack::min_announce_interval)) @@ -3440,12 +3440,12 @@ namespace libtorrent if (want_peers()) m_ses.prioritize_connections(shared_from_this()); } - ptime torrent::next_announce() const + time_point torrent::next_announce() const { return m_waiting_tracker?m_tracker_timer.expires_at():min_time(); } - void torrent::force_tracker_request(ptime t, int tracker_idx) + void torrent::force_tracker_request(time_point t, int tracker_idx) { if (is_paused()) return; if (tracker_idx == -1) @@ -3462,7 +3462,7 @@ namespace libtorrent announce_entry& e = m_trackers[tracker_idx]; e.next_announce = (std::max)(t, e.min_announce) + seconds(1); } - update_tracker_timer(time_now_hires()); + update_tracker_timer(clock_type::now()); } void torrent::set_tracker_login( @@ -4939,7 +4939,7 @@ namespace libtorrent return; } - ptime deadline = time_now() + milliseconds(t); + time_point deadline = aux::time_now() + milliseconds(t); // if we already have the piece, no need to set the deadline. // however, if the user asked to get the piece data back, we still @@ -5049,7 +5049,7 @@ namespace libtorrent { // update the average download time and average // download time deviation - int dl_time = total_milliseconds(time_now() - i->first_requested); + int dl_time = total_milliseconds(aux::time_now() - i->first_requested); if (m_average_piece_time == 0) { @@ -6177,7 +6177,7 @@ namespace libtorrent #endif // unavailable, retry in 30 minutes - web->retry = time_now() + minutes(30); + web->retry = aux::time_now() + minutes(30); return; } @@ -7891,7 +7891,7 @@ namespace libtorrent boost::int64_t lhs_transferred = lhs->statistics().total_payload_download(); boost::int64_t rhs_transferred = rhs->statistics().total_payload_download(); - ptime now = time_now(); + time_point now = aux::time_now(); boost::int64_t lhs_time_connected = total_seconds(now - lhs->connected_time()); boost::int64_t rhs_time_connected = total_seconds(now - rhs->connected_time()); @@ -8068,7 +8068,7 @@ namespace libtorrent std::vector().swap(m_file_progress); if (!m_announcing) return; - ptime now = time_now(); + time_point now = aux::time_now(); for (std::vector::iterator i = m_trackers.begin() , end(m_trackers.end()); i != end; ++i) { @@ -9329,7 +9329,7 @@ namespace libtorrent do_connect_boost(); } - void torrent::update_tracker_timer(ptime now) + void torrent::update_tracker_timer(time_point now) { TORRENT_ASSERT(is_single_thread()); if (!m_announcing) @@ -9340,7 +9340,7 @@ namespace libtorrent return; } - ptime next_announce = max_time(); + time_point next_announce = max_time(); int tier = INT_MAX; bool found_working = false; @@ -9375,7 +9375,7 @@ namespace libtorrent } else { - ptime next_tracker_announce = (std::max)(i->next_announce, i->min_announce); + time_point next_tracker_announce = (std::max)(i->next_announce, i->min_announce); if (next_tracker_announce < next_announce && (!found_working || i->is_working())) next_announce = next_tracker_announce; @@ -9481,7 +9481,7 @@ namespace libtorrent m_announcing = false; - ptime now = time_now(); + time_point now = aux::time_now(); for (std::vector::iterator i = m_trackers.begin() , end(m_trackers.end()); i != end; ++i) { @@ -9754,7 +9754,7 @@ namespace libtorrent { std::list::iterator w = i++; if (w->peer_info.connection) continue; - if (w->retry > time_now()) continue; + if (w->retry > aux::time_now()) continue; if (w->resolving) continue; connect_to_url_seed(w); @@ -10073,7 +10073,7 @@ namespace libtorrent { using namespace libtorrent; - ptime now = time_now_hires(); + time_point now = clock_type::now(); float deadline = 0.f; float last_request = 0.f; @@ -10211,7 +10211,7 @@ namespace libtorrent std::vector backup2; std::vector ignore; - ptime now = time_now(); + time_point now = aux::time_now(); // loop until every block has been requested from this piece (i->piece) do @@ -10434,7 +10434,7 @@ namespace libtorrent // piece is done std::vector ignore_peers; - ptime now = time_now_hires(); + time_point now = clock_type::now(); // now, iterate over all time critical pieces, in order of importance, and // request them from the peers, in order of responsiveness. i.e. request @@ -10634,7 +10634,7 @@ namespace libtorrent TORRENT_ASSERT(i != m_web_seeds.end()); if (i == m_web_seeds.end()) return; if (retry == 0) retry = m_ses.settings().get_int(settings_pack::urlseed_wait_retry); - i->retry = time_now() + seconds(retry); + i->retry = aux::time_now() + seconds(retry); } torrent_state torrent::get_policy_state() @@ -11246,7 +11246,7 @@ namespace libtorrent { INVARIANT_CHECK; - ptime now = time_now(); + time_point now = aux::time_now(); st->handle = get_handle(); st->info_hash = info_hash(); @@ -11557,7 +11557,7 @@ namespace libtorrent // announce to the next working tracker if ((!m_abort && !is_paused()) || r.event == tracker_request::stopped) announce_with_tracker(r.event); - update_tracker_timer(time_now()); + update_tracker_timer(aux::time_now()); } #if defined TORRENT_LOGGING diff --git a/src/torrent_handle.cpp b/src/torrent_handle.cpp index c290332bd..fa5cd1a76 100644 --- a/src/torrent_handle.cpp +++ b/src/torrent_handle.cpp @@ -747,7 +747,7 @@ namespace libtorrent void torrent_handle::force_reannounce( boost::posix_time::time_duration duration) const { - TORRENT_ASYNC_CALL2(force_tracker_request, time_now() + TORRENT_ASYNC_CALL2(force_tracker_request, aux::time_now() + seconds(duration.total_seconds()), -1); } #endif @@ -761,7 +761,7 @@ namespace libtorrent void torrent_handle::force_reannounce(int s, int idx) const { - TORRENT_ASYNC_CALL2(force_tracker_request, time_now() + seconds(s), idx); + TORRENT_ASYNC_CALL2(force_tracker_request, aux::time_now() + seconds(s), idx); } void torrent_handle::file_status(std::vector& status) const diff --git a/src/torrent_info.cpp b/src/torrent_info.cpp index 7cfbac555..18f4f9f48 100644 --- a/src/torrent_info.cpp +++ b/src/torrent_info.cpp @@ -659,10 +659,10 @@ namespace libtorrent announce_entry::~announce_entry() {} int announce_entry::next_announce_in() const - { return total_seconds(next_announce - time_now()); } + { return total_seconds(next_announce - aux::time_now()); } int announce_entry::min_announce_in() const - { return total_seconds(min_announce - time_now()); } + { return total_seconds(min_announce - aux::time_now()); } void announce_entry::reset() { @@ -681,11 +681,11 @@ namespace libtorrent * tracker_retry_delay_min * sett.get_int(settings_pack::tracker_backoff) / 100 , int(tracker_retry_delay_max)); delay = (std::max)(delay, retry_interval); - next_announce = time_now() + seconds(delay); + next_announce = aux::time_now() + seconds(delay); updating = false; } - bool announce_entry::can_announce(ptime now, bool is_seed) const + bool announce_entry::can_announce(time_point now, bool is_seed) const { // if we're a seed and we haven't sent a completed // event, we need to let this announce through diff --git a/src/tracker_manager.cpp b/src/tracker_manager.cpp index 6f40a3a76..340e81bcc 100644 --- a/src/tracker_manager.cpp +++ b/src/tracker_manager.cpp @@ -58,7 +58,7 @@ namespace libtorrent { timeout_handler::timeout_handler(io_service& ios) : m_completion_timeout(0) - , m_start_time(time_now_hires()) + , m_start_time(clock_type::now()) , m_read_time(m_start_time) , m_timeout(ios) , m_read_timeout(0) @@ -69,7 +69,7 @@ namespace libtorrent { m_completion_timeout = completion_timeout; m_read_timeout = read_timeout; - m_start_time = m_read_time = time_now_hires(); + m_start_time = m_read_time = clock_type::now(); TORRENT_ASSERT(completion_timeout > 0 || read_timeout > 0); @@ -95,7 +95,7 @@ namespace libtorrent void timeout_handler::restart_read_timeout() { - m_read_time = time_now_hires(); + m_read_time = clock_type::now(); } void timeout_handler::cancel() @@ -113,7 +113,7 @@ namespace libtorrent #endif if (m_abort) return; - ptime now = time_now_hires(); + time_point now = clock_type::now(); time_duration receive_timeout = now - m_read_time; time_duration completion_timeout = now - m_start_time; diff --git a/src/udp_socket.cpp b/src/udp_socket.cpp index 55f787b48..38841061c 100644 --- a/src/udp_socket.cpp +++ b/src/udp_socket.cpp @@ -39,6 +39,8 @@ POSSIBILITY OF SUCH DAMAGE. #include "libtorrent/string_util.hpp" // for allocate_string_copy #include "libtorrent/broadcast_socket.hpp" // for is_any #include "libtorrent/settings_pack.hpp" +#include "libtorrent/aux_/time.hpp" // for aux::time_now() + #include #include #include @@ -1332,13 +1334,13 @@ rate_limited_udp_socket::rate_limited_udp_socket(io_service& ios) : udp_socket(ios) , m_rate_limit(8000) , m_quota(8000) - , m_last_tick(time_now()) + , m_last_tick(aux::time_now()) { } bool rate_limited_udp_socket::has_quota() { - ptime now = time_now_hires(); + time_point now = clock_type::now(); time_duration delta = now - m_last_tick; m_last_tick = now; // add any new quota we've accrued since last time @@ -1349,7 +1351,7 @@ bool rate_limited_udp_socket::has_quota() bool rate_limited_udp_socket::send(udp::endpoint const& ep, char const* p , int len, error_code& ec, int flags) { - ptime now = time_now_hires(); + time_point now = clock_type::now(); time_duration delta = now - m_last_tick; m_last_tick = now; diff --git a/src/udp_tracker_connection.cpp b/src/udp_tracker_connection.cpp index e78aea20e..28a572a2e 100644 --- a/src/udp_tracker_connection.cpp +++ b/src/udp_tracker_connection.cpp @@ -54,6 +54,7 @@ POSSIBILITY OF SUCH DAMAGE. #include "libtorrent/aux_/session_settings.hpp" #include "libtorrent/resolver_interface.hpp" #include "libtorrent/ip_filter.hpp" +#include "libtorrent/aux_/time.hpp" #if defined TORRENT_LOGGING #include "libtorrent/socket_io.hpp" @@ -289,7 +290,7 @@ namespace libtorrent { // we found a cached entry! Now, we can only // use if if it hasn't expired - if (time_now() < cc->second.expires) + if (aux::time_now() < cc->second.expires) { if (tracker_req().kind == tracker_request::announce_request) send_udp_announce(); @@ -468,7 +469,7 @@ namespace libtorrent mutex::scoped_lock l(m_cache_mutex); connection_cache_entry& cce = m_connection_cache[m_target.address()]; cce.connection_id = connection_id; - cce.expires = time_now() + seconds(m_man.settings().get_int(settings_pack::udp_tracker_token_expiry)); + cce.expires = aux::time_now() + seconds(m_man.settings().get_int(settings_pack::udp_tracker_token_expiry)); if (tracker_req().kind == tracker_request::announce_request) send_udp_announce(); diff --git a/src/upnp.cpp b/src/upnp.cpp index 9bd82e4cb..603523640 100644 --- a/src/upnp.cpp +++ b/src/upnp.cpp @@ -39,6 +39,7 @@ POSSIBILITY OF SUCH DAMAGE. #include "libtorrent/enum_net.hpp" #include "libtorrent/escape_string.hpp" #include "libtorrent/random.hpp" +#include "libtorrent/aux_/time.hpp" // for aux::time_now() #if defined TORRENT_ASIO_DEBUGGING #include "libtorrent/debug.hpp" @@ -366,7 +367,7 @@ void upnp::on_reply(udp::endpoint const& from, char* buffer */ error_code ec; - if (time_now_hires() - seconds(60) > m_last_if_update) + if (clock_type::now() - seconds(60) > m_last_if_update) { m_interfaces = enum_net_interfaces(m_io_service, ec); if (ec) @@ -376,7 +377,7 @@ void upnp::on_reply(udp::endpoint const& from, char* buffer , print_endpoint(from).c_str(), convert_from_native(ec.message()).c_str()); log(msg, l); } - m_last_if_update = time_now(); + m_last_if_update = aux::time_now(); } if (!ec && !in_local_network(m_interfaces, from.address())) @@ -1431,10 +1432,10 @@ void upnp::on_upnp_map_response(error_code const& e l.lock(); if (d.lease_duration > 0) { - m.expires = time_now() + m.expires = aux::time_now() + seconds(int(d.lease_duration * 0.75f)); - ptime next_expire = m_refresh_timer.expires_at(); - if (next_expire < time_now() + time_point next_expire = m_refresh_timer.expires_at(); + if (next_expire < aux::time_now() || next_expire > m.expires) { #if defined TORRENT_ASIO_DEBUGGING @@ -1540,8 +1541,8 @@ void upnp::on_expire(error_code const& ec) #endif if (ec) return; - ptime now = time_now(); - ptime next_expire = max_time(); + time_point now = aux::time_now(); + time_point next_expire = max_time(); mutex::scoped_lock l(m_mutex); diff --git a/src/ut_metadata.cpp b/src/ut_metadata.cpp index f13a7e2e3..adf7198cc 100644 --- a/src/ut_metadata.cpp +++ b/src/ut_metadata.cpp @@ -196,7 +196,7 @@ namespace libtorrent { namespace { metadata_piece(): num_requests(0), last_request(min_time()) {} int num_requests; - ptime last_request; + time_point last_request; boost::weak_ptr source; bool operator<(metadata_piece const& rhs) const { return num_requests < rhs.num_requests; } @@ -410,7 +410,7 @@ namespace libtorrent { namespace break; case 2: // have no data { - m_request_limit = (std::max)(time_now() + minutes(1), m_request_limit); + m_request_limit = (std::max)(aux::time_now() + minutes(1), m_request_limit); std::vector::iterator i = std::find(m_sent_requests.begin() , m_sent_requests.end(), piece); // unwanted piece? @@ -463,10 +463,10 @@ namespace libtorrent { namespace bool has_metadata() const { - return m_pc.has_metadata() || (time_now() > m_request_limit); + return m_pc.has_metadata() || (aux::time_now() > m_request_limit); } - void failed_hash_check(ptime const& now) + void failed_hash_check(time_point const& now) { m_request_limit = now + seconds(20 + (boost::int64_t(random()) * 50) / UINT_MAX); } @@ -481,7 +481,7 @@ namespace libtorrent { namespace // again. It is updated every time we get a // "I don't have metadata" message, but also when // we receive metadata that fails the infohash check - ptime m_request_limit; + time_point m_request_limit; // request queues std::vector m_sent_requests; @@ -521,7 +521,7 @@ namespace libtorrent { namespace int piece = i - m_requested_metadata.begin(); // don't request the same block more than once every 3 seconds - ptime now = time_now(); + time_point now = aux::time_now(); if (m_requested_metadata[piece].last_request != min_time() && total_seconds(now - m_requested_metadata[piece].last_request) < 3) return -1; @@ -606,7 +606,7 @@ namespace libtorrent { namespace { if (!m_torrent.valid_metadata()) { - ptime now = time_now(); + time_point now = aux::time_now(); // any peer that we downloaded metadata from gets a random time // penalty, from 5 to 30 seconds or so. During this time we don't // make any metadata requests from those peers (to mix it up a bit diff --git a/src/ut_pex.cpp b/src/ut_pex.cpp index 6dc72af22..05115dd21 100644 --- a/src/ut_pex.cpp +++ b/src/ut_pex.cpp @@ -112,7 +112,7 @@ namespace libtorrent { namespace // max_peer_entries limits the packet size virtual void tick() { - ptime now = time_now(); + time_point now = aux::time_now(); if (now - seconds(60) < m_last_msg) return; m_last_msg = now; @@ -229,7 +229,7 @@ namespace libtorrent { namespace torrent& m_torrent; std::set m_old_peers; - ptime m_last_msg; + time_point m_last_msg; std::vector m_ut_pex_msg; int m_peers_in_message; }; @@ -286,7 +286,7 @@ namespace libtorrent { namespace if (body.left() < length) return true; - ptime now = time_now(); + time_point now = aux::time_now(); if (now - seconds(60) < m_last_pex[0]) { // this client appears to be trying to flood us @@ -433,7 +433,7 @@ namespace libtorrent { namespace // no handshake yet if (!m_message_index) return; - ptime now = time_now(); + time_point now = aux::time_now(); if (now - seconds(60) < m_last_msg) { #ifdef TORRENT_LOGGING @@ -442,7 +442,7 @@ namespace libtorrent { namespace #endif return; } - static ptime global_last = min_time(); + static time_point global_last = min_time(); int num_peers = m_torrent.num_peers(); if (num_peers <= 1) return; @@ -636,9 +636,9 @@ namespace libtorrent { namespace // then once we read from the socket it will look like // we received them all back to back. That's why // we look at 6 pex messages back. - ptime m_last_pex[6]; + time_point m_last_pex[6]; - ptime m_last_msg; + time_point m_last_msg; int m_message_index; // this is initialized to true, and set to diff --git a/src/utp_socket_manager.cpp b/src/utp_socket_manager.cpp index 9d76b81b7..b372a11a3 100644 --- a/src/utp_socket_manager.cpp +++ b/src/utp_socket_manager.cpp @@ -38,6 +38,7 @@ POSSIBILITY OF SUCH DAMAGE. #include "libtorrent/broadcast_socket.hpp" // for is_teredo #include "libtorrent/random.hpp" #include "libtorrent/performance_counters.hpp" +#include "libtorrent/aux_/time.hpp" // for aux::time_now() // #define TORRENT_DEBUG_MTU 1135 @@ -70,7 +71,7 @@ namespace libtorrent } } - void utp_socket_manager::tick(ptime now) + void utp_socket_manager::tick(time_point now) { for (socket_map_t::iterator i = m_utp_sockets.begin() , end(m_utp_sockets.end()); i != end;) @@ -89,9 +90,9 @@ namespace libtorrent void utp_socket_manager::mtu_for_dest(address const& addr, int& link_mtu, int& utp_mtu) { - if (time_now() - seconds(60) > m_last_route_update) + if (aux::time_now() - seconds(60) > m_last_route_update) { - m_last_route_update = time_now(); + m_last_route_update = aux::time_now(); error_code ec; m_routes = enum_routes(m_sock.get_io_service(), ec); } @@ -198,9 +199,9 @@ namespace libtorrent tcp::endpoint socket_ep = m_sock.local_endpoint(ec); // first enumerate the routes in the routing table - if (time_now() - seconds(60) > m_last_route_update) + if (aux::time_now() - seconds(60) > m_last_route_update) { - m_last_route_update = time_now(); + m_last_route_update = aux::time_now(); error_code ec; m_routes = enum_routes(m_sock.get_io_service(), ec); if (ec) return socket_ep; @@ -229,9 +230,9 @@ namespace libtorrent // for this target. Now figure out what the local address // is for that interface - if (time_now() - seconds(60) > m_last_if_update) + if (aux::time_now() - seconds(60) > m_last_if_update) { - m_last_if_update = time_now(); + m_last_if_update = aux::time_now(); error_code ec; m_interfaces = enum_net_interfaces(m_sock.get_io_service(), ec); if (ec) return socket_ep; @@ -262,7 +263,7 @@ namespace libtorrent if (ph->get_version() != 1) return false; - const ptime receive_time = time_now_hires(); + const time_point receive_time = clock_type::now(); // parse out connection ID and look for existing // connections. If found, forward to the utp_stream. diff --git a/src/utp_stream.cpp b/src/utp_stream.cpp index c209394ad..f4b2830ff 100644 --- a/src/utp_stream.cpp +++ b/src/utp_stream.cpp @@ -77,8 +77,8 @@ static struct utp_logger void utp_log(char const* fmt, ...) { mutex::scoped_lock lock(log_file_holder.utp_log_mutex); - static ptime start = time_now_hires(); - fprintf(log_file_holder.utp_log_file, "[%012" PRId64 "] ", total_microseconds(time_now_hires() - start)); + 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; va_start(l, fmt); vfprintf(log_file_holder.utp_log_file, fmt, l); @@ -142,7 +142,7 @@ TORRENT_EXTRA_EXPORT bool compare_less_wrap(boost::uint32_t lhs, boost::uint32_t struct packet { // the last time this packet was sent - ptime send_time; + time_point send_time; // the number of bytes actually allocated in 'buf' boost::uint16_t allocated; @@ -234,8 +234,8 @@ struct utp_socket_impl , m_write_handler(false) , m_connect_handler(false) , m_remote_address() - , m_timeout(time_now_hires() + milliseconds(m_sm->connect_timeout())) - , m_last_history_step(time_now_hires()) + , m_timeout(clock_type::now() + milliseconds(m_sm->connect_timeout())) + , m_last_history_step(clock_type::now()) , m_cwnd(TORRENT_ETHERNET_MTU << 16) , m_ssthres(0) , m_buffered_incoming_bytes(0) @@ -288,10 +288,10 @@ struct utp_socket_impl ~utp_socket_impl(); - void tick(ptime now); + void tick(time_point now); void init_mtu(int link_mtu, int utp_mtu); bool incoming_packet(boost::uint8_t const* buf, int size - , udp::endpoint const& ep, ptime receive_time); + , udp::endpoint const& ep, time_point receive_time); void writable(); bool should_delete() const; @@ -321,14 +321,14 @@ struct utp_socket_impl bool resend_packet(packet* p, bool fast_resend = false); void send_reset(utp_header* ph); void parse_sack(boost::uint16_t packet_ack, boost::uint8_t const* ptr - , int size, int* acked_bytes, ptime const now, boost::uint32_t& min_rtt); + , int size, int* acked_bytes, time_point const now, boost::uint32_t& min_rtt); void parse_close_reason(boost::uint8_t const* ptr, int size); void write_payload(boost::uint8_t* ptr, int size); void maybe_inc_acked_seq_nr(); - void ack_packet(packet* p, ptime const& receive_time + void ack_packet(packet* p, time_point const& receive_time , boost::uint32_t& min_rtt, boost::uint16_t seq_nr); void write_sack(boost::uint8_t* buf, int size) const; - void incoming(boost::uint8_t const* buf, int size, packet* p, ptime now); + void incoming(boost::uint8_t const* buf, int size, packet* p, time_point now); void do_ledbat(int acked_bytes, int delay, int in_flight); int packet_timeout() const; bool test_socket_state(); @@ -336,7 +336,7 @@ struct utp_socket_impl void maybe_trigger_send_callback(); bool cancel_handlers(error_code const& ec, bool kill); bool consume_incoming_data( - utp_header const* ph, boost::uint8_t const* ptr, int payload_size, ptime now); + utp_header const* ph, boost::uint8_t const* ptr, int payload_size, time_point now); void update_mtu_limits(); void experienced_loss(int seq_nr); @@ -441,10 +441,10 @@ public: // cwnd is set to less than one MSS during congestion control. // it can also happen if the other end sends an advertized window // size less than one MSS. - ptime m_timeout; + time_point m_timeout; // the last time we stepped the timestamp history - ptime m_last_history_step; + time_point m_last_history_step; // the max number of bytes in-flight. This is a fixed point // value, to get the true number of bytes, shift right 16 bits @@ -702,7 +702,7 @@ bool should_delete(utp_socket_impl* s) return s->should_delete(); } -void tick_utp_impl(utp_socket_impl* s, ptime now) +void tick_utp_impl(utp_socket_impl* s, time_point now) { s->tick(now); } @@ -713,7 +713,7 @@ void utp_init_mtu(utp_socket_impl* s, int link_mtu, int utp_mtu) } bool utp_incoming_packet(utp_socket_impl* s, char const* p - , int size, udp::endpoint const& ep, ptime receive_time) + , int size, udp::endpoint const& ep, time_point receive_time) { return s->incoming_packet((boost::uint8_t const*)p, size, ep, receive_time); } @@ -1343,7 +1343,7 @@ void utp_socket_impl::send_syn() h->seq_nr = m_seq_nr; h->ack_nr = 0; - ptime now = time_now_hires(); + time_point now = clock_type::now(); p->send_time = now; h->timestamp_microseconds = boost::uint32_t( total_microseconds(now.time_since_epoch()) & 0xffffffff); @@ -1437,7 +1437,7 @@ void utp_socket_impl::send_reset(utp_header* ph) h.wnd_size = 0; h.seq_nr = random() & 0xffff; h.ack_nr = ph->seq_nr; - ptime now = time_now_hires(); + time_point now = clock_type::now(); h.timestamp_microseconds = boost::uint32_t( total_microseconds(now.time_since_epoch()) & 0xffffffff); @@ -1470,7 +1470,7 @@ void utp_socket_impl::parse_close_reason(boost::uint8_t const* ptr, int size) } void utp_socket_impl::parse_sack(boost::uint16_t packet_ack, boost::uint8_t const* ptr - , int size, int* acked_bytes, ptime const now, boost::uint32_t& min_rtt) + , int size, int* acked_bytes, time_point const now, boost::uint32_t& min_rtt) { INVARIANT_CHECK; @@ -1983,7 +1983,7 @@ bool utp_socket_impl::send_pkt(int flags) h->type_ver = (ST_FIN << 4) | 1; // fill in the timestamp as late as possible - ptime now = time_now_hires(); + time_point now = clock_type::now(); p->send_time = now; h->timestamp_microseconds = boost::uint32_t( total_microseconds(now.time_since_epoch()) & 0xffffffff); @@ -2176,7 +2176,7 @@ bool utp_socket_impl::resend_packet(packet* p, bool fast_resend) utp_header* h = (utp_header*)p->buf; // update packet header h->timestamp_difference_microseconds = m_reply_micro; - p->send_time = time_now_hires(); + p->send_time = clock_type::now(); h->timestamp_microseconds = boost::uint32_t( total_microseconds(p->send_time.time_since_epoch()) & 0xffffffff); @@ -2317,7 +2317,7 @@ void utp_socket_impl::maybe_inc_acked_seq_nr() m_duplicate_acks = 0; } -void utp_socket_impl::ack_packet(packet* p, ptime const& receive_time +void utp_socket_impl::ack_packet(packet* p, time_point const& receive_time , boost::uint32_t& min_rtt, boost::uint16_t seq_nr) { INVARIANT_CHECK; @@ -2365,7 +2365,7 @@ void utp_socket_impl::ack_packet(packet* p, ptime const& receive_time } void utp_socket_impl::incoming(boost::uint8_t const* buf, int size, packet* p - , ptime /* now */) + , time_point /* now */) { INVARIANT_CHECK; @@ -2448,7 +2448,7 @@ bool utp_socket_impl::cancel_handlers(error_code const& ec, bool kill) bool utp_socket_impl::consume_incoming_data( utp_header const* ph, boost::uint8_t const* ptr, int payload_size - , ptime now) + , time_point now) { INVARIANT_CHECK; @@ -2635,7 +2635,7 @@ void utp_socket_impl::init_mtu(int link_mtu, int utp_mtu) // return false if this is an invalid packet bool utp_socket_impl::incoming_packet(boost::uint8_t const* buf, int size - , udp::endpoint const& ep, ptime receive_time) + , udp::endpoint const& ep, time_point receive_time) { INVARIANT_CHECK; @@ -3470,7 +3470,7 @@ int utp_socket_impl::packet_timeout() const return timeout; } -void utp_socket_impl::tick(ptime now) +void utp_socket_impl::tick(time_point now) { INVARIANT_CHECK; diff --git a/test/dht_server.cpp b/test/dht_server.cpp index d4c3cc590..911e4d34b 100644 --- a/test/dht_server.cpp +++ b/test/dht_server.cpp @@ -37,6 +37,7 @@ POSSIBILITY OF SUCH DAMAGE. #include "libtorrent/io_service.hpp" #include "libtorrent/error_code.hpp" #include "libtorrent/socket.hpp" +#include "libtorrent/aux_/time.hpp" #include "dht_server.hpp" #include @@ -85,7 +86,7 @@ struct dht_server return; } - fprintf(stderr, "%s: DHT initialized on port %d\n", time_now_string(), m_port); + fprintf(stderr, "%s: DHT initialized on port %d\n", aux::time_now_string(), m_port); m_thread.reset(new thread(boost::bind(&dht_server::thread_fun, this))); } @@ -170,8 +171,8 @@ int num_dht_hits() void stop_dht() { - fprintf(stderr, "%s: stop_dht()\n", time_now_string()); + fprintf(stderr, "%s: stop_dht()\n", aux::time_now_string()); g_dht.reset(); - fprintf(stderr, "%s: stop_dht() done\n", time_now_string()); + fprintf(stderr, "%s: stop_dht() done\n", aux::time_now_string()); } diff --git a/test/main.cpp b/test/main.cpp index 75d3f9ae8..f2bf7739b 100644 --- a/test/main.cpp +++ b/test/main.cpp @@ -95,7 +95,7 @@ int main() | SEM_NOGPFAULTERRORBOX | SEM_NOOPENFILEERRORBOX); #endif - srand((total_microseconds(time_now_hires() - min_time())) & 0x7fffffff); + srand((total_microseconds(clock_type::now() - min_time())) & 0x7fffffff); #ifdef O_NONBLOCK // on darwin, stdout is set to non-blocking mode by default // which sometimes causes tests to fail with EAGAIN just diff --git a/test/peer_server.cpp b/test/peer_server.cpp index 20a030faa..bc73f1143 100644 --- a/test/peer_server.cpp +++ b/test/peer_server.cpp @@ -37,6 +37,7 @@ POSSIBILITY OF SUCH DAMAGE. #include "libtorrent/io_service.hpp" #include "libtorrent/error_code.hpp" #include "libtorrent/socket.hpp" +#include "libtorrent/aux_/time.hpp" #include "peer_server.hpp" #include @@ -87,7 +88,7 @@ struct peer_server return; } - fprintf(stderr, "%s: PEER peer initialized on port %d\n", time_now_string(), m_port); + fprintf(stderr, "%s: PEER peer initialized on port %d\n", aux::time_now_string(), m_port); m_thread.reset(new thread(boost::bind(&peer_server::thread_fun, this))); } @@ -134,7 +135,7 @@ struct peer_server return; } - fprintf(stderr, "%s: PEER incoming peer connection\n", time_now_string()); + fprintf(stderr, "%s: PEER incoming peer connection\n", aux::time_now_string()); ++m_peer_requests; socket.close(ec); } @@ -158,8 +159,8 @@ int num_peer_hits() void stop_peer() { - fprintf(stderr, "%s: PEER stop_peer()\n", time_now_string()); + fprintf(stderr, "%s: PEER stop_peer()\n", aux::time_now_string()); g_peer.reset(); - fprintf(stderr, "%s: PEER stop_peer() done\n", time_now_string()); + fprintf(stderr, "%s: PEER stop_peer() done\n", aux::time_now_string()); } diff --git a/test/setup_transfer.cpp b/test/setup_transfer.cpp index 21dba8c67..1da7d61ee 100644 --- a/test/setup_transfer.cpp +++ b/test/setup_transfer.cpp @@ -145,10 +145,10 @@ std::map get_counters(libtorrent::session& s) std::auto_ptr wait_for_alert(lt::session& ses, int type, char const* name) { std::auto_ptr ret; - ptime end = time_now() + seconds(10); + time_point end = aux::time_now() + seconds(10); while (!ret.get()) { - ptime now = time_now(); + time_point now = aux::time_now(); if (now > end) return std::auto_ptr(); ses.wait_for_alert(end - now); @@ -157,7 +157,7 @@ std::auto_ptr wait_for_alert(lt::session& ses, int type, char const* name for (std::deque::iterator i = alerts.begin() , end(alerts.end()); i != end; ++i) { - fprintf(stderr, "%s: %s: [%s] %s\n", time_now_string(), name + fprintf(stderr, "%s: %s: [%s] %s\n", aux::time_now_string(), name , (*i)->what(), (*i)->message().c_str()); if (!ret.get() && (*i)->type() == type) { @@ -268,14 +268,14 @@ bool print_alerts(lt::session& ses, char const* name if (predicate && predicate(*i)) ret = true; if (peer_disconnected_alert* p = alert_cast(*i)) { - fprintf(stderr, "%s: %s: [%s] (%s): %s\n", time_now_string(), name, (*i)->what(), print_endpoint(p->ip).c_str(), p->message().c_str()); + fprintf(stderr, "%s: %s: [%s] (%s): %s\n", aux::time_now_string(), name, (*i)->what(), print_endpoint(p->ip).c_str(), p->message().c_str()); } else if ((*i)->message() != "block downloading" && (*i)->message() != "block finished" && (*i)->message() != "piece finished" && !no_output) { - fprintf(stderr, "%s: %s: [%s] %s\n", time_now_string(), name, (*i)->what(), (*i)->message().c_str()); + fprintf(stderr, "%s: %s: [%s] %s\n", aux::time_now_string(), name, (*i)->what(), (*i)->message().c_str()); } TEST_CHECK(alert_cast(*i) == 0 || allow_failed_fastresume); @@ -283,7 +283,7 @@ bool print_alerts(lt::session& ses, char const* name peer_error_alert* pea = alert_cast(*i); if (pea) { - fprintf(stderr, "%s: peer error: %s\n", time_now_string(), pea->error.message().c_str()); + fprintf(stderr, "%s: peer error: %s\n", aux::time_now_string(), pea->error.message().c_str()); TEST_CHECK((!handles.empty() && h.status().is_seeding) || pea->error.message() == "connecting to peer" || pea->error.message() == "closing connection to ourself" @@ -503,7 +503,7 @@ int start_proxy(int proxy_type) if (i->second.type == proxy_type) { return i->first; } } - unsigned int seed = total_microseconds(time_now_hires() - min_time()) & 0xffffffff; + unsigned int seed = total_microseconds(clock_type::now() - min_time()) & 0xffffffff; printf("random seed: %u\n", seed); std::srand(seed); @@ -541,13 +541,13 @@ int start_proxy(int proxy_type) char buf[512]; snprintf(buf, sizeof(buf), "%s --port %d%s", cmd, port, auth); - fprintf(stderr, "%s starting proxy on port %d (%s %s)...\n", time_now_string(), port, type, auth); + fprintf(stderr, "%s starting proxy on port %d (%s %s)...\n", aux::time_now_string(), port, type, auth); fprintf(stderr, "%s\n", buf); pid_type r = async_run(buf); if (r == 0) exit(1); proxy_t t = { r, proxy_type }; running_proxies.insert(std::make_pair(port, t)); - fprintf(stderr, "%s launched\n", time_now_string()); + fprintf(stderr, "%s launched\n", aux::time_now_string()); test_sleep(500); return port; } @@ -823,7 +823,7 @@ setup_transfer(lt::session* ses1, lt::session* ses2, lt::session* ses3 port = ses2->listen_port(); fprintf(stderr, "%s: ses1: connecting peer port: %d\n" - , time_now_string(), port); + , aux::time_now_string(), port); tor1.connect_peer(tcp::endpoint(address::from_string("127.0.0.1", ec) , port)); @@ -860,7 +860,7 @@ pid_type web_server_pid = 0; int start_web_server(bool ssl, bool chunked_encoding, bool keepalive) { - unsigned int seed = total_microseconds(time_now_hires() - min_time()) & 0xffffffff; + unsigned int seed = total_microseconds(clock_type::now() - min_time()) & 0xffffffff; fprintf(stderr, "random seed: %u\n", seed); std::srand(seed); int port = 5000 + (rand() % 55000); @@ -869,13 +869,13 @@ int start_web_server(bool ssl, bool chunked_encoding, bool keepalive) snprintf(buf, sizeof(buf), "python ../web_server.py %d %d %d %d" , port, chunked_encoding , ssl, keepalive); - fprintf(stderr, "%s starting web_server on port %d...\n", time_now_string(), port); + fprintf(stderr, "%s starting web_server on port %d...\n", aux::time_now_string(), port); fprintf(stderr, "%s\n", buf); pid_type r = async_run(buf); if (r == 0) exit(1); web_server_pid = r; - fprintf(stderr, "%s launched\n", time_now_string()); + fprintf(stderr, "%s launched\n", aux::time_now_string()); test_sleep(500); return port; } diff --git a/test/swarm_suite.cpp b/test/swarm_suite.cpp index f5308d060..0feea40f8 100644 --- a/test/swarm_suite.cpp +++ b/test/swarm_suite.cpp @@ -191,10 +191,10 @@ void test_swarm(int flags) ses3.remove_torrent(tor3, lt::session::delete_files); std::auto_ptr a = ses1.pop_alert(); - ptime end = time_now() + seconds(20); + time_point end = aux::time_now() + seconds(20); while (a.get() == 0 || alert_cast(a.get()) == 0) { - if (ses1.wait_for_alert(end - time_now()) == 0) + if (ses1.wait_for_alert(end - aux::time_now()) == 0) { std::cerr << "wait_for_alert() expired" << std::endl; break; @@ -210,13 +210,13 @@ void test_swarm(int flags) // make sure that the timer in wait_for_alert() works // this should time out (ret == 0) and it should take // about 2 seconds - ptime start = time_now_hires(); + time_point start = clock_type::now(); alert const* ret; while ((ret = ses1.wait_for_alert(seconds(2)))) { a = ses1.pop_alert(); std::cerr << ret->message() << std::endl; - start = time_now(); + start = aux::time_now(); } // this allows shutting down the sessions in parallel @@ -224,8 +224,8 @@ void test_swarm(int flags) p2 = ses2.abort(); p3 = ses3.abort(); - TEST_CHECK(time_now_hires() - start < seconds(3)); - TEST_CHECK(time_now_hires() - start >= seconds(2)); + TEST_CHECK(clock_type::now() - start < seconds(3)); + TEST_CHECK(clock_type::now() - start >= seconds(2)); TEST_CHECK(!exists("tmp1_swarm/temporary")); TEST_CHECK(!exists("tmp2_swarm/temporary")); diff --git a/test/test_bdecode_performance.cpp b/test/test_bdecode_performance.cpp index fca95d4af..1d18042ab 100644 --- a/test/test_bdecode_performance.cpp +++ b/test/test_bdecode_performance.cpp @@ -43,7 +43,7 @@ int test_main() { using namespace libtorrent; - ptime start(time_now()); + time_point start(clock_type::now()); for (int i = 0; i < 100000; ++i) { @@ -52,7 +52,7 @@ int test_main() error_code ec; lazy_bdecode(b, b + sizeof(b)-1, e, ec); } - ptime stop(time_now()); + time_point stop(clock_type::now()); std::cout << "done in " << total_milliseconds(stop - start) / 100. << " seconds per million message" << std::endl; return 0; diff --git a/test/test_dos_blocker.cpp b/test/test_dos_blocker.cpp index cd581e721..0b12132d1 100644 --- a/test/test_dos_blocker.cpp +++ b/test/test_dos_blocker.cpp @@ -46,7 +46,7 @@ int test_main() address spammer = address_v4::from_string("10.10.10.10"); - ptime now = time_now(); + time_point now = aux::time_now(); for (int i = 0; i < 1000; ++i) { b.incoming(spammer, now); diff --git a/test/test_fast_extension.cpp b/test/test_fast_extension.cpp index 5e66d493a..8b5dd09a1 100644 --- a/test/test_fast_extension.cpp +++ b/test/test_fast_extension.cpp @@ -53,7 +53,7 @@ int read_message(stream_socket& s, char* buffer) , libtorrent::asio::transfer_all(), ec); if (ec) { - std::cout << time_now_string() << ": " << ec.message() << std::endl; + std::cout << aux::time_now_string() << ": " << ec.message() << std::endl; TEST_ERROR("read_message: " + ec.message()); return 0; } @@ -64,7 +64,7 @@ int read_message(stream_socket& s, char* buffer) , libtorrent::asio::transfer_all(), ec); if (ec) { - std::cout << time_now_string() << ": " << ec.message() << std::endl; + std::cout << aux::time_now_string() << ": " << ec.message() << std::endl; TEST_ERROR("read_message: " + ec.message()); return 0; } @@ -111,12 +111,12 @@ void print_message(char const* buffer, int len) } } - fprintf(stderr, "%s <== %s %s\n", time_now_string(), message, extra); + fprintf(stderr, "%s <== %s %s\n", aux::time_now_string(), message, extra); } void send_allow_fast(stream_socket& s, int piece) { - std::cout << time_now_string() << " ==> allow fast: " << piece << std::endl; + std::cout << aux::time_now_string() << " ==> allow fast: " << piece << std::endl; using namespace libtorrent::detail; char msg[] = "\0\0\0\x05\x11\0\0\0\0"; char* ptr = msg + 5; @@ -128,7 +128,7 @@ void send_allow_fast(stream_socket& s, int piece) void send_suggest_piece(stream_socket& s, int piece) { - std::cout << time_now_string() << " ==> suggest piece: " << piece << std::endl; + std::cout << aux::time_now_string() << " ==> suggest piece: " << piece << std::endl; using namespace libtorrent::detail; char msg[] = "\0\0\0\x05\x0d\0\0\0\0"; char* ptr = msg + 5; @@ -140,7 +140,7 @@ void send_suggest_piece(stream_socket& s, int piece) void send_keepalive(stream_socket& s) { - std::cout << time_now_string() << " ==> keepalive" << std::endl; + std::cout << aux::time_now_string() << " ==> keepalive" << std::endl; char msg[] = "\0\0\0\0"; error_code ec; libtorrent::asio::write(s, libtorrent::asio::buffer(msg, 4) @@ -149,7 +149,7 @@ void send_keepalive(stream_socket& s) void send_unchoke(stream_socket& s) { - std::cout << time_now_string() << " ==> unchoke" << std::endl; + std::cout << aux::time_now_string() << " ==> unchoke" << std::endl; char msg[] = "\0\0\0\x01\x01"; error_code ec; libtorrent::asio::write(s, libtorrent::asio::buffer(msg, 5) @@ -158,7 +158,7 @@ void send_unchoke(stream_socket& s) void send_have_all(stream_socket& s) { - std::cout << time_now_string() << " ==> have_all" << std::endl; + std::cout << aux::time_now_string() << " ==> have_all" << std::endl; char msg[] = "\0\0\0\x01\x0e"; // have_all error_code ec; libtorrent::asio::write(s, libtorrent::asio::buffer(msg, 5) @@ -167,7 +167,7 @@ void send_have_all(stream_socket& s) void send_have_none(stream_socket& s) { - std::cout << time_now_string() << " ==> have_none" << std::endl; + std::cout << aux::time_now_string() << " ==> have_none" << std::endl; char msg[] = "\0\0\0\x01\x0f"; // have_none error_code ec; libtorrent::asio::write(s, libtorrent::asio::buffer(msg, 5) @@ -185,7 +185,7 @@ void send_bitfield(stream_socket& s, char const* bits) char* ptr = msg; write_int32(packet_size-4, ptr); write_int8(5, ptr); - std::cout << time_now_string() << " ==> bitfield [" << bits << "]" << std::endl;; + std::cout << aux::time_now_string() << " ==> bitfield [" << bits << "]" << std::endl;; for (int i = 0; i < num_pieces; ++i) { ptr[i/8] |= (bits[i] == '1' ? 1 : 0) << i % 8; @@ -200,7 +200,7 @@ void do_handshake(stream_socket& s, sha1_hash const& ih, char* buffer) char handshake[] = "\x13" "BitTorrent protocol\0\0\0\0\0\x10\0\x04" " " // space for info-hash "aaaaaaaaaaaaaaaaaaaa"; // peer-id - std::cout << time_now_string() << " ==> handshake" << std::endl; + std::cout << aux::time_now_string() << " ==> handshake" << std::endl; error_code ec; std::memcpy(handshake + 28, ih.begin(), 20); libtorrent::asio::write(s, libtorrent::asio::buffer(handshake, sizeof(handshake) - 1) @@ -211,10 +211,10 @@ void do_handshake(stream_socket& s, sha1_hash const& ih, char* buffer) , libtorrent::asio::transfer_all(), ec); if (ec) { - std::cout << time_now_string() << ": " << ec.message() << std::endl; + std::cout << aux::time_now_string() << ": " << ec.message() << std::endl; exit(1); } - std::cout << time_now_string() << " <== handshake" << std::endl; + std::cout << aux::time_now_string() << " <== handshake" << std::endl; TEST_CHECK(buffer[0] == 19); TEST_CHECK(std::memcmp(buffer + 1, "BitTorrent protocol", 19) == 0); @@ -303,7 +303,7 @@ void test_reject_fast() // send reject request recv_buffer[0] = 0x10; error_code ec; - std::cerr << time_now_string() << " ==> reject" << std::endl; + std::cerr << aux::time_now_string() << " ==> reject" << std::endl; libtorrent::asio::write(s, libtorrent::asio::buffer("\0\0\0\x0d", 4) , libtorrent::asio::transfer_all(), ec); libtorrent::asio::write(s, libtorrent::asio::buffer(recv_buffer, 13) @@ -361,7 +361,7 @@ void test_respect_suggest() // send reject request recv_buffer[0] = 0x10; error_code ec; - std::cerr << time_now_string() << " ==> reject" << std::endl; + std::cerr << aux::time_now_string() << " ==> reject" << std::endl; libtorrent::asio::write(s, libtorrent::asio::buffer("\0\0\0\x0d", 4) , libtorrent::asio::transfer_all(), ec); libtorrent::asio::write(s, libtorrent::asio::buffer(recv_buffer, 13) diff --git a/test/test_http_connection.cpp b/test/test_http_connection.cpp index a9c039020..7bc2f3da3 100644 --- a/test/test_http_connection.cpp +++ b/test/test_http_connection.cpp @@ -55,12 +55,12 @@ char data_buffer[4000]; void print_http_header(http_parser const& p) { - std::cerr << time_now_string() << " < " << p.status_code() << " " << p.message() << std::endl; + std::cerr << aux::time_now_string() << " < " << p.status_code() << " " << p.message() << std::endl; for (std::multimap::const_iterator i = p.headers().begin(), end(p.headers().end()); i != end; ++i) { - std::cerr << time_now_string() << " < " << i->first << ": " << i->second << std::endl; + std::cerr << aux::time_now_string() << " < " << i->first << ": " << i->second << std::endl; } } @@ -69,7 +69,7 @@ void http_connect_handler(http_connection& c) ++connect_handler_called; TEST_CHECK(c.socket().is_open()); error_code ec; - std::cerr << time_now_string() << " connected to: " << print_endpoint(c.socket().remote_endpoint(ec)) + std::cerr << aux::time_now_string() << " connected to: " << print_endpoint(c.socket().remote_endpoint(ec)) << std::endl; // this is not necessarily true when using a proxy and proxying hostnames // TEST_CHECK(c.socket().remote_endpoint(ec).address() == address::from_string("127.0.0.1", ec)); @@ -111,7 +111,7 @@ void run_test(std::string const& url, int size, int status, int connected std::cerr << " ===== TESTING: " << url << " =====" << std::endl; - std::cerr << time_now_string() + std::cerr << aux::time_now_string() << " expecting: size: " << size << " status: " << status << " connected: " << connected @@ -124,14 +124,14 @@ void run_test(std::string const& url, int size, int status, int connected ios.reset(); error_code e; ios.run(e); - if (e) std::cerr << time_now_string() << " run failed: " << e.message() << std::endl; + if (e) std::cerr << aux::time_now_string() << " run failed: " << e.message() << std::endl; - std::cerr << time_now_string() << " connect_handler_called: " << connect_handler_called << std::endl; - std::cerr << time_now_string() << " handler_called: " << handler_called << std::endl; - std::cerr << time_now_string() << " status: " << http_status << std::endl; - std::cerr << time_now_string() << " size: " << data_size << std::endl; - std::cerr << time_now_string() << " expected-size: " << size << std::endl; - std::cerr << time_now_string() << " error_code: " << g_error_code.message() << std::endl; + std::cerr << aux::time_now_string() << " connect_handler_called: " << connect_handler_called << std::endl; + std::cerr << aux::time_now_string() << " handler_called: " << handler_called << std::endl; + std::cerr << aux::time_now_string() << " status: " << http_status << std::endl; + std::cerr << aux::time_now_string() << " size: " << data_size << std::endl; + std::cerr << aux::time_now_string() << " expected-size: " << size << std::endl; + std::cerr << aux::time_now_string() << " error_code: " << g_error_code.message() << std::endl; TEST_CHECK(connect_handler_called == connected); TEST_CHECK(handler_called == 1); TEST_CHECK(data_size == size || size == -1); diff --git a/test/test_metadata_extension.cpp b/test/test_metadata_extension.cpp index 19614127a..595fa5476 100644 --- a/test/test_metadata_extension.cpp +++ b/test/test_metadata_extension.cpp @@ -137,7 +137,7 @@ void test_transfer(int flags error_code ec; int port = seed->listen_port(); fprintf(stderr, "%s: downloader: connecting peer port: %d\n" - , time_now_string(), port); + , aux::time_now_string(), port); tor2.connect_peer(tcp::endpoint(address::from_string("127.0.0.1", ec) , port)); } @@ -146,7 +146,7 @@ void test_transfer(int flags error_code ec; int port = downloader->listen_port(); fprintf(stderr, "%s: seed: connecting peer port: %d\n" - , time_now_string(), port); + , aux::time_now_string(), port); tor1.connect_peer(tcp::endpoint(address::from_string("127.0.0.1", ec) , port)); } diff --git a/test/test_priority.cpp b/test/test_priority.cpp index 844a9aff4..8569c5a39 100644 --- a/test/test_priority.cpp +++ b/test/test_priority.cpp @@ -260,7 +260,7 @@ void test_transfer(settings_pack const& sett) std::vector resume_data; alert const* a = ses2.wait_for_alert(seconds(10)); - ptime start = time_now_hires(); + time_point start = clock_type::now(); while (a) { std::auto_ptr holder = ses2.pop_alert(); @@ -277,7 +277,7 @@ void test_transfer(settings_pack const& sett) fprintf(stderr, "save resume failed\n"); break; } - if (total_seconds(time_now_hires() - start) > 10) + if (total_seconds(clock_type::now() - start) > 10) break; a = ses2.wait_for_alert(seconds(10)); diff --git a/test/test_privacy.cpp b/test/test_privacy.cpp index 5a6f5dd63..1df97feb7 100644 --- a/test/test_privacy.cpp +++ b/test/test_privacy.cpp @@ -229,7 +229,7 @@ session_proxy test_proxy(settings_pack::proxy_type_t proxy_type, int flags) if (flags & expect_http_reject) TEST_CHECK(std::find(rejected_trackers.begin(), rejected_trackers.end(), http_tracker_url) != rejected_trackers.end()); - fprintf(stderr, "%s: ~session\n", time_now_string()); + fprintf(stderr, "%s: ~session\n", aux::time_now_string()); session_proxy pr = s->abort(); delete s; diff --git a/test/test_storage.cpp b/test/test_storage.cpp index c7b5e82bb..30042e69f 100644 --- a/test/test_storage.cpp +++ b/test/test_storage.cpp @@ -62,33 +62,33 @@ char* piece3 = page_aligned_allocator::malloc(piece_size); void signal_bool(bool* b, char const* string) { *b = true; - std::cerr << time_now_string() << " " << string << std::endl; + std::cerr << aux::time_now_string() << " " << string << std::endl; } void on_read_piece(int ret, disk_io_job const& j, char const* data, int size) { - std::cerr << time_now_string() << " on_read_piece piece: " << j.piece << std::endl; + std::cerr << aux::time_now_string() << " on_read_piece piece: " << j.piece << std::endl; TEST_EQUAL(ret, size); if (ret > 0) TEST_CHECK(std::equal(j.buffer, j.buffer + ret, data)); } void on_check_resume_data(disk_io_job const* j, bool* done) { - std::cerr << time_now_string() << " on_check_resume_data ret: " << j->ret; + std::cerr << aux::time_now_string() << " on_check_resume_data ret: " << j->ret; switch (j->ret) { case piece_manager::no_error: - std::cerr << time_now_string() << " success" << std::endl; + std::cerr << aux::time_now_string() << " success" << std::endl; break; case piece_manager::fatal_disk_error: - std::cerr << time_now_string() << " disk error: " << j->error.ec.message() + std::cerr << aux::time_now_string() << " disk error: " << j->error.ec.message() << " file: " << j->error.file << std::endl; break; case piece_manager::need_full_check: - std::cerr << time_now_string() << " need full check" << std::endl; + std::cerr << aux::time_now_string() << " need full check" << std::endl; break; case piece_manager::disk_check_aborted: - std::cerr << time_now_string() << " aborted" << std::endl; + std::cerr << aux::time_now_string() << " aborted" << std::endl; break; } std::cerr << std::endl; @@ -98,7 +98,7 @@ void on_check_resume_data(disk_io_job const* j, bool* done) void print_error(char const* call, int ret, storage_error const& ec) { fprintf(stderr, "%s: %s() returned: %d error: \"%s\" in file: %d operation: %d\n" - , time_now_string(), call, ret, ec.ec.message().c_str(), ec.file, ec.operation); + , aux::time_now_string(), call, ret, ec.ec.message().c_str(), ec.file, ec.operation); } void run_until(io_service& ios, bool const& done) @@ -113,7 +113,7 @@ void run_until(io_service& ios, bool const& done) std::cerr << "run_one: " << ec.message().c_str() << std::endl; return; } - std::cerr << time_now_string() << " done: " << done << std::endl; + std::cerr << aux::time_now_string() << " done: " << done << std::endl; } } @@ -678,12 +678,12 @@ void test_fastresume(std::string const& test_path) torrent_handle h = ses.add_torrent(p, ec); std::auto_ptr a = ses.pop_alert(); - ptime end = time_now() + seconds(20); - while (time_now() < end + time_point end = aux::time_now() + seconds(20); + while (aux::time_now() < end && (a.get() == 0 || alert_cast(a.get()) == 0)) { - if (ses.wait_for_alert(end - time_now()) == 0) + if (ses.wait_for_alert(end - aux::time_now()) == 0) { std::cerr << "wait_for_alert() expired" << std::endl; break; diff --git a/test/test_time.cpp b/test/test_time.cpp index 1fbd24be0..f3f9c1c33 100644 --- a/test/test_time.cpp +++ b/test/test_time.cpp @@ -38,7 +38,7 @@ POSSIBILITY OF SUCH DAMAGE. using namespace libtorrent; -void check_timer_loop(mutex& m, ptime& last, condition_variable& cv) +void check_timer_loop(mutex& m, time_point& last, condition_variable& cv) { mutex::scoped_lock l(m); cv.wait(l); @@ -47,7 +47,7 @@ void check_timer_loop(mutex& m, ptime& last, condition_variable& cv) for (int i = 0; i < 10000; ++i) { mutex::scoped_lock l(m); - ptime now = time_now_hires(); + time_point now = clock_type::now(); TEST_CHECK(now >= last); last = now; } @@ -70,11 +70,11 @@ int test_main() // make sure the timer is monotonic - ptime now = time_now_hires(); - ptime last = now; + time_point now = clock_type::now(); + time_point last = now; for (int i = 0; i < 1000; ++i) { - now = time_now_hires(); + now = clock_type::now(); TEST_CHECK(now >= last); last = now; } diff --git a/test/test_transfer.cpp b/test/test_transfer.cpp index 6b58ee8d3..410ef1c69 100644 --- a/test/test_transfer.cpp +++ b/test/test_transfer.cpp @@ -306,7 +306,7 @@ void test_transfer(int proxy_type, settings_pack const& sett // at this point we probably disconnected the seed // so we need to reconnect as well - fprintf(stderr, "%s: reconnecting peer\n", time_now_string()); + fprintf(stderr, "%s: reconnecting peer\n", aux::time_now_string()); error_code ec; tor2.connect_peer(tcp::endpoint(address::from_string("127.0.0.1", ec) , ses1.listen_port())); @@ -314,7 +314,7 @@ void test_transfer(int proxy_type, settings_pack const& sett TEST_CHECK(tor2.status().is_finished == false); fprintf(stderr, "disconnects: %d\n", peer_disconnects); TEST_CHECK(peer_disconnects >= 2); - fprintf(stderr, "%s: discovered disk full mode. Raise limit and disable upload-mode\n", time_now_string()); + fprintf(stderr, "%s: discovered disk full mode. Raise limit and disable upload-mode\n", aux::time_now_string()); peer_disconnects = 0; continue; } diff --git a/test/udp_tracker.cpp b/test/udp_tracker.cpp index d9e747404..f8d3abfb5 100644 --- a/test/udp_tracker.cpp +++ b/test/udp_tracker.cpp @@ -39,6 +39,7 @@ POSSIBILITY OF SUCH DAMAGE. #include "libtorrent/socket.hpp" #include "libtorrent/socket_io.hpp" #include "libtorrent/io.hpp" +#include "libtorrent/aux_/time.hpp" #include "udp_tracker.hpp" #include @@ -65,17 +66,17 @@ struct udp_tracker { if (ec) { - fprintf(stderr, "%s: UDP tracker, read failed: %s\n", time_now_string(), ec.message().c_str()); + fprintf(stderr, "%s: UDP tracker, read failed: %s\n", aux::time_now_string(), ec.message().c_str()); return; } if (bytes_transferred < 16) { - fprintf(stderr, "%s: UDP message too short (from: %s)\n", time_now_string(), print_endpoint(*from).c_str()); + fprintf(stderr, "%s: UDP message too short (from: %s)\n", aux::time_now_string(), print_endpoint(*from).c_str()); return; } - fprintf(stderr, "%s: UDP message %d bytes\n", time_now_string(), int(bytes_transferred)); + fprintf(stderr, "%s: UDP message %d bytes\n", aux::time_now_string(), int(bytes_transferred)); char* ptr = buffer; detail::read_uint64(ptr); @@ -88,7 +89,7 @@ struct udp_tracker { case 0: // connect - fprintf(stderr, "%s: UDP connect from %s\n", time_now_string() + fprintf(stderr, "%s: UDP connect from %s\n", aux::time_now_string() , print_endpoint(*from).c_str()); ptr = buffer; detail::write_uint32(0, ptr); // action = connect @@ -96,15 +97,15 @@ struct udp_tracker detail::write_uint64(10, ptr); // connection_id m_socket.send_to(asio::buffer(buffer, 16), *from, 0, e); if (e) fprintf(stderr, "%s: UDP send_to failed. ERROR: %s\n" - , time_now_string(), e.message().c_str()); + , aux::time_now_string(), e.message().c_str()); else fprintf(stderr, "%s: UDP sent response to: %s\n" - , time_now_string(), print_endpoint(*from).c_str()); + , aux::time_now_string(), print_endpoint(*from).c_str()); break; case 1: // announce ++m_udp_announces; - fprintf(stderr, "%s: UDP announce [%d]\n", time_now_string() + fprintf(stderr, "%s: UDP announce [%d]\n", aux::time_now_string() , int(m_udp_announces)); ptr = buffer; detail::write_uint32(1, ptr); // action = announce @@ -115,16 +116,16 @@ struct udp_tracker // 0 peers m_socket.send_to(asio::buffer(buffer, 20), *from, 0, e); if (e) fprintf(stderr, "%s: UDP send_to failed. ERROR: %s\n" - , time_now_string(), e.message().c_str()); + , aux::time_now_string(), e.message().c_str()); else fprintf(stderr, "%s: UDP sent response to: %s\n" - , time_now_string(), print_endpoint(*from).c_str()); + , aux::time_now_string(), print_endpoint(*from).c_str()); break; case 2: // ignore scrapes - fprintf(stderr, "%s: UDP scrape (ignored)\n", time_now_string()); + fprintf(stderr, "%s: UDP scrape (ignored)\n", aux::time_now_string()); break; default: - fprintf(stderr, "%s: UDP unknown message: %d\n", time_now_string() + fprintf(stderr, "%s: UDP unknown message: %d\n", aux::time_now_string() , action); break; } @@ -160,7 +161,7 @@ struct udp_tracker return; } - fprintf(stderr, "%s: UDP tracker initialized on port %d\n", time_now_string(), m_port); + fprintf(stderr, "%s: UDP tracker initialized on port %d\n", aux::time_now_string(), m_port); m_thread.reset(new thread(boost::bind(&udp_tracker::thread_fun, this))); } @@ -222,8 +223,8 @@ int num_udp_announces() void stop_udp_tracker() { - fprintf(stderr, "%s: UDP stop_udp_tracker()\n", time_now_string()); + fprintf(stderr, "%s: UDP stop_udp_tracker()\n", aux::time_now_string()); g_udp_tracker.reset(); - fprintf(stderr, "%s: UDP stop_udp_tracker() done\n", time_now_string()); + fprintf(stderr, "%s: UDP stop_udp_tracker() done\n", aux::time_now_string()); }