Changeset 800

Timestamp:

11/04/06 11:05:28 (5 years ago)

Author:

rakshasa

Message:

* Properly nul-terminate the info hash and client id in the tracker
request.

* Implemented options for read-ahead of
chunks. 'preload_min_pipelined', 'preload_min_size' and
'preload_required_rate' are used to decide when to read-ahead a chunk.

Location:

trunk

Files:

• libtorrent/rak/error_number.h (modified) (2 diffs)
• libtorrent/src/data/chunk_list.cc (modified) (1 diff)
• libtorrent/src/data/chunk_list_node.h (modified) (3 diffs)
• libtorrent/src/data/entry_list.cc (modified) (4 diffs)
• libtorrent/src/protocol/handshake.cc (modified) (2 diffs)
• libtorrent/src/protocol/peer_connection_base.cc (modified) (2 diffs)
• libtorrent/src/torrent/chunk_manager.cc (modified) (1 diff)
• libtorrent/src/torrent/chunk_manager.h (modified) (3 diffs)
• libtorrent/src/torrent/hash_string.h (modified) (2 diffs)
• libtorrent/src/tracker/tracker_http.cc (modified) (1 diff)
• rtorrent/rak/error_number.h (modified) (2 diffs)
• rtorrent/src/option_handler_rules.cc (modified) (1 diff)

trunk/libtorrent/rak/error_number.h

@@ -54 +54 @@
   static const int e_nomem       = ENOMEM;
   static const int e_notdir      = ENOTDIR;
+  static const int e_isdir       = EISDIR;
   
   static const int e_intr        = EINTR;
@@ -74 +75 @@
   static error_number current()                    { return errno; }
   static void         clear_global()               { errno = 0; }
+  static void         set_global(error_number err) { errno = err.m_errno; }
 
   bool operator == (const error_number& e) const   { return m_errno == e.m_errno; }

trunk/libtorrent/src/data/chunk_list.cc

@@ -184 +184 @@
 
   } else {
-    handle->object()->dec_references();
-
-    if (handle->object()->references() == 0) {
+    if (handle->object()->dec_references() == 0) {
       if (is_queued(handle->object()))
         throw internal_error("ChunkList::release(...) tried to unmap a queued chunk.");

trunk/libtorrent/src/data/chunk_list_node.h

@@ -71 +71 @@
   void                set_chunk(Chunk* c)            { m_chunk = c; }
 
-  const rak::timer&   time_modified() const           { return m_timeModified; }
-  void                set_time_modified(rak::timer t) { m_timeModified = t; }
+  const rak::timer&   time_modified() const            { return m_timeModified; }
+  void                set_time_modified(rak::timer t)  { m_timeModified = t; }
+
+  const rak::timer&   time_preloaded() const           { return m_timePreloaded; }
+  void                set_time_preloaded(rak::timer t) { m_timePreloaded = t; }
 
   bool                sync_triggered() const         { return m_asyncTriggered; }
@@ -78 +81 @@
 
   int                 references() const             { return m_references; }
-  void                dec_references()               { m_references--; }
-  void                inc_references()               { m_references++; }
+  int                 dec_references()               { return --m_references; }
+  int                 inc_references()               { return ++m_references; }
 
   int                 writable() const               { return m_writable; }
-  void                dec_writable()                 { m_writable--; }
-  void                inc_writable()                 { m_writable++; }
+  int                 dec_writable()                 { return --m_writable; }
+  int                 inc_writable()                 { return ++m_writable; }
 
   void                inc_rw()                       { inc_writable(); inc_references(); }
@@ -95 +98 @@
   int                 m_writable;
 
+  bool                m_asyncTriggered;
+
   rak::timer          m_timeModified;
-  bool                m_asyncTriggered;
+  rak::timer          m_timePreloaded;
 };
 

trunk/libtorrent/src/data/entry_list.cc

@@ -98 +98 @@
 
   try {
-    if (::mkdir(m_rootDir.c_str(), 0777) && errno != EEXIST)
+    if (::mkdir(m_rootDir.c_str(), 0777) != 0 && errno != EEXIST)
       throw storage_error("Could not create directory '" + m_rootDir + "': " + strerror(errno));
   
@@ -205 +205 @@
       break;
 
-    if (::mkdir(path.c_str(), 0777) && errno != EEXIST)
+    if (::mkdir(path.c_str(), 0777) != 0 && errno != EEXIST)
       throw storage_error("Could not create directory '" + path + "': " + strerror(errno));
   }
@@ -223 +223 @@
   }
 
+  rak::error_number::clear_global();
+
   make_directory(path->begin(), path->end(), firstMismatch);
 
@@ -229 +231 @@
   if (path->back().empty())
     return node->size() == 0;
+
+  rak::file_stat fileStat;
+
+  if (fileStat.update(node->file_meta()->get_path()) &&
+      !fileStat.is_regular() && !fileStat.is_link()) {
+    // Might also bork on other kinds of file types, but there's no
+    // suitable errno for all cases.
+    rak::error_number::set_global(rak::error_number::e_isdir);
+    return false;
+  }
 
   return

trunk/libtorrent/src/protocol/handshake.cc

@@ -418 +418 @@
       // Have the download from the encrypted handshake, make sure it
       // matches the BT handshake.
-      if (m_download->info()->hash() != (char*)m_readBuffer.position())
+      if (m_download->info()->hash().not_equal_to((char*)m_readBuffer.position()))
         throw handshake_error(ConnectionManager::handshake_failed, EH_InvalidValue);
 
@@ -429 +429 @@
 
   } else {
-    if (m_download->info()->hash() != (char*)m_readBuffer.position())
+    if (m_download->info()->hash().not_equal_to((char*)m_readBuffer.position()))
       throw handshake_error(ConnectionManager::handshake_failed, EH_InvalidValue);
   }

trunk/libtorrent/src/protocol/peer_connection_base.cc

@@ -42 +42 @@
 #include "torrent/exceptions.h"
 #include "torrent/block.h"
+#include "torrent/chunk_manager.h"
 #include "data/chunk_iterator.h"
 #include "data/chunk_list.h"
@@ -182 +183 @@
   }
 
-  // Make sure we preload the next step once we get past the length
-  // here. This is just some testing, don't include this with the
-  // release. (Yet)
-//   if (m_peerChunks.upload_throttle()->rate()->rate() >= 10 << 10)
-//     m_upChunk.chunk()->preload(m_upPiece.offset(), m_upChunk.chunk()->size());
-//   m_upChunk.chunk()->preload(m_upPiece.offset(), std::min(128u << 10, m_peerChunks.upload_throttle()->rate()->rate() * 10));
+  // Also check if we've already preloaded in the recent past, even
+  // past unmaps.
+  ChunkManager* cm = manager->chunk_manager();
+
+  if (cm->preload_min_pipelined() == 0 ||
+      m_upChunk.object()->time_preloaded() >= cachedTime - rak::timer::from_seconds(60))
+    return;
+
+  uint32_t preloadSize = m_upPiece.offset() < cm->preload_min_size();
+
+  if (preloadSize < cm->preload_min_size() ||
+      m_peerChunks.upload_throttle()->rate()->rate() < cm->preload_required_rate() * (preloadSize + (2 << 20) - 1) / (2 << 20))
+    return;
+
+  m_upChunk.chunk()->preload(m_upPiece.offset(), m_upChunk.chunk()->chunk_size());
 }
 

trunk/libtorrent/src/torrent/chunk_manager.cc

@@ -55 +55 @@
   m_timeoutSync(600),
   m_timeoutSafeSync(900),
+
+  m_preloadMinPipelined(0),
+  m_preloadMinSize(256 << 10),
+  m_preloadRequiredRate(10),
 
   m_timerStarved(0),

trunk/libtorrent/src/torrent/chunk_manager.h

@@ -61 +61 @@
   // usage to a resonable value. This should be based on the arch,
   // ulimit and errors encountered when mmap'ing.
-  bool                auto_memory() const                     { return m_autoMemory; }
-  void                set_auto_memory(bool state)             { m_autoMemory = state; }
+  bool                auto_memory() const                       { return m_autoMemory; }
+  void                set_auto_memory(bool state)               { m_autoMemory = state; }
 
-  uint64_t            memory_usage() const                    { return m_memoryUsage; }
+  uint64_t            memory_usage() const                      { return m_memoryUsage; }
 
   // Should we allow the client to reserve some memory?
 
   // The client should set this automatically if ulimit is set.
-  uint64_t            max_memory_usage() const                { return m_maxMemoryUsage; }
-  void                set_max_memory_usage(uint64_t bytes)    { m_maxMemoryUsage = bytes; }
+  uint64_t            max_memory_usage() const                  { return m_maxMemoryUsage; }
+  void                set_max_memory_usage(uint64_t bytes)      { m_maxMemoryUsage = bytes; }
 
   // Estimate the max memory usage possible, capped at 1GB.
@@ -77 +77 @@
   uint64_t            safe_free_diskspace() const;
 
-  bool                safe_sync() const                       { return m_safeSync; }
-  void                set_safe_sync(uint32_t state)           { m_safeSync = state; }
+  bool                safe_sync() const                         { return m_safeSync; }
+  void                set_safe_sync(uint32_t state)             { m_safeSync = state; }
 
   // Set the interval to wait after the last write to a chunk before
   // trying to sync it. By not forcing a sync too early it should give
   // the kernel an oppertunity to sync at its convenience.
-  uint32_t            timeout_sync() const                    { return m_timeoutSync; }
-  void                set_timeout_sync(uint32_t seconds)      { m_timeoutSync = seconds; }
+  uint32_t            timeout_sync() const                      { return m_timeoutSync; }
+  void                set_timeout_sync(uint32_t seconds)        { m_timeoutSync = seconds; }
 
-  uint32_t            timeout_safe_sync() const               { return m_timeoutSafeSync; }
-  void                set_timeout_safe_sync(uint32_t seconds) { m_timeoutSafeSync = seconds; }
+  uint32_t            timeout_safe_sync() const                 { return m_timeoutSafeSync; }
+  void                set_timeout_safe_sync(uint32_t seconds)   { m_timeoutSafeSync = seconds; }
+
+  // Set to 0 to disable preloading.
+  //
+  // How the value is used is yet to be determined, but it won't be
+  // able to use actual requests in the request queue as we can easily
+  // stay ahead of it causing preloading to fail.
+  uint32_t            preload_min_pipelined() const             { return m_preloadMinPipelined; }
+  void                set_preload_min_pipelined(uint32_t size)  { m_preloadMinPipelined = size; }
+
+  uint32_t            preload_min_size() const                  { return m_preloadMinSize; }
+  void                set_preload_min_size(uint32_t bytes)      { m_preloadMinSize = bytes; }
+
+  // Required rate before attempting to preload chunk, per whole
+  // megabyte of chunk size.
+  uint32_t            preload_required_rate() const             { return m_preloadRequiredRate; }
+  void                set_preload_required_rate(uint32_t bytes) { m_preloadRequiredRate = bytes; }
 
   void                insert(ChunkList* chunkList);
@@ -119 +135 @@
   uint32_t            m_timeoutSafeSync;
 
+  uint32_t            m_preloadMinPipelined;
+  uint32_t            m_preloadMinSize;
+  uint32_t            m_preloadRequiredRate;
+
   int32_t             m_timerStarved;
   size_type           m_lastFreed;

trunk/libtorrent/src/torrent/hash_string.h

@@ -86 +86 @@
   void                assign(const value_type* src)     { std::memcpy(data(), src, size()); }
 
-  bool                compare(const char* hash)         { return std::memcmp(m_data, hash, size()); }
+  bool                equal_to(const char* hash) const     { return std::memcmp(m_data, hash, size()) == 0; }
+  bool                not_equal_to(const char* hash) const { return std::memcmp(m_data, hash, size()) == 1; }
 
 private:
@@ -107 +108 @@
 }
 
-inline bool
-operator == (const HashString& one, const char* two) {
-  return std::memcmp(one.begin(), two, HashString::size_data) == 0;
-}
-
-inline bool
-operator != (const HashString& one, const char* two) {
-  return std::memcmp(one.begin(), two, HashString::size_data) != 0;
-}
-
-inline bool
-operator == (const char* one, const HashString& two) {
-  return std::memcmp(one, two.begin(), HashString::size_data) == 0;
-}
-
-inline bool
-operator != (const char* one, const HashString& two) {
-  return std::memcmp(one, two.begin(), HashString::size_data) != 0;
-}
-
 }
 

trunk/libtorrent/src/tracker/tracker_http.cc

@@ -91 +91 @@
   s.imbue(std::locale::classic());
 
-  char hash[60];
-  char localId[60];
-
-  rak::copy_escape_html(m_info->hash().begin(), m_info->hash().end(), hash);
-  rak::copy_escape_html(m_info->local_id().begin(), m_info->local_id().end(), localId);
+  char hash[61];
+  char localId[61];
+
+  *rak::copy_escape_html(m_info->hash().begin(), m_info->hash().end(), hash) = '\0';
+  *rak::copy_escape_html(m_info->local_id().begin(), m_info->local_id().end(), localId) = '\0';
 
   s << m_url

trunk/rtorrent/rak/error_number.h

@@ -54 +54 @@
   static const int e_nomem       = ENOMEM;
   static const int e_notdir      = ENOTDIR;
+  static const int e_isdir       = EISDIR;
   
   static const int e_intr        = EINTR;
@@ -74 +75 @@
   static error_number current()                    { return errno; }
   static void         clear_global()               { errno = 0; }
+  static void         set_global(error_number err) { errno = err.m_errno; }
 
   bool operator == (const error_number& e) const   { return m_errno == e.m_errno; }

trunk/rtorrent/src/option_handler_rules.cc

@@ -515 +515 @@
                                                                           rak::mem_fn(torrent::chunk_manager(), &torrent::ChunkManager::set_timeout_safe_sync)));
 
+  variables->insert("preload_min_pipelined", new utils::VariableValueSlot(rak::mem_fn(torrent::chunk_manager(), &torrent::ChunkManager::preload_min_pipelined),
+                                                                          rak::mem_fn(torrent::chunk_manager(), &torrent::ChunkManager::set_preload_min_pipelined)));
+
+  variables->insert("preload_min_size",      new utils::VariableValueSlot(rak::mem_fn(torrent::chunk_manager(), &torrent::ChunkManager::preload_min_size),
+                                                                          rak::mem_fn(torrent::chunk_manager(), &torrent::ChunkManager::set_preload_min_size)));
+
+  variables->insert("preload_required_rate", new utils::VariableValueSlot(rak::mem_fn(torrent::chunk_manager(), &torrent::ChunkManager::preload_required_rate),
+                                                                          rak::mem_fn(torrent::chunk_manager(), &torrent::ChunkManager::set_preload_required_rate)));
+
   variables->insert("port_range",            new utils::VariableStringSlot(rak::value_fn(std::string()), rak::bind_ptr_fn(&apply_port_range, c)));