Maximum no of clients that rust event driven server can handle? - server

Question

I am working on an event-driven server in Rust and want it able to connect it to maximum no of clients possible.
But only up to 700 clients I am able to connect and send data at the same time. If I try to increase the clients, client connections from client side start breaking. I am using threads to create multiple clients, it starts giving the following error:
thread '<unnamed>' panicked at 'called `Result::unwrap()` on an `Err` value:
Os { code: 104, kind: ConnectionReset, message: "Connection reset by peer" }',
src/libcore/result.rs
If data sending is disabled it is able to connect 1017 clients and can be increased by allowing a process to open more files than 1024.
I checked the max. no of threads that can be created in my os is 62096. Memory usage of the server program is also around 15KB.
I tried to increase the event loop capacity to 20,480 still it is not supporting 800 clients.
Server.rs:
extern crate mio;
use mio::net::{TcpListener, TcpStream};
use mio::*;
use mio::{Poll, PollOpt, Ready, Token};
use std::collections::HashMap;
use std::env;
use std::io::{Error, Read, Write};
fn process_events(
e: Event,
listener: &TcpListener,
poll: &Poll,
clients: &mut HashMap<Token, TcpStream>,
mut count: usize,
) {
if e.token() == Token(0) {
match listener.accept() {
Ok((mut stream, addr)) => {
let new_token = Token(count);
println!("new token {:?}", new_token);
poll.register(
&stream,
new_token,
Ready::readable(),
PollOpt::edge() | PollOpt::oneshot(),
)
.unwrap();
println!("Got a client: {:?}", stream.peer_addr().unwrap());
clients.insert(new_token, stream);
}
Err(e) => panic!("Error during connection{}", e),
}
}
if e.token() != Token(0) && e.readiness().is_readable() {
let mut buf = [0; 512];
let mut t = e.token();
let reader = clients.get_mut(&e.token()).unwrap().read(&mut buf);
match reader {
Ok(_) => {
let bytes_no = reader.unwrap();
println!("No of bytes read : {:?}, {:?}", bytes_no, e.token());
}
Err(e) => {
println!("could not read: {}", e);
}
}
poll.reregister(
&clients[&e.token()],
e.token(),
Ready::readable(),
PollOpt::edge() | PollOpt::oneshot(),
)
.unwrap();
}
}
fn main() {
const server: Token = Token(0);
let args: Vec<String> = env::args().collect();
if args.len() != 2 {
eprintln!("Provide the argument");
std::process::exit(1);
}
let listen = &args[1];
let addr = listen.parse().unwrap();
let mut listener = TcpListener::bind(&addr).expect("Could not bind");
println!("Server listening on : {}", addr);
let mut clients = HashMap::new();
let mut eve = Events::with_capacity(20480);
let poll = Poll::new().unwrap();
let mut count = 1;
poll.register(
&listener,
server,
Ready::readable(),
PollOpt::edge() | PollOpt::oneshot(),
)
.unwrap();
loop {
poll.poll(&mut eve, None);
for e in &eve {
process_events(e, &listener, &poll, &mut clients, count);
if e.token() == Token(0) {
count += 1;
}
}
poll.reregister(
&listener,
server,
Ready::readable(),
PollOpt::edge() | PollOpt::oneshot(),
)
.unwrap();
}
}
Client.rs:
use std::io;
use std::io::Write;
use std::net::TcpStream;
use std::thread;
fn handle_client() {
let server_addr = String::from("localhost:3000");
if let Ok(mut stream) = TcpStream::connect(server_addr) {
println!("Connected to server {} ", c);
let msg = [0u8; 512];
loop {
stream.write(&msg).unwrap();
}
} else {
println!("could not connect");
}
}
fn main() {
for _i in 0..10000 {
thread::spawn(move || handle_client());
}
}
As the event-driven approach is better than the multi-threaded server, expected clients should more than 1020.