Which good practice to test benchmark call Tarantool store prodecdure?

[measproem]

I am new with Tarantool I test benchmark Rust project Actix Web by cloned code from repo Link
My local CentoS7, CPU 8 cores, RAM 16G I got results:

• ~5k/s (Actix Web with Tarantool)
• ~40k/s (When I modified code without connect to Tarantool keep only Rust loop)

With the benchmark between ~5k/s and ~40k/s it so difference I don't know problem from which part.
I found article medium said that Tarantool support 200k 20K RPS

Note: beside Rust I tested with Python less than ~5k/s
Help advise with good practice

use rusty_tarantool::tarantool::ClientConfig;

use std::io;
use std::sync::atomic::{AtomicUsize, Ordering};
use std::time::Instant;

static COUNTER: AtomicUsize = AtomicUsize::new(0);

#[tokio::main]
async fn main() -> io::Result<()> {
	println!("Simple client run!");

	let client = ClientConfig::new("127.0.0.1:3301", "rust", "rust")
		.set_timeout_time_ms(2000)
		.set_reconnect_time_ms(2000)
		.build();
	let start = Instant::now();
	let count = 100000;

	for x in 0..count {
		let response = client.call_fn("test", &(("aa", "aa"), x)).await?;
		let s: (Vec<String>, u64, Option<u64>) = response.decode()?;
		let v = COUNTER.fetch_add(1, Ordering::SeqCst);
		if v == count - 1 {
			println!("All finished res={:?}", s);
			let elapsed = start.elapsed();
			// debug format:
			println!("{:?}", elapsed);
			std::process::exit(0);
		}
	}

	Ok(())
}

[Totktonada]

It seems that the benchmark code just waits for a response most of time:

1. client.call_fn() sends a request to the network.
2. .await? waits for a response. Here we spend most of time. And here we do nothing.
3. The response is processed.
4. Go to 1.

(Since I'm not familiar with the programming language, the framefork and the connector you're using, I can completely misunderstand the code.)

I can't suggest how exactly you should reorganize the code to use the power of asynchronous interation with the network. However I can sketchy describe an approach, which should give better numbers:

1. Send BATCH_SIZE (say, 1000) requests asynchronously. Save future/promise objects. Let's name it batch N.
2. Wait for all responses from batch (N-1) (.await? on each future/promise object) and process them.
3. Go to 1.

It will not utilize network and CPU ideally, but it is simple and should be much better than the synchronous approach (I mean, waiting for each response individually without any CPU utilization).

(Maybe the Tokio framework offers something that allows to better balance network/CPU utilization and write more elegant code. I just don't know, sorry.)

There is a StackOverflow question, where I talk about synchronous and asynchronous processing. It may be useful to understand those concepts. However the idea is simple and mostly the same as pipelining in other computer systems with slow and fast operations.

[measproem]

Thank your explained saved my time finally I found problems as below:

• Rust project connector problem with async "await" as you mentioned
• I have tested with official Tarantool's python connector also problem but because of me not carefully read document comparison
  Finally problem solved by Python connector name: asynctnt
  The result 100k rps in 0.14s