remove Makefile

update README and change it to markdown.

Reviewed-by: Tomas Mraz <[email protected]>
Reviewed-by: Saša Nedvědický <[email protected]>
(Merged from #39)

Author: quarckster

README renamed to README.md

@@ -1,5 +1,4 @@
-Performance testing tools
-=========================
+# OpenSSL performance testing tools
 
 This directory holds tools for carrying out performance tests on OpenSSL.
 
@@ -11,47 +10,45 @@ OpenSSL version, e.g. 3.1, 3.0, 1.1.1 - which is the version of OpenSSL that
 is to be tested. Typically we would expect the apps to be built multiple times
 (once for each target OpenSSL version to be tested).
 
-To build the tests we assume that the target OpenSSL has already been built.
-Two environment variables are required:
-
-TARGET_OSSL_INCLUDE_PATH: Points to a directory where the OpenSSL include files
-are held (e.g. typically "include" under the build directory).
+## Build
 
-TARGET_OSSL_LIBRARY_PATH: Points to a directory where libcrypto.so and libssl.so
-are contained.
+To build the tests we assume that the target OpenSSL has already been built.
 
-To build:
+```sh
+cmake -S . -B <OUTPUT PATH> -DOPENSSL_ROOT_DIR=<OPENSSL_ROOT_DIR>
+cmake --build <OUTPUT PATH> --config Release
+```
 
-export TARGET_OSSL_INCLUDE_PATH=/path/to/openssl/include
-export TARGET_OSSL_LIBRARY_PATH=/path/to/openssl/lib
-make
+## Run
 
-The performance testing apps must be run ensuring that libcrypto.so and
-libssl.so are on the library path.
+The performance testing apps must be run ensuring that `libcrypto.so` and
+`libssl.so` are on the library path.
 
 For example:
 
-LD_LIBRARY_PATH=/path/to/openssl/lib ./randbytes 10
+```sh
+LD_LIBRARY_PATH=<PATH TO OPENSSL LIB> ./randbytes 10
+```
 
 Each performance testing app will take different parameters. They are described
-individually below. All performance testing apps take the "--terse" option
+individually below. All performance testing apps take the `--terse` option
 which has the affect of just printing bare performance numbers without any
 labels.
 
-randbytes
----------
+## randbytes
 
-The randbytes test does 10000 calls of the RAND_bytes() function divided
+The randbytes test does 10000 calls of the [RAND_bytes()](https://docs.openssl.org/master/man3/RAND_bytes/) function divided
 evenly among multiple threads. The number of threads to use is provided as
 an argument and the test reports the average time take to execute a block of
-1000 RAND_bytes() calls.
+1000 [RAND_bytes()](https://docs.openssl.org/master/man3/RAND_bytes/) calls.
 
-handshake
----------
+## handshake
 
 Performs a combined in-memory client and server handshake. In total 100000
 handshakes are performed divided evenly among each thread. It take 2 optional
 and two required arguments:
+
+```
 handshake [-t] [-s] <certsdir> <threadcount>
 -t - produce terse output
 -s - create an ssl_ctx per connection, rather than a single thread-shared ctx
@@ -62,6 +59,7 @@ handshake [-t] [-s] <certsdir> <threadcount>
 -l - use ssl_ctx pool
 certsdir - Directory where the test can locate servercert.pem and serverkey.pem
 threadcount - Number of concurrent threads to run in test
+```
 
 The output is two values: the average time taken for a single handshake in us,
 and the average number of simultaneous handshakes per second performed over the
@@ -70,123 +68,130 @@ course of the test.
 Note: Note on OpenSSL earlier than 3.6 you might hit the thread key local storage
 limit with higher number of threads.
 
-sslnew
-------
+## sslnew
 
-The sslnew test repeatedly constructs a new SSL object and associates it with a
+The `sslnew` test repeatedly constructs a new SSL object and associates it with a
 newly constructed read BIO and a newly constructed write BIO, and finally frees
 them again. It does 100000 repetitions divided evenly among each thread.
 The number of threads to use is provided as an argument and the test
 reports the average time taken to execute a block of 1000 construction/free
 calls.
 
-newrawkey
----------
+## newrawkey
 
-The newrawkey test repeatedly calls the EVP_PKEY_new_raw_public_key_ex()
+The `newrawkey` test repeatedly calls the [EVP_PKEY_new_raw_public_key_ex()](https://docs.openssl.org/master/man3/EVP_PKEY_new/)
 function. It does 100000 repetitions divided evenly among each thread. The
 number of threads to use is provided as an argument and the test reports the
-average time take to execute a block of 1000 EVP_PKEY_new_raw_public_key_ex()
+average time take to execute a block of 1000 [EVP_PKEY_new_raw_public_key_ex()](https://docs.openssl.org/master/man3/EVP_PKEY_new/)
 calls.
 
 Note that this test does not support OpenSSL 1.1.1.
 
-rsasign
--------
+## rsasign
 
-The rsasign test repeatedly calls the EVP_PKEY_sign_init()/EVP_PKEY_sign()
+The `rsasign` test repeatedly calls the [EVP_PKEY_sign_init()/EVP_PKEY_sign()](https://docs.openssl.org/master/man3/EVP_PKEY_sign/)
 functions, using a 512 bit RSA key. It does 100000 repetitions divided evenly
 among each thread. The number of threads to use is provided as an argument and
 the test reports the average time take to execute a block of 1000
-EVP_PKEY_sign_init()/EVP_PKEY_sign() calls.
+[EVP_PKEY_sign_init()/EVP_PKEY_sign()](https://docs.openssl.org/master/man3/EVP_PKEY_sign/) calls.
 
-x509storeissuer
----------------
+## x509storeissuer
 
-Runs the function call X509_STORE_CTX_get1_issuer() repeatedly in a loop (which
+Runs the function call [X509_STORE_CTX_get1_issuer()](https://docs.openssl.org/master/man3/X509_STORE_set_verify_cb_func/) repeatedly in a loop (which
 is used in certificate chain building as part of a verify operation). The test
 assumes that the default certificates directly exists but is empty. For a
 default configuration this is "/usr/local/ssl/certs". The test takes the number
 of threads to use as an argument and the test reports the average time take to
-execute a block of 1000 X509_STORE_CTX_get1_issuer() calls.
+execute a block of 1000 [X509_STORE_CTX_get1_issuer()](https://docs.openssl.org/master/man3/X509_STORE_set_verify_cb_func/) calls.
 
-providerdoall
--------------
+## providerdoall
 
-The providerdoall test repeatedly calls the OSSL_PROVIDER_do_all() function.
+The `providerdoall` test repeatedly calls the [OSSL_PROVIDER_do_all()](https://docs.openssl.org/master/man3/OSSL_PROVIDER) function.
 It does 100000 repetitions divided evenly among each thread. The number of
 threads to use is provided as an argument and the test reports the average time
-take to execute a block of 1000 OSSL_PROVIDER_do_all() calls.
+take to execute a block of 1000 [OSSL_PROVIDER_do_all()](https://docs.openssl.org/master/man3/OSSL_PROVIDER) calls.
+
+## rwlocks
 
-rwlocks
--------------
-the rwlocks test creates the command line specified number of threads, splitting
+The `rwlocks` test creates the command line specified number of threads, splitting
 them evenly between read and write functions (though this is adjustable via the
 LOCK_WRITERS environment variable).  Threads then iteratively acquire a shared
 rwlock to read or update some shared data.  The number of read and write
 lock/unlock pairs are reported as a performance measurement
 
-pkeyread
---------
+## pkeyread
 
-The pkeyread test repeatedly calls the PEM_read_bio_PrivateKey() function on a
+The `pkeyread` test repeatedly calls the [PEM_read_bio_PrivateKey()](https://docs.openssl.org/master/man3/PEM_read_bio_PrivateKey/) function on a
 memory BIO with a private key of desired type, when it is running in pem mode
 (-f pem).  If test is running in der mode (-f der) it calls to
-d2i_PrivateKey_ex() function to repeatedly read private key of desired type.
+[d2i_PrivateKey_ex()](https://docs.openssl.org/master/man3/d2i_PrivateKey/) function to repeatedly read private key of desired type.
 It does 10000 repetitions divided evenly among each thread. The number of
-threads to use is provided by option -t. The test reports average time per
-call. Use option -k to select key type for benchmark.  The list of keys for
+threads to use is provided by option `-t`. The test reports average time per
+call. Use option `-k` to select key type for benchmark.  The list of keys for
 testing is as follows: dh, dhx, dsa, ec, rsa, xkey.  To run benchmark for all
 keys and formats using 4 threads run pkeyread as follows:
-    ./pkeyread -f all -k all -t 4
 
-evp_setpeer
--------
+```sh
+./pkeyread -f all -k all -t 4
+```
+
+## evp_setpeer
 
-The evp_setpeer test repeatedly calls the EVP_PKEY_derive_set_peer() function
+The `evp_setpeer` test repeatedly calls the [EVP_PKEY_derive_set_peer()](https://docs.openssl.org/master/man3/EVP_PKEY_derive/) function
 on a memory BIO with a private key of desired type.  It does 10000
 repetitions divided evenly among each thread. The last argument will be the
-number of threads run. The test reports average time per call. Use option -k
+number of threads run. The test reports average time per call. Use option `-k`
 to select key type for benchmark.  The list of keys for testing is as follows:
 dh, ec256, ec521, x25519.  To run benchmark for all keys using 4 threads, run
 evp_setpeer as follows:
-    ./evp_setpeer -k all -t 4
 
-writeread
----------
+```sh
+./evp_setpeer -k all -t 4
+```
+
+## writeread
 
 Performs an in-memory client and server handshake and measures the average
-time taken for a single sequence of calling SSL_write_ex() on the client and
-SSL_read_ex() on the server.  In total 1000000 writes and reads are performed
+time taken for a single sequence of calling [SSL_write_ex()](https://docs.openssl.org/master/man3/SSL_write/) on the client and
+[SSL_write_ex()](https://docs.openssl.org/master/man3/SSL_write/) on the server.  In total 1000000 writes and reads are performed
 divided evenly among each thread. It take 4 optional and 2 required arguments:
+
+```
 writeread [-t] [-s] [-d] [-b size] <certsdir> <threadcount>
 -t - produce terse output.
 -s - create an ssl_ctx per connection, rather than a single thread-shared ctx.
 -d - use DTLS as connection method.
 -b - size of buffer to write and read, default is 1024 bytes.
 certsdir - directory where the test can locate servercert.pem and serverkey.pem.
 threadcount - number of concurrent threads to run in test.
+```
 
-ssl_poll_perf
--------------
+## ssl_poll_perf
 
 Tool to evaluate performance of QUIC client and server which both use
-SSL_poll(3ossl). Application creates two threads, one for client the
+[SSL_poll](https://docs.openssl.org/master/man3/SSL_poll/)(3ossl). Application creates two threads, one for client the
 other for server. Server and client can both accept/create simultanous
 connections. Each connection then can carry multiple unidirectional/bidirectional
 streams. The streams handle HTTP/1.0 GET request/responses only.
 Server always drains the incoming stream initiated by client.  It answers to
 any GET request. The default reply is 200 OK with 12345 bytes of payload.
 Client may request desired payload with URL as follows:
-    /any/path/to_8192whatever/foo_4096.txt
+
+```
+/any/path/to_8192whatever/foo_4096.txt
+```
+
 In which case the server will send response with 8kB http/1.0 body.
 The URL parser attempts to find leftmost number, which denotes the number
 of bytes client expects in response.
 The test program supports options as follows:
+
+```
 -c - number of connections to create (default 10)
 -b - number of bidirectional streams each connection creates (default 10)
 -u - number of unidirectional streams each connection creates (default 10)
 -s - the size of reply body, the maximum size is 100MB. The default size is 64.
 -w - the size of request body, the maximum size is 100MB. The default size is 64.
 -p - port number to use
 -t - terse output
+```