Issue title: Profile the rocksDB performance in deleting and writing
 Issue body: ### Description
Profile the rocksDB performance in deleting and writing. What happens when we start deleting or writing a large number of transactions?

### Motivation
Explain why this feature is needed.

### Requirements
Create a list of what you want this feature request to fulfill.

### Open Questions (optional)
Anything you want to discuss.

### Am I planning to do it myself with a PR?
Yes/No.

 Comments: 
 Comment 0: @alon-e and @jakubcech 

I am creating a separate benchmarking project that will be part of tangle tools.

I think it is better to first do tests on RockDbPersistenceProvider isolated from the node.
This is so that we know how changes that we make to RocksDbPersistenceProvider affect its performance.
 Comment 1: I decided in the end to implement this as a *unit test* that will not be ran as part of the maven lifecycle.
Currently the best way to run this directly is by `mvn surefire:test -Dtest=BenchmarkRunner` or if you want to compile first to do `mvn -Dtest=BenchmarkRunner <goals>`.

It is very important to run those benchmarks in a clean environment to reduce noise. For example when I run this on my laptop while working I got the following results:

```
Benchmark                         (numTxsToTest)  Mode  Cnt    Score     Error  Units
RocksDbBenchmark.deleteBatch                  10  avgt   20    8.485 ±   0.038  ms/op
RocksDbBenchmark.deleteBatch                 100  avgt   20    8.696 ±   0.049  ms/op
RocksDbBenchmark.deleteBatch                 500  avgt   20    8.944 ±   0.145  ms/op
RocksDbBenchmark.deleteBatch                1000  avgt   20   11.558 ±   0.639  ms/op
RocksDbBenchmark.deleteBatch                3000  avgt   20   27.561 ±   1.720  ms/op
RocksDbBenchmark.deleteOneByOne               10  avgt   20    0.116 ±   0.017  ms/op
RocksDbBenchmark.deleteOneByOne              100  avgt   20    1.054 ±   0.117  ms/op
RocksDbBenchmark.deleteOneByOne              500  avgt   20    6.717 ±   1.223  ms/op
RocksDbBenchmark.deleteOneByOne             1000  avgt   20   17.201 ±   3.121  ms/op
RocksDbBenchmark.deleteOneByOne             3000  avgt   20   43.366 ±   9.175  ms/op
RocksDbBenchmark.dropAll                      10  avgt   20    0.329 ±   0.080  ms/op
RocksDbBenchmark.dropAll                     100  avgt   20    3.412 ±   0.572  ms/op
RocksDbBenchmark.dropAll                     500  avgt   20   17.000 ±   3.756  ms/op
RocksDbBenchmark.dropAll                    1000  avgt   20   37.898 ±   7.543  ms/op
RocksDbBenchmark.dropAll                    3000  avgt   20   64.127 ±  16.081  ms/op
RocksDbBenchmark.fetchBatch                   10  avgt   20    0.071 ±   0.002  ms/op
RocksDbBenchmark.fetchBatch                  100  avgt   20    1.304 ±   0.978  ms/op
RocksDbBenchmark.fetchBatch                  500  avgt   20    9.997 ±   4.622  ms/op
RocksDbBenchmark.fetchBatch                 1000  avgt   20   25.455 ±   8.109  ms/op
RocksDbBenchmark.fetchBatch                 3000  avgt   20  108.476 ±  15.976  ms/op
RocksDbBenchmark.persistOneByOne              10  avgt   20    0.031 ±   0.001  ms/op
RocksDbBenchmark.persistOneByOne             100  avgt   20    0.480 ±   0.331  ms/op
RocksDbBenchmark.persistOneByOne             500  avgt   20    4.902 ±   3.419  ms/op
RocksDbBenchmark.persistOneByOne            1000  avgt   20   14.489 ±   6.685  ms/op
RocksDbBenchmark.persistOneByOne            3000  avgt   20  131.039 ± 206.119  ms/op
```

As you can see in some cases the error is quite unacceptable.
When I run the test on Hetzner (cloud) machine that has nothing running on I got better results.

```
Benchmark                         (numTxsToTest)  Mode  Cnt   Score   Error  Units
RocksDbBenchmark.deleteBatch                3000  avgt   20  14.468 ? 0.534  ms/op
RocksDbBenchmark.deleteOneByOne             3000  avgt   20  11.412 ? 0.341  ms/op
RocksDbBenchmark.dropAll                    3000  avgt   20  23.479 ? 4.598  ms/op
RocksDbBenchmark.fetchBatch                 3000  avgt   20  46.698 ? 7.336  ms/op
RocksDbBenchmark.persistOneByOne            3000  avgt   20  30.745 ? 2.609  ms/op
```

On the Hetzner you are only seeing the results for 3000 because I skipped the other tests to save time.
The whole suit can take a very long time to complete. I just need to make it recognize the `±` character :-P. 

`Cnt` btw is the number of measurement iterations (2 forks X 10 iterations). In #962 I reduced the number of forks to 1 because from experimenting I didn't notice that the forks changed the results too much and the tests are long enough as it is.
 Comment 2: By the way it is very surprising that `deleteOneByOne` is faster than the other deleting methods...
I may have to do more experiments to see how I can get results that I can count on...
 Comment 3: I don't seem to be able to get better results by changing the order of the tests.
By looking at the implementation of `dropAll` it is not so surprising that it is slow.

I am surprised that `deleteBatch` is a bit slower though...
{'source': 'GithubIssues', 'repo_name_with_owner': 'iotaledger/iri', 'issue_id': 349482038, 'repo_stars': 1353.0}