perf: raise transfer defaults and stop uploads sleeping on their slot

The slot cap merged from master defaults to 2 uploads, and the CLI capped
downloads at 5. Those are the numbers you pick when your own bandwidth is the
scarce resource, but a Soulseek transfer is paced by the peer on the other end
— usually a few hundred KiB/s — so what fills a modern link is many transfers
at once, not faster ones. Upload slots go to 10, downloads to 20. The queue
itself stays: privileged users being able to jump it is a condition of being a
tolerated third-party client.

serve_file also slept half a second after the last byte so the downloader could
drain before the socket closed. With a cap that is time no other peer can use,
and 64 uploads over 10 slots paid it six times over. A half-close says "that is
the whole file" and TCP still delivers everything written before the FIN.

Measured with 64 waiting peers: 2 slots 24.2s, 8 slots 6.2s, 32 slots 3.1s; at
10 slots the linger alone was 5.4s to 3.05s.

soulseek-rs-lib/examples/stress.rs

@@ -13,6 +13,7 @@
 //!   STRESS_DOWNLOADS  downloads started at once
 //!   STRESS_LEECHERS   mock peers pulling uploads from us at once
 //!   STRESS_BROWSES    browses fired at once
+//!   STRESS_UPLOAD_SLOTS  concurrent upload slots (default: every leecher)
 //!   STRESS_FILE_KB    size of every transferred file
 //!   STRESS_TIMEOUT    seconds before the run is called off
 //!   STRESS_SAVE=1     store this run as the new baseline
@@ -54,6 +55,7 @@ struct Config {
     downloads: usize,
     leechers: usize,
     browses: usize,
+    upload_slots: usize,
     file_bytes: usize,
     timeout: Duration,
     save: bool,
@@ -74,6 +76,13 @@ impl Config {
             downloads: env_usize("STRESS_DOWNLOADS", 512),
             leechers: env_usize("STRESS_LEECHERS", 256),
             browses: env_usize("STRESS_BROWSES", 128),
+            // Serve every leecher at once by default: this profile measures
+            // concurrency, and the shipped slot cap would otherwise make it a
+            // measurement of the queue. Lower it deliberately to stress that.
+            upload_slots: env_usize(
+                "STRESS_UPLOAD_SLOTS",
+                env_usize("STRESS_LEECHERS", 256).max(1),
+            ),
             file_bytes: env_usize("STRESS_FILE_KB", 4096) * 1024,
             timeout: Duration::from_secs(env_usize("STRESS_TIMEOUT", 60) as u64),
             save: std::env::var("STRESS_SAVE").is_ok_and(|v| v == "1"),
@@ -980,6 +989,7 @@ fn main() {
     });
     client.connect().expect("client connect");
     assert!(client.login().expect("client login"), "client login failed");
+    client.set_upload_slots(cfg.upload_slots);
     std::thread::sleep(Duration::from_secs(1));
 
     let client = Arc::new(client);

soulseek-rs-lib/src/actor/mod.rs

@@ -87,7 +87,7 @@ impl ActorSystem {
     /// The callback receives the actor handle before `on_start` is called
     pub fn spawn_with_handle<A: Actor, F>(
         &self,
-        actor: A,
+        mut actor: A,
         init: F,
     ) -> ActorHandle<A::Message>
     where
@@ -96,7 +96,6 @@ impl ActorSystem {
         let (sender, receiver) = channel::<ActorMessage<A::Message>>();
         let handle = ActorHandle { sender };
         let handle_for_init = handle.clone();
-        let mut actor = actor;
 
         let spawned = thread::Builder::new()
             .name("soulseek-actor".to_string())

soulseek-rs-lib/src/client/mod.rs

@@ -48,10 +48,17 @@ pub const DEFAULT_WISHLIST_INTERVAL: Duration = Duration::from_mins(12);
 
 /// How many uploads run at once by default.
 ///
-/// Two is what makes the queue real: with unlimited slots there is nothing for
-/// a privileged peer to jump, and a home connection split across every peer
-/// that asks serves all of them badly.
-pub const DEFAULT_UPLOAD_SLOTS: usize = 2;
+/// The cap is what makes the queue real — with unlimited slots there is nothing
+/// for a privileged peer to jump — but it must not be the thing throttling a
+/// modern connection. On Soulseek the per-transfer rate is usually set by the
+/// *other* end, so concurrency is what fills an uplink: ten peers at a typical
+/// few hundred KiB/s each is a few MiB/s, which a 50 Mbit uplink carries and a
+/// pair of slots leaves mostly idle. Ten still divides a modest uplink into
+/// shares big enough that no peer times out waiting.
+///
+/// Measured on the stress benchmark (64 waiting peers, loopback): two slots
+/// took 24.2s, eight took 6.2s, thirty-two took 3.1s.
+pub const DEFAULT_UPLOAD_SLOTS: usize = 10;
 
 /// How long to wait for a server-brokered (firewalled) peer to connect back
 /// before giving up and failing the download. Matches the direct-dial timeout.

soulseek-rs-lib/src/client/operations.rs

@@ -471,10 +471,7 @@ impl Client {
                                 let registry = context.peer_registry.clone();
                                 drop(context);
                                 if let Some(registry) = registry {
-                                    let response =
-                                        crate::message::server::MessageFactory::build_transfer_response_message(
-                                            transfer,
-                                        );
+                                    let response = MessageFactory::build_transfer_response_message(transfer);
                                     let _ = registry.send_to_peer(
                                         &username,
                                         PeerMessage::SendMessage(response),

soulseek-rs-lib/src/peer/upload_peer.rs

@@ -83,8 +83,11 @@ pub fn serve_file(
     }
     stream.flush()?;
 
-    // Linger so the downloader drains everything before the socket closes.
-    std::thread::sleep(Duration::from_millis(500));
+    // Half-close instead of lingering: the FIN tells the downloader it has the
+    // whole file, and TCP still delivers everything written before it. Sleeping
+    // here held an upload slot for an extra half-second per transfer, which with
+    // a slot cap is time no other peer can use.
+    stream.shutdown(std::net::Shutdown::Write).ok();
     trace!("[upload] served {} to {}:{}", path.display(), host, port);
     Ok(())
 }