-
-
- disk cache stats -
- disk access stats -
- session stats +
- high performance seeding +
- benchmarking + +
- contributions
The typical buffer usage of libtorrent, for a single download, with the cache size set to 256 blocks (256 * 16 kiB = 4 MiB) is:
-read cache: 149.5 (2392 kiB) -write cache: 89.5 (1432 kiB) -receive buffers: 6.5 (104 kiB) -send buffers: 4 (64 kiB) -hash temp: 0.5 (8 kiB) +read cache: 128.6 (2058 kiB) +write cache: 103.5 (1656 kiB) +receive buffers: 7.3 (117 kiB) +send buffers: 4.8 (77 kiB) +hash temp: 0.001 (19 Bytes)
The receive buffers is proportional to the number of connections we make, and is limited by the total number of connections in the session (default is 200).
@@ -102,7 +109,7 @@ speed or memory usage. In this test run it was optimized for memory usage.disable disk cache
The bulk of the memory libtorrent will use is used for the disk cache. To save -the absolute most amount of memory, you can disable the the cache by setting +the absolute most amount of memory, you can disable the cache by setting session_settings::cache_size to 0. You might want to consider using the cache but just disable caching read operations. You do this by settings session_settings::use_read_cache to false. This is the main factor in how much @@ -112,7 +119,7 @@ informed trade-off.
remove torrents
-Torrents that have been added to libtorrent will inevitably use up memory, event +
Torrents that have been added to libtorrent will inevitably use up memory, even when it's paused. A paused torrent will not use any peer connection objects or any send or receive buffers though. Any added torrent holds the entire .torrent file in memory, it also remembers the entire list of peers that it's heard about @@ -130,7 +137,7 @@ in the greatest need of seeding, and libtorrent will prioritize to seed those.socket buffer sizes
You can make libtorrent explicitly set the kernel buffer sizes of all its peer sockets. If you set this to a low number, you may see reduced throughput, especially -for high latency connections. It is however an oportunity to save memory per +for high latency connections. It is however an opportunity to save memory per connection, and might be worth considering if you have a very large number of peer connections. This memory will not be visible in your process, this sets the amount of kernel memory is used for your sockets.
@@ -213,17 +220,263 @@ than zero. This number is the number of milliseconds to sleep between each read but the number will be multiplied by the number of blocks that were read, to maintain the same semantics.high performance seeding
+In the case of a high volume seed, there are two main concerns. Performance and scalability. +This transelates into high send rates, and low memory and CPU usage per peer connection.
+file pool
+libtorrent keeps an LRU file cache. Each file that is opened, is stuck in the cache. The main +purpose of this is because of anti-virus software that hooks och file-open and file close to +scan the file. Anti-virus software that does that will significantly increase the cost of +opening and closing files. However, for a high performance seed, the file open/close might +be so frequent that it becomes a significant cost. It might therefore be a good idea to allow +a large file descriptor cache. Adjust this though session_settings::file_pool_size.
+Don't forget to set a high rlimit for file descriptors in yor process as well. This limit +must be high enough to keep all connections and files open.
+disk cache
+You typically want to set the cache size to as high as possible. The +session_settings::cache_size is specified in 16 kiB blocks. Since you're seeding, +the cache would be useless unless you also set session_settings::use_read_cache +to true.
+In order to increase the possibility of read cache hits, set the +session_settings::cache_expiry to a large number. This won't degrade anything as +long as the client is only seeding, and not downloading any torrents.
+peers
+First of all, in order to allow many connections, set the global connection limit +high, session::set_max_connections(). Also set the upload rate limit to +infinite, session::set_upload_rate_limit(), passing 0 means infinite.
+When dealing with a large number of peers, it might be a good idea to have slightly +stricter timeouts, to get rid of lingering connections as soon as possible.
+There are a couple of relevant settings: session_settings::request_timeout, +session_settings::peer_timeout and session_settings::inactivity_timeout.
+For seeds that are critical for a delivery system, you most likely want to allow +multiple connections from the same IP. That way two people from behind the same NAT +can use the service simultaneously. This is controlled by +session_settings::allow_multiple_connections_per_ip.
+In order to always unchoke peers, turn off automatic unchoke +session_settings::auto_upload_slots and set the number of upload slots to a large +number via session::set_max_uploads().
+torrent limits
+To seed thousands of torrents, you need to increase the session_settings::active_limit +and session_settings::active_seeds.
+benchmarking
-disk cache stats
+There are a bunch of built-in instrumentation of libtorrent that can be used to get an insight +into what it's doing and how well it performs. This instrumentation is enabled by defining +preprocessor symbols when building.
+There are also a number of scripts that parses the log files and generates graphs (requires +gnuplot and python).
+disk metrics
+To enable disk I/O instrumentation, define TORRENT_DISK_STATS when building. When built +with this configuration libtorrent will create three log files, measuring various aspects of +the disk I/O. The following table is an overview of these files and what they measure.
+| filename | +description | +
|---|---|
| disk_io_thread.log | +This is a log of which operation the disk I/O thread is +engaged in, with timestamps. This tells you what the thread +is spending its time doing. | +
| disk_buffers.log | +This log keeps track of what the buffers allocated from the +disk buffer pool are used for. There are 5 categories. +receive buffer, send buffer, write cache, read cache and +temporary hash storage. This is key when optimizing memory +usage. | +
| disk_access.log | +This is a low level log of read and write operations, with +timestamps and file offsets. The file offsets are byte +offsets in the torrent (not in any particular file, in the +case of a multi-file torrent). This can be used as an +estimate of the physical drive location. The purpose of +this log is to identify the amount of seeking the drive has +to do. | +
disk_io_thread.log
+The structure of this log is simple. For each line, there are two columns, a timestamp and +the operation that was started. There is a special operation called idle which means +it looped back to the top and started waiting for new jobs. If there are more jobs to +handle immediately, the idle state is still there, but the timestamp is the same as the +next job that is handled.
+Some operations have a 3:rd column with an optional parameter. read and write tells +you the number of bytes that were requested to be read or written. flushing tells you +the number of bytes that were flushed from the disk cache.
+This is an example excerpt from a log:
++3702 idle +3706 check_fastresume +3707 idle +4708 save_resume_data +4708 idle +8230 read 16384 +8255 idle +8431 read 16384 ++
The script to parse this log and generate a graph is called parse_disk_log.py. It takes +the log file as the first command line argument, and produces a file: disk_io.png. +The time stamp is in milliseconds since start.
+You can pass in a second, optional, argument to specify the window size it will average +the time measurements over. The default is 5 seconds. For long test runs, it might be interesting +to increase that number. It is specified as a number of seconds.
+
+This is an example graph generated by the parse script.
+disk_buffers.log
+The disk buffer log tells you where the buffer memory is used. The log format has a time stamp, +the name of the buffer usage which use-count changed, colon, and the new number of blocks that are +in use for this particular key. For example:
++23671 write cache: 18 +23671 receive buffer: 3 +24153 receive buffer: 2 +24153 write cache: 19 +24154 receive buffer: 3 +24198 receive buffer: 2 +24198 write cache: 20 +24202 receive buffer: 3 +24305 send buffer: 0 +24305 send buffer: 1 +24909 receive buffer: 2 +24909 write cache: 21 +24910 receive buffer: 3 ++
The time stamp is in milliseconds since start.
+To generate a graph, use parse_disk_buffer_log.py. It takes the log file as the first +command line argument. It generates disk_buffer.png.
+
+This is an example graph generated by the parse script.
+disk_access.log
+The disc access log has three fields. The timestamp (milliseconds since start), operation +and offset. The offset is the absolute offset within the torrent (not within a file). This +log is only useful when you're downloading a single torrent, otherwise the offsets will not +be unique.
+In order to easily plot this directly in gnuplot, without parsing it, there are two lines +associated with each read or write operation. The first one is the offset where the operation +started, and the second one is where the operation ended.
+Example:
++15437 read 301187072 +15437 read_end 301203456 +16651 read 213385216 +16680 read_end 213647360 +25879 write 249036800 +25879 write_end 249298944 +26811 read 325582848 +26943 read_end 325844992 +36736 read 367001600 +36766 read_end 367263744 ++
The disk access log does not have any good visualization tool yet. There is however a gnuplot +file, disk_access.gnuplot which assumes disk_access.log is in the current directory.
+
+The density of the disk seeks tells you how hard the drive has to work.
disk access stats
session stats
+By defining TORRENT_STATS libtorrent will write a log file called session_stats.log which +is in a format ready to be passed directly into gnuplot. The parser script parse_session_stats.py +will however parse out the field names and generate 3 different views of the data. This script +is easy to modify to generate the particular view you're interested in.
+The first line in the log contains all the field names, separated by colon:
++second:upload rate:download rate:downloading torrents:seeding torrents:peers... ++
The rest of the log is one line per second with all the fields' values.
+These are the fields:
+| field name | +description | +
|---|---|
| second | +the time, in seconds, for this log line | +
| upload rate | +the number of bytes uploaded in the last second | +
| download rate | +the number of bytes downloaded in the last second | +
| downloading torrents | +the number of torrents that are not seeds | +
| seeding torrents | +the number of torrents that are seed | +
| peers | +the total number of connected peers | +
| connecting peers | +the total number of peers attempting to connect (half-open) | +
| disk block buffers | +the total number of disk buffer blocks that are in use | +
| unchoked peers | +the total number of unchoked peers | +
| num list peers | +the total number of known peers, but not necessarily connected | +
| peer allocations | +the total number of allocations for the peer list pool | +
| peer storage bytes | +the total number of bytes allocated for the peer list pool | +
This is an example of a graph that can be generated from this log:
+
+It shows statistics about the number of peers and peers states. How at the startup +there are a lot of half-open connections, which tapers off as the total number of +peers approaches the limit (50). It also shows how the total peer list slowly but steadily +grows over time. This list is plotted against the right axis, as it has a different scale +as the other fields.
contributions
+If you have added instrumentation for some part of libtorrent that is not covered here, or +if you have improved any of the parser scrips, please consider contributing it back to the +project.
+If you have run tests and found that some algorithm or default value in libtorrent is +suboptimal, please contribute that knowledge back as well, to allow us to improve the library.
+If you have additional suggestions on how to tune libtorrent for any specific use case, +please let us know and we'll update this document.