lib/libssh
1
0
Fork 0
mirror of https://git.libssh.org/projects/libssh.git synced 2025-08-05 20:55:46 +03:00
Code Activity

Reformat tests/benchmarks/benchmarks.c

Browse Source 
tests/benchmarks/benchmarks.c has been reformatted
according to current coding style.

Signed-off-by: Eshan Kelkar <eshankelkar@galorithm.com>
Reviewed-by: Sahana Prasad <sahana@redhat.com>
Reviewed-by: Jakub Jelen <jjelen@redhat.com>
This commit is contained in:
Eshan Kelkar
2023-06-01 20:18:05 +05:30
committed by Sahana Prasad
parent 4768d2970a
commit d8790d06c4
1 changed files with 320 additions and 290 deletions
Download Patch File Download Diff File Expand all files Collapse all files

610
tests/benchmarks/benchmarks.c
View File

@@ -27,42 +27,42 @@
#include <stdlib.h> #include <stdlib.h>
#include <stdio.h> #include <stdio.h>
struct benchmark benchmarks[]= { struct benchmark benchmarks[] = {
{ {
.name="benchmark_raw_upload", .name = "benchmark_raw_upload",
.fct=benchmarks_raw_up, .fct = benchmarks_raw_up,
.enabled=0 .enabled = 0
}, },
{ {
.name="benchmark_raw_download", .name = "benchmark_raw_download",
.fct=benchmarks_raw_down, .fct = benchmarks_raw_down,
.enabled=0 .enabled = 0
}, },
{ {
.name="benchmark_scp_upload", .name = "benchmark_scp_upload",
.fct=benchmarks_scp_up, .fct = benchmarks_scp_up,
.enabled=0 .enabled = 0
}, },
{ {
.name="benchmark_scp_download", .name = "benchmark_scp_download",
.fct=benchmarks_scp_down, .fct = benchmarks_scp_down,
.enabled=0 .enabled = 0
}, },
#ifdef WITH_SFTP #ifdef WITH_SFTP
{ {
.name="benchmark_sync_sftp_upload", .name = "benchmark_sync_sftp_upload",
.fct=benchmarks_sync_sftp_up, .fct = benchmarks_sync_sftp_up,
.enabled=0 .enabled = 0
}, },
{ {
.name="benchmark_sync_sftp_download", .name = "benchmark_sync_sftp_download",
.fct=benchmarks_sync_sftp_down, .fct = benchmarks_sync_sftp_down,
.enabled=0 .enabled = 0
}, },
{ {
.name="benchmark_async_sftp_download", .name = "benchmark_async_sftp_download",
.fct=benchmarks_async_sftp_down, .fct = benchmarks_async_sftp_down,
.enabled=0 .enabled = 0
} }
#endif /* WITH_SFTP */ #endif /* WITH_SFTP */
}; };
@@ -73,7 +73,7 @@ struct benchmark benchmarks[]= {
const char *argp_program_version = "libssh benchmarks 2011-08-28"; const char *argp_program_version = "libssh benchmarks 2011-08-28";
const char *argp_program_bug_address = "Aris Adamantiadis <aris@0xbadc0de.be>"; const char *argp_program_bug_address = "Aris Adamantiadis <aris@0xbadc0de.be>";
static char **cmdline; static char **cmdline = NULL;
/* Program documentation. */ /* Program documentation. */
static char doc[] = "libssh benchmarks"; static char doc[] = "libssh benchmarks";
@@ -81,128 +81,126 @@ static char doc[] = "libssh benchmarks";
/* The options we understand. */ /* The options we understand. */
static struct argp_option options[] = { static struct argp_option options[] = {
{ {
.name = "verbose", .name = "verbose",
.key = 'v', .key = 'v',
.arg = NULL, .arg = NULL,
.flags = 0, .flags = 0,
.doc = "Make libssh benchmark more verbose", .doc = "Make libssh benchmark more verbose",
.group = 0 .group = 0
}, },
{ {
.name = "raw-upload", .name = "raw-upload",
.key = '1', .key = '1',
.arg = NULL, .arg = NULL,
.flags = 0, .flags = 0,
.doc = "Upload raw data using channel", .doc = "Upload raw data using channel",
.group = 0 .group = 0
}, },
{ {
.name = "raw-download", .name = "raw-download",
.key = '2', .key = '2',
.arg = NULL, .arg = NULL,
.flags = 0, .flags = 0,
.doc = "Download raw data using channel", .doc = "Download raw data using channel",
.group = 0 .group = 0
}, },
{ {
.name = "scp-upload", .name = "scp-upload",
.key = '3', .key = '3',
.arg = NULL, .arg = NULL,
.flags = 0, .flags = 0,
.doc = "Upload data using SCP", .doc = "Upload data using SCP",
.group = 0 .group = 0
}, },
{ {
.name = "scp-download", .name = "scp-download",
.key = '4', .key = '4',
.arg = NULL, .arg = NULL,
.flags = 0, .flags = 0,
.doc = "Download data using SCP", .doc = "Download data using SCP",
.group = 0 .group = 0
}, },
{ {
.name = "sync-sftp-upload", .name = "sync-sftp-upload",
.key = '5', .key = '5',
.arg = NULL, .arg = NULL,
.flags = 0, .flags = 0,
.doc = "Upload data using synchronous SFTP", .doc = "Upload data using synchronous SFTP",
.group = 0 .group = 0
},
{
.name = "sync-sftp-download",
.key = '6',
.arg = NULL,
.flags = 0,
.doc = "Download data using synchronous SFTP (slow)",
.group = 0
},
{
.name = "async-sftp-download",
.key = '7',
.arg = NULL,
.flags = 0,
.doc = "Download data using asynchronous SFTP (fast)",
.group = 0
},
{
.name = "host",
.key = 'h',
.arg = "HOST",
.flags = 0,
.doc = "Add a host to connect for benchmark (format user@hostname)",
.group = 0
},
{
.name = "size",
.key = 's',
.arg = "MBYTES",
.flags = 0,
.doc = "MBytes of data to send/receive per test",
.group = 0
},
{
.name = "chunk",
.key = 'c',
.arg = "bytes",
.flags = 0,
.doc = "size of data chunks to send/receive",
.group = 0
},
{
.name = "prequests",
.key = 'p',
.arg = "number [20]",
.flags = 0,
.doc = "[async SFTP] number of concurrent requests",
.group = 0
},
{
.name = "cipher",
.key = 'C',
.arg = "cipher",
.flags = 0,
.doc = "Cryptographic cipher to be used",
.group = 0
},
}, {NULL, 0, NULL, 0, NULL, 0}
{
.name = "sync-sftp-download",
.key = '6',
.arg = NULL,
.flags = 0,
.doc = "Download data using synchronous SFTP (slow)",
.group = 0
},
{
.name = "async-sftp-download",
.key = '7',
.arg = NULL,
.flags = 0,
.doc = "Download data using asynchronous SFTP (fast)",
.group = 0
},
{
.name = "host",
.key = 'h',
.arg = "HOST",
.flags = 0,
.doc = "Add a host to connect for benchmark (format user@hostname)",
.group = 0
},
{
.name = "size",
.key = 's',
.arg = "MBYTES",
.flags = 0,
.doc = "MBytes of data to send/receive per test",
.group = 0
},
{
.name = "chunk",
.key = 'c',
.arg = "bytes",
.flags = 0,
.doc = "size of data chunks to send/receive",
.group = 0
},
{
.name = "prequests",
.key = 'p',
.arg = "number [20]",
.flags = 0,
.doc = "[async SFTP] number of concurrent requests",
.group = 0
},
{
.name = "cipher",
.key = 'C',
.arg = "cipher",
.flags = 0,
.doc = "Cryptographic cipher to be used",
.group = 0
},
{NULL, 0, NULL, 0, NULL, 0}
}; };
/* Parse a single option. */ /* Parse a single option. */
static error_t parse_opt (int key, char *arg, struct argp_state *state) { static error_t parse_opt (int key, char *arg, struct argp_state *state)
/* Get the input argument from argp_parse, which we {
* know is a pointer to our arguments structure. /* Get the input argument from argp_parse, which we
*/ * know is a pointer to our arguments structure.
struct argument_s *arguments = state->input; */
struct argument_s *arguments = state->input;
/* arg is currently not used */ /* arg is currently not used */
(void) arg; (void) arg;
switch (key) { switch (key) {
case '1': case '1':
case '2': case '2':
case '3': case '3':
@@ -210,42 +208,43 @@ static error_t parse_opt (int key, char *arg, struct argp_state *state) {
case '5': case '5':
case '6': case '6':
case '7': case '7':
benchmarks[key - '1'].enabled = 1; benchmarks[key - '1'].enabled = 1;
arguments->ntests ++; arguments->ntests++;
break; break;
case 'v': case 'v':
arguments->verbose++; arguments->verbose++;
break; break;
case 's': case 's':
arguments->datasize = atoi(arg); arguments->datasize = atoi(arg);
break; break;
case 'p': case 'p':
arguments->concurrent_requests = atoi(arg); arguments->concurrent_requests = atoi(arg);
break; break;
case 'c': case 'c':
arguments->chunksize = atoi(arg); arguments->chunksize = atoi(arg);
break; break;
case 'C': case 'C':
arguments->cipher = arg; arguments->cipher = arg;
break; break;
case 'h': case 'h':
if(arguments->nhosts >= MAX_HOSTS_CONNECT){ if (arguments->nhosts >= MAX_HOSTS_CONNECT) {
fprintf(stderr, "Too much hosts\n"); fprintf(stderr, "Too much hosts\n");
return ARGP_ERR_UNKNOWN; return ARGP_ERR_UNKNOWN;
} }
arguments->hosts[arguments->nhosts]=arg;
arguments->nhosts++;
break;
case ARGP_KEY_ARG:
/* End processing here. */
cmdline = &state->argv [state->next - 1];
state->next = state->argc;
break;
default:
return ARGP_ERR_UNKNOWN;
}
return 0; arguments->hosts[arguments->nhosts] = arg;
arguments->nhosts++;
break;
case ARGP_KEY_ARG:
/* End processing here. */
cmdline = &state->argv [state->next - 1];
state->next = state->argc;
break;
default:
return ARGP_ERR_UNKNOWN;
}
return 0;
} }
/* Our argp parser. */ /* Our argp parser. */
@@ -253,150 +252,181 @@ static struct argp argp = {options, parse_opt, NULL, doc, NULL, NULL, NULL};
#endif /* HAVE_ARGP_H */ #endif /* HAVE_ARGP_H */
static void cmdline_parse(int argc, char **argv, struct argument_s *arguments) { static void cmdline_parse(int argc, char **argv, struct argument_s *arguments)
/* {
* Parse our arguments; every option seen by parse_opt will /*
* be reflected in arguments. * Parse our arguments; every option seen by parse_opt will
*/ * be reflected in arguments.
*/
#ifdef HAVE_ARGP_H #ifdef HAVE_ARGP_H
argp_parse(&argp, argc, argv, 0, 0, arguments); argp_parse(&argp, argc, argv, 0, 0, arguments);
#else /* HAVE_ARGP_H */ #else /* HAVE_ARGP_H */
(void) argc; (void) argc;
(void) argv; (void) argv;
arguments->hosts[0]="localhost"; arguments->hosts[0] = "localhost";
arguments->nhosts=1; arguments->nhosts = 1;
#endif /* HAVE_ARGP_H */ #endif /* HAVE_ARGP_H */
} }
static void arguments_init(struct argument_s *arguments){ static void arguments_init(struct argument_s *arguments)
memset(arguments,0,sizeof(*arguments)); {
arguments->chunksize=32758; memset(arguments, 0, sizeof(*arguments));
arguments->concurrent_requests=20; arguments->chunksize = 32758;
arguments->datasize = 10; arguments->concurrent_requests = 20;
arguments->datasize = 10;
} }
static ssh_session connect_host(const char *host, int verbose, char *cipher){ static ssh_session connect_host(const char *host, int verbose, char *cipher)
ssh_session session=ssh_new(); {
if(session==NULL) ssh_session session = ssh_new();
goto error; if (session == NULL)
if(ssh_options_set(session,SSH_OPTIONS_HOST, host)<0) goto error;
goto error;
ssh_options_set(session, SSH_OPTIONS_LOG_VERBOSITY, &verbose); if (ssh_options_set(session, SSH_OPTIONS_HOST, host) < 0)
if(cipher != NULL){ goto error;
if (ssh_options_set(session, SSH_OPTIONS_CIPHERS_C_S, cipher) ||
ssh_options_set(session, SSH_OPTIONS_CIPHERS_S_C, cipher)){ ssh_options_set(session, SSH_OPTIONS_LOG_VERBOSITY, &verbose);
goto error; if (cipher != NULL) {
if (ssh_options_set(session, SSH_OPTIONS_CIPHERS_C_S, cipher) ||
ssh_options_set(session, SSH_OPTIONS_CIPHERS_S_C, cipher)) {
goto error;
}
} }
}
ssh_options_parse_config(session, NULL); ssh_options_parse_config(session, NULL);
if(ssh_connect(session)==SSH_ERROR) if (ssh_connect(session) == SSH_ERROR)
goto error; goto error;
if(ssh_userauth_autopubkey(session,NULL) != SSH_AUTH_SUCCESS) if (ssh_userauth_autopubkey(session, NULL) != SSH_AUTH_SUCCESS)
goto error; goto error;
return session; return session;
error: error:
fprintf(stderr,"Error connecting to \"%s\": %s\n",host,ssh_get_error(session)); fprintf(stderr, "Error connecting to \"%s\": %s\n",
ssh_free(session); host, ssh_get_error(session));
return NULL; ssh_free(session);
return NULL;
} }
static char *network_speed(float bps){ static char *network_speed(float bps)
static char buf[128]; {
if(bps > 1000*1000*1000){ static char buf[128];
/* Gbps */ if (bps > 1000 * 1000 * 1000) {
snprintf(buf,sizeof(buf),"%f Gbps",bps/(1000*1000*1000)); /* Gbps */
} else if(bps > 1000*1000){ snprintf(buf, sizeof(buf), "%f Gbps", bps / (1000 * 1000 * 1000));
/* Mbps */ } else if (bps > 1000 * 1000) {
snprintf(buf,sizeof(buf),"%f Mbps",bps/(1000*1000)); /* Mbps */
} else if(bps > 1000){ snprintf(buf, sizeof(buf), "%f Mbps", bps / (1000 * 1000));
snprintf(buf,sizeof(buf),"%f Kbps",bps/1000); } else if (bps > 1000) {
} else { snprintf(buf, sizeof(buf), "%f Kbps", bps / 1000);
snprintf(buf,sizeof(buf),"%f bps",bps); } else {
} snprintf(buf, sizeof(buf), "%f bps", bps);
return buf; }
return buf;
} }
static void do_benchmarks(ssh_session session, struct argument_s *arguments, static void do_benchmarks(ssh_session session, struct argument_s *arguments,
const char *hostname){ const char *hostname)
float ping_rtt=0.0; {
float ssh_rtt=0.0; float ping_rtt = 0.0;
float bps=0.0; float ssh_rtt = 0.0;
int i; float bps = 0.0;
int err; int i;
struct benchmark *b; int err;
struct benchmark *b = NULL;
if(arguments->verbose>0) if (arguments->verbose > 0)
fprintf(stdout,"Testing ICMP RTT\n"); fprintf(stdout, "Testing ICMP RTT\n");
err=benchmarks_ping_latency(hostname, &ping_rtt);
if(err == 0){ err = benchmarks_ping_latency(hostname, &ping_rtt);
fprintf(stdout,"ping RTT : %f ms\n",ping_rtt); if (err == 0) {
} fprintf(stdout, "ping RTT : %f ms\n", ping_rtt);
err=benchmarks_ssh_latency(session, &ssh_rtt); }
if(err==0){
fprintf(stdout, "SSH RTT : %f ms. Theoretical max BW (win=128K) : %s\n",ssh_rtt,network_speed(128000.0/(ssh_rtt / 1000.0))); err = benchmarks_ssh_latency(session, &ssh_rtt);
} if (err == 0) {
for (i=0 ; i<BENCHMARK_NUMBER ; ++i){ fprintf(stdout,
b = &benchmarks[i]; "SSH RTT : %f ms. Theoretical max BW (win=128K) : %s\n",
if(b->enabled){ ssh_rtt, network_speed(128000.0 / (ssh_rtt / 1000.0)));
err=b->fct(session,arguments,&bps); }
if(err==0){
fprintf(stdout, "%s : %s : %s\n",hostname, b->name, network_speed(bps)); for (i=0; i < BENCHMARK_NUMBER; ++i){
} b = &benchmarks[i];
if (b->enabled) {
err=b->fct(session, arguments, &bps);
if (err == 0) {
fprintf(stdout,
"%s : %s : %s\n",
hostname, b->name, network_speed(bps));
}
}
} }
}
} }
char *buffer; char *buffer = NULL;
int main(int argc, char **argv){ int main(int argc, char **argv)
struct argument_s arguments; {
ssh_session session; struct argument_s arguments;
int i; ssh_session session = NULL;
int i;
arguments_init(&arguments); arguments_init(&arguments);
cmdline_parse(argc, argv, &arguments); cmdline_parse(argc, argv, &arguments);
if (arguments.nhosts==0){ if (arguments.nhosts == 0) {
fprintf(stderr,"At least one host (-h) must be specified\n"); fprintf(stderr, "At least one host (-h) must be specified\n");
return EXIT_FAILURE; return EXIT_FAILURE;
}
if (arguments.ntests==0){
for(i=0; i < BENCHMARK_NUMBER ; ++i){
benchmarks[i].enabled=1;
} }
arguments.ntests=BENCHMARK_NUMBER;
}
buffer=malloc(arguments.chunksize > 1024 ? arguments.chunksize : 1024);
if(buffer == NULL){
fprintf(stderr,"Allocation of chunk buffer failed\n");
return EXIT_FAILURE;
}
if (arguments.verbose > 0){
fprintf(stdout, "Will try hosts ");
for(i=0;i<arguments.nhosts;++i){
fprintf(stdout,"\"%s\" ", arguments.hosts[i]);
}
fprintf(stdout,"with benchmarks ");
for(i=0;i<BENCHMARK_NUMBER;++i){
if(benchmarks[i].enabled)
fprintf(stdout,"\"%s\" ",benchmarks[i].name);
}
fprintf(stdout,"\n");
}
for(i=0; i<arguments.nhosts;++i){ if (arguments.ntests == 0) {
if(arguments.verbose > 0) for (i=0; i < BENCHMARK_NUMBER; ++i) {
fprintf(stdout,"Connecting to \"%s\"...\n",arguments.hosts[i]); benchmarks[i].enabled = 1;
session=connect_host(arguments.hosts[i], arguments.verbose, arguments.cipher); }
if(session != NULL && arguments.verbose > 0) arguments.ntests = BENCHMARK_NUMBER;
fprintf(stdout,"Success\n");
if(session == NULL){
fprintf(stderr,"Errors occurred, stopping\n");
return EXIT_FAILURE;
} }
do_benchmarks(session, &arguments, arguments.hosts[i]);
ssh_disconnect(session); buffer = malloc(arguments.chunksize > 1024 ? arguments.chunksize : 1024);
ssh_free(session); if (buffer == NULL) {
} fprintf(stderr, "Allocation of chunk buffer failed\n");
return EXIT_SUCCESS; return EXIT_FAILURE;
}
if (arguments.verbose > 0) {
fprintf(stdout, "Will try hosts ");
for (i=0; i < arguments.nhosts; ++i) {
fprintf(stdout, "\"%s\" ", arguments.hosts[i]);
}
fprintf(stdout, "with benchmarks ");
for (i = 0; i < BENCHMARK_NUMBER; ++i) {
if (benchmarks[i].enabled)
fprintf(stdout, "\"%s\" ", benchmarks[i].name);
}
fprintf(stdout,"\n");
}
for (i = 0; i < arguments.nhosts; ++i) {
if (arguments.verbose > 0)
fprintf(stdout, "Connecting to \"%s\"...\n", arguments.hosts[i]);
session = connect_host(arguments.hosts[i],
arguments.verbose,
arguments.cipher);
if (session != NULL && arguments.verbose > 0)
fprintf(stdout, "Success\n");
if (session == NULL) {
fprintf(stderr, "Errors occurred, stopping\n");
return EXIT_FAILURE;
}
do_benchmarks(session, &arguments, arguments.hosts[i]);
ssh_disconnect(session);
ssh_free(session);
}
return EXIT_SUCCESS;
} }